pax_global_header00006660000000000000000000000064130017411470014510gustar00rootroot0000000000000052 comment=91dc62dea5e649f5923fa70119a21fab1e1b1138 sollya-6.0+ds/000077500000000000000000000000001300174114700132625ustar00rootroot00000000000000sollya-6.0+ds/AUTHORS000066400000000000000000000003311300174114700143270ustar00rootroot00000000000000Sylvain Chevillard Christoph Lauter Nicolas Jourdan Mioara Joldes Marc Mezzarobba sollya-6.0+ds/COPYING000066400000000000000000000725171300174114700143310ustar00rootroot00000000000000This file COPYING indicates your rights and liabilties for using, modifying and redistributing this software, named Sollya. Sollya is reigned by the terms of the CeCILL-C Free Software License agreement which can be found below in english. It links to other libraries reigned by the GNU Lesser General Public License. A copy of this license is given below in english. ------------------------------------------------------------------------- CeCILL-C FREE SOFTWARE LICENSE AGREEMENT Notice This Agreement is a Free Software license agreement that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting: * firstly, compliance with the principles governing the distribution of Free Software: access to source code, broad rights granted to users, * secondly, the election of a governing law, French law, with which it is conformant, both as regards the law of torts and intellectual property law, and the protection that it offers to both authors and holders of the economic rights over software. The authors of the CeCILL-C (for Ce[a] C[nrs] I[nria] L[ogiciel] L[ibre]) license are: Commissariat à l'Energie Atomique - CEA, a public scientific, technical and industrial research establishment, having its principal place of business at 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris, France. Centre National de la Recherche Scientifique - CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange, 75794 Paris cedex 16, France. Institut National de Recherche en Informatique et en Automatique - INRIA, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex, France. Preamble The purpose of this Free Software license agreement is to grant users the right to modify and re-use the software governed by this license. The exercising of this right is conditional upon the obligation to make available to the community the modifications made to the source code of the software so as to contribute to its evolution. In consideration of access to the source code and the rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors only have limited liability. In this respect, the risks associated with loading, using, modifying and/or developing or reproducing the software by the user are brought to the user's attention, given its Free Software status, which may make it complicated to use, with the result that its use is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the suitability of the software as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no provisions are either added or removed herefrom. This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the use thereof to its provisions. Article 1 - DEFINITIONS For the purpose of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning: Agreement: means this license agreement, and its possible subsequent versions and annexes. Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, "as is" when the Licensee accepts the Agreement. Initial Software: means the Software in its Source Code and possibly its Object Code form and, where applicable, its documentation, "as is" when it is first distributed under the terms and conditions of the Agreement. Modified Software: means the Software modified by at least one Integrated Contribution. Source Code: means all the Software's instructions and program lines to which access is required so as to modify the Software. Object Code: means the binary files originating from the compilation of the Source Code. Holder: means the holder(s) of the economic rights over the Initial Software. Licensee: means the Software user(s) having accepted the Agreement. Contributor: means a Licensee having made at least one Integrated Contribution. Licensor: means the Holder, or any other individual or legal entity, who distributes the Software under the Agreement. Integrated Contribution: means any or all modifications, corrections, translations, adaptations and/or new functions integrated into the Source Code by any or all Contributors. Related Module: means a set of sources files including their documentation that, without modification to the Source Code, enables supplementary functions or services in addition to those offered by the Software. Derivative Software: means any combination of the Software, modified or not, and of a Related Module. Parties: mean both the Licensee and the Licensor. These expressions may be used both in singular and plural form. Article 2 - PURPOSE The purpose of the Agreement is the grant by the Licensor to the Licensee of a non-exclusive, transferable and worldwide license for the Software as set forth in Article 5 hereinafter for the whole term of the protection granted by the rights over said Software. Article 3 - ACCEPTANCE 3.1 The Licensee shall be deemed as having accepted the terms and conditions of this Agreement upon the occurrence of the first of the following events: * (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium; * (ii) the first time the Licensee exercises any of the rights granted hereunder. 3.2 One copy of the Agreement, containing a notice relating to the characteristics of the Software, to the limited warranty, and to the fact that its use is restricted to experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 hereinabove, and the Licensee hereby acknowledges that it has read and understood it. Article 4 - EFFECTIVE DATE AND TERM 4.1 EFFECTIVE DATE The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1. 4.2 TERM The Agreement shall remain in force for the entire legal term of protection of the economic rights over the Software. Article 5 - SCOPE OF RIGHTS GRANTED The Licensor hereby grants to the Licensee, who accepts, the following rights over the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter. Besides, if the Licensor owns or comes to own one or more patents protecting all or part of the functions of the Software or of its components, the Licensor undertakes not to enforce the rights granted by these patents against successive Licensees using, exploiting or modifying the Software. If these patents are transferred, the Licensor undertakes to have the transferees subscribe to the obligations set forth in this paragraph. 5.1 RIGHT OF USE The Licensee is authorized to use the Software, without any limitation as to its fields of application, with it being hereinafter specified that this comprises: 1. permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form. 2. loading, displaying, running, or storing the Software on any or all medium. 3. entitlement to observe, study or test its operation so as to determine the ideas and principles behind any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder. 5.2 RIGHT OF MODIFICATION The right of modification includes the right to translate, adapt, arrange, or make any or all modifications to the Software, and the right to reproduce the resulting software. It includes, in particular, the right to create a Derivative Software. The Licensee is authorized to make any or all modification to the Software provided that it includes an explicit notice that it is the author of said modification and indicates the date of the creation thereof. 5.3 RIGHT OF DISTRIBUTION In particular, the right of distribution includes the right to publish, transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, one or more copies of the Software by any means. The Licensee is further authorized to distribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter. 5.3.1 DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION The Licensee is authorized to distribute true copies of the Software in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by: 1. a copy of the Agreement, 2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9, and that, in the event that only the Object Code of the Software is redistributed, the Licensee allows effective access to the full Source Code of the Software at a minimum during the entire period of its distribution of the Software, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data. 5.3.2 DISTRIBUTION OF MODIFIED SOFTWARE When the Licensee makes an Integrated Contribution to the Software, the terms and conditions for the distribution of the resulting Modified Software become subject to all the provisions of this Agreement. The Licensee is authorized to distribute the Modified Software, in source code or object code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by: 1. a copy of the Agreement, 2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9, and that, in the event that only the object code of the Modified Software is redistributed, the Licensee allows effective access to the full source code of the Modified Software at a minimum during the entire period of its distribution of the Modified Software, it being understood that the additional cost of acquiring the source code shall not exceed the cost of transferring the data. 5.3.3 DISTRIBUTION OF DERIVATIVE SOFTWARE When the Licensee creates Derivative Software, this Derivative Software may be distributed under a license agreement other than this Agreement, subject to compliance with the requirement to include a notice concerning the rights over the Software as defined in Article 6.4. In the event the creation of the Derivative Software required modification of the Source Code, the Licensee undertakes that: 1. the resulting Modified Software will be governed by this Agreement, 2. the Integrated Contributions in the resulting Modified Software will be clearly identified and documented, 3. the Licensee will allow effective access to the source code of the Modified Software, at a minimum during the entire period of distribution of the Derivative Software, such that such modifications may be carried over in a subsequent version of the Software; it being understood that the additional cost of purchasing the source code of the Modified Software shall not exceed the cost of transferring the data. 5.3.4 COMPATIBILITY WITH THE CeCILL LICENSE When a Modified Software contains an Integrated Contribution subject to the CeCILL license agreement, or when a Derivative Software contains a Related Module subject to the CeCILL license agreement, the provisions set forth in the third item of Article 6.4 are optional. Article 6 - INTELLECTUAL PROPERTY 6.1 OVER THE INITIAL SOFTWARE The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to modify the terms and conditions for the distribution of said Initial Software. The Holder undertakes that the Initial Software will remain ruled at least by this Agreement, for the duration set forth in Article 4.2. 6.2 OVER THE INTEGRATED CONTRIBUTIONS The Licensee who develops an Integrated Contribution is the owner of the intellectual property rights over this Contribution as defined by applicable law. 6.3 OVER THE RELATED MODULES The Licensee who develops a Related Module is the owner of the intellectual property rights over this Related Module as defined by applicable law and is free to choose the type of agreement that shall govern its distribution under the conditions defined in Article 5.3.3. 6.4 NOTICE OF RIGHTS The Licensee expressly undertakes: 1. not to remove, or modify, in any manner, the intellectual property notices attached to the Software; 2. to reproduce said notices, in an identical manner, in the copies of the Software modified or not; 3. to ensure that use of the Software, its intellectual property notices and the fact that it is governed by the Agreement is indicated in a text that is easily accessible, specifically from the interface of any Derivative Software. The Licensee undertakes not to directly or indirectly infringe the intellectual property rights of the Holder and/or Contributors on the Software and to take, where applicable, vis-à-vis its staff, any and all measures required to ensure respect of said intellectual property rights of the Holder and/or Contributors. Article 7 - RELATED SERVICES 7.1 Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software. However, the Licensor is entitled to offer this type of services. The terms and conditions of such technical assistance, and/or such maintenance, shall be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor. 7.2 Similarly, any Licensor is entitled to offer to its licensees, under its sole responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it is free to decide. Said warranty, and the financial terms and conditions of its application, shall be subject of a separate instrument executed between the Licensor and the Licensee. Article 8 - LIABILITY 8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled to claim compensation for any direct loss it may have suffered from the Software as a result of a fault on the part of the relevant Licensor, subject to providing evidence thereof. 8.2 The Licensor's liability is limited to the commitments made under this Agreement and shall not be incurred as a result of in particular: (i) loss due the Licensee's total or partial failure to fulfill its obligations, (ii) direct or consequential loss that is suffered by the Licensee due to the use or performance of the Software, and (iii) more generally, any consequential loss. In particular the Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor. Article 9 - WARRANTY 9.1 The Licensee acknowledges that the scientific and technical state-of-the-art when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of possible defects to be detected. In this respect, the Licensee's attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software which are reserved for experienced users. The Licensee shall be responsible for verifying, by any or all means, the suitability of the product for its requirements, its good working order, and for ensuring that it shall not cause damage to either persons or properties. 9.2 The Licensor hereby represents, in good faith, that it is entitled to grant all the rights over the Software (including in particular the rights set forth in Article 5). 9.3 The Licensee acknowledges that the Software is supplied "as is" by the Licensor without any other express or tacit warranty, other than that provided for in Article 9.2 and, in particular, without any warranty as to its commercial value, its secured, safe, innovative or relevant nature. Specifically, the Licensor does not warrant that the Software is free from any error, that it will operate without interruption, that it will be compatible with the Licensee's own equipment and software configuration, nor that it will meet the Licensee's requirements. 9.4 The Licensor does not either expressly or tacitly warrant that the Software does not infringe any third party intellectual property right relating to a patent, software or any other property right. Therefore, the Licensor disclaims any and all liability towards the Licensee arising out of any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal assistance for its defense. Such technical and legal assistance shall be decided on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any and all liability as regards the Licensee's use of the name of the Software. No warranty is given as regards the existence of prior rights over the name of the Software or as regards the existence of a trademark. Article 10 - TERMINATION 10.1 In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective. 10.2 A Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof. Article 11 - MISCELLANEOUS 11.1 EXCUSABLE EVENTS Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as defective functioning or interruptions of the electricity or telecommunications networks, network paralysis following a virus attack, intervention by government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc. 11.2 Any failure by either Party, on one or more occasions, to invoke one or more of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its right to invoke said provision(s) subsequently. 11.3 The Agreement cancels and replaces any or all previous agreements, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as between the Parties unless it is made in writing and signed by their duly authorized representatives. 11.4 In the event that one or more of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall prevail, and the Parties shall make the necessary amendments so as to comply with said act or legislative text. All other provisions shall remain effective. Similarly, invalidity of a provision of the Agreement, for any reason whatsoever, shall not cause the Agreement as a whole to be invalid. 11.5 LANGUAGE The Agreement is drafted in both French and English and both versions are deemed authentic. Article 12 - NEW VERSIONS OF THE AGREEMENT 12.1 Any person is authorized to duplicate and distribute copies of this Agreement. 12.2 So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, who reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software. 12.3 Any Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement or a subsequent version. Article 13 - GOVERNING LAW AND JURISDICTION 13.1 The Agreement is governed by French law. The Parties agree to endeavor to seek an amicable solution to any disagreements or disputes that may arise during the performance of the Agreement. 13.2 Failing an amicable solution within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the more diligent Party. Version 1.0 dated 2006-09-05. -------------------------------------------------------------------------------- GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below. 0. Additional Definitions. As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License. "The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below. An "Application" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library. A "Combined Work" is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the "Linked Version". The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version. The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work. 1. Exception to Section 3 of the GNU GPL. You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL. 2. Conveying Modified Versions. If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version: a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy. 3. Object Code Incorporating Material from Library Header Files. The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following: a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the object code with a copy of the GNU GPL and this license document. 4. Combined Works. You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following: a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the Combined Work with a copy of the GNU GPL and this license document. c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document. d) Do one of the following: 0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source. 1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version. e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.) 5. Combined Libraries. You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License. b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 6. Revised Versions of the GNU Lesser General Public License. The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation. If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library. sollya-6.0+ds/ChangeLog000066400000000000000000037463431300174114700150600ustar00rootroot000000000000002016-10-17 Sylvain Chevillard * Makefile.am: The man page was not distributed when help2man was not present... 2016-10-17 Sylvain Chevillard * doc/sollya.tex, doc/www/sollya.php: Added missing documentation for the sollya_lib_range function 2016-10-17 Christoph Lauter * polynomials.c: Patched a small bug in an evaluation function. 2016-10-17 Christoph Lauter * polynomials.c: A certain cache in the polynomial code needs to be invalidated in certain situations. 2016-10-11 Christoph Lauter * polynomials.c: Performance optimizations in polynomial code. 2016-10-10 Christoph Lauter * expression.c, expression.h, polynomials.c: Performance optimizations with a code that uses rational arithmetic on polynomials a lot. 2016-10-10 Christoph Lauter * polynomials.c: Slight performance improvement to functions handling polynomials with rational constants. 2016-10-17 Christoph Lauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/introExample51.tex, doc/remez.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/introExample51.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, help.h: Recompiled the documentation. 2016-10-16 Sylvain Chevillard * NEWS: Updated NEWS file with the modification we did since last time. 2016-10-16 Sylvain Chevillard * : Reintroduced sollya.pdf that has mysteriously be removed in a previous commit 2016-10-16 Sylvain Chevillard * configure.ac: Configure checks that pdflatex comes with the required packages. Otherwise, when pdflatex was detected, make tried to compile the doc when doing make all, and this could fail, leading `make all` to fail without even trying to compile sollya. 2016-10-16 Sylvain Chevillard * tests-tool/check024.sollya, tests-tool/check024.sollya.reference: Introducing a non-regression test for the bug patched at commit e34e380 2016-10-16 Sylvain Chevillard * Makefile.am, doc/Makefile.am: In silent-mode, pdflatex and help2man now display nice messages. 2016-10-15 Sylvain Chevillard * configure.ac, tests-lib/Makefile.am: Patched a bug preventing make check-lib to build. Of course, I reverted the temporary patch committed by Christoph with commit d632607. 2016-10-15 Christoph Lauter * general.c: Slightly changed the logic with srand/rand in __unique_id generation. 2016-10-15 Christoph Lauter * tests-lib/Makefile.am: F**ing temporary solution to make the tests compile again. 2016-10-14 Sylvain Chevillard * general.c: Replaced calls to rand_r by calls to rand (rand_r is marked as obsolete from POSIX.1-2008). I am not sure that this is related to the fact that it is obsolete, but we had a warning 'implicitely declared function' under Debian about rand_r which was mysterious. It did not appear clearly to me that rand_r was really necessary in our context, so I switched to the couple srand/rand. 2016-10-14 Sylvain Chevillard * configure.ac: Replaced a trick that we used to do before we knew about abs_srcdir variable 2016-10-14 Sylvain Chevillard * general.c, parser.y, sollya.1: Integrated last patch proposed by J. Benoit. Do not include the built information in the version and help texts used by help2man to generate the man page. 2016-10-14 Sylvain Chevillard * sollya.1, version.h: Integrated 7th patch proposed by J. Benoit Enhanced formatting of the version text, so as to generate a nicer looking man page. 2016-10-14 Sylvain Chevillard * tests-tool/Makefile.am: Integrated 6th patch proposed by J. Benoit. Simple reformatting of a long line in tests-tool/Makefile.am in order to break it into several shorter ones. 2016-10-14 Sylvain Chevillard * configure.ac, doc/Makefile.am: Integrated 5th patch proposed by J. Benoit Nicer way of compiling the documentation through make sollya.pdf I understood that `make install` should now install sollya.pdf but did not test this feature yet. 2016-10-14 Sylvain Chevillard * Makefile.am, configure.ac: Integrated 4th patch suggested by J. Benoit. Enhanced configure.ac with modern practices 2016-10-14 Sylvain Chevillard * doc/sollya.tex: Integrated 3rd patch suggested by J. Benoit. Nicer formatting of the pdf title page, licence page, and table of contents. 2016-10-14 Sylvain Chevillard * doc/sollya.tex: Integrated 2nd patch proposed by J. Benoit. Enhanced table of contents in sollya.pdf 2016-10-14 Sylvain Chevillard * doc/dirtyintegral.shlp, doc/dirtyintegral.tex, doc/honorcoeffprec.tex, doc/implementpoly.tex, doc/www/dirtyintegral.php, doc/www/honorcoeffprec.php, doc/www/implementpoly.php, general.c, help.h, implement.c, infnorm.c, sollya-library-wrappers.c, sollya-messaging.h, sollya.1, sollya.h2m, tests-lib/timplementpoly.c, tests-lib/timplementpoly.reference, tests-lib/tv_implementpoly.c, tests-lib/tv_implementpoly.reference, tests-tool/check004.sollya.reference, tests-tool/check005.sollya.reference, tests-tool/check029.sollya.reference: Integrated 1st patch suggested by J. Benoit. Spelling mistakes. 2016-10-14 Christoph Lauter * internlexer.l: Patching a strange bug that made "showmessagenumbers = on/off" constructions to be ignored in Sollya files when these files were read not with read nor parse but with execute. 2016-10-13 Christoph Lauter * general.c: Trying to patch a regression in the Sollya library introduced with commit f175f2b938036f38a027adf2f0f381db87bd1e21 2016-10-07 Sylvain Chevillard * Makefile.am: Added the man page to the distributed tarballs 2016-10-07 Sylvain Chevillard * sollya.1: and the corresponding generated sollya.1... 2016-10-07 Sylvain Chevillard * Makefile.am: Yet another small fix for help2man 2016-10-07 Sylvain Chevillard * sollya.1: Added the manual page to the git repository. 2016-10-07 Sylvain Chevillard * Makefile.am, version.h: Fixed minor issues with the generation of the man page 2016-10-07 Christoph Lauter * doc/Makefile.am, doc/bashevaluate.tex, doc/bashexecute.tex, doc/introExample51.tex, doc/remez.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/introExample51.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, help.h: Recompiled the documentation. 2016-10-07 Christoph Lauter * execute.c: Patching a small issue with parse(), used in combination with DOS-like CR/LF sequences at the end of the parsed string. 2016-10-07 Sylvain Chevillard * tests-tool/Makefile.am, tests-tool/check031.sollya, tests-tool/check031.sollya.reference: Attempt for non-regression tests regarding correct handling of "\r\n" 2016-10-06 Sylvain Chevillard * tests-tool/check031.sollya: Proposition of tests for the '\r\n' compatibility. 2016-10-07 Christoph Lauter * NEWS: Slightly changed the NEWS file. 2016-10-06 Sylvain Chevillard * NEWS: Concrete proposition of a NEWS file. 2016-10-05 Christoph Lauter * : commit 8a4aecd3585080e55ea2f69b30666c98d55ecc7d Author: Christoph Lauter Date: Wed Oct 5 16:45:27 2016 +0200 2016-10-05 Sylvain Chevillard * NEWS: Updated the proposition of NEWS file with the bug fixed a few days ago 2016-10-04 Sylvain Chevillard * tests-tool/check024.sollya, tests-tool/check024.sollya.reference: Added non-regression test for bug [#20818] 2016-10-04 Christoph Lauter * execute.c, tests-tool/check013.sollya.reference, tests-tool/timecheck.sollya.reference: Trying to patch "[#20818] Expression tree changes when it is written in a file and read back". 2016-09-30 Sylvain Chevillard * configure.ac: Corrected a typo. 2016-09-29 Sylvain Chevillard * configure.ac: Completely reworked the configure tests for FPLLL. The recent change of API in fplll introduce new combinatoric possibilities: one might or now want to add the -std=c++11 option, and one might or not use the new API. This is to add to the old possibilities regarding the position of fplll.h in the include directory tree and the question of whether -lfplll flag should be passed or not the linker. At first, I thought that things were not much more difficult: the new -std requirement comes with the new API and that's it. It turns out that fplll API is currently not stable and the new API for instance was the one to use with fpllll 5.0 but not with the current git repository of fpllll. Nevertheless, the requirement of -std=c++11 is stays present with the current repository, although the old API is used. To make things more complicated, we have examples of versions of fplll (observed when trying to compile under Christoph's Cygwin system) where passing -std=c+11 breaks the compilation while not passing it works fine. Also, recently Victor Magron signaled that versions of g++ around 4.8 and 4.9 works fine with modern versions of fplll *only* is the option -std=c++11 is explicitely passed (although with more recent versions of g++, it compiles fine with or without the option). So, I decided to more or less systematically test the possible combinations of these four parameters. Some combinations really seem to be unlikely because they refer to behaviors of fplll at very different time of its history. So we indeed try only 7 possibilities over the 16 possibilities. Hopefully, this should allow us to compile sollya with more or less any version of fplll. 2016-09-26 Sylvain Chevillard * tests-tool/timecheck.sollya: Non-regression tests for the couple of bugs hidden behind the same example. These two bugs have been addressed (without a bug report) during the past three weeks. Contrary to what we once thought, there is absolutely no cache issue involved, so I reverted commit 1b7a727 on my way. 2016-09-26 Sylvain Chevillard * sturm.c: Updated copyrights 2016-09-23 Sylvain Chevillard * ChangeLog, NEWS: Selection of items to put in the NEWS of 6.0 2016-09-19 Sylvain Chevillard * tests-tool/Makefile.am, tests-tool/check031.sollya, tests-tool/check031.sollya.reference: Removed non-regression test for the bug fixed at commit 9b578b8. It seems really not easy to do a robust test that would also work on platforms without an X server. 2016-09-23 Sylvain Chevillard * fpminimax.c: Better formatting of fpminimax messages at verbosity level >= 4 2016-09-23 Christoph Lauter * sturm.c: Slight performance improvement to numberroots. 2016-09-22 Christoph Lauter * infnorm.c, tests-tool/timecheck.sollya: Patching the most difficult bug ever to be patched inside Sollya. 2016-09-21 Christoph Lauter * polynomials.c: Revert "Patched a small bug with the reuse of a global variable." This reverts commit b5cbc68511a8a5178a8044cdf43c9e04bdbe0608. 2016-09-20 Christoph Lauter * polynomials.c: Patched a small bug with the reuse of a global variable. 2016-09-19 Christoph Lauter * tests-tool/timecheck.sollya: Get rid of certain caching effects. 2016-09-19 Christoph Lauter * tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Updated tests for min and max. 2016-09-13 Christoph Lauter * tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Added additional checks for min and max. 2016-09-13 Christoph Lauter * execute.c: Patching a bug with infinities in min and max. 2016-09-13 Christoph Lauter * tests-tool/check031.sollya: Some improvements to check031, making it run when no X is available and improving locking behavior. 2016-09-12 Sylvain Chevillard * tests-tool/Makefile.am, tests-tool/check031.sollya, tests-tool/check031.sollya.reference: Kind of non regression test for the bug patched with commit f175f2b. 2016-09-12 Sylvain Chevillard * tests-tool/timecheck.sollya, tests-tool/timecheck.sollya.reference: Non-regression test for a performance bug addressed at commit e0b3184. The test currently does not pass as the performance issue seems to still exist, although it has been already much improved by commit e0b3184. 2016-09-12 Sylvain Chevillard * remez.c: Patched a memory leak in remez 2016-09-09 Sylvain Chevillard * tests-tool/check030.sollya, tests-tool/check030.sollya.reference: Added non-regression tests for bugs #12892 and (parts of) #17200. 2016-09-09 Sylvain Chevillard * remez.c, sollya-messages.h, sollya-messaging.h: Kind of patched bug #12892. The patch is not perfect, but works and will work in most situations, although this is not the smartest thing we could do. The problem was that multi-point exchange algorithm sometimes behaves badly when Haar condition is not fulfilled, leading to a situation where epsilon could suddenly decrease (instead of constantly increase), therefore leading to possible pseudo-cycles in the algorithm. When we detect that epsilon has decreased, we now simply switch to the single point exchange algorithm and keep this choice active until the end of the algorithm. This ensures that no cycle can happen. We could do better by starting over from the previous set of points (instead of simply continuing with the set of points that led to epsilon decreasing) but the patch to do it would be more involved, and in practice it does not seem to be very harmful to simply continue the algorithm with the points obtained after epsilon has decreased. Indeed, this patch also fixes bug #17200 except for one case where, precisely, it is not a good idea to continue the algorithm after epsilon has decreased. 2016-09-07 Sylvain Chevillard * Makefile.am: Removed definitions of sollya_C*FLAGS in Makefile.am (they seem useless). Christoph introduced them when we started compiling the interactive tool from the library. He could not come with any precise argument why he put these definitions, except that he remembers having copied it from some more or less official example found on the web. As far as I understand the logic of automake, this is useless because AM_C*FLAGS are automatically added to any target. I tried removing it and compiling sollya on a computer where the usual libs are installed in some prefix, providing them through the --with- mechanism and it worked perfectly. 2016-09-07 Sylvain Chevillard * infnorm.c: Removed code that seems useless. While investigating the bug addressed by Christoph at commit e0b3184, I found a piece of code I could not understand the logic of in infnorm.c. This code adds a complementary test to an existing test deciding whether we should run Newton's algorithm within dirtyinfnorm algorithm. The addition has been made by Christoph at commit 9b1d5e6. This commit performs many non trivial modifications on many files, including infnorm.c, but this precise modification is completely isolated (in particular, it is the only modification to the dirtyinfnorm algorithm). There is no comment that would provide us with an idea of the intent behing this modification, and the commit log is not more helpful. I cannot see any logic in this modification, although it is rather harmless in the sense that it would simply conclude that it is necessary to run Newton's algorithm in situations where it does not seem quite useful. The present commit reverts this modification. All the tests keep passing. 2016-09-07 Christoph Lauter * infnorm.c: Trying to patch a strange performance bug in interval evaluation with low precision. 2016-09-05 Sylvain Chevillard * tests-tool/check029.sollya: Changed variable names to uppercase in the systematic tests for objectname. This is to clearly separate variable names in the generated script from variable names in the generating script. This is made necessary by Christoph's change of commit 10f890b that removed a 'restart' that would be otherwise required. 2016-09-05 Christoph Lauter * tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Still improving debuggability of a test. 2016-09-05 Christoph Lauter * : commit 10f890bf3389fa9023743ce4b21271fd89bf5df5 Author: Christoph Lauter Date: Mon Sep 5 11:54:46 2016 +0200 2016-08-31 Sylvain Chevillard * external.c, infnorm.h: Updated copyrights. 2016-08-30 Sylvain Chevillard * doc/shlp2tex.sh: shlp2tex.sh now automatically adds new .tex files to Makefile.am 2016-08-30 Sylvain Chevillard * tests-lib/tget_element_in_list_timecomplexity.c: Made tget_element_in_list_timecomplexity test be skipped instead of failure Whenever this complexity check does not pass, it returns a code meaning SKIP instead of FAIL, so as not to disturb users or Debian robots. This is similar to what is performed in tests-tool with the MAYFAIL_TESTS 2016-08-30 Sylvain Chevillard * configure.ac: Attempt to patch configure issue with fplll on Cygwin. The changes introduced at commit ea4ede2 break configure with some versions of fplll on Cygwin. Indeed, the option -std=g++11 was now systematically added when supported by the compiler, but it turns out that the compilation of some older versions of fplll under Cygwin raise an error when compiled with this option, although they compile fine without the option... This commit attempts to fix this issue by adding the -std=g++11 option only when the new API is detected, indicating that fplll is recent enough. 2016-08-30 Christoph Lauter * fpminimax.c, general.c, plot.c: Worked around some compiler warnings. 2016-08-30 Christoph Lauter * external.c, general.c, general.h, lexer.l, plot.c: Still trying to fix a strange issue with fork() and the input streams used for read. 2016-08-29 Sylvain Chevillard * fplll_wrapper.cpp: Support both old and new API for fplll. 2016-08-29 Sylvain Chevillard * Makefile.am, fplll_wrapper.cpp, fplll_wrapper.h, fpminimax.c, fpminimax.cpp: Separated C++ from C in fpminimax. 2016-08-29 Sylvain Chevillard * configure.ac: Prepared configure, so as to detect rather FPLLL should be used with the old API 2016-08-29 Sylvain Chevillard * configure.ac: Option -fPIC was given twice. 2016-08-26 Sylvain Chevillard * Makefile.am, general.c, sollya.h2m, version.h: Minor modifications to restore proper behavior of help2man It turns out that an innocent and small modification to Jerome Benoit's proposition when merging it back to the trunk at commit 972f2d6 was completely messing up the work of help2man. This commit restores a nice behavior. 2016-08-25 Sylvain Chevillard * tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Added non-regression test for bug #8867 2016-08-02 Sylvain Chevillard * execute.c, implement.c, infnorm.c, infnorm.h, remez.c: (Kind of) fixing bug [#8867] Possible infinite loop in Remez This led me to introduce a new argument to uncertifiedInfnorm that allows one to store an argmax. The patch is a patch over a patched algorithm, and all this does not really make sense any more. At least, this patch makes both examples reported in the bug report terminate. I have no proof of any kind that it completely patches the problem. 2016-08-02 Sylvain Chevillard * remez.c: Reworked verbosity levels for some messages of remez algorithm. 2016-08-14 Christoph Lauter * execute.c: Patched a minor issue with displaying of code elements in match - with constructs. 2016-08-05 Christoph Lauter * external.c, general.c, general.h, lexer.l, plot.c: Making the interworking between read and forking commands like plot extra-safe. 2016-07-27 Sylvain Chevillard * remez.c: Message "function oscillates too much" is displayed at most once per remez step. 2016-07-27 Sylvain Chevillard * remez.c, tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Fixed a subtle bug in remez When the function was not defined close after the right end-point of the domain, the algorithm could fall into a more or less infinite loop, trying to evaluate it again and again at points not in the domain. A non regression test was added. 2016-07-13 Sylvain Chevillard * general.c, main.c, sollya-library-wrappers.c: Updated copyrights and checked that PDF and PHP are synchonized. 2016-07-13 Sylvain Chevillard * doc/Makefile.am: Makes it possible to recompile the doc within a VPATH build 2016-07-13 Sylvain Chevillard * doc/Makefile.am: Make automake happy (it gives a special meaning to underscores) 2016-07-13 Sylvain Chevillard * doc/Makefile.am: Added source tex files into the distributed packages 2016-07-12 Sylvain Chevillard * library.c: Removed a warning. 2016-07-12 Sylvain Chevillard * .gitignore: Yet another update of .gitignore For files in tests-lib this time... 2016-07-12 Sylvain Chevillard * general.c, sollya.map, tests-lib/Makefile.am, tests-lib/tget_element_in_list.c, tests-lib/tget_element_in_list.reference, tests-lib/tget_element_in_list_timecomplexity.c, tests-lib/tget_element_in_list_timecomplexity.reference: Time-complexity checks in tests-lib independent from Sollya library In order to avoid declaring symbols in sollya.map that are useless except for the checks of the lib, I propose the following patch: - separate tests of tget_element_in_list into two separate files: one file is specifically for checking the time complexity. - this time check is performed only on systems where gettimeofday is available Right now, if gettimeofday is available the test is performed and may fail (as opposed to tests-tool/timecheck.sollya that is marked as 'SKIP' instead of 'FAIL' when it does not pass). Normally, the check for tget_element_in_list_timecomplexity is designed to be really robust and measure a theoretical complexity, so I am in favor of really marking it as 'FAIL' in case it does not pass. But notice that this behavior is easy to change if we wish. Normally, I should have removed everything that had been added to the source code specifically to make sollya_gettime available and usable in the tests of the lib. 2016-07-12 Sylvain Chevillard * Makefile.am, libsollyaexample.c: Removed libsollyaexample.c This file had been created initially to offer a panorama of how to used the library but it has never been really filled with something non-trivial. The idea remains good in itself but would require some work. Currently, the official documentation does the job and the test-lib/*.c files offer a lot of practical examples, more valuable than the current libsollyaexample.c 2016-07-12 Sylvain Chevillard * tests-tool/Makefile.am, tests-tool/check.proto: Less fragile support for timecheck timecheck is designed to be quite robust, but, by its nature may fail on some unusual architectures. This could be misleading to people that might think that they have a problem with their compilation of Sollya. An idea proposed by Jerome Benoit was to list it as XFAIL, but timecheck *is not* expected to fail: it is expected to pass, although, sometimes, it might not pass (notice that these situations are worth being reported). As a compromise, I propose in this patch simply to mark it as skipped when it does not pass. 2016-07-12 Sylvain Chevillard * .gitignore: Updated .gitignore with files produced my modern versions of automake 2016-07-11 Christoph Lauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/introExample51.tex, doc/remez.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/introExample51.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, help.h: Recompiled the documentation. 2016-07-10 Sylvain Chevillard * Makefile.am: Forgotten file in the EXTRA_DIST variable. 2016-07-10 Sylvain Chevillard * sollya.map: Modified sollya.map in order to allow the tool to compile again. 2016-07-10 Sylvain Chevillard * : Merge the one-commit branch devoted to directly linking the tool against the library 2016-06-08 Sylvain Chevillard * TODO_sollya5.0: Updated TODO file 2016-07-08 Sylvain Chevillard * : Merge sixth (and last) part of the patches proposed by Jerome Benoit 2016-07-06 Sylvain Chevillard * : Merge fifth part of the patches proposed by Jerome Benoit 2016-07-06 Sylvain Chevillard * : Merge fourth part of the patches proposed by Jerome Benoit 2016-07-05 Sylvain Chevillard * : Merge second part of the patches proposed by Jerome Benoit 2016-07-05 Christoph Lauter * Makefile.am: Made the Sollya tool be built out of the Sollya library. 2016-07-05 Christoph Lauter * plot.c: Patching a funny bug found on non-standard VT100 terminals (not enough memory). 2016-07-05 Christoph Lauter * Makefile.am, general.c, general.h, main.c, main.h: Started working on making the Sollya tool be just a wrapper of the Sollya library. 2016-07-05 Christoph Lauter * general.c: Reintegrating Jerome's patches for Debian into Sollya Master. There were serveral regressions induced by Jerome's patch, so we should run this commit by Jerome to see if he can integrate this commit into Debian, too. 2016-07-04 Sylvain Chevillard * xml.c: Minor modif to xml.c so as not to perturb our copyright helper script. 2016-07-04 Sylvain Chevillard * libsollyaexample.c: Updated libsollyaexample.c so as to compile. We should definitely think of the status of this file before next release. 2016-07-04 Sylvain Chevillard * Makefile.am: Removed lines that have been commented by Jerome Benoit. If they are useless, there is no need to keep them as a comment. If they turn out to be useful for some reason, we can always revert the change. Also, I did not remove the carriage return introduce by Jerome Benoit in Makefile.am before the -version-info flag. I assume he introduced it for some reason (maybe to prepare the use of version script?). I wonder why he removed $(AM_LDFLAGS) however. I would think we introduced it for some reason in the first place. The proof of the pudding is in the eating: let us see if we manage to compile everywhere without this parameter. 2016-07-04 Sylvain Chevillard * general.c, parser.y, version.h: Corrected an error introduced in previous commit. Contrary to what one could think at first sight, both version messages were not perfectly identical. This led to some globbish in the displayed message. Now, both version messages are the same. Also, some indentation problem was introduced in previous commit and is now fixed. 2016-07-04 Sylvain Chevillard * ChangeLog, doc/annotatefunction.shlp, doc/annotatefunction.tex, doc/autodiff.shlp, doc/autodiff.tex, doc/chebyshevform.shlp, doc/chebyshevform.tex, doc/evaluate.shlp, doc/evaluate.tex, doc/implementconstant.shlp, doc/implementconstant.tex, doc/rationalapprox.shlp, doc/rationalapprox.tex, doc/remez.shlp, doc/remez.tex, doc/return.shlp, doc/return.tex, doc/sollya.tex, doc/taylor.shlp, doc/taylor.tex, doc/taylorform.shlp, doc/taylorform.tex, doc/www/annotatefunction.php, doc/www/autodiff.php, doc/www/chebyshevform.php, doc/www/evaluate.php, doc/www/implementconstant.php, doc/www/rationalapprox.php, doc/www/remez.php, doc/www/return.php, doc/www/sollya.php, doc/www/taylor.php, doc/www/taylorform.php, help.h: Reported spelling corrections into doc source files. Based on the suggestions made by Jerome Benoit for the Debian team on previous commits. We accept all proposed corrections except for ChangeLog which is an automatically generated file from the commit messages: if there are spelling errors in the commit messages, that is too bad, but it is the way it is and there is no reason to change it in the generated ChangeLog. 2016-07-04 Christoph Lauter * sollya.h: Removed a superfluous function declaration from the Sollya library. 2016-07-02 Jerome Benoit * sollya.map: upstream-07-autotools-ld_version_script (forgotten piece) Forgotten piece (but essential one) for the previous commit. 2016-07-02 Jerome Benoit * Makefile.am, configure.ac, sollya-library-wrappers.c: upstream-07-autotools-ld_version_script Description: autotools machinery: libtoolization: version script support Provides version scripts [1] for the sollya library. Originally the map (or version script) was basically generated from the package header sollya.h with the help of cproto(1). Afterwards some functions were renamed in view to used a wildcard in the version scrit in view to ease maintenance. The version script was modified by hand to add some timing related functions used in one of the tests; it is assumed that these functions are of usage interest. Meant to be submitted to the upstream maintainer team. [1] https://www.gnu.org/software/gnulib/manual/html_node/LD-Version-Scripts.htmlOrigin: debian Author: Jerome Benoit Last-Update: 2016-06-24 2016-07-02 Jerome Benoit * Makefile.am, configure.ac, sollya.h2m: upstream-06-autotools-help2man Description: autotools machinery: help2man Introduce autotools material to generate on the fly the manpage for the interactive tool sallya; meant to be submitted to the upstream maintainer team. Origin: debian Author: Jerome Benoit Last-Update: 2016-06-24 2016-07-02 Jerome Benoit * Makefile.am, tests-lib/Makefile.am: upstream-05-autotools-revisit.patch Description: autotools machinery: revisit Attempt to rationalize the autotools machinery to ease maintenance and further modifications; meant to be submitted to the upstream maintainer team. Origin: debian Author: Jerome Benoit Last-Update: 2016-06-24 2016-07-02 Jerome Benoit * general.c: upstream-04-source-C2help2man Description: format usages, helps and version material. Attempt to format and harmonize the help message and to introduce a version message for the sollya interactive tool wrt UN*X customs in view to employ help2man to generate a manpage. The `make' and `man' GNU utilities were taken as example. Meant to be submitted to the upstream maintainer team. Origin: debian Author: Jerome Benoit Last-Update: 2016-06-24 2016-07-02 Jerome Benoit * Makefile.am, general.c, parser.y, version.h: upstream-03-source-version_h Description: source: version.h header: introduce Gather version information (as displayed through --version) in a unique header file to ease maintenance as help materail is gathered in the dedicated header file help.h ; minor spelling and layout corrections have been performed. Meant to be submitted to the upstream maintainer team. Origin: debian Author: Jerome Benoit Last-Update: 2016-06-24 2016-07-02 Jerome Benoit * README, assignment.c, assignment.h, autodiff.c, autodiff.h, bitfields.c, bitfields.h, chain.c, chain.h, chebyshevform.c, chebyshevform.h, chebyshevformaux.c, chebyshevformaux.h, double.c, double.h, execute.c, execute.h, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.cpp, fpminimax.h, general.c, general.h, hash.c, hash.h, help.h, hooks.c, hooks.h, implement.c, implement.h, implementconst.c, implementconst.h, infnorm.c, infnorm.h, integral.c, integral.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, libsollyaexample.c, main.c, main.h, match.c, match.h, minilexer.l, miniparser.y, mpfi-compat.c, mpfi-compat.h, parser.y, plot.c, plot.h, polynomials.c, polynomials.h, printf.c, printf.h, proof.c, proof.h, remez.c, remez.h, signalhandling.c, signalhandling.h, sollya-library-wrappers.c, sollya-library-wrappers.h, sollya-messages.h, sollya-messaging.c, sollya-messaging.h, sollya.h, sturm.c, sturm.h, supnorm.c, supnorm.h, taylor.c, taylor.h, taylorform.c, taylorform.h, tests-lib/timplementpoly.reference, tests-lib/tv_implementpoly.reference, worstcase.c, worstcase.h, xml.c, xml.h: upstream-02-lintian-spelling-error-silence--massive Description: source typo Correct massively the spelling error `automatized' --> `automated' as reported by lintian in some binraries; meant to silence lintian and eventually to be submitted to the upstream maintainer team. Origin: debian Comment: spelling-error-in-binary Author: Jerome Benoit Last-Update: 2016-06-18 2016-07-02 Jerome Benoit * README, assignment.c, assignment.h, autodiff.c, autodiff.h, bitfields.c, bitfields.h, chain.c, chain.h, chebyshevform.c, chebyshevform.h, chebyshevformaux.c, chebyshevformaux.h, double.c, double.h, execute.c, execute.h, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.cpp, fpminimax.h, general.c, general.h, hash.c, hash.h, help.h, hooks.c, hooks.h, implement.c, implement.h, implementconst.c, implementconst.h, infnorm.c, infnorm.h, integral.c, integral.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, libsollyaexample.c, main.c, main.h, match.c, match.h, minilexer.l, miniparser.y, mpfi-compat.c, mpfi-compat.h, parser.y, plot.c, plot.h, polynomials.c, polynomials.h, printf.c, printf.h, proof.c, proof.h, remez.c, remez.h, signalhandling.c, signalhandling.h, sollya-library-wrappers.c, sollya-library-wrappers.h, sollya-messages.h, sollya-messaging.c, sollya-messaging.h, sollya.h, sturm.c, sturm.h, supnorm.c, supnorm.h, taylor.c, taylor.h, taylorform.c, taylorform.h, tests-lib/timplementpoly.reference, tests-lib/tv_implementpoly.reference, worstcase.c, worstcase.h, xml.c, xml.h: upstream-01-lintian-spelling-error-silence--massive Description: source typo Correct massively the spelling error `particularily' --> `particularly' as reported by lintian in some binraries; meant to silence lintian and eventually to be submitted to the upstream maintainer team. Origin: debian Comment: spelling-error-in-binary Author: Jerome Benoit Last-Update: 2016-06-18 2016-07-02 Jerome Benoit * ChangeLog, chebyshevform.c, double.c, externalfun.c, fpminimax.cpp, general.c, help.h, implement.c, infnorm.c, library.c, remez.c, sollya-messaging.h, supnorm.c, taylorform.c, tests-lib/timplementpoly.c, tests-lib/timplementpoly.reference, tests-lib/tv_implementpoly.c, tests-lib/tv_implementpoly.reference, worstcase.c: upstream-00-lintian-spelling-error-silence Description: source typo Correct spelling errors as reported by lintian in some binraries; meant to silence lintian and eventually to be submitted to the upstream maintainer team. Origin: debian Comment: spelling-error-in-binary Author: Jerome Benoit Last-Update: 2016-06-18 2016-06-15 Sylvain Chevillard * doc/www/sollya.php: Forgot an update of copyright... PDF and PHP are synchronized. 2016-06-14 Sylvain Chevillard * tests-lib/tget_element_in_list.c: Made the timing tests for tget_element_in_list more robust. 2016-06-14 Christoph Lauter * configure.ac: Trying to live without the -f option of readlink. 2016-06-14 Christoph Lauter * general.c: Working on __unique_id 2016-06-13 Christoph Lauter * ChangeLog: New ChangeLog. 2016-06-13 Christoph Lauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/remez.tex, doc/time.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, help.h: Recompiled the documentation. 2016-06-13 Sylvain Chevillard * README: Slight update of README file 2016-06-13 Sylvain Chevillard * NEWS, doc/concat.shlp, doc/concat.tex, doc/www/concat.php, help.h: Modified the doc of "@" to mention its usage with external procedures. Slightly modified the NEWS file. 2016-06-13 Sylvain Chevillard * TODO_sollya5.0: Updated TODO file 2016-06-13 Christoph Lauter * NEWS: New NEWS file. 2016-06-13 Christoph Lauter * : Recompiled the pdf. 2016-06-13 Sylvain Chevillard * configure.ac, doc/sollya.tex, doc/www/sollya.php, general.c, help.h, parser.y: Still some updates of copyrights + correction of a bug affecting the string explaining what version of fplll is installed. Also replaced empty lines by a space followed by '\n' in help.h, to prevent formatting of the copyright to be destroyed each time shlp2txt.sh is run. 2016-06-13 Christoph Lauter * NEWS: Started working on new NEWS file. 2016-06-13 Christoph Lauter * configure.ac, doc/sollya.tex, doc/www/sollya.php: Changed slightly the copyright messages. 2016-06-10 Christoph Lauter * AUTHORS, configure.ac, doc/bashevaluate.tex, doc/bashexecute.tex, doc/implementconstant.shlp, doc/implementconstant.tex, doc/remez.tex, doc/sollya.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/implementconstant.php, doc/www/remez.php, doc/www/sollya.php, doc/www/time.php, doc/www/timing.php, general.c, help.h, parser.y, tests-lib/timplementpoly.reference, tests-lib/tv_implementpoly.reference: Updated some files with respect to the copyright changes. Made the tests pass again. Recompiled the documentation. 2016-06-10 Sylvain Chevillard * assignment.c, assignment.h, autodiff.c, chain.c, chain.h, doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php, double.c, execute.c, execute.h, expression.c, expression.h, fpminimax.cpp, general.c, general.h, hash.c, help.h, hooks.c, implement.c, implementconst.c, infnorm.c, infnorm.h, internlexer.l, internparser.y, lexer.l, library.c, minilexer.l, miniparser.y, mpfi-compat.c, mpfi-compat.h, parser.y, plot.c, polynomials.c, polynomials.h, printf.c, remez.c, remez.h, signalhandling.c, signalhandling.h, sollya-library-wrappers.c, sollya-messages.h, sollya-messaging.h, sollya.h, sturm.c, sturm.h, supnorm.c, xml.c: Updated the copyrights 2016-06-08 Christoph Lauter * Makefile.am: Updated version info. 2016-06-07 Christoph Lauter * : commit 8125941fe5009c3f14f9fb4630c4dbbdfe878d7e Author: Christoph Lauter Date: Tue Jun 7 21:30:55 2016 +0200 2016-06-07 Sylvain Chevillard * tests-tool/check010.sollya, tests-tool/check010.sollya.reference: Non-regression test for bug [#20369] Double-rounding issue with round() operator 2016-06-07 Christoph Lauter * execute.c, expression.c: Finally understood and patched the complexity problem in get_element_in_list. 2016-06-07 Christoph Lauter * sollya-library-wrappers.c: Patching a memory leak. Trying to understand a complexity issue with get_element_in_list. 2016-06-07 Christoph Lauter * polynomials.c: Working for compiler happiness. 2016-06-07 Christoph Lauter * general.c: Patched bugs in reimplementation of dup2. 2016-06-06 Sylvain Chevillard * tests-lib/tget_element_in_list.c: Modified the tests of tget_element_in_list in order to avoid calls to gettimeofday 2016-06-06 Christoph Lauter * general.c, tests-lib/tget_element_in_list.c: A small update to the timing mechanisms. 2016-06-06 Christoph Lauter * : commit 2cf04d3583e94476779ff9a253cdc6745eab2bae Author: Christoph Lauter Date: Mon Jun 6 19:21:09 2016 +0200 2016-06-06 Sylvain Chevillard * configure.ac, double.c, external.c, plot.c, printf.c, tests-lib/tprintf.c: Removed a warning about _BSD_SOURCE 2016-06-06 Sylvain Chevillard * configure.ac: Stricter tests for functions and headers tested by configure. Normally Sollya's configure should now abort in pretty much every case where we cannot compile. 2016-06-06 Christoph Lauter * plot.c: Protected a variable declaration. 2016-06-06 Christoph Lauter * plot.c: Checking for the presence of a header file. 2016-06-06 Christoph Lauter * : commit 2ea8a8a3b3bc478e12b6d76c8e4bf9c16c0721a1 Author: Christoph Lauter Date: Mon Jun 6 16:58:58 2016 +0200 2016-06-06 Sylvain Chevillard * configure.ac: Removed the check for lib [fl]. On second thought it is not clear it is useful 2016-06-06 Christoph Lauter * : commit 644a6994acfd1f9e2edbdf52ee48b93d14cf2939 Author: Christoph Lauter Date: Mon Jun 6 16:15:48 2016 +0200 2016-06-06 Sylvain Chevillard * Makefile.am, configure.ac: Following suggestions from libtoolize. 2016-06-06 Sylvain Chevillard * plot.c: Removed an include that seems useless. 2016-06-06 Sylvain Chevillard * configure.ac: Updated configure.ac after suggestions of autoscan 2016-06-06 Christoph Lauter * configure.ac, general.c: Removed an unused function from the configure list. 2016-06-06 Christoph Quirin Lauter * configure.ac: Corrected a mistake in configure. 2016-06-06 Christoph Lauter * signalhandling.c: Added a comment. 2016-06-01 Christoph Quirin Lauter * fpminimax.cpp, internlexer.l, lexer.l, minilexer.l, mpfi-compat.c, mpfi-compat.h: Patching bugs found on kosmos. 2016-05-31 Christoph Lauter * general.c: Patching an issue found on fuchs (Raspberry 3) 2016-05-31 Christoph Lauter * configure.ac, signalhandling.c: Got rid of last warnings on Cygwin. 2016-05-31 Sylvain Chevillard * tests-lib/tconstruct_function.c, tests-lib/tconstruct_function.reference, tests-lib/tget_nth_subfunction.c, tests-lib/tget_nth_subfunction.reference, tests-lib/tv_construct_function.c, tests-lib/tv_construct_function.reference: Updated tests for construct_function and get_nth_subfunction... ... so as to reflect the new behavior of construct_function with constant pi and to avoid possible segfault due to the fact that we do not provide enough argument. Also, for get_nth_subfunction, since we now officially support to feed it with NULL, the case is now tested. 2016-05-31 Sylvain Chevillard * doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php: Updated the doc * new behavior of sollya_lib_construct_function with SOLLYA_BASE_FUNC_PI * made the section about faithful evaluation clearer. In particular, explicitly mention the possibility of using sollya_lib_apply. PDF and Php are checked to be synchronized. 2016-05-31 Christoph Lauter * execute.c, signalhandling.c: Correcting two small issues. 2016-05-31 Christoph Lauter * execute.c, signalhandling.c: Working on the signalhandling issue on Cygwin. 2016-05-31 Christoph Lauter * configure.ac, signalhandling.c: Starting to work on the sig* issue on Cygwin. 2016-05-31 Christoph Lauter * general.c: Finally solved gettimeofday issue for Cygwin. 2016-05-31 Christoph Lauter * configure.ac, execute.c, general.c, general.h: Trying to solve the issue with gettimeofday that we encountered on Cygwin. 2016-05-31 Christoph Lauter * expression.c, polynomials.c, tests-lib/tprintf.c: Corrected use of config.h header. 2016-05-31 Christoph Lauter * sollya-library-wrappers.c: Corrected several mistakes in sollya_lib_construct_function Improved several library functions with respect to NULL pointers. 2016-05-30 Sylvain Chevillard * doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php: Updated the documentation to reflect the recently introduced changes regarding subfunctions of pi. 2016-05-30 Sylvain Chevillard * tests-lib/tdecompose_function.reference, tests-lib/tget_subfunctions.reference, tests-lib/tv_decompose_function.reference, tests-lib/tv_get_subfunctions.reference: Fixed tests files after Chrsitoph's change of revision 91edf09 2016-05-30 Christoph Lauter * sollya-library-wrappers.c, tests-lib/tget_nth_subfunction.reference: Slightly changed behavior of decompose function family concerning pi. 2016-05-30 Christoph Lauter * : commit fc2a5bfa89edea079e1c4179ef3209617a1775b4 Author: Christoph Lauter Date: Mon May 30 16:22:50 2016 +0200 2016-05-27 Sylvain Chevillard * TODO_sollya5.0: Updated TODO file. 2016-05-30 Sylvain Chevillard * tests-lib/Makefile.am, tests-lib/tconstruct_function.c, tests-lib/tconstruct_function.reference, tests-lib/tv_construct_function.c, tests-lib/tv_construct_function.reference: Tests for sollya_lib_[v]_construct_function. 2016-05-27 Sylvain Chevillard * doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php: Documented sollya_lib_[v_]construct_function sollya.tex and sollya.php are checked to be synchronized. 2016-05-27 Sylvain Chevillard * tests-lib/Makefile.am, tests-lib/tget_nth_subfunction.c, tests-lib/tget_nth_subfunction.reference: Added tests for tget_nth_subfunction Tests do not pass anymore. 2016-05-27 Sylvain Chevillard * doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php: Documented sollya_lib_get_nth_subfunction 2016-05-30 Christoph Lauter * execute.c: Working around 1 (sic!) warning found on Cygwin with gcc -O3 -Wall -Wextra 2016-05-30 Christoph Lauter * infnorm.c: Working around warnings found with gcc, when compiling with -O3 -Wall -Wextra 2016-05-30 Christoph Lauter * infnorm.c, polynomials.c, tests-tool/timecheck.sollya: Working around warnings and problems found with clang when compiling with -O3 -Wall -Wextra 2016-05-30 Christoph Lauter * tests-lib/tbuild_function_libraryconstant.c, tests-lib/tbuild_function_libraryfunction.c, tests-lib/tdecompose_externalprocedure_with_data.c, tests-lib/tlibraryconstant.c, tests-lib/tlibraryfunction.c: Working around warnings found using a non-free compiler sold by a large processor vendor. 2016-05-28 Christoph Lauter * supnorm.c: Working around a warning emitted by clang. 2016-05-27 Christoph Lauter * sollya-library-wrappers.c, sollya.h: Some small adjustments to the Sollya library interface. 2016-05-27 Christoph Lauter * sollya-library-wrappers.c, sollya.h: Removed a function that seems to be useless (at least it can be emulated pretty easily). Sylvain is the person to blame if this removal was too much doing. 2016-05-26 Sylvain Chevillard * TODO_sollya5.0: Updated TODO file. 2016-05-26 Sylvain Chevillard * doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php: Documented sollya_lib_obj_is_externalprocedure PDF and PHP are synchronized. 2016-05-26 Sylvain Chevillard * tests-lib/Makefile.am, tests-lib/tis_absolute.c, tests-lib/tis_binary.c, tests-lib/tis_decimal.c, tests-lib/tis_default.c, tests-lib/tis_double_double_obj.c, tests-lib/tis_double_obj.c, tests-lib/tis_doubleextended_obj.c, tests-lib/tis_dyadic.c, tests-lib/tis_false.c, tests-lib/tis_file.c, tests-lib/tis_fixed.c, tests-lib/tis_floating.c, tests-lib/tis_halfprecision_obj.c, tests-lib/tis_hexadecimal.c, tests-lib/tis_honorcoeffprec.c, tests-lib/tis_off.c, tests-lib/tis_on.c, tests-lib/tis_perturb.c, tests-lib/tis_pi.c, tests-lib/tis_postscript.c, tests-lib/tis_postscriptfile.c, tests-lib/tis_powers.c, tests-lib/tis_quad_obj.c, tests-lib/tis_relative.c, tests-lib/tis_round_down.c, tests-lib/tis_round_to_nearest.c, tests-lib/tis_round_towards_zero.c, tests-lib/tis_round_up.c, tests-lib/tis_single_obj.c, tests-lib/tis_triple_double_obj.c, tests-lib/tis_true.c, tests-lib/tis_void.c, tests-lib/tobj_is_end_elliptic_list.c, tests-lib/tobj_is_error.c, tests-lib/tobj_is_externalprocedure.c, tests-lib/tobj_is_externalprocedure.reference, tests-lib/tobj_is_function.c, tests-lib/tobj_is_list.c, tests-lib/tobj_is_procedure.c, tests-lib/tobj_is_range.c, tests-lib/tobj_is_string.c, tests-lib/tobj_is_structure.c: Added tests for sollya_lib_obj_is_externalprocedure. 2016-05-25 Christoph Lauter * library.c: Patched a small problem with the deallocation function pointers for external procedures, library functions and library constants. 2016-05-25 Christoph Lauter * tests-lib/tcmp_objs_structurally.c, tests-lib/tcmp_objs_structurally.reference, tests-tool/Makefile.am, tests-tool/check030.sollya, tests-tool/check030.sollya.reference, tests-tool/libexternal_structural_cmp.c: Working to make tests run on Cygwin again. 2016-05-25 Sylvain Chevillard * TODO_sollya5.0: Updated TODO file 2016-05-24 Sylvain Chevillard * doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php: Clarify some points of the documentation of sollya_lib_decompose_*_with_data PHP and PDF still synchronized. 2016-05-24 Sylvain Chevillard * tests-lib/tbuild_function_libraryconstant_with_data.c, tests-lib/tbuild_function_libraryconstant_with_data.reference, tests-lib/tbuild_function_libraryfunction_with_data.c, tests-lib/tbuild_function_libraryfunction_with_data.reference, tests-lib/tdecompose_externalprocedure_with_data.c, tests-lib/tdecompose_externalprocedure_with_data.reference, tests-lib/tdecompose_libraryconstant_with_data.c, tests-lib/tdecompose_libraryconstant_with_data.reference, tests-lib/tdecompose_libraryfunction_with_data.c, tests-lib/tdecompose_libraryfunction_with_data.reference, tests-lib/texternalprocedure.c, tests-lib/texternalprocedure.reference, tests-lib/texternalprocedure_with_data.c, tests-lib/texternalprocedure_with_data.reference, tests-lib/tlibraryconstant_with_data.c, tests-lib/tlibraryconstant_with_data.reference, tests-lib/tlibraryfunction_with_data.c, tests-lib/tlibraryfunction_with_data.reference: Read and completed the tests of sollya_lib_*_with_data. Discovered a bug (therefore make check does not pass currently) 2016-05-24 Sylvain Chevillard * doc/externalproc.shlp, doc/externalproc.tex, doc/shlp2html.sh, doc/sollya.pdf, doc/www/externalproc.php, help.h: Small improvements to the formatting of the doc of externalproc 2016-05-20 Sylvain Chevillard * doc/sollya.tex, doc/www/sollya.php: Resynchronized sollya.php and sollya.tex. 2016-05-25 Christoph Lauter * configure.ac: The Cygwin stuff does not work on Linux. 2016-05-25 Christoph Lauter * configure.ac, general.c: Some improvements for Cygwin. 2016-05-24 Christoph Lauter * parser.y: Updated help help list. 2016-05-24 Sylvain Chevillard * tests-lib/texternalprocedure_with_data.c: Synchro with Christoph in order to debug a problem. 2016-05-24 Christoph Lauter * sollya-library-wrappers.c: Patched a small memory leak. 2016-05-24 Christoph Lauter * TODO_sollya5.0: Added an item on the TODO list. 2016-05-24 Christoph Lauter * sollya-library-wrappers.c, sollya.h: Corrected a mistake in sollya_lib_apply: the construction sollya_lib_apply(procedure, NULL) was impossible to use. 2016-05-24 Christoph Lauter * expression.c: Corrected a mistake in the code for rational simplifications. Expressions like a/1 now get simplified in all cases, independingly of the current precision prec. 2016-05-23 Christoph Lauter * execute.c: Improved printing of fractions with denominator 1. 2016-05-23 Christoph Lauter * expression.c: Patched two small bugs in a recursive function used to simplify expressions dirtily. 2016-05-20 Christoph Lauter * TODO_sollya5.0: New TODO. 2016-05-20 Christoph Lauter * : For some strange reason sollya.pdf became untracked. 2016-05-20 Christoph Lauter * TODO_sollya5.0, doc/bashevaluate.tex, doc/bashexecute.tex, doc/introExample51.tex, doc/remez.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/introExample51.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, help.h: Recompiled the documentation. Looked at the TODOs. 2016-05-20 Christoph Lauter * polynomials.c: Improved coeff() quite a bit. 2016-05-19 Christoph Lauter * sollya-library-wrappers.c, tests-tool/Makefile.am, tests-tool/external_structural_cmp.c, tests-tool/libexternal_structural_cmp.c: Making distributions using external_structural_cmp.c in the tools testing work again. I really like autohell, it's terribly understandable for humans. 2016-05-18 Sylvain Chevillard * doc/absolute.tex, doc/accurateinfnorm.tex, doc/and.tex, doc/annotatefunction.tex, doc/append.tex, doc/approx.tex, doc/asciiplot.tex, doc/autodiff.tex, doc/autosimplify.tex, doc/bashevaluate.tex, doc/bashexecute.tex, doc/bind.tex, doc/canonical.tex, doc/chebyshevform.tex, doc/checkinfnorm.tex, doc/coeff.tex, doc/composepolynomials.tex, doc/concat.tex, doc/default.tex, doc/degree.tex, doc/denominator.tex, doc/dieonerrormode.tex, doc/diff.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/dirtysimplify.tex, doc/display.tex, doc/divide.tex, doc/double.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/equal.tex, doc/error.tex, doc/evaluate.tex, doc/execute.tex, doc/expand.tex, doc/exponent.tex, doc/externalplot.tex, doc/externalproc.tex, doc/false.tex, doc/file.tex, doc/findzeros.tex, doc/fixed.tex, doc/floating.tex, doc/fpminimax.tex, doc/fullparentheses.tex, doc/function.tex, doc/ge.tex, doc/getbacktrace.tex, doc/getsuppressedmessages.tex, doc/gt.tex, doc/guessdegree.tex, doc/halfprecision.tex, doc/head.tex, doc/honorcoeffprec.tex, doc/hopitalrecursions.tex, doc/horner.tex, doc/implementpoly.tex, doc/in.tex, doc/inf.tex, doc/infnorm.tex, doc/integral.tex, doc/isbound.tex, doc/isevaluable.tex, doc/le.tex, doc/length.tex, doc/library.tex, doc/libraryconstant.tex, doc/lt.tex, doc/mantissa.tex, doc/max.tex, doc/mid.tex, doc/midpointmode.tex, doc/min.tex, doc/minus.tex, doc/mult.tex, doc/neq.tex, doc/nop.tex, doc/not.tex, doc/numberroots.tex, doc/numerator.tex, doc/objectname.tex, doc/off.tex, doc/on.tex, doc/or.tex, doc/parse.tex, doc/perturb.tex, doc/pi.tex, doc/plot.tex, doc/plus.tex, doc/points.tex, doc/postscript.tex, doc/postscriptfile.tex, doc/power.tex, doc/prec.tex, doc/precision.tex, doc/prepend.tex, doc/print.tex, doc/printdouble.tex, doc/printexpansion.tex, doc/printsingle.tex, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/quad.tex, doc/quit.tex, doc/rationalapprox.tex, doc/rationalmode.tex, doc/rd.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.tex, doc/remez.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/rn.tex, doc/round.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/roundingwarnings.tex, doc/ru.tex, doc/rz.tex, doc/searchgal.tex, doc/shlp2tex.sh, doc/showmessagenumbers.tex, doc/simplify.tex, doc/single.tex, doc/sort.tex, doc/subpoly.tex, doc/substitute.tex, doc/sup.tex, doc/supnorm.tex, doc/suppressmessage.tex, doc/tail.tex, doc/taylor.tex, doc/taylorform.tex, doc/taylorrecursions.tex, doc/time.tex, doc/timing.tex, doc/tripledouble.tex, doc/true.tex, doc/unsuppressmessage.tex, doc/var.tex, doc/verbosity.tex, doc/void.tex, doc/worstcase.tex, doc/write.tex, doc/xfreevariable.tex: Fixed (somehow) a bug related to the new skipping-of-output feature and recompiled the doc. 2016-05-18 Christoph Lauter * doc/absolute.tex, doc/accurateinfnorm.tex, doc/and.tex, doc/annotatefunction.tex, doc/append.tex, doc/approx.tex, doc/asciiplot.tex, doc/autodiff.tex, doc/autosimplify.tex, doc/bashevaluate.tex, doc/bashexecute.tex, doc/bind.tex, doc/canonical.tex, doc/chebyshevform.tex, doc/checkinfnorm.tex, doc/coeff.tex, doc/composepolynomials.tex, doc/concat.tex, doc/default.tex, doc/degree.tex, doc/denominator.tex, doc/dieonerrormode.tex, doc/diff.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/dirtysimplify.tex, doc/display.tex, doc/divide.tex, doc/double.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/equal.tex, doc/error.tex, doc/evaluate.tex, doc/execute.tex, doc/expand.tex, doc/exponent.tex, doc/externalplot.tex, doc/externalproc.tex, doc/false.tex, doc/file.tex, doc/findzeros.tex, doc/fixed.tex, doc/floating.tex, doc/fpminimax.tex, doc/fullparentheses.tex, doc/function.tex, doc/ge.tex, doc/getbacktrace.tex, doc/getsuppressedmessages.tex, doc/gt.tex, doc/guessdegree.tex, doc/halfprecision.tex, doc/head.tex, doc/honorcoeffprec.tex, doc/hopitalrecursions.tex, doc/horner.tex, doc/implementconstant.shlp, doc/implementconstant.tex, doc/implementpoly.tex, doc/in.tex, doc/inf.tex, doc/infnorm.tex, doc/integral.tex, doc/introExample51.tex, doc/isbound.tex, doc/isevaluable.tex, doc/le.tex, doc/length.tex, doc/library.tex, doc/libraryconstant.tex, doc/lt.tex, doc/mantissa.tex, doc/max.tex, doc/mid.tex, doc/midpointmode.tex, doc/min.tex, doc/minus.tex, doc/mult.tex, doc/neq.tex, doc/nop.tex, doc/not.tex, doc/numberroots.tex, doc/numerator.tex, doc/objectname.tex, doc/off.tex, doc/on.tex, doc/or.tex, doc/parse.tex, doc/perturb.tex, doc/pi.tex, doc/plot.tex, doc/plus.tex, doc/points.tex, doc/postscript.tex, doc/postscriptfile.tex, doc/power.tex, doc/prec.tex, doc/precision.tex, doc/prepend.tex, doc/print.tex, doc/printdouble.tex, doc/printexpansion.tex, doc/printsingle.tex, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/quad.tex, doc/quit.tex, doc/rationalapprox.tex, doc/rationalmode.tex, doc/rd.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.tex, doc/remez.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/rn.tex, doc/round.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/roundingwarnings.tex, doc/ru.tex, doc/rz.tex, doc/searchgal.tex, doc/showmessagenumbers.tex, doc/simplify.tex, doc/single.tex, doc/sort.tex, doc/subpoly.tex, doc/substitute.tex, doc/sup.tex, doc/supnorm.tex, doc/suppressmessage.tex, doc/tail.tex, doc/taylor.tex, doc/taylorform.tex, doc/taylorrecursions.tex, doc/time.tex, doc/timing.tex, doc/tripledouble.tex, doc/true.tex, doc/unsuppressmessage.tex, doc/var.tex, doc/verbosity.tex, doc/void.tex, doc/worstcase.tex, doc/write.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/implementconstant.php, doc/www/introExample51.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, doc/xfreevariable.tex, help.h: Recompiled the doc. 2016-05-18 Sylvain Chevillard * doc/shlp2txt.sh: Removed support for color in text mode when skipping lines of output in examples 2016-05-18 Sylvain Chevillard * doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh, doc/sollya.tex, doc/www/sollyacss.css: Added support for skipping lines of output in the examples of shlp files. In a #EXAMPLE section of a shlp file it is now possible to add a comment of the form /* Skip NN */ at the end of a line. The first NN lines of the output produced by this specific line will be removed and a warning will be displayed explaining that some lines have been removed. This feature is quite fragile because of the constraints imposed by the Verbatim environment in LaTeX. It will most probably fail if the (non removed part of the) output contains one of the characters '\', '~' or '|'. 2016-05-12 Christoph Lauter * library.c: Added missing Sollya keywords to the list in library.c. 2016-05-11 Christoph Lauter * : recompiled the pdf 2016-05-11 Sylvain Chevillard * TODO_sollya5.0, doc/sollya.tex: Some small modifications on the sections about creating library functions/constants and external procedures. Also fixed the "--" bug in the arguments of Sollya interactive tool. Finally, reverted a useless (and possibly confusing) change of Christoph in Table 5 "Testing the type of a Sollya object" 2016-05-11 Christoph Lauter * TODO_sollya5.0: New TODO file 2016-05-11 Christoph Lauter * TODO_sollya5.0: New TODO file 2016-05-11 Christoph Lauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/introExample51.tex, doc/remez.tex, doc/time.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/introExample51.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, help.h: Documentation work. 2016-05-11 Christoph Lauter * : commit d03cdedbac584b4d92a73bec3c4aeb505c406f23 Author: Christoph Lauter Date: Wed May 11 12:13:24 2016 +0200 2016-05-11 Sylvain Chevillard * doc/CommandsAndFunctions.tex, doc/keywords.def, doc/www/ListOfCommands.php, doc/www/xfreevariable.php, doc/xfreevariable.shlp, doc/xfreevariable.tex, help.h, parser.y: Added an explicit documentation for _x_ 2016-05-10 Christoph Lauter * TODO_sollya5.0, doc/keywords.def, sollya-library-wrappers.c, sollya.h: Removed certain deprecated functions from the Sollya library. Sylvain Chevillard, who authorized the removal by phone, assumes the full, entire responsability of this removal forever and until the end of time. Added new things to do in the TODO file. 2016-05-10 Christoph Lauter * TODO_sollya5.0: Added a list of undocumented functions in the Sollya library to the TODO file. 2016-05-10 Christoph Lauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/implementconstant.shlp, doc/implementconstant.tex, doc/implementpoly.shlp, doc/implementpoly.tex, doc/introExample51.tex, doc/library.shlp, doc/library.tex, doc/libraryconstant.shlp, doc/libraryconstant.tex, doc/remez.tex, doc/sollya.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/externalproc.php, doc/www/implementconstant.php, doc/www/implementpoly.php, doc/www/introExample51.php, doc/www/library.php, doc/www/libraryconstant.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, help.h: Documentation work. 2016-05-03 Sylvain Chevillard * TODO_sollya5.0, doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php: Modified the order of sections 10.5.* --> made it more logical (useful sections first, less used sections at the end) --> and made a new section to document sollya_lib_externalprocedure which was actually undocumented. 2016-05-03 Christoph Lauter * tests-tool/Makefile.am, tests-tool/check.proto, tests-tool/check030.sollya: Updated some mechanisms concerning testing. 2016-04-28 Sylvain Chevillard * tests-lib/tobj_is_range.c: Fixed a bad definition of the size of an array. For some obscure reason tobj_is_range had not been fully modified as the other files at commit 937a6c3. 2016-04-13 Sylvain Chevillard * .gitignore: Updated .gitignore to ignore tobj_is_procedure[.sh] 2016-04-13 Sylvain Chevillard * doc/sollya.tex, doc/www/sollya.php: Updated the doc of hash. * Present cmp_objs_structurally * Better explain situations when hashes are equal even though the objects are not structurally equal. PDF and PHP are synchronized. 2016-04-12 Sylvain Chevillard * TODO_sollya5.0: Updated TODO file 2016-04-12 Sylvain Chevillard * tests-lib/Makefile.am, tests-lib/tis_absolute.c, tests-lib/tis_binary.c, tests-lib/tis_decimal.c, tests-lib/tis_default.c, tests-lib/tis_double_double_obj.c, tests-lib/tis_double_obj.c, tests-lib/tis_doubleextended_obj.c, tests-lib/tis_dyadic.c, tests-lib/tis_false.c, tests-lib/tis_file.c, tests-lib/tis_fixed.c, tests-lib/tis_floating.c, tests-lib/tis_halfprecision_obj.c, tests-lib/tis_hexadecimal.c, tests-lib/tis_honorcoeffprec.c, tests-lib/tis_off.c, tests-lib/tis_on.c, tests-lib/tis_perturb.c, tests-lib/tis_pi.c, tests-lib/tis_postscript.c, tests-lib/tis_postscriptfile.c, tests-lib/tis_powers.c, tests-lib/tis_quad_obj.c, tests-lib/tis_relative.c, tests-lib/tis_round_down.c, tests-lib/tis_round_to_nearest.c, tests-lib/tis_round_towards_zero.c, tests-lib/tis_round_up.c, tests-lib/tis_single_obj.c, tests-lib/tis_triple_double_obj.c, tests-lib/tis_true.c, tests-lib/tis_void.c, tests-lib/tobj_is_end_elliptic_list.c, tests-lib/tobj_is_error.c, tests-lib/tobj_is_function.c, tests-lib/tobj_is_list.c, tests-lib/tobj_is_procedure.c, tests-lib/tobj_is_procedure.reference, tests-lib/tobj_is_range.c, tests-lib/tobj_is_string.c, tests-lib/tobj_is_structure.c: Added test for sollya_lib_tobj_is_procedure 2016-04-27 Christoph Lauter * tests-lib/texternalprocedure_with_data.c: Patching a memory leak in a test. 2016-04-27 Christoph Lauter * polynomials.c, tests-tool/check014.sollya.reference: Improved memory handling in polynomial code. 2016-04-27 Christoph Lauter * tests-tool/timecheck.sollya: Updating time test reference values for some systems. 2016-04-26 Christoph Lauter * general.c, polynomials.c, polynomials.h: Slightly improved memory handling in constants used in polynomials. 2016-04-26 Christoph Lauter * execute.c: Implemented "[#20284] Make == be aware of end-elliptic lists" No non-regression tests have been added. All existing tests run through fine; the corresponding behavior hence seems to be essentially untested. 2016-04-15 Christoph Lauter * polynomials.c: Patching a bug in structural comparisons of polynomials. 2016-04-15 Christoph Lauter * polynomials.c, tests-tool/check030.sollya, tests-tool/check030.sollya.reference: Adding tests for structural comparison of polynomials. 2016-04-12 Sylvain Chevillard * tests-tool/check030.sollya, tests-tool/check030.sollya.reference: Enhanced test for hash and structural comparison following Christoph' suggestions 2016-04-12 Christoph Lauter * execute.c, execute.h, polynomials.c: Patching a bug with an infinite recursion in the hashing of a constant polynomial. 2016-04-12 Sylvain Chevillard * .gitignore, tests-tool/Makefile.am, tests-tool/check030.sollya, tests-tool/check030.sollya.reference, tests-tool/external_structural_cmp.c: Tests for sollya_lib_cmp_objs_structurally and sollya_lib_hash 2016-04-12 Sylvain Chevillard * tests-tool/check030.sollya, tests-tool/check030.sollya.reference: Added a test for annotatefunction. 2016-04-11 Sylvain Chevillard * tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Tests for objectname. 2016-04-11 Sylvain Chevillard * TODO_sollya5.0, tests-lib/texecute_procedure.c, tests-lib/texecute_procedure.reference, tests-lib/tv_execute_procedure.c, tests-lib/tv_execute_procedure.reference: Added some complementary tests for execute_procedure and updated TODO file. 2016-04-11 Sylvain Chevillard * TODO_sollya5.0: Updated TODO file. execute has been added in library mode at dbebb71, documented at b53566d and tests have been added at 0af3bce. 2016-04-08 Sylvain Chevillard * TODO_sollya5.0: Updated TODO file. 2016-04-08 Sylvain Chevillard * tests-tool/check030.sollya, tests-tool/check030.sollya.reference: Changes in the checks for annotatefunction. Slightly modified the code of the tests for on Christoph's demand + added roundingwarnings=on. 2016-04-08 Christoph Lauter * hooks.c, infnorm.c, sollya-messages.h, sollya-messaging.h, tests-tool/check030.sollya.reference: Improved precision handling in evaluation hooks. 2016-04-06 Sylvain Chevillard * tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Added tests for getbacktrace 2016-04-06 Sylvain Chevillard * doc/getbacktrace.shlp, doc/getbacktrace.tex, doc/www/getbacktrace.php, help.h: Fixed a space typo in the doc of getbacktrace. 2016-04-06 Sylvain Chevillard * tests-tool/check030.sollya, tests-tool/check030.sollya.reference: Added some additional tests for annotatefunction. I am not sure that everything behaves as expected. To be discussed. 2016-04-06 Sylvain Chevillard * TODO_sollya5.0: Updated TODO file. 2016-03-21 Sylvain Chevillard * tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Further tests after bug [#20094] NaN comparisons do not work as expected. 2016-03-29 Christoph Lauter * autodiff.c, execute.c, execute.h, infnorm.c, tests-tool/check030.sollya.reference: Patched the last caching problem left with issue [#20071] Using annotatefunction leads to a unexpected approximation warning. 2016-03-18 Sylvain Chevillard * doc/equal.shlp, doc/equal.tex, doc/www/equal.php, help.h: Updated the doc of == to make it match better reality. 2016-03-18 Sylvain Chevillard * tests-tool/check024.sollya, tests-tool/check024.sollya.reference: Added tests for __unique_id. 2016-03-18 Christoph Lauter * general.c: Patching "[#20162] __unique_id is not unique". 2016-03-14 Christoph Lauter * polynomials.c: Corrected a mistake in structural vs. mathematical comparisons in constant values. 2016-03-11 Christoph Lauter * polynomials.c: Slight improvement to code for polynomials. 2016-03-02 Christoph Lauter * TODO_sollya5.0, doc/annotatefunction.tex, doc/bashevaluate.tex, doc/bashexecute.tex, doc/equal.tex, doc/introExample33.tex, doc/introExample51.tex, doc/remez.tex, doc/time.tex, doc/timing.tex, doc/www/annotatefunction.php, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/equal.php, doc/www/introExample33.php, doc/www/introExample51.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, execute.c, help.h, tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Patching bug [#20094] NaN comparisons do not work as expected. Added a non-regression test. Recompiled the documentation as the bug was discovered by reading the documentation. 2016-03-02 Christoph Lauter * execute.c, expression.c, polynomials.c, polynomials.h, tests-tool/check029.sollya.reference: Improved structural comparison. Made hexadecimal printing compatible with a strict interpretation of the C99 standard. 2016-02-29 Christoph Lauter * execute.c, execute.h, expression.h, polynomials.c, polynomials.h, sollya-library-wrappers.c: Some improvements to structural comparison. 2016-02-24 Christoph Lauter * infnorm.c: Improved evaluation with hooks a little bit. 2016-02-24 Christoph Lauter * tests-tool/check029.sollya, tests-tool/check029.sollya.reference, tests-tool/timecheck.sollya: Improved testing. 2016-02-23 Christoph Lauter * : commit 8275f848cdab68fb5c489c3a99b93c34e7fac3c5 Author: Christoph Lauter Date: Tue Feb 23 17:12:48 2016 +0100 2016-02-16 Sylvain Chevillard * TODO_sollya5.0: Updated TODO file 2016-02-23 Sylvain Chevillard * doc/annotatefunction.shlp, doc/annotatefunction.tex, doc/www/annotatefunction.php, help.h: Slight modification in the doc of annotatefunction. 2016-02-23 Christoph Lauter * doc/getbacktrace.shlp, doc/getbacktrace.tex, doc/www/getbacktrace.php, execute.c, help.h, tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Patched bug [#20070] getbacktrace does not conform to its documentation Non regression tests have been added. 2016-02-22 Sylvain Chevillard * doc/annotatefunction.shlp, doc/annotatefunction.tex, doc/getbacktrace.shlp, doc/getbacktrace.tex, doc/objectname.shlp, doc/objectname.tex, doc/www/annotatefunction.php, doc/www/getbacktrace.php, doc/www/objectname.php, help.h: Attempt to enhance the doc of annotatefunction, getbacktrace and objectname 2016-02-22 Sylvain Chevillard * doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh: Corrected a bug in shlp2* scripts When simulating an example whose code contains escaped characters such as '\n' or '\"', the string was evaluated which was of course not intended. As a result, in some case, the output of the simulation was wrong. This should now be fixed. After checking, the only file related to the bug was objectname.shlp (which was the file that made me discover the bug). 2016-02-22 Sylvain Chevillard * doc/sollya.tex, doc/www/sollya.php: Updated the doc about hashes. 2016-02-22 Sylvain Chevillard * doc/sollya.tex, doc/www/sollya.php: Small precisions in the documentation of __unique_id. 2016-02-22 Sylvain Chevillard * doc/sollya.tex, doc/www/sollya.php: Updated the doc for accounting changes in sollya_lib_printlibrarymessage. PHP and PDF are checked to be synchronized. 2016-02-22 Christoph Lauter * doc/annotatefunction.shlp, doc/annotatefunction.tex, doc/www/annotatefunction.php, help.h: Improved documentation for annotatefunction. 2016-02-22 Christoph Lauter * remez.c, tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Patched bug [#14451] guessdegree has a strange behavior on point intervals A non regression test has been added. 2016-02-22 Christoph Lauter * tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Added a non regression test for bug [#17196] Inconsistent behavior of evaluate The bug was already patched with commit 9f9d12d3dd8d7a5a058545350402973155159f3f 2016-02-22 Christoph Lauter * tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Added a non regression test for bug [#7085] Rounding to simple value with infinity overflow is wrong. 2016-02-22 Christoph Lauter * doc/sollya.tex, doc/www/sollya.php, sollya-library-wrappers.c: Reworked removal of init functions with arguments. Removed corresponding sections in documentation. 2016-02-19 Christoph Lauter * general.c, general.h, sollya-library-wrappers.c, sollya.h, tests-lib/Makefile.am, tests-lib/tinit_with_arguments.c, tests-lib/tinit_with_arguments.reference, tests-lib/tinit_with_custom_memory_functions_with_arguments.c, tests-lib/tinit_with_custom_memory_functions_with_arguments.referen ce: Changed some of the library functions after discussion with Sylvain. 2016-02-18 Sylvain Chevillard * doc/sollya.tex, doc/www/sollya.php: A typo in the doc + unification of the way we reference sections in the php doc 2016-02-18 Sylvain Chevillard * doc/sollya.tex, doc/www/sollya.php: Typos in the doc. PHP and PDF stay synchronized. 2016-02-18 Sylvain Chevillard * configure.ac, tests-lib/check.proto: Final form for the special printf test on systems like Ubuntu. Should finally fix bug [#17198]. 2016-02-18 Sylvain Chevillard * tests-lib/check.proto, tests-lib/tprintf.c: Attempt to make tprintf skipped on systems like Ubuntu --> those systems that consider that a %n in a malloced string is dangerous 2016-02-18 Sylvain Chevillard * configure.ac: Slightly improved what is displayed in the test of %n 2016-02-18 Sylvain Chevillard * configure.ac: Add a #define for systems like Ubuntu that do not allow %n in malloced strings. 2016-02-17 Christoph Lauter * tests-lib/tend_elliptic_list.c, tests-lib/tlist.c: Working against compiler bugs. 2016-02-17 Sylvain Chevillard * doc/sollya.tex, doc/www/sollya.php: Changed a little bit the way sollya_lib_decompose_*_with_data are displayed in the doc. Also recompiled the doc. PDF and PHP are still checked to be synchronized. 2016-02-17 Sylvain Chevillard * doc/www/help.php, doc/www/sollya.php: Made php doc compliant with W3C standards (HTML and CSS). 2016-02-17 Sylvain Chevillard * doc/sollya.tex, doc/www/sollya.php: Checked the doc in tex and php format. Also unified the use of a initial capital letter in the word "section" when referring to a given section. sollya.tex and sollya.php are now checked to be synchronized. 2016-02-16 Sylvain Chevillard * tests-lib/tend_elliptic_list.c, tests-lib/tlist.c, tests-lib/tprintdouble.c, tests-lib/tprintf.c, tests-lib/tprintsingle.c: Removing some warnings in the compilation of the library tests. 2016-02-16 Christoph Lauter * printf.c: Validating the commit 55d14a9807223f0088458dd46bc8736e27ed3b5d and unifying the code. 2016-02-16 Sylvain Chevillard * tests-tool/Makefile.am, tests-tool/check.proto: Patched a problem occuring with VPATH builds. The *.output generated files used to contaminate the source directory. 2016-02-16 Sylvain Chevillard * sollya-library-wrappers.c: Patched a warning. 2016-02-16 Sylvain Chevillard * infnorm.c, printf.c: Patched some warning issues. Double-checking would be good. 2016-02-16 Sylvain Chevillard * chain.c: Removed some warnings. 2016-02-16 Sylvain Chevillard * tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Added non regression tests for bug [#19925] 2016-02-16 Sylvain Chevillard * tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Added non regression test for bug [#20056] 2016-02-16 Christoph Lauter * : commit 4877ffb68ddebde58141875ebb3faffab596b077 Author: Christoph Lauter Date: Tue Feb 16 10:17:48 2016 +0100 2016-02-16 Sylvain Chevillard * tests-tool/check018.sollya, tests-tool/check018.sollya.reference: Update check018 so as to work even on systems with small memory. 2016-02-16 Sylvain Chevillard * .gitignore: Updated .gitignore to ignore new test files of the lib. 2016-02-15 Sylvain Chevillard * configure.ac: Attempt to remove a warning when compiling under Ubuntu. Namely, on Ubuntu, I got the following warning: ar: `u' modifier ignored since `D' is the default (see `U') Accroding to the discussion on the following thread http://gnu-automake.7480.n7.nabble.com/bug-20082-new-warning-from-ar-on-rawhide-systems-td21769.htmlon the mailing list of automake, a safe patch seems to simply and manually set ar flags to 'cr' which I believe I do with this patch. Compiles without a warning on Ubuntu and my Fedora. 2016-02-15 Sylvain Chevillard * : commit 250d1a9bc985b0151f1b67c4c381435ff5b802a3 Author: Sylvain Chevillard Date: Mon Feb 15 17:33:24 2016 +0100 2016-02-15 Christoph Lauter * TODO_sollya5.0: Removed a point on the TODO list 2016-02-15 Christoph Lauter * : commit ff5fcb1afec3da8db79828429a5aecb3b9f25839 Author: Christoph Lauter Date: Mon Feb 15 14:39:15 2016 +0100 2016-02-15 Sylvain Chevillard * TODO_sollya5.0: Update TODO_sollya5.0 after this morning work. 2016-02-15 Sylvain Chevillard * : commit cfaaeca9549fd01c5b8060ee09865bafe4079846 Merge: 9abef82 fac5a55 Author: Sylvain Chevillard Date: Mon Feb 15 12:19:16 2016 +0100 2016-02-15 Sylvain Chevillard * README, configure.ac: Updated --enable-strict-lexer-parser-check tests in order to check for recent enough versions of bison. Also updated README so as to inform the user about what version of Bison is officially supported. 2016-02-15 Christoph Lauter * : commit 858b603a8de3641d165b8492aa21dc045c1c01ef Author: Christoph Lauter Date: Mon Feb 15 11:35:11 2016 +0100 2016-02-15 Sylvain Chevillard * TODO_sollya5.0: Update of TODO list. 2016-02-15 Sylvain Chevillard * tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Added non-regression test for [#19666] 2016-02-15 Sylvain Chevillard * : commit bc4e2a3d75600ba9b805a8210d1078aefb4499d5 Merge: 851ef00 3728734 Author: Sylvain Chevillard Date: Mon Feb 15 11:13:07 2016 +0100 2016-02-15 Sylvain Chevillard * remez.c: Adding an information message in a case of bisection in Newton's algorithm. 2016-02-15 Christoph Lauter * doc/dirtyfindzeros.shlp, doc/dirtyfindzeros.tex, doc/www/dirtyfindzeros.php, help.h: Added a phrase in the documentation that describes a case when dirtyfindzeros may return the same value twice. This is related to the bug [#11967] dirtyfindzeros returns the same zero twice 2016-02-12 Sylvain Chevillard * : commit 6742285c3d3732f275032238bbd82a69f140b4d5 Author: Sylvain Chevillard Date: Thu Feb 11 09:54:06 2016 +0100 2016-02-11 Sylvain Chevillard * : commit de5dae82e5564cebae98ed9ba57d747cbc2ac964 Author: Sylvain Chevillard Date: Wed Feb 10 19:41:06 2016 +0100 2016-02-10 Sylvain Chevillard * configure.ac: Changed configure.ac so as to ensure that the version of MPFR is >= 3.0.0 Indeed we check that mpfr_set_z_2exp is available because it is required in polynomials.c. This function has appeared with MPFR 3.0.0 2016-02-09 Christoph Lauter * general.c: Patched a very subtle bug in the way the custom memory functions are handled. 2016-02-08 Christoph Lauter * library.c: Patching a bug in displaying of external objects with data fields. 2016-02-08 Christoph Lauter * configure.ac: Making things work again under Debian. 2016-02-08 Christoph Lauter * : commit 8c0e108abd5205ed20e28defb9b3468066290604 Author: Christoph Lauter Date: Mon Feb 8 13:22:30 2016 +0100 2016-02-08 Sylvain Chevillard * TODO_sollya5.0: TODO file for releasing 5.0. 2016-02-05 Sylvain Chevillard * configure.ac, tests-lib/Makefile.am: Attempt to fix a bug introduced with the patch of bug [#17197] When mpfi was not available on a system-wise basis, but only on a prefix, the patch proposed at rev 2dc3e48 prevents the user from compiling libraryexample and aborts the checks of the lib. 2016-02-05 Christoph Lauter * configure.ac, polynomials.c: Trying to make Sollya work with old versions of GMP that do not have mp_bitcnt_t. 2016-02-03 Christoph Lauter * general.c, hash.c, printf.c, tests-lib/libraryexample.c, tests-lib/tbuild_function_libraryconstant_with_data.c, tests-lib/tbuild_function_libraryfunction_with_data.c, tests-lib/tdecompose_externalprocedure.c, tests-lib/tdecompose_externalprocedure_with_data.c, tests-lib/tdecompose_libraryconstant_with_data.c, tests-lib/tdecompose_libraryfunction_with_data.c, tests-lib/tlibraryconstant_with_data.c, tests-lib/tlibraryfunction_with_data.c: Working against compiler warnings. 2016-02-03 Christoph Lauter * library.c: Updated list of reserved keywords. This list should be double-checked by someone else at some point. 2016-02-03 Christoph Lauter * configure.ac, expression.h: Removed legacy support to compile Sollya without support for memory references. 2016-02-03 Christoph Lauter * doc/CommandsAndFunctions.tex, doc/getbacktrace.shlp, doc/getbacktrace.tex, doc/keywords.def, doc/objectname.shlp, doc/objectname.tex, doc/www/ListOfCommands.php, doc/www/getbacktrace.php, doc/www/objectname.php, help.h: Documented objectname. 2016-01-20 Christoph Lauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/display.tex, doc/introExample51.tex, doc/print.tex, doc/remez.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/display.php, doc/www/introExample51.php, doc/www/print.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, help.h: Recompiled the documentation. 2016-01-20 Christoph Lauter * sturm.c, tests-lib/tnumberroots.c, tests-lib/tnumberroots.reference, tests-tool/check013.sollya.reference: Patching "[#19976] A warning message is displayed at verbosity level 1 but does not endanger safety" 2016-01-13 Christoph Lauter * expression.c, tests-lib/tprintf.reference, tests-tool/check002.sollya.reference, tests-tool/check008.sollya.reference: Hexadecimal display mode: implemented the consistant behavior specified in the tracker #19925 Convention used for hexadecimal display. 2015-12-16 Christoph Lauter * expression.c, expression.h, infnorm.c: Added some additional checks before applying Taylor interval evaluation. 2015-12-16 Christoph Lauter * general.c, general.h, sollya-library-wrappers.c, sollya.h: Added Sollya library initialization functions with an additional argument to circumvent some of GMP's memory management behavior in a Sage binding for Sollya. 2015-12-15 Christoph Lauter * external.c, plot.c: Improved handling of temporary plot files in plot and externalplot. 2015-12-15 Christoph Lauter * general.c: Revert "Made plot files be removed unconditionnally." This reverts commit 3c42b090bb9953c5cc8fd590d96bebec97eb1a9d. 2015-11-20 Christoph Lauter * general.c: Made plot files be removed unconditionnally. 2015-11-20 Christoph Lauter * : Merging. 2015-11-20 Sylvain Chevillard * execute.c, tests-tool/check029.sollya, tests-tool/check029.sollya.reference: Patched a segfault bug in fpminimax. 2015-11-20 Christoph Lauter * doc/CommandsAndFunctions.tex, doc/bashevaluate.tex, doc/bashexecute.tex, doc/concat.shlp, doc/concat.tex, doc/getbacktrace.shlp, doc/getbacktrace.tex, doc/keywords.def, doc/proc.shlp, doc/proc.tex, doc/procedure.shlp, doc/procedure.tex, doc/remez.tex, doc/time.tex, doc/www/ListOfCommands.php, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/concat.php, doc/www/getbacktrace.php, doc/www/proc.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, help.h: Documentation work. 2015-11-20 Christoph Lauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/library.shlp, doc/library.tex, doc/libraryconstant.shlp, doc/libraryconstant.tex, doc/remez.tex, doc/sollya.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/externalproc.php, doc/www/library.php, doc/www/libraryconstant.php, doc/www/remez.php, doc/www/sollya.php, doc/www/time.php, help.h: Some documentation work. 2015-11-11 Marc Mezzarobba * sollya.h: "Strict prototypes" in sollya.h Make it possible to build modules that include sollya.h with -Wstrict-prototypes. 2015-11-19 Marc Mezzarobba * expression.c: Missing break; 2015-11-18 Christoph Lauter * execute.c: Added support for application of lists as arguments to external procedures using '@'. 2015-11-17 Christoph Lauter * execute.c, execute.h, library.c, library.h, sollya-library-wrappers.c, sollya.h, tests-lib/tbuild_function_libraryconstant_with_data.c, tests-lib/tbuild_function_libraryfunction_with_data.c, tests-lib/tdecompose_externalprocedure_with_data.c, tests-lib/tdecompose_externalprocedure_with_data.reference, tests-lib/tdecompose_libraryconstant_with_data.c, tests-lib/tdecompose_libraryconstant_with_data.reference, tests-lib/tdecompose_libraryfunction_with_data.c, tests-lib/tdecompose_libraryfunction_with_data.reference, tests-lib/texternalprocedure_with_data.c, tests-lib/tlibraryconstant_with_data.c, tests-lib/tlibraryfunction_with_data.c: Added deallocator to external functions, constants and libraries when they come with a data field. Added some support functions for the Python binding. 2015-11-17 Christoph Lauter * library.h: Forgotten file. 2015-11-17 Christoph Lauter * : commit ad8537bbd0ac93dcffa4ecd51abb397b574341db Author: Christoph Lauter Date: Tue Nov 17 10:53:04 2015 +0100 2015-11-16 Sylvain Chevillard * doc/www/sollya.php: Stupid typo in the php file. 2015-11-16 Sylvain Chevillard * doc/sollya.tex, doc/www/sollya.php: Corrected a typo in the doc + added the case of a BASE_FUNC_CONSTANT in decompose_function 2015-11-16 Marc Mezzarobba * doc/sollya.tex: tex preamble 2015-09-23 Christoph Lauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/introExample51.tex, doc/remez.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/introExample51.php, doc/www/remez.php, doc/www/time.php, help.h: Recompiled the documentation. 2015-09-23 Christoph Lauter * : Merge remote-tracking branch 'remotes/origin/libraryExtensions' 2015-09-23 Christoph Lauter * tests-lib/Makefile.am, tests-lib/tbuild_function_libraryconstant_with_data.c, tests-lib/tbuild_function_libraryconstant_with_data.reference, tests-lib/tdecompose_libraryconstant_with_data.c, tests-lib/tdecompose_libraryconstant_with_data.reference, tests-lib/tlibraryconstant_with_data.c, tests-lib/tlibraryconstant_with_data.reference: Added tests for library constants with a data field. 2015-09-23 Christoph Lauter * tests-lib/Makefile.am, tests-lib/tbuild_function_libraryfunction_with_data.c, tests-lib/tbuild_function_libraryfunction_with_data.reference, tests-lib/tdecompose_libraryfunction_with_data.c, tests-lib/tdecompose_libraryfunction_with_data.reference, tests-lib/tlibraryfunction_with_data.c, tests-lib/tlibraryfunction_with_data.reference: Testing for library functions with data field. 2015-09-23 Christoph Lauter * doc/sollya.tex, doc/www/sollya.php, sollya-library-wrappers.c, sollya.h: Documented sollya_lib_hash. Added stupid wrapper for evaluation 'at Sollya object'. 2015-09-21 Sylvain Chevillard * tests-tool/check020.sollya, tests-tool/check020.sollya.reference: Corrected the test introduced at revision 2c93e1a to make it independent of the version of MPFR used. 2015-09-17 Christoph Lauter * tests-lib/Makefile.am, tests-lib/libraryexample.c, tests-lib/tdecompose_externalprocedure.c, tests-lib/tdecompose_externalprocedure.reference: Added tests for sollya_lib_decompose_externalprocedure. 2015-09-17 Christoph Lauter * general.c: Preparing a custom interface for the SAGE wrapper. 2015-09-17 Christoph Lauter * tests-lib/texternalprocedure.c, tests-lib/texternalprocedure.reference: Made the test for sollya_lib_externalprocedure platform-independent. 2015-09-17 Christoph Lauter * doc/sollya.tex, doc/www/sollya.php: Again documentation work. 2015-09-17 Christoph Lauter * doc/annotatefunction.tex, doc/approx.tex, doc/asciiplot.tex, doc/autodiff.tex, doc/bashevaluate.tex, doc/bashexecute.tex, doc/boolean.shlp, doc/boolean.tex, doc/chebyshevform.tex, doc/composepolynomials.tex, doc/constant.shlp, doc/constant.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/dirtysimplify.tex, doc/divide.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/evaluate.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/floating.tex, doc/fpminimax.tex, doc/function.shlp, doc/function.tex, doc/guessdegree.tex, doc/hopitalrecursions.tex, doc/implementconstant.tex, doc/implementpoly.tex, doc/infnorm.tex, doc/integer.shlp, doc/integer.tex, doc/integral.tex, doc/introExample10.tex, doc/introExample12.tex, doc/introExample15.tex, doc/introExample17.tex, doc/introExample27.tex, doc/introExample32.tex, doc/introExample33.tex, doc/introExample38.tex, doc/introExample39.tex, doc/introExample40.tex, doc/introExample42.tex, doc/introExample43.tex, doc/introExample46.tex, doc/introExample51.tex, doc/introExample57.tex, doc/introExample8.tex, doc/isevaluable.tex, doc/length.tex, doc/library.shlp, doc/library.tex, doc/libraryconstant.shlp, doc/libraryconstant.tex, doc/listof.shlp, doc/listof.tex, doc/max.tex, doc/object.shlp, doc/object.tex, doc/pi.tex, doc/points.tex, doc/power.tex, doc/print.tex, doc/range.shlp, doc/range.tex, doc/rationalmode.tex, doc/remez.tex, doc/roundcorrectly.tex, doc/searchgal.tex, doc/showmessagenumbers.tex, doc/sollya.tex, doc/string.shlp, doc/string.tex, doc/subpoly.tex, doc/suppressmessage.tex, doc/taylorform.tex, doc/time.tex, doc/timing.tex, doc/tripledouble.tex, doc/unsuppressmessage.tex, doc/verbosity.tex, doc/void.shlp, doc/void.tex, doc/www/annotatefunction.php, doc/www/approx.php, doc/www/asciiplot.php, doc/www/autodiff.php, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/boolean.php, doc/www/chebyshevform.php, doc/www/composepolynomials.php, doc/www/constant.php, doc/www/dirtyfindzeros.php, doc/www/dirtyinfnorm.php, doc/www/dirtyintegral.php, doc/www/dirtysimplify.php, doc/www/divide.php, doc/www/doubledouble.php, doc/www/doubleextended.php, doc/www/evaluate.php, doc/www/externalproc.php, doc/www/floating.php, doc/www/fpminimax.php, doc/www/function.php, doc/www/guessdegree.php, doc/www/hopitalrecursions.php, doc/www/implementconstant.php, doc/www/implementpoly.php, doc/www/infnorm.php, doc/www/integer.php, doc/www/integral.php, doc/www/introExample10.php, doc/www/introExample12.php, doc/www/introExample15.php, doc/www/introExample17.php, doc/www/introExample27.php, doc/www/introExample32.php, doc/www/introExample33.php, doc/www/introExample38.php, doc/www/introExample39.php, doc/www/introExample40.php, doc/www/introExample42.php, doc/www/introExample43.php, doc/www/introExample46.php, doc/www/introExample51.php, doc/www/introExample57.php, doc/www/introExample8.php, doc/www/isevaluable.php, doc/www/length.php, doc/www/library.php, doc/www/libraryconstant.php, doc/www/listof.php, doc/www/max.php, doc/www/object.php, doc/www/pi.php, doc/www/points.php, doc/www/power.php, doc/www/print.php, doc/www/range.php, doc/www/rationalmode.php, doc/www/remez.php, doc/www/roundcorrectly.php, doc/www/searchgal.php, doc/www/showmessagenumbers.php, doc/www/string.php, doc/www/subpoly.php, doc/www/suppressmessage.php, doc/www/taylorform.php, doc/www/time.php, doc/www/timing.php, doc/www/tripledouble.php, doc/www/unsuppressmessage.php, doc/www/verbosity.php, doc/www/void.php, help.h: Some documentation work. 2015-09-16 Sylvain Chevillard * tests-tool/check020.sollya, tests-tool/check020.sollya.reference: Added a non-regression test for the bug fixed at rev 9f9d12d. See the comment in check020.sollya for more details about the history of this bug and the reason why this non-regression test is added only now and not before. 2015-09-16 Christoph Lauter * library.h, sollya-library-wrappers.c, sollya.h: Finished implementation work on extending the Sollya library for externalprocedures, libraryfunctions and libraryconstants. Testing and documentation work is still required. 2015-09-15 Christoph Lauter * autodiff.c, execute.c, expression.c, infnorm.c, library.c, library.h, sollya-library-wrappers.c, sollya.h, tests-lib/texternalprocedure.c, tests-lib/texternalprocedure.reference: Some progress with data field support for external procedures, library functions and library constants. 2015-09-15 Christoph Lauter * hash.c, tests-lib/thash.c, tests-lib/thash.reference: Better hashes. 2015-09-14 Christoph Lauter * assignment.c, execute.c, execute.h, expression.c, hash.c, hash.h, polynomials.c, polynomials.h, sollya-library-wrappers.c, sollya.h, tests-lib/Makefile.am, tests-lib/thash.c, tests-lib/thash.reference: Finished work on the hashing function for the Sollya library. 2015-09-14 Christoph Lauter * execute.c, execute.h, expression.h, general.c, general.h, hash.c, hash.h, library.c, library.h, sollya-library-wrappers.c, sollya.h, tests-lib/Makefile.am, tests-lib/texternalprocedure.c, tests-lib/texternalprocedure.reference: Added a way to bind external procedures to Sollya in library mode. Started working on a hashing function for Sollya Objects. 2015-09-11 Christoph Lauter * execute.c: Patched a small bug in 'round'. 2015-09-10 Christoph Lauter * Makefile.am, hash.c, hash.h: Started working on providing a hashing function in the Sollya library. 2015-09-09 Christoph Lauter * sollya-library-wrappers.c: Added a small additional check on the sollya_lib_init* functions to avoid double initializations. 2015-05-29 Christoph Lauter * expression.c, infnorm.c, polynomials.c, sollya-messages.h, sollya-messaging.h, tests-tool/check001.sollya.reference: Adressing bug [#18992] degree returns -1 instead of the degree without any warning. This commit changes the reference behavior of degree(0/x) to yield 0, as the reason given at commit 5029f0ed4e75bdee04c7b979030405e883ea30d2 is no longer true, because Sollya is now able to perform such simplifications. 2015-05-29 Christoph Lauter * expression.c, external.c: Avoiding compiler warnings. 2015-05-22 Sylvain Chevillard * configure.ac: Fixed deprecated == syntax in configure.ac tests (replaced it by =) 2015-05-21 Sylvain Chevillard * expression.c: Added a missing header. For some reason, on my computer, the fact that inttypes.h is not included before mpfr.h results in mpfr.h not declaring mpfr_get_sj. 2015-05-19 Sylvain Chevillard * tests-lib/Makefile.am: A comment about the line AM_CPPFLAGS = -I$(top_srcdir) introduced @2dc3e48ebc 2015-05-13 Christoph Lauter * expression.c, tests-lib/tappend.reference, tests-lib/tcheckinfnorm.reference, tests-lib/tcmp_equal.reference, tests-lib/tcmp_greater.reference, tests-lib/tcmp_greater_equal.reference, tests-lib/tcmp_in.reference, tests-lib/tcmp_less.reference, tests-lib/tcmp_less_equal.reference, tests-lib/tcmp_not_equal.reference, tests-lib/tconstant_from_double.reference, tests-lib/tdirtyinfnorm.reference, tests-lib/tdirtyintegral.reference, tests-lib/tdirtysimplify.reference, tests-lib/tevaluate_function_at_constant_expression.reference, tests-lib/tevaluate_function_at_point.reference, tests-lib/texecute.reference, tests-lib/tget_bounds_from_range.reference, tests-lib/tget_constant_as_double.reference, tests-lib/tget_constant_as_int.reference, tests-lib/tget_constant_as_int64.reference, tests-lib/tget_constant_as_mpq.reference, tests-lib/tget_constant_as_mpz.reference, tests-lib/tget_constant_as_uint64.reference, tests-lib/tget_interval_from_range.reference, tests-lib/tinf.reference, tests-lib/tintegral.reference, tests-lib/tinterval_list_ops.reference, tests-lib/tlength.reference, tests-lib/tmax.reference, tests-lib/tmid.reference, tests-lib/tmin.reference, tests-lib/tnumberroots.reference, tests-lib/tprecision.reference, tests-lib/tprepend.reference, tests-lib/tprocedurefunction.reference, tests-lib/trange_from_bounds.reference, tests-lib/trange_from_interval.reference, tests-lib/tsearchgal.reference, tests-lib/tsup.reference, tests-lib/tv_max.reference, tests-lib/tv_min.reference, tests-tool/check001.sollya.reference, tests-tool/check002.sollya.reference, tests-tool/check003.sollya.reference, tests-tool/check004.sollya.reference, tests-tool/check005.sollya.reference, tests-tool/check007.sollya.reference, tests-tool/check008.sollya.reference, tests-tool/check009.sollya.reference, tests-tool/check010.sollya.reference, tests-tool/check011.sollya.reference, tests-tool/check012.sollya.reference, tests-tool/check013.sollya.reference, tests-tool/check014.sollya.reference, tests-tool/check015.sollya.reference, tests-tool/check016.sollya.reference, tests-tool/check018.sollya.reference, tests-tool/check019.sollya.reference, tests-tool/check021.sollya.reference, tests-tool/check022.sollya.reference, tests-tool/check025.sollya.reference, tests-tool/check027.sollya.reference, tests-tool/check028.sollya.reference, tests-tool/check030.sollya.reference: Trying to fix the bug '[#12665] The practical complexity of decimal display is very bad'. 2015-05-11 Sylvain Chevillard * tests-lib/Makefile.am, tests-lib/check.proto, tests-tool/Makefile.am: Attempt to include the patch proposed by Jeff Arnold regarding bug #17197 2015-05-11 Sylvain Chevillard * tests-tool/check027.sollya, tests-tool/check027.sollya.reference: Non regression test for bug #18940. 2015-05-11 Christoph Lauter * execute.c: Correcting a small bug consisting in a superfluous warning message. 2015-05-08 Christoph Lauter * execute.c, external.c, general.c, general.h, implement.c, internlexer.l, lexer.l, minilexer.l, printf.c, signalhandling.c, signalhandling.h: Trying to improve the situation with respect to that f**g stupid 'contact with Houston lost' issue. 2015-05-07 Christoph Lauter * general.c: Improved terminal handling. 2015-03-12 Sylvain Chevillard * tests-tool/check016.sollya, tests-tool/check016.sollya.reference: Added non regression test for [#18746] Bug with pattern matching 2015-03-11 Christoph Lauter * execute.c: Patching "#18746 Bug with pattern matching". No regression test added, yet. 2015-03-06 Christoph Lauter * execute.c, sollya-messages.h, sollya-messaging.h, tests-lib/tget_bounds_from_range.c, tests-lib/tget_interval_from_range.c, tests-tool/check001.sollya.reference: Corrected a bug in a precision value displayed in a warning message and unified warning messages displayed for evaluation of ranges. All messages now make clear that the inclusion property is satisfied. 2015-03-04 Sylvain Chevillard * doc/proc.shlp, doc/proc.tex, doc/www/proc.php, help.h: Corrected a typo in the doc of proc. 2015-02-20 Christoph Lauter * tests-lib/tinit_with_custom_memory_functions_with_arguments.c, tests-lib/tinit_with_custom_memory_functions_with_arguments.referen ce: Finished testing of new functions in this branch libraryExtensions. 2015-02-20 Christoph Lauter * : Merge remote-tracking branch 'origin/master' into libraryExtensions Conflicts: doc/sollya.pdf help.h 2015-02-18 Sylvain Chevillard * infnorm.c, infnorm.h: Removed the implementation of sollya_mpfi_equal_p in infnorm.c The same function is already implemented in mpfi-compat.c 2015-02-13 Sylvain Chevillard * configure.ac: Corrected kind of a bug in configure when using --with-package without argument When --with-package is given to configure without any "=something" argument, the value of the argument defaults to "yes" which is non-sense in the purpose with which we use the --with-package option when configuring Sollya. Moreover, the extra "-Lyes" produced by configure in this case turns out to be a problem at compile time (though not at configure time) because libtool seems to be extra careful about it and checks that the directory given as argument of "-L" indeed exists. This commit patch this behavior by simply ignoring the --with-package directive when no argument or an empty argument is given. 2015-02-13 Sylvain Chevillard * doc/fpminimax.shlp, doc/fpminimax.tex, doc/www/fpminimax.php, help.h: * Corrected a typo in the doc of fpminimax (thx G. Revy for reporting it) 2015-02-13 Sylvain Chevillard * .gitignore: * Modified .gitignore so as to hide tests files. 2015-02-12 Christoph Lauter * doc/sollya.tex, doc/www/sollya.php: Corrected a bug in *.tex version and reported changes in *.tex version into *.php version. To be checked. 2015-02-11 Christoph Lauter * tests-lib/tinit_with_arguments.c: Improving the way to code a constant. 2015-02-11 Christoph Lauter * tests-lib/tinit_with_arguments.c, tests-lib/tinit_with_arguments.reference: Added testing for sollya_lib_init_with_arguments(). 2015-02-02 Christoph Lauter * tests-lib/texecute_procedure.c, tests-lib/texecute_procedure.reference, tests-lib/tv_execute_procedure.c, tests-lib/tv_execute_procedure.reference: Added tests for sollya_lib_execute_procedure and sollya_lib_v_execute_procedure. 2015-01-28 Christoph Lauter * tests-lib/texecute.c, tests-lib/texecute.reference: Adding a test for sollya_lib_execute(). 2015-01-28 Christoph Lauter * tests-lib/Makefile.am, tests-lib/texecute.c, tests-lib/texecute.reference, tests-lib/texecute_procedure.c, tests-lib/texecute_procedure.reference, tests-lib/tinit_with_arguments.c, tests-lib/tinit_with_arguments.reference, tests-lib/tinit_with_custom_memory_functions_with_arguments.c, tests-lib/tinit_with_custom_memory_functions_with_arguments.referen ce, tests-lib/tv_execute_procedure.c, tests-lib/tv_execute_procedure.reference: Starting work on testing for the new library functions. 2015-01-28 Christoph Lauter * doc/execute.shlp, doc/execute.tex, doc/sollya.tex, doc/www/execute.php, help.h: Some documentation work. The new texts in sollya.tex still need to be reported into sollya.php 2015-01-23 Christoph Lauter * : Merge remote-tracking branch 'origin/master' into libraryExtensions 2015-01-21 Christoph Lauter * expression.c: Patching memory allocation problems. 2015-01-20 Christoph Lauter * expression.c, infnorm.c, polynomials.c, tests-tool/timecheck.sollya: Patching memory leaks. 2015-01-14 Christoph Lauter * expression.c: Trying to patch a bug in differentiation of polynomials. 2014-12-15 Christoph Lauter * execute.h, sollya-library-wrappers.c, sollya.h: Added a test function sollya_lib_obj_is_procedure. 2014-12-01 Christoph Lauter * sollya-library-wrappers.c, sollya.h: Added support for calls to Sollya procedures from the Sollya library. Untested. 2014-11-28 Christoph Lauter * sollya-library-wrappers.c, sollya.h: Added library support for execute. Untested. 2014-11-28 Christoph Lauter * general.c, general.h, sollya-library-wrappers.c, sollya.h: Added support for argc, argv in library mode. (untested) 2014-11-26 Christoph Lauter * polynomials.c: Addressing -Wextra issues. 2014-11-26 Christoph Lauter * execute.c, hooks.c: Addressing some -Wall warnings. 2014-11-03 Christoph Lauter * infnorm.c: Adapted worst-case precision for hook evaluation in first-guess faithful rounded evaluation to a much lower level. 2014-10-31 Christoph Lauter * hooks.c, infnorm.c, tests-tool/check030.sollya.reference: Struggling agin with hook evaluation precisions. 2014-10-31 Christoph Lauter * hooks.c, infnorm.c, mpfi-compat.c, mpfi-compat.h: Still trying to optimize hook evaluation. 2014-10-30 Christoph Lauter * hooks.c, hooks.h, infnorm.c, tests-tool/check030.sollya.reference: Some improvements to hook evaluation. 2014-10-30 Christoph Lauter * expression.c: Small improvements to hook handling. 2014-10-29 Christoph Lauter * expression.c, tests-lib/tfpminimax.reference, tests-lib/tv_fpminimax.reference, tests-tool/check016.sollya.reference: Corrected a bug with Hornerization. 2014-10-28 Christoph Lauter * hooks.c: Being extra safe for hook evaluation. 2014-10-28 Christoph Lauter * expression.c, hooks.c, hooks.h, infnorm.c, tests-tool/check030.sollya.reference: Playing with required tightness of evaluation results for hooked functions. 2014-10-28 Christoph Lauter * infnorm.c, tests-tool/check030.sollya.reference: Precision setting for hook evaluation again. 2014-10-28 Christoph Lauter * execute.c, polynomials.c: Patched a bug in polynomial division. 2014-10-28 Christoph Lauter * hooks.c, infnorm.c, infnorm.h: Improving precision handling for hooks. 2014-10-28 Christoph Lauter * hooks.c, infnorm.c, tests-tool/check030.sollya.reference: Improved precision handling in hook evaluation. 2014-10-27 Christoph Lauter * hooks.c, tests-tool/check030.sollya.reference: Optimized function hook evaluation. 2014-10-27 Christoph Lauter * expression.c, sollya-library-wrappers.c, tests-lib/tsubstitute.reference: Better polynomial handling for particular cases. 2014-10-27 Christoph Lauter * hooks.c: Better behavior for composition of composed hooks. 2014-10-24 Christoph Lauter * tests-lib/tfpminimax.reference, tests-lib/tv_fpminimax.reference, tests-tool/check016.sollya.reference, tests-tool/timecheck.sollya: New reference values. 2014-10-24 Christoph Lauter * expression.c: A small test. 2014-10-24 Christoph Lauter * execute.c, expression.c, expression.h, hooks.c: Improved Hook handling. 2014-10-24 Christoph Lauter * expression.c, hooks.c, hooks.h, infnorm.c, infnorm.h, tests-tool/check030.sollya.reference: Hook recursion again. This should be fixed now --> finally! 2014-10-23 Christoph Lauter * execute.c: Still maintaining hooks in place. 2014-10-23 Christoph Lauter * execute.c, expression.h: Still trying to keep hooks alive for a longer period. 2014-10-23 Christoph Lauter * execute.c, execute.h, expression.c: Trying to keep annotations for a longer period. 2014-10-16 Christoph Lauter * general.c, general.h, remez.c: Prevented evaluation of a function over an interval when its result is just used to provoke the displaying of a message, which in turn, might be suppressed. 2014-10-15 Christoph Lauter * hooks.c: A small modification on a flag. 2014-10-15 Christoph Lauter * expression.c: Improved derivative hook evaluation even more. 2014-10-15 Christoph Lauter * expression.c, hooks.c, hooks.h, tests-tool/check030.sollya, tests-tool/check030.sollya.reference: Improved use of hooks for derivatives of functions that are repeatedly composed variants of hooked derivates of functions. 2014-10-15 Christoph Lauter * remez.c, tests-lib/tannotatefunction.reference, tests-lib/tv_annotatefunction.reference, tests-tool/check030.sollya.reference: Improved memory reference handling in remez. 2014-10-15 Christoph Lauter * expression.c, hooks.c, hooks.h, infnorm.c: Recursion again. 2014-10-15 Christoph Lauter * expression.c, hooks.c, infnorm.c, infnorm.h: Prevented recursion on certain annotations. 2014-10-14 Christoph Lauter * hooks.c, hooks.h: Trying to optimize precision handling in composition hooks. 2014-10-14 Christoph Lauter * hooks.c, hooks.h: Improved polynomial hook evaluation when the hooked function has a zero at a point that is not in zero. 2014-10-08 Christoph Lauter * infnorm.c: Improved precision handling in faithful evaluation code. 2014-10-07 Christoph Lauter * : Merging in local changes. commit 87c88704f9d12f8d00b978b0702df4062ef94bbd Author: Christoph Lauter Date: Tue Oct 7 18:22:13 2014 +0200 2014-09-21 Marc Mezzarobba * .gitignore: .gitignore 2014-10-06 Christoph Lauter * execute.c, expression.c, expression.h, polynomials.c, polynomials.h: Prevented memory reference looping in polynomial code. 2014-09-24 Christoph Lauter * library.c: Added new keywords to the Sollya keyword list. 2014-09-23 Christoph Lauter * execute.c: Made output of getbacktrace() reparsable. 2014-09-23 Christoph Lauter * execute.c, execute.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y, sollya-library-wrappers.c, sollya.h: Finishing backtrace() functionality. Untested; testing still required. 2014-09-22 Christoph Lauter * execute.c: Progress on backtrace() functionality. 2014-09-22 Christoph Lauter * execute.c, execute.h, general.c: Again progress with backtrace() functionality. 2014-09-22 Christoph Lauter * execute.c, execute.h, general.c, general.h: Continuing work on backtrace functionnality. 2014-09-22 Christoph Lauter * execute.c: Starting work on backtrace. 2014-09-22 Christoph Lauter * assignment.c, assignment.h, execute.c: Some progress with objectname() functionality. 2014-09-19 Christoph Lauter * infnorm.c: Making sure a function doesn't get evaluated outside its definition domain by MPFR newton. 2014-09-18 Christoph Lauter * expression.c, infnorm.c: Trying to make Hopital evaluation faster. 2014-09-18 Christoph Lauter * expression.c: Adding hook-based evaluation to legacy MPFR evaluation code. 2014-09-17 Christoph Lauter * assignment.c, assignment.h, execute.c, execute.h, expression.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y, sollya-library-wrappers.c, sollya.h: Starting to work on objectname and __this_proc_name features. 2014-09-12 Christoph Lauter * assignment.c: Added a comment on an idea on memory referencing. 2014-09-11 Christoph Lauter * expression.c: Again the hooks 2014-09-11 Christoph Lauter * expression.c: Still working on the hooks. 2014-09-11 Christoph Lauter * assignment.c, expression.c: Some improvements in hook handling. 2014-09-11 Christoph Lauter * expression.c, hooks.c, tests-tool/check030.sollya, tests-tool/check030.sollya.reference: Finished work necessary to keep hooks on functions when these functions are composed with other functions. 2014-09-10 Christoph Lauter * expression.c, hooks.c, hooks.h: Started work on extension of hook logic to allow for function composition when hooks are present. 2014-09-10 Christoph Lauter * hooks.c: Improved precision handling in polynomial hooks. 2014-09-08 Christoph Lauter * hooks.c: Allowing for better debug. 2014-09-08 Christoph Lauter * match.c: Putting some extra-safety net into legacy matcher code. 2014-09-04 Christoph Lauter * infnorm.c: Patched a nasty bug with simplification of rational functions that simplify to 1, when numerator and denominator are not structually the same polynomial and different from 1. 2014-08-28 Christoph Lauter * infnorm.c: Patched a huge bug in a function related to faithful evaluation. 2014-08-27 Sylvain Chevillard * tests-lib/tdirtyinfnorm.c: Removed variables that are useless since previous commit. 2014-08-27 Sylvain Chevillard * tests-lib/tdirtyinfnorm.c, tests-lib/tdirtyinfnorm.reference, tests-tool/check002.sollya, tests-tool/check002.sollya.reference, tests-tool/check008.sollya, tests-tool/check008.sollya.reference, tests-tool/check009.sollya, tests-tool/check009.sollya.reference, tests-tool/check012.sollya, tests-tool/check012.sollya.reference: Modified tests of dirtyinfnorm so as to test something like its semantics. 2014-08-27 Christoph Lauter * expression.c, polynomials.c: Patching a nasty bug in the polynomials. 2014-08-27 Christoph Lauter * tests-tool/timecheck.sollya: New timecheck to cope with newly observed values. 2014-08-26 Christoph Lauter * : commit 71d8673257018d179e497fd145ca0aec87c5f709 Author: Christoph Lauter Date: Tue Aug 26 17:06:07 2014 +0200 2014-08-26 Christoph Lauter * sollya-library-wrappers.c, tests-lib/tannotatefunction.c, tests-lib/tannotatefunction.reference: Added library testing for annotatefunction and patched a small incompatibility in the Sollya library. 2014-08-26 Christoph Lauter * tests-lib/Makefile.am, tests-lib/tannotatefunction.c, tests-lib/tannotatefunction.reference: Starting work on a library test for annotatefuntion. 2014-08-26 Christoph Lauter * tests-lib/tcmp_equal.c, tests-lib/tcmp_equal.reference, tests-lib/tcmp_not_equal.c, tests-lib/tcmp_not_equal.reference, tests-lib/tsubstitute.c, tests-lib/tsubstitute.reference: Updated tests and references as agreed to with Sylvain. 2014-08-26 Christoph Lauter * doc/autosimplify.shlp, doc/autosimplify.tex, doc/equal.shlp, doc/equal.tex, doc/neq.shlp, doc/neq.tex, doc/sollya.tex, doc/www/autosimplify.php, doc/www/equal.php, doc/www/neq.php, doc/www/sollya.php, help.h, sollya-library-wrappers.c: Updated documentation and added an extra safety test in sollya_lib_printmessage. 2014-08-26 Christoph Lauter * tests-lib/tdirtysimplify.reference, tests-lib/tevaluate_function_at_constant_expression.reference, tests-lib/tevaluate_function_at_point.c, tests-lib/tevaluate_function_at_point.reference, tests-lib/timplementpoly.reference, tests-lib/tv_implementpoly.reference: Updated test references after discussion with Sylvain. 2014-08-26 Christoph Lauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/remez.tex, doc/sollya.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/remez.php, doc/www/sollya.php, doc/www/time.php, doc/www/timing.php, help.h: Recompiled the documentation. 2014-08-26 Christoph Lauter * execute.c, expression.c, polynomials.c, tests-lib/tdiff.reference: Patched a bug in dirty simplification of polynomials. Updated a test file. 2014-08-26 Christoph Lauter * tests-tool/check003.sollya.reference, tests-tool/check011.sollya.reference, tests-tool/check013.sollya.reference, tests-tool/check018.sollya.reference, tests-tool/check019.sollya.reference, tests-tool/check024.sollya.reference: Updated test-tool reference file after discussion with Sylvain about the validity of that update. 2014-08-25 Christoph Lauter * execute.c, polynomials.c, tests-tool/check003.sollya: Reworking equality tests for polynomials. 2014-08-22 Christoph Lauter * tests-tool/timecheck.sollya: New timecheck. 2014-08-22 Christoph Lauter * execute.c, expression.c, expression.h: Patching a simplification bug where autosimplify is not respected for polynomials. 2014-08-22 Christoph Lauter * doc/annotatefunction.shlp, doc/annotatefunction.tex, doc/bashevaluate.tex, doc/bashexecute.tex, doc/equal.tex, doc/evaluate.tex, doc/implementconstant.tex, doc/introExample33.tex, doc/introExample34.tex, doc/introExample51.tex, doc/printsingle.tex, doc/remez.tex, doc/showmessagenumbers.tex, doc/sollya.tex, doc/taylor.tex, doc/taylorform.tex, doc/time.tex, doc/timing.tex, doc/www/annotatefunction.php, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/equal.php, doc/www/evaluate.php, doc/www/implementconstant.php, doc/www/introExample33.php, doc/www/introExample34.php, doc/www/introExample51.php, doc/www/printsingle.php, doc/www/remez.php, doc/www/showmessagenumbers.php, doc/www/sollya.php, doc/www/taylor.php, doc/www/taylorform.php, doc/www/time.php, doc/www/timing.php, help.h: Finished work on documentation for this branch. 2014-08-22 Christoph Lauter * doc/annotatefunction.shlp: Working on the documentation. 2014-08-22 Christoph Lauter * doc/annotatefunction.shlp, doc/annotatefunction.tex, doc/www/annotatefunction.php: Forgotten files. 2014-08-22 Christoph Lauter * doc/CommandsAndFunctions.tex, doc/keywords.def, doc/sollya.tex, doc/www/ListOfCommands.php, doc/www/sollya.php, help.h: Worked on documenting the new features of this branch. 2014-08-21 Christoph Lauter * execute.c, hooks.c: Patched two memory leaks. 2014-08-21 Christoph Lauter * infnorm.c, tests-tool/Makefile.am, tests-tool/check030.sollya, tests-tool/check030.sollya.reference: Added testing for annotatefunction functionnality and corrected a bug. 2014-08-21 Christoph Lauter * tests-tool/check030.sollya, tests-tool/check030.sollya.reference: Starting work on tests for the new annotate functionnality. 2014-08-09 Sylvain Chevillard * remez.c, remez.h: Some uncommitted optimization in Newton's algorithm that were forgotten. We set up these optimization with Mark and Christoph a while ago but that I forgot until now. If I remember well, these optimization did not change much the efficiency of Newton's algorithm by that time, but it could be different once the branch improvedEvaluate will be ported back onto the trunk. Also removed an old wrapper that is now useless. 2014-07-16 Christoph Lauter * : Merging master onto the branch 2014-07-09 Sylvain Chevillard * doc/sollya.tex, doc/www/sollya.php: Changed svn to git in the documentation titles. 2014-07-09 Sylvain Chevillard * README: Updated README from svn to git. 2014-07-09 Christoph Lauter * configure.ac: Changed name of development version from SVN trunk to git devel. 'devel' stands for 'development' and is no longer name of a branch as naming a branch has no longer a global meaning. 2014-07-08 clauter * general.c: Extended --args command prompt syntax. If the option order is non-ambiguous, the --args indication becomes optional. This commit was extracted from SVN r2321. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2321 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-07-07 clauter * compile.sh, expansion.c, expansion.h: Moved metalibm-related files to metalibm repository. This commit was extracted from SVN r2320. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2320 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-07-07 clauter * general.c: Added support to pass command line (bash) arguments to a Sollya script and added support for a unique id identifier in a Sollya session. This commit was extracted from SVN r2319. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2319 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-07-02 clauter * execute.c, polynomials.c: Patching a problem with autoprint and high-degree polynomials. This commit was extracted from SVN r2318. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2318 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-06-23 clauter * execute.c: Working against a spurious rounding. This commit was extracted from SVN r2317. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2317 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-06-02 clauter * signalhandling.c, signalhandling.h: Starting work to make memory-references signal-safe. This commit was extracted from SVN r2316. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2316 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-28 clauter * expression.h, infnorm.c, mpfi-compat.c, mpfi-compat.h: Improved result predicates for faithfully/correctly rounded evaluation. This commit was extracted from SVN r2315. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2315 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-27 clauter * infnorm.c: Worked for compiler happiness. This commit was extracted from SVN r2314. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2314 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-26 clauter * polynomials.c: Changed algorithm for powering of polynomials with constant expressions that are no rational constants from very slow to half-slow. The algorithm is nevertheless faster than what we had with expression handling. This commit was extracted from SVN r2313. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2313 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-26 clauter * expression.c, expression.h, polynomials.c: Re-removed useless code. This commit was extracted from SVN r2312. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2312 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-26 clauter * expression.c, expression.h, infnorm.c, polynomials.c, polynomials.h, tests-tool/check015.sollya, tests-tool/check015.sollya.reference: Some progress on evaluation and polynomials. This commit was extracted from SVN r2311. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2311 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-23 clauter * infnorm.c: Some issues subsist, some checks still fail. This commit was extracted from SVN r2310. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2310 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-23 clauter * execute.c, expression.h, infnorm.c: Again performance regression. Trying to adapt working precision on intervals is non-sense, actually. This commit was extracted from SVN r2309. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2309 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-22 clauter * polynomials.c: Worked against a performance regression for certain types of polynomials. This commit was extracted from SVN r2308. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2308 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-22 clauter * infnorm.c, infnorm.h: Working for compiler happiness. This commit was extracted from SVN r2307. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2307 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-22 clauter * infnorm.c, parser.y: Patched a bug and added support for library functions and procedure functions for fast faithful evaluation. This commit was extracted from SVN r2306. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2306 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-22 clauter * infnorm.c: Converted all faithful evaluation code to a style where MPFR initializations are amortized as long as possible. This commit was extracted from SVN r2305. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2305 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-21 clauter * infnorm.c: Corrected an improperly determined precision setting. This commit was extracted from SVN r2304. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2304 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-21 clauter * infnorm.c: Still some performance improvements. This commit was extracted from SVN r2303. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2303 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-21 clauter * infnorm.c: Removed a forgotten debug line. This commit was extracted from SVN r2302. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2302 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-21 clauter * general.c, general.h, infnorm.c: Preparing use of globally reused MPFR variables. This commit was extracted from SVN r2301. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2301 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-21 clauter * execute.c, expression.h, infnorm.c, polynomials.c: Some progress with evaluation of functions using pure MPFR arithmetic as long as possible. This commit was extracted from SVN r2300. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2300 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-21 clauter * infnorm.c: Some progress with evaluation of functions using pure MPFR arithmetic as long as possible. This commit was extracted from SVN r2299. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2299 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-20 clauter * infnorm.c: Some progress with evaluation of functions using pure MPFR arithmetic as long as possible. This commit was extracted from SVN r2298. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2298 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-05-20 clauter * execute.c, expression.c, expression.h, infnorm.c, mpfi-compat.c, mpfi-compat.h, polynomials.c, remez.c: Some progress with evaluation of functions using pure MPFR arithmetic as long as possible. This commit was extracted from SVN r2297. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2297 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-28 clauter * infnorm.c: Some progress on improved evaluation of functions over quasi-point intervals. This commit was extracted from SVN r2296. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2296 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-28 clauter * infnorm.c, mpfi-compat.c, mpfi-compat.h: Started working on improved evaluation of functions over quasi-point intervals. This commit was extracted from SVN r2295. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2295 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-28 clauter * AUTHORS, autodiff.c, autodiff.h, chebyshevform.c, chebyshevform.h, chebyshevformaux.c, chebyshevformaux.h, configure.ac, doc/implementconstant.tex, doc/implementpoly.tex, doc/precision.shlp, doc/precision.tex, doc/sollya.tex, doc/www/implementconstant.php, doc/www/implementpoly.php, doc/www/precision.php, doc/www/sollya.php, double.c, execute.c, expression.c, help.h, implement.c, internparser.y, miniparser.y, mpfi-compat.c, mpfi-compat.h, parser.y, remez.c, sollya-messages.h, sollya-messaging.h, sollya.h, sturm.c, supnorm.c, supnorm.h, taylorform.c, taylorform.h, tests-lib/timplementpoly.reference, tests-lib/tprintsingle.reference, tests-lib/tv_implementpoly.reference, tests-tool/check001.sollya.reference, tests-tool/check027.sollya, tests-tool/check027.sollya.reference: Merged trunk onto branch using svn merge -r 2207:2293 svn://scm.gforge.inria.fr/svn/sollya/trunk . This commit was extracted from SVN r2294. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2294 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-28 schevill * tests-lib/tprintsingle.reference: Same as rev2279, but from tests-lib side This commit was extracted from SVN r2293. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2293 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-23 schevill * infnorm.c: * Small modification of the number of guard bits used when computing x^(-k) where k is a non-negative integer, so as to reproduce the same behavior as before the optimization of sollya_lib_mpfi_pow. This commit was extracted from SVN r2292. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2292 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-23 clauter * expression.c, hooks.c, hooks.h, polynomials.c: Optimisations for the polynomials, patched a bug in polynomialGetDegree and added code to allow hooks to be copied. This commit was extracted from SVN r2291. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2291 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-23 clauter * expression.c: Patched a bug in isHorner. This commit was extracted from SVN r2290. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2290 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-23 clauter * execute.c, expression.c, polynomials.c, polynomials.h: Still improved polynomial handling quite a bit. This commit was extracted from SVN r2289. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2289 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-22 clauter * execute.c: Still some additional optimizations for the polynomials. This commit was extracted from SVN r2288. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2288 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-22 clauter * execute.h, expression.c, polynomials.c: Some small progress on polynomials. This commit was extracted from SVN r2287. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2287 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-22 clauter * infnorm.c: Avoiding a problem in the rare case when two MPFI arguments are the same MPFI variable. This commit was extracted from SVN r2286. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2286 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-22 clauter * double.c, execute.c, expression.c, general.c, polynomials.c, printf.c, remez.c: Avoided some warnings. This commit was extracted from SVN r2285. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2285 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-22 clauter * execute.c, polynomials.c: Changed some lines in the polynomial code. This commit was extracted from SVN r2284. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2284 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-22 clauter * infnorm.c: Synchro with Sylvain. This commit was extracted from SVN r2283. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2283 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-22 schevill * infnorm.c: * Wrote the same optimization for computing x^y when y is a negative integer as in the case when it is a non-negative integer. This commit was extracted from SVN r2282. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2282 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-22 clauter * infnorm.c: Improved sollya_mpfi_pow_ulong This commit was extracted from SVN r2281. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2281 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-22 clauter * infnorm.c: Improved sollya_mpfi_pow_ulong This commit was extracted from SVN r2280. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2280 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-22 schevill * tests-tool/check001.sollya.reference: * The patch at revision 2272 did not only fix a bug in the warning but also a double-rounding issue that was present from a very long time ago. Irony of history: a test was present in the checks precisely for this purpose, but the reference value had not been checked carefully enough and was wrong. So, to sum up: a bug has been fixed @2272 while we were not even aware of the presence of the bug. And the fact that the bug has been corrected has been detected by failure of routine checks during the weekly... This commit was extracted from SVN r2279. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2279 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-22 clauter * tests-tool/check013.sollya: Some progress again with the polynomials. The check013 fails and really seems to be bugged. This commit was extracted from SVN r2278. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2278 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-22 clauter * execute.c, execute.h, expression.c, polynomials.c, polynomials.h, tests-tool/check013.sollya: Some progress again with the polynomials. The check013 fails and really seems to be bugged. This commit was extracted from SVN r2277. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2277 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-17 clauter * execute.c, expression.c, expression.h, infnorm.c, polynomials.c: Again *some* progress with the polynomials. This commit was extracted from SVN r2276. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2276 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-16 clauter * expression.c, polynomials.c, polynomials.h: Some progress with the integration and debugging of the polynomials. This commit was extracted from SVN r2275. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2275 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-15 clauter * execute.c, expression.c, expression.h, polynomials.c, polynomials.h: Some progress with using polynomial annotations. This commit was extracted from SVN r2274. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2274 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-15 schevill * internparser.y, miniparser.y, parser.y: * Make Sollya's parser compatible with versions of Bison more recent than a century ago. This commit was extracted from SVN r2273. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2273 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-15 schevill * double.c, tests-tool/check027.sollya, tests-tool/check027.sollya.reference: * Simplified the code for displaying floats in hexa, and fixing in the same time a bug in the warning that was displayed when a rounding occurs. Also added non-regression tests. This commit was extracted from SVN r2272. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2272 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-15 schevill * expression.c: Patched a division-by-zero bug on the following example: p = ((1 + x)^3000); degree(diff(p)); This commit was extracted from SVN r2271. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2271 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-14 clauter * execute.c, expression.c: Starting work on polynomial hooks. This commit was extracted from SVN r2270. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2270 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-14 clauter * polynomials.c: Debugging the polynomials. This commit was extracted from SVN r2269. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2269 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-14 schevill * remez.c, sollya-messages.h, sollya-messaging.h: Added a warning message in the case when guessdegree is called with a weight function that does not seem to be continuous over the given interval. This commit was extracted from SVN r2268. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2268 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-14 clauter * polynomials.c: Debugging the polynomials. This commit was extracted from SVN r2267. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2267 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-11 clauter * polynomials.c: Debugging the polynomials. This commit was extracted from SVN r2266. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2266 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-11 clauter * polynomials.c: Debugging the polynomials. This commit was extracted from SVN r2265. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2265 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-11 clauter * polynomials.c: Debugging the polynomials. This commit was extracted from SVN r2264. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2264 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-11 clauter * polynomials.c: Again some progress with a new implementation of polynomials. This commit was extracted from SVN r2263. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2263 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-11 clauter * polynomials.c: Again some progress with a new implementation of polynomials. This commit was extracted from SVN r2262. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2262 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-11 clauter * polynomials.c: Again some progress with a new implementation of polynomials. This commit was extracted from SVN r2261. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2261 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-11 clauter * general.c, general.h, polynomials.c, polynomials.h: Again some progress with a new implementation of polynomials. This commit was extracted from SVN r2260. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2260 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-04-09 clauter * general.c, general.h, infnorm.c, infnorm.h, mpfi-compat.c, mpfi-compat.h, polynomials.c, polynomials.h: Some progress with the polynomials, still not finished. This commit was extracted from SVN r2259. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2259 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-03-27 schevill * doc/precision.shlp, doc/precision.tex, doc/www/precision.php, help.h, remez.c: Fixed bug [#17133] Minor bug in the documentation of precision() This commit was extracted from SVN r2258. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2258 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-03-20 clauter * Makefile.am, polynomials.c, polynomials.h: Started working on a better way to represent polynomials in Sollya. This commit was extracted from SVN r2257. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2257 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-21 clauter * implement.c: Patched a nasty bug in implementpoly occuring with precision handling inside that function. This commit was extracted from SVN r2256. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2256 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-21 clauter * infnorm.c: A small improvement to evaluation speed. This commit was extracted from SVN r2255. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2255 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-20 clauter * hooks.c, hooks.h, infnorm.c, tests-tool/timecheck.sollya: Still some enhancements to the polynomial evaluation hooks. This commit was extracted from SVN r2254. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2254 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-20 clauter * general.c, general.h, sollya-library-wrappers.c, sollya-messages.h, sollya-messaging.h, sollya.h: Added a generic printmessage function to the Sollya library. This commit was extracted from SVN r2253. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2253 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-19 schevill * remez.c: * Forgotten file at rev 2248 This commit was extracted from SVN r2252. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2252 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-18 clauter * infnorm.c, remez.c: Patched a problem with the evaluation of multiplication of functions containing divisions. This commit was extracted from SVN r2251. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2251 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-18 clauter * remez.c: Did something wrong in the last commit. This commit was extracted from SVN r2250. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2250 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-18 clauter * infnorm.c, remez.c: A slight improvement to reused-variables evaluation. This commit was extracted from SVN r2249. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2249 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-18 schevill * infnorm.c: * A better attempt to make remez' calls to uncertifiedInfnorm faster. This commit was extracted from SVN r2248. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2248 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-18 clauter * remez.c: Making the timecheck pass again, leaving the real work behind that to Sylvain. This commit was extracted from SVN r2247. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2247 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-18 clauter * general.c: Some improvement to global reused variable management. This commit was extracted from SVN r2246. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2246 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-17 clauter * general.c, general.h, hooks.c, hooks.h, infnorm.c: Still some more improvements for evaluation. This commit was extracted from SVN r2245. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2245 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-17 schevill * remez.c: * Attempt to make dirtyinform faster when computed inside remez. This commit was extracted from SVN r2244. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2244 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-13 clauter * infnorm.c: Patched a small bug. This commit was extracted from SVN r2243. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2243 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-13 clauter * infnorm.c: Still some slight improvements. This commit was extracted from SVN r2242. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2242 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-13 clauter * infnorm.c, mpfi-compat.c, remez.c: Still some improvements in making evaluations faster. This commit was extracted from SVN r2241. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2241 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-12 clauter * general.c, general.h, infnorm.c, tests-tool/timecheck.sollya: Still working on optimizing evaluations. This commit was extracted from SVN r2240. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2240 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-11 clauter * infnorm.c: Tried to improve performance of common case interval evaluations. This commit was extracted from SVN r2239. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2239 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-11 clauter * infnorm.c: A small optimization for sollya_mpfi_pow in order to fit the use of pow the remez algorithm makes (polynomials in canonical form). This commit was extracted from SVN r2238. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2238 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-10 clauter * execute.c: Still some improvements to memory reuse. This commit was extracted from SVN r2237. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2237 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-10 clauter * execute.c, tests-tool/check016.sollya.reference: Still some more progress on memory reference reuse that makes for hooks to survive Sollya level operations. This commit was extracted from SVN r2236. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2236 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-10 clauter * chain.c, chain.h, execute.c, tests-tool/check016.sollya, tests-tool/check016.sollya.reference: Some progress in making hooked functions survive match constructs. This commit was extracted from SVN r2235. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2235 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-07 clauter * hooks.c, infnorm.c: Tried some stuff with the evaluation hooks. This commit was extracted from SVN r2234. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2234 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-06 clauter * hooks.c: Again some progress with the evaluation hooks. This commit was extracted from SVN r2233. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2233 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-06 clauter * execute.c, execute.h, hooks.c, hooks.h, internlexer.l, internparser.y, lexer.l, library.c, minilexer.l, miniparser.y, mpfi-compat.c, mpfi-compat.h, parser.y, sollya-library-wrappers.c, sollya-messages.h, sollya-messaging.h, sollya.h, sturm.c, sturm.h, supnorm.c: Again some progress with the evaluation hooks. This commit was extracted from SVN r2232. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2232 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-06 clauter * hooks.c, hooks.h: Again some progress with the evaluation hooks. This commit was extracted from SVN r2231. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2231 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-05 clauter * hooks.c, hooks.h: Again some progress with evaluation hooks. This commit was extracted from SVN r2230. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2230 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-04 clauter * hooks.c: Again some progress with the hooks. This commit was extracted from SVN r2229. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2229 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-04 clauter * hooks.c, hooks.h: Added a forgotten parameter to two functions. This commit was extracted from SVN r2228. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2228 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-03 clauter * execute.c, expression.c, expression.h, hooks.c, hooks.h, infnorm.c: Some progress with evaluation hooks. This commit was extracted from SVN r2227. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2227 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-03 clauter * Makefile.am, hooks.c, hooks.h: Added files for regrouping functions related to evaluation and delayed-simplification hooks. This commit was extracted from SVN r2226. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2226 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2014-02-03 clauter * assignment.c, execute.c, expression.c, expression.h, infnorm.c, match.c, sollya-library-wrappers.c, tests-tool/timecheck.sollya, xml.c: Posed some ground-work in order to be able to add some evaluation and delayed-transformation hooks. This commit was extracted from SVN r2225. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2225 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-28 clauter * general.c, general.h: Started working on a double-linked chain of all memref'ed objects to allow them to be dagified when appropriate. This commit was extracted from SVN r2224. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2224 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-28 clauter * infnorm.c, tests-lib/tevaluate_function_at_constant_expression.reference: Trying to fix a couple of false positives in the tests for the Sollya library. This commit was extracted from SVN r2223. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2223 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-28 clauter * tests-tool/check024.sollya.reference, tests-tool/check027.sollya, tests-tool/timecheck.sollya: Fixing a couple of issues with false positives in the tool tests. This commit was extracted from SVN r2222. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2222 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-28 clauter * execute.c, expression.c, expression.h: Again some progress on DAG-ification of Sollya objects. This commit was extracted from SVN r2221. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2221 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-27 clauter * execute.c, expression.c, expression.h: Some progress with DAG-ified differentiation. This commit was extracted from SVN r2220. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2220 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-27 schevill * AUTHORS, autodiff.c, autodiff.h, chebyshevform.c, chebyshevform.h, chebyshevformaux.c, chebyshevformaux.h, configure.ac, doc/implementconstant.tex, doc/implementpoly.tex, doc/sollya.tex, doc/www/implementconstant.php, doc/www/implementpoly.php, doc/www/sollya.php, execute.c, help.h, implement.c, mpfi-compat.c, mpfi-compat.h, sollya.h, sturm.c, supnorm.c, supnorm.h, taylorform.c, taylorform.h, tests-lib/timplementpoly.reference, tests-lib/tv_implementpoly.reference: * Corrected Mioara's email address. This commit was extracted from SVN r2219. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2219 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-27 clauter * execute.c, expression.c: Continued working on caching evaluation results. This commit was extracted from SVN r2218. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2218 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-26 schevill * configure.ac, doc/sollya.tex, doc/www/sollya.php: * Back to "SVN trunk" as a name of version in the trunk. This commit was extracted from SVN r2217. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2217 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-26 clauter * execute.c, expression.c, expression.h, infnorm.c, mpfi-compat.c, mpfi-compat.h: Started working on caching evaluation results. This commit was extracted from SVN r2215. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2215 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-22 clauter * infnorm.c: Optimized precision setting in uncertified infnorm. This commit was extracted from SVN r2214. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2214 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-22 clauter * infnorm.c: Optimized precision settings again (2). This commit was extracted from SVN r2213. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2213 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-22 clauter * infnorm.c: Optimized precision settings again. This commit was extracted from SVN r2212. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2212 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-22 clauter * infnorm.c: Corrected a small precision bug. This commit was extracted from SVN r2211. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2211 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-22 clauter * infnorm.c: Continuing to improve the precision settings. This commit was extracted from SVN r2210. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2210 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-22 clauter * infnorm.c: Started working on a more sensible approach to precision incrementation for faithful or correct rounding. This commit was extracted from SVN r2209. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2209 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-22 schevill * : * New branch to work on the optimization of the evaluation functions of Sollya. This commit was extracted from SVN r2207. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/improvedEvaluate@2207 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-21 clauter * ChangeLog: New Changelog. This commit was extracted from SVN r2204. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2204 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-21 schevill * NEWS: * Proposition for an updated NEWS for sollya 4.1 beta 2. This commit was extracted from SVN r2203. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2203 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-21 schevill * tests-tool/Makefile.am, tests-tool/check029.sollya, tests-tool/check029.sollya.reference: * Non-regression test for bug #16632. This commit was extracted from SVN r2202. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2202 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-21 schevill * remez.c: * Patched bug #16632 [Infinite loop in dirtyfindzeros] Also, there was a bug in the estimation of the precision of a root computed by Newton's algorithm. As a result, I think that the algorithm could have oscillate between some value and its successor in the given floating-point format, without an end. I hope that this revision also solves this issue, but I am not able to artificially produce such an example of oscillation, so I cannot check that my patch corrects this issue. This commit was extracted from SVN r2201. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2201 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-13 schevill * configure.ac: * Second attempt. The problem that we try to fix here is that adding -lstdc++ in the compilation line does not work when gcc is used to link and when gcc version does not agreee with g++ version. Also, it might not work if the version of g++ does not agree with the version of lstdc++. We add -lstdc++ to the compilation line only if we are sure that it works. Not adding it does no harm in general, as it is only needed on Cygwin, with old versions of fplll. Hopefully (but it is hard to test it in order to be certain), if we are in the unlikely case when: 1) we have an old version of fplll 2) we are on Cygwin 3) we cannot add -lstdc++ to the compilation line, configure will detect that sollya cannot be build on this specific machine. What makes me optimistic about it is the fact that there is a test after all this mess that tries to compile and run a small example program using fplll. I think that that test will fail on this particular architecture. This commit was extracted from SVN r2200. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2200 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-13 schevill * configure.ac: * Attempt to patch configure.ac so as to test if -lstdc++ can be added or not to the compilation line. This commit was extracted from SVN r2199. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2199 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-13 schevill * double.c: * Added a comment about corner cases for the new function convertHexadecimalStringToInt32. This commit was extracted from SVN r2198. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2198 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-13 schevill * tests-lib/tconstant_from_mpq.reference, tests-lib/tget_constant_as_mpq.reference: * The bug corrected by Christoph @rev 2194 was indeed detected by the test suite. However, the reference files had not been correctly manually checked (my fault) so it was approving a wrong behavior. Should be ok right now. This commit was extracted from SVN r2197. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2197 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-13 schevill * doc/sollya.tex, doc/www/sollya.php, tests-lib/tprintf.c, tests-lib/tprintf.reference: * Updated tests and documentation with the new %k modifier of sollya_lib_printf. HTML and TeX versions are checked to be synchronized. This commit was extracted from SVN r2196. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2196 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-13 clauter * library.c, library.h: Preventing externalproc, library and libraryconstant from calling dlopen, dlclose and the deconstructor sollya_external_lib_close more than once per *.so, even if the *.so contains a library function and an external procedure at a time. This commit was extracted from SVN r2195. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2195 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-12 clauter * sturm.c: Patched a display bug in sollya_lib_printf for r and k conversions when integers to be displayed become larger than 2^128. This commit was extracted from SVN r2194. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2194 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-11-12 clauter * printf.c, sturm.c, sturm.h: Added sollya_lib_*printf modifier k for printing mpz_t values. This commit was extracted from SVN r2193. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2193 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-23 clauter * double.c: Avoided use of strtoll, which does not seem to be POSIX compliant. This commit was extracted from SVN r2192. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2192 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-15 clauter * tests-tool/libraryexample.c: Patching a warning message. This commit was extracted from SVN r2191. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2191 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-14 schevill * doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php: * Changed "4.1" to "Release 4.1", in order to unify with what we did for previous releases. --> Second release candidate. This commit was extracted from SVN r2190. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2190 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-14 schevill * NEWS: * First release candidate for 4.1 This commit was extracted from SVN r2189. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2189 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-14 clauter * ChangeLog: New Changelog. This commit was extracted from SVN r2188. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2188 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-14 clauter * configure.ac, doc/sollya.tex, doc/www/sollya.php: Changed name of Sollya version to 4.1. This commit was extracted from SVN r2187. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2187 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-14 clauter * NEWS: Better NEWS file. This commit was extracted from SVN r2186. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2186 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-14 clauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/evaluate.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/isevaluable.tex, doc/library.shlp, doc/library.tex, doc/libraryconstant.shlp, doc/libraryconstant.tex, doc/remez.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/evaluate.php, doc/www/externalproc.php, doc/www/isevaluable.php, doc/www/library.php, doc/www/libraryconstant.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, help.h: Added documentation for destructor function in library functions, library constants and external procedures and recompiled the whole documentation. This commit was extracted from SVN r2185. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2185 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-11 schevill * tests-lib/Makefile.am, tests-lib/tconstant_from_mpq.c, tests-lib/tconstant_from_mpq.reference, tests-lib/tconstant_from_mpz.c, tests-lib/tconstant_from_mpz.reference, tests-lib/tget_constant_as_mpq.c, tests-lib/tget_constant_as_mpq.reference, tests-lib/tget_constant_as_mpz.c, tests-lib/tget_constant_as_mpz.reference: * Tests for the new get_constant_mp* and constant_from_mp* functions. This commit was extracted from SVN r2184. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2184 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-11 schevill * fpminimax.cpp: * suppress some warning appearing in fpminimax.cpp with -std=c99 + revert a change committed by mistake at previous revision. This commit was extracted from SVN r2183. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2183 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-11 schevill * double.c, double.h, execute.h, fpminimax.cpp, implement.c, implement.h, implementconst.c, internlexer.l, lexer.l, proof.c, proof.h, remez.c, sollya-messages.h, sollya-messaging.h: * Copyrights are now up to date. This commit was extracted from SVN r2182. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2182 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-11 schevill * NEWS: * First draft for NEWS file. This commit was extracted from SVN r2180. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2180 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-11 clauter * ChangeLog: A new changelog. This commit was extracted from SVN r2179. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2179 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-11 schevill * tests-tool/check027.sollya, tests-tool/check027.sollya.reference: * Non-regression tests for bugs #13046 and #16434. Bug #16434 is not completely fixed though, because it still requires to take a decision about what Sollya should return when asked for evaluating a/b with a and b mathematically equal to 0. Currently, we return [-Inf, Inf] (this is the behavior considered as correct in the newly added tests in check027.sollya, for instance). We have always considered that [-Inf, Inf] and NaN were approximately as useless, so we did not think too much about when we should return one or another. However, for instance sin([-Inf, Inf]) can legitimately return [-1, 1], while sin([NaN, NaN]) must return NaN. One means 'some arbitrary value in the range of sin' while the other means 'some computation was incorrect'. We do not change this behavior now, but we might think of this problem and change the behavior for a future release. This commit was extracted from SVN r2178. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2178 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-11 clauter * execute.c, tests-tool/Makefile.am, tests-tool/check001.sollya.reference, tests-tool/check028.sollya, tests-tool/check028.sollya.reference: Trying to patch "[#16521] Incoherent behavior" This commit was extracted from SVN r2177. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2177 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-10 schevill * infnorm.c, integral.c, tests-tool/check004.sollya.reference, tests-tool/check005.sollya.reference, tests-tool/check027.sollya, tests-tool/check027.sollya.reference: * Removed some old portion of code that seems to be useless and too conservative. This commit was extracted from SVN r2176. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2176 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-10 schevill * remez.c: * Patched a nasty bug in Newton: whenever the iterator of Newton's algorithm evaluates to NaN, the next point of the algorithm used to be NaN leading to an infinite loop. This bug is here for a very long time, but seems to have been undiscovered until now, because it is barely impossible to produce. We incidentally discovered it two revisions ago, because of deep modifications that we made in the code used to simplify expressions. The problem has been detected by check012 which felt into an infinite loop. These modifications have been further improved at previous revision, hiding again the bug in Newton. I am unfortunately not able to produce a non-regression test in the current state of the repository. This commit was extracted from SVN r2175. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2175 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-10 clauter * expression.c, tests-tool/check012.sollya, tests-tool/check012.sollya.reference: Make checks pass again. This commit was extracted from SVN r2174. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2174 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-10 clauter * expression.c: Synchronizing with Sylvain. This commit was extracted from SVN r2173. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2173 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-10 clauter * expression.c: Synchronizing with Sylvain. This commit was extracted from SVN r2172. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2172 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-10 schevill * expression.c, expression.h: * Final version of the safe simplification procedures, finally solving bug #16434. Non-regression tests still to come. Does not solve #13046 however. This commit was extracted from SVN r2171. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2171 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-09 schevill * tests-tool/check027.sollya, tests-tool/check027.sollya.reference: * Added non-regression test for bug #10317. This commit was extracted from SVN r2170. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2170 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-09 clauter * expression.c: Simplifying the simplification test code again. This commit was extracted from SVN r2169. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2169 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-09 clauter * expression.c: Synchronizing with Sylvain. This commit was extracted from SVN r2168. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2168 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-09 clauter * expression.c: Simplifying the simplification test code. This commit was extracted from SVN r2167. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2167 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-09 schevill * expression.c: * Few corrections to containsOnlyRealNumbers so as to make it test really if some expression contains only real numbers (and no NaN nor infinities). This commit was extracted from SVN r2166. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2166 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-09 clauter * expression.c: Synchronization with Sylvain. This commit was extracted from SVN r2165. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2165 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-09 schevill * doc/sollya.tex, doc/www/sollya.php: * Updated documentation with the new functions sollya_lib_get_constant_from_mp[qz] and sollya_lib_constant_from_mp[qz]. The tests for these functions remain to be done. HTML and TeX versions are checked to be synchronized. This commit was extracted from SVN r2164. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2164 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-09 schevill * tests-tool/check027.sollya, tests-tool/check027.sollya.reference: * Added non-regression test for bug #15239. This commit was extracted from SVN r2163. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2163 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-08 clauter * expression.c: Updated simplification test code again after discussion with Sylvain. This commit was extracted from SVN r2162. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2162 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-08 clauter * expression.c, tests-lib/tdirtysimplify.reference, tests-tool/check014.sollya.reference: A proposal for a patch addressing the issue "[#15239] Constant subexpressions of expressions that are not constant not evaluated faithfully for autoprint". If the discussion in the tracker ends up showing that we should not do such simplifications, it suffices to revert this commit. This commit was extracted from SVN r2161. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2161 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-07 schevill * expression.c: * Added some comments about about simplification tests. Should be discussed with Christoph. This commit was extracted from SVN r2160. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2160 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-04 clauter * expression.c: Removing extra-pessimistic tests from simplification testing code. This commit was extracted from SVN r2159. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2159 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-04 schevill * expression.c: * Gave a precise semantic to the functions defined by Christoph for safe simplification of expressions. This commit was extracted from SVN r2158. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2158 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-03 clauter * expression.c: Corrected a problem with illegal simplifications on logarithms. This commit was extracted from SVN r2157. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2157 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-03 clauter * doc/expand.shlp, doc/expand.tex, doc/www/expand.php, help.h: Patching documentation accordance to the agreement found in the bug tracker [#13844] Documentation of expand does not correspond to actual behavior of expand. This commit was extracted from SVN r2156. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2156 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-10-03 clauter * tests-tool/check027.sollya, tests-tool/check027.sollya.reference: Updating a test file and its reference to be more verbose. This commit was extracted from SVN r2155. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2155 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-09-27 clauter * expression.c: Removed some dead code. This commit was extracted from SVN r2154. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2154 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-09-27 clauter * execute.c, expression.c, tests-tool/check001.sollya.reference: Trying to patch [#16434] Illegal simplification This commit was extracted from SVN r2153. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2153 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-09-24 schevill * fpminimax.cpp: * Reverts a change in fpminimax committed by mistake. This commit was extracted from SVN r2152. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2152 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-09-24 schevill * double.c, double.h, fpminimax.cpp, tests-tool/Makefile.am, tests-tool/check027.sollya, tests-tool/check027.sollya.reference: * Patched bugs #10322 and #15256 and added non-regression tests. This commit was extracted from SVN r2151. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2151 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-09-23 clauter * execute.c: Patching a small problem with evaluate. This commit was extracted from SVN r2150. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2150 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-09-12 clauter * tests-lib/timplementpoly.reference, tests-lib/tv_implementpoly.reference: Committing two forgotten files. This commit was extracted from SVN r2147. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2147 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-09-11 schevill * tests-tool/Makefile.am, tests-tool/check024.sollya, tests-tool/check024.sollya.reference, tests-tool/libraryexample.c: * Patched a bug with check024 when tested on Cygwin. This commit was extracted from SVN r2146. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2146 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-09-09 clauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/implementconstant.tex, doc/implementpoly.tex, doc/remez.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/implementconstant.php, doc/www/implementpoly.php, doc/www/remez.php, doc/www/time.php, doc/www/timing.php, help.h, implement.c, implement.h, implementconst.c: Added copyright statement and disclaimer in output of implementpoly and implementconstant. Recompiled the documentation. This commit was extracted from SVN r2141. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2141 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-08-01 clauter * expression.c, expression.h, sollya-library-wrappers.c, sollya-messages.h, sollya-messaging.h, sollya.h: Added the functions sollya_obj_t sollya_lib_constant_from_mpz(mpz_t), sollya_obj_t sollya_lib_constant_from_mpq(mpq_t), int sollya_lib_get_constant_as_mpz(mpz_t, sollya_obj_t) and int sollya_lib_get_constant_as_mpq(mpq_t, sollya_obj_t) to the Sollya library. Testing is still required. This commit was extracted from SVN r2140. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2140 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-07-29 clauter * chebyshevform.c, remez.c, taylorform.c: Slightly change messaging behavior for some algorithms. This commit was extracted from SVN r2139. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2139 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-07-29 clauter * expression.c, external.c, plot.c: Overcame a couple of compilation warnings seen with clang. This commit was extracted from SVN r2138. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2138 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-07-26 clauter * sollya-library-wrappers.c: Fixed a warning found with clang. This commit was extracted from SVN r2137. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2137 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-07-25 schevill * fpminimax.cpp, tests-tool/check012.sollya, tests-tool/check012.sollya.reference: * Patched bug #16164 and added non-regression test. This commit was extracted from SVN r2136. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2136 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-07-25 schevill * double.c, tests-lib/tget_constant_as_int64.reference, tests-lib/tget_constant_as_uint64.reference, tests-tool/check025.sollya, tests-tool/check025.sollya.reference: * Non regression tests for bug #16155. This commit was extracted from SVN r2135. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2135 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-07-25 clauter * double.c, expression.c, expression.h, sollya-library-wrappers.c: Making some progress with the recent nearestint changes and associated issues in sollya_lib_get_constant_as_int64 and sollya_lib_get_constant_as_uint64. This commit was extracted from SVN r2134. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2134 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-07-25 clauter * double.c, double.h, expression.c, infnorm.c: Making check013 pass again (nearestint now returns the even integer in case of a tie) This commit was extracted from SVN r2133. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2133 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-07-24 clauter * expression.c, infnorm.c: Trying to patch bug #16155 "A computation involving ceil leads to a result with wrong sign" This commit was extracted from SVN r2132. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2132 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-07-15 schevill * tests-tool/check013.sollya, tests-tool/check013.sollya.reference: * Non-regression tests for bug #8078. This commit was extracted from SVN r2131. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2131 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-07-01 clauter * library.c: Putting back a line that Sylvain removed too soon. This commit was extracted from SVN r2130. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2130 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-07-01 schevill * parser.y: * Removed simplifysafe from the 'help help' list. This commit was extracted from SVN r2129. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2129 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-30 schevill * library.c, tests-lib/tdirtysimplify.c: * Forgotten changes following the creation of new command dirtysimplify. This commit was extracted from SVN r2128. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2128 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-28 schevill * tests-lib/tsimplify.c: * Forgotten to modify some file in previous commit. This commit was extracted from SVN r2127. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2127 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-28 schevill * tests-lib/tsimplify.c, tests-lib/tsimplify.reference, tests-lib/tsimplifysafe.c, tests-lib/tsimplifysafe.reference: * 2nd round of modifications of the tests, according to the new semantics of simplify. This commit was extracted from SVN r2126. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2126 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-28 schevill * tests-lib/Makefile.am, tests-lib/tdirtysimplify.c, tests-lib/tdirtysimplify.reference, tests-lib/tmantissa_and_exponent.c, tests-lib/tsimplify.c, tests-lib/tsimplify.reference, tests-tool/check011.sollya, tests-tool/memoryleaks.sollya, tests-tool/timecheck.sollya: * First round of modifications of the tests, according to the new semantics of simplify. This commit was extracted from SVN r2125. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2125 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-28 schevill * tests-tool/Makefile.am, tests-tool/check026.sollya, tests-tool/check026.sollya.reference: * Added non-regression tests for bug #8306 This commit was extracted from SVN r2124. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2124 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-28 clauter * doc/CommandsAndFunctions.tex, doc/dirtysimplify.shlp, doc/dirtysimplify.tex, doc/expand.shlp, doc/expand.tex, doc/horner.shlp, doc/horner.tex, doc/introExample51.tex, doc/keywords.def, doc/rationalmode.shlp, doc/rationalmode.tex, doc/simplify.shlp, doc/simplify.tex, doc/simplifysafe.shlp, doc/simplifysafe.tex, doc/www/ListOfCommands.php, doc/www/dirtysimplify.php, doc/www/expand.php, doc/www/horner.php, doc/www/introExample51.php, doc/www/rationalmode.php, doc/www/simplify.php, doc/www/simplifysafe.php, help.h, parser.y: Finished moving around the simplify/simplifysafe/dirtysimplify commands. This commit was extracted from SVN r2123. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2123 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-28 clauter * doc/dirtysimplify.shlp, doc/dirtysimplify.tex, doc/introExample51.tex, doc/simplifysafe.shlp, doc/simplifysafe.tex, doc/www/dirtysimplify.php, doc/www/introExample51.php, doc/www/simplifysafe.php: Corrected an error on library name correspondence. This commit was extracted from SVN r2122. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2122 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-28 clauter * doc/expand.shlp, doc/expand.tex, doc/introExample51.tex, doc/simplifysafe.shlp, doc/simplifysafe.tex, doc/www/expand.php, doc/www/introExample51.php, doc/www/simplifysafe.php, help.h: Made documentation compile again. This commit was extracted from SVN r2121. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2121 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-28 clauter * doc/CommandsAndFunctions.tex, doc/bashevaluate.tex, doc/bashexecute.tex, doc/dirtysimplify.shlp, doc/dirtysimplify.tex, doc/expand.tex, doc/honorcoeffprec.shlp, doc/honorcoeffprec.tex, doc/horner.tex, doc/implementpoly.shlp, doc/implementpoly.tex, doc/introExample51.tex, doc/keywords.def, doc/rationalapprox.shlp, doc/rationalapprox.tex, doc/rationalmode.tex, doc/remez.tex, doc/simplify.shlp, doc/simplify.tex, doc/simplifysafe.shlp, doc/simplifysafe.tex, doc/time.tex, doc/timing.tex, doc/www/ListOfCommands.php, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/dirtysimplify.php, doc/www/expand.php, doc/www/honorcoeffprec.php, doc/www/horner.php, doc/www/implementpoly.php, doc/www/introExample51.php, doc/www/rationalapprox.php, doc/www/rationalmode.php, doc/www/remez.php, doc/www/simplify.php, doc/www/simplifysafe.php, doc/www/time.php, doc/www/timing.php, execute.c, execute.h, help.h, internlexer.l, internparser.y, lexer.l, library.c, minilexer.l, miniparser.y, parser.y, sollya-library-wrappers.c, sollya.h: Changed simplify to dirtysimplify and aliased simplifysafe with simplify. HTML doc not published, PDF doc does not compile. Check do not pass. This commit was extracted from SVN r2120. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2120 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-28 clauter * execute.c: Trying to finally patch bug #8306 "Parsing of non-representable decimal constants in point-interval notation may give FP point intervals". This commit was extracted from SVN r2119. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2119 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-28 schevill * tests-tool/check025.sollya, tests-tool/check025.sollya.reference: * Kind of non-regression test for bug #8726. This commit was extracted from SVN r2118. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2118 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-24 schevill * tests-tool/check025.sollya, tests-tool/check025.sollya.reference: * Non regression test for bug #15018 This commit was extracted from SVN r2117. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2117 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-24 schevill * tests-tool/check025.sollya, tests-tool/check025.sollya.reference: * Non-regression test for bug #15249 This commit was extracted from SVN r2116. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2116 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-24 schevill * tests-tool/Makefile.am, tests-tool/check025.sollya, tests-tool/check025.sollya.reference: Non-regression test for bug #15250. This commit was extracted from SVN r2115. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2115 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-21 schevill * tests-tool/Makefile.am, tests-tool/check024.sollya, tests-tool/check024.sollya.reference: * Non-regression test for bug #15927 This commit was extracted from SVN r2114. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2114 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-21 schevill * configure.ac: * Removed too much at previous revision. This commit was extracted from SVN r2113. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2113 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-21 schevill * configure.ac: * Removing some code in configure.ac that neither Christoph nor me understands. This code was probably designed to prevent some possible trouble on Cygwin but it seems incomplete and we cannot complete it without fully understanding what circumstances it is intended to catch. This commit was extracted from SVN r2112. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2112 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-21 schevill * configure.ac: * Improved configure.ac, in particular with a more systematic test suite for FPLLL. This commit was extracted from SVN r2111. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2111 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-20 clauter * configure.ac: Trying to patch the FPLLL build bug on Ubuntu. This commit was extracted from SVN r2110. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2110 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-18 clauter * implement.c, proof.c, proof.h: Making Gappa proof generation work better with recent versions of Gappa. This commit was extracted from SVN r2108. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2108 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-17 clauter * expression.c: Patched a bug on printing library functions. This commit was extracted from SVN r2107. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2107 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-11 clauter * compile.sh, expansion.c: Metalibm synchronization. This commit was extracted from SVN r2106. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2106 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-10 schevill * tests-tool/check001.sollya.reference: * Forgot a new line character. This commit was extracted from SVN r2105. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2105 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-10 schevill * tests-tool/check001.sollya.reference: * The behavior of degree on '0/x' is actually expected to be -1, since we cannot simplify expressions of the form 0/something and degree of an expression that is not a polynomial is expected to be -1. This commit was extracted from SVN r2104. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2104 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-10 schevill * tests-tool/check001.sollya, tests-tool/check001.sollya.reference: * Non-regression tests for bug #15858 patched at revision 2102. Yet, the current behavior of degree on 0/x does not seems normal to me. Consequently, the just added non-regression test fails currently. This commit was extracted from SVN r2103. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2103 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-10 clauter * execute.c, expression.c, expression.h: Patched a bug in hornerization, division by a power of x and computation of the degree of a polynomial. The patch required adding some optimization to the code extracting the i-th coefficient of a polynomial expression. This commit was extracted from SVN r2102. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2102 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-06-03 clauter * library.c, sollya-messages.h, sollya-messaging.h: Added support for an optional destructor function in an external library. This commit was extracted from SVN r2101. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2101 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-31 schevill * doc/sollya.pdf, doc/sollya.tex, doc/www/index.php, doc/www/sollya.php: * Typos. Removed index.php from versionning because it is not part of the documentation. This commit was extracted from SVN r2100. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2100 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-29 schevill * README, configure.ac: * configure.ac more readable and simpler. Should patch a bug observed with configure observed on machines that do not have mpfi installed. Amongst other, the test for dladdr used to systematically think that dladdr was not present, as soon as mpfi was not present. This commit was extracted from SVN r2093. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2093 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-29 clauter * configure.ac, library.c: Made dladdr use more portable. This commit was extracted from SVN r2092. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2092 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-28 schevill * doc/sollya.tex: * Restored previous formatting of the title of sollya.pdf, for homogeneity with what is used when we release. This commit was extracted from SVN r2088. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2088 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 clauter * ChangeLog: New ChangeLog. This commit was extracted from SVN r2079. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2079 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 clauter * doc/introExample51.tex, doc/www/introExample51.php: Recompiled the examples in the generalities section of the documentation. This commit was extracted from SVN r2078. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2078 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 clauter * ChangeLog, doc/bashevaluate.tex, doc/bashexecute.tex, doc/range.tex, doc/remez.tex, doc/time.tex, doc/timing.tex, doc/www/accurateinfnorm.php, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/bind.php, doc/www/boolean.php, doc/www/constant.php, doc/www/d.php, doc/www/dd.php, doc/www/de.php, doc/www/execute.php, doc/www/externalproc.php, doc/www/hp.php, doc/www/integer.php, doc/www/isbound.php, doc/www/isevaluable.php, doc/www/listof.php, doc/www/nop.php, doc/www/object.php, doc/www/print.php, doc/www/proc.php, doc/www/procedure.php, doc/www/qd.php, doc/www/quit.php, doc/www/range.php, doc/www/readfile.php, doc/www/remez.php, doc/www/restart.php, doc/www/return.php, doc/www/sg.php, doc/www/string.php, doc/www/td.php, doc/www/time.php, doc/www/timing.php, doc/www/var.php, doc/www/write.php, help.h: Recompiled the whole documentation, published its html version and updated the Changelog file. This commit was extracted from SVN r2077. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2077 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 schevill * doc/shlp2html.sh: * New MemoRelease and corrected a bug in shlp2html This commit was extracted from SVN r2076. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2076 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 clauter * ChangeLog: New Changelog. This commit was extracted from SVN r2075. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2075 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 clauter * doc/round.shlp, doc/round.tex, doc/www/round.php, help.h: Corrected a typo. This commit was extracted from SVN r2074. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2074 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 clauter * configure.ac, doc/round.shlp, doc/round.tex, doc/sollya.tex, doc/www/round.php, doc/www/sollya.php, help.h: Added a section in documentation for round. This commit was extracted from SVN r2073. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2073 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 schevill * doc/chebyshevform.shlp, doc/chebyshevform.tex, doc/www/chebyshevform.php, help.h: * Updated doc of chebyshevform This commit was extracted from SVN r2072. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2072 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 clauter * doc/externalproc.shlp, doc/externalproc.tex, doc/www/externalproc.php, externalproc.c, help.h: Updated externalproc documentation. This commit was extracted from SVN r2071. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2071 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 schevill * doc/externalproc.shlp, doc/externalproc.tex, doc/publishwww.sh, doc/www/externalproc.php, externalproc.c, help.h: * doc of externalproc should be up-to-date. This commit was extracted from SVN r2069. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2069 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 clauter * : Recompiled the documentation. This commit was extracted from SVN r2068. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2068 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 clauter * doc/CommandsAndFunctions.tex, doc/boolean.shlp, doc/boolean.tex, doc/constant.shlp, doc/constant.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/function.shlp, doc/function.tex, doc/integer.shlp, doc/integer.tex, doc/keywords.def, doc/listof.shlp, doc/listof.tex, doc/object.shlp, doc/object.tex, doc/range.shlp, doc/string.shlp, doc/string.tex, doc/taylorform.shlp, doc/taylorform.tex, doc/www/ListOfCommands.php, doc/www/boolean.php, doc/www/constant.php, doc/www/function.php, doc/www/integer.php, doc/www/listof.php, doc/www/object.php, doc/www/string.php, doc/www/taylorform.php, help.h: Added documentation for object and added some SEEALSOs This commit was extracted from SVN r2067. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2067 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-27 clauter * parser.y: Added some entries to help help list. This commit was extracted from SVN r2066. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2066 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-24 clauter * doc/chebyshevform.shlp, doc/chebyshevform.tex, doc/fullparentheses.shlp, doc/fullparentheses.tex, doc/implementconstant.shlp, doc/implementconstant.tex, doc/www/chebyshevform.php, doc/www/fullparentheses.php, doc/www/implementconstant.php, help.h, sollya-library-wrappers.c, sollya.h: Removed a doubled function name in sollya.h and implementation, added library function names for chebyshevform, fullparentheses and implementconstant. This commit was extracted from SVN r2065. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2065 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-24 clauter * parser.y: Corrected help help. This commit was extracted from SVN r2064. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2064 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-24 clauter * ChangeLog: New Changelog file. This commit was extracted from SVN r2063. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2063 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-24 clauter * doc/chebyshevform.shlp, doc/chebyshevform.tex, doc/taylorform.shlp, doc/taylorform.tex, doc/www/chebyshevform.php, doc/www/taylorform.php, help.h: Reformatted the documentation a little bit. This commit was extracted from SVN r2060. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2060 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-23 clauter * general.c: A small change to the parser inclusion structure. This commit was extracted from SVN r2059. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2059 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-23 clauter * general.c, parser.y: A small change to the parser inclusion structure. This commit was extracted from SVN r2058. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2058 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-23 clauter * configure.ac, doc/bashevaluate.tex, doc/bashexecute.tex, doc/remez.tex, doc/sollya.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/remez.php, doc/www/sollya.php, doc/www/time.php, doc/www/timing.php, general.c, help.h: Updated revision number and recompiled the whole documentation. This commit was extracted from SVN r2057. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2057 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-23 schevill * doc/remez.shlp, doc/remez.tex, doc/www/remez.php, help.h: * Updated remez documentation with the new 6th argument. This commit was extracted from SVN r2056. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2056 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-23 clauter * ChangeLog: Updated the Changelog file. This commit was extracted from SVN r2055. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2055 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-23 clauter * NEWS: Corrected two typos in the new NEWS file. This commit was extracted from SVN r2054. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2054 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-23 schevill * NEWS: * Final (?) NEWS file. This commit was extracted from SVN r2053. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2053 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-23 clauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/fpminimax.tex, doc/nop.shlp, doc/nop.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/fpminimax.php, doc/www/nop.php, doc/www/time.php, doc/www/timing.php, help.h: Updated documentation for nop and recompiled the whole documentation. This commit was extracted from SVN r2052. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2052 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-22 schevill * NEWS: * NEWS file, in progress as usual... This commit was extracted from SVN r2051. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2051 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-22 schevill * NEWS: * NEWS file, in progress. This commit was extracted from SVN r2050. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2050 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-22 schevill * NEWS: * NEWS file as it is. This commit was extracted from SVN r2049. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2049 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-16 clauter * NEWS, expansion.c: Updated interface with metalibm. This commit was extracted from SVN r2048. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2048 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-03 schevill * NEWS: * Current NEWS file (work in progress). This commit was extracted from SVN r2047. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2047 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-03 schevill * NEWS: Current version of NEWS (work in progress) This commit was extracted from SVN r2046. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2046 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-05-02 clauter * execute.c, external.c, mpfi-compat.c, sollya-library-wrappers.c: Added code to make sure that any zero that leaves Sollya in a binary manner (as an MPFR or a double) has a + sign, and made sure that all intervals handled internally and passed out in a binary manner through MPFIs have zeros that are signed according to the rules adopted by MPFI. The committer covers his opinion on MPFI's convention under the veil of philosophic silence. Test are still missing and will be required. This commit was extracted from SVN r2045. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2045 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-22 schevill * NEWS: First classification for the NEWS of 4.0 This commit was extracted from SVN r2044. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2044 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-15 schevill * doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php: * Updated doc according to Christoph's remarks. HTML and tex are synchronized. This commit was extracted from SVN r2043. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2043 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-15 clauter * ChangeLog: New ChangeLog. This commit was extracted from SVN r2042. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2042 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-15 clauter * ChangeLog, NEWS: New Changelog and a draft for a new NEWS file. This commit was extracted from SVN r2041. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2041 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-05 schevill * doc/www/sollya.php: * Synchronized HTML version with tex version + corrected typos specific to the HTML version. This commit was extracted from SVN r2040. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2040 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-05 schevill * doc/sollya.tex, tests-lib/Makefile.am, tests-lib/tmsg_callback_functions.c, tests-lib/tmsg_callback_functions.reference: * Tests for meassge callbacks. This commit was extracted from SVN r2039. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2039 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-05 clauter * general.c, general.h, sollya-library-wrappers.c, sollya.h: Changed type of sollya_lib_get_msg_callback in order to allow the function to return the void * pointer to the user data that might have been registered together with the callback function. This commit was extracted from SVN r2038. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2038 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-03 schevill * tests-lib/tprintf.c, tests-lib/tprintf.reference: * Final (!) modification for tprintf. This commit was extracted from SVN r2037. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2037 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-03 clauter * printf.c: Synchronizing with Sylvain. This commit was extracted from SVN r2036. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2036 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-03 schevill * tests-lib/tprintf.c, tests-lib/tprintf.reference: * Last modifications (?) to tprintf. The reference file has been manually checked. As a consequence, the test currently fails because of a bug in the way sollya_lib_printf handles "%.v" and "%.w" (should be handled the same way as "%.0v" and "%.0w") This commit was extracted from SVN r2035. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2035 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-03 clauter * tests-lib/tconstant_from_double.c, tests-lib/tdecompose_function.c, tests-lib/tget_head_function.c, tests-lib/tv_decompose_function.c: Patched a couple of warnings seen with icc in the test files. This commit was extracted from SVN r2034. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2034 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-03 clauter * configure.ac: Patched a problem with fplll detection on Cygwin. This commit was extracted from SVN r2033. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2033 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-03 clauter * configure.ac: Synchro with Sylvain. This commit was extracted from SVN r2032. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2032 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-03 clauter * configure.ac: Tried to make mechanism for .so libraries in configure script portable. - Version 2 This commit was extracted from SVN r2031. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2031 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-03 clauter * configure.ac: Tried to make mechanism for .so libraries in configure script portable. This commit was extracted from SVN r2030. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2030 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-02 schevill * doc/www/sollya.php: * Corrected bugged href. This commit was extracted from SVN r2029. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2029 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-02 schevill * tests-lib/Makefile.am, tests-lib/tcopy_obj.c, tests-lib/tcopy_obj.reference: * Tests for sollya_lib_copy_obj. * Updated TODO list. This commit was extracted from SVN r2028. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2028 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-04-01 schevill * tests-lib/tprintf.c, tests-lib/tprintf.reference: * Final (?) set of tests for printf. The reference file must still be checked manually. This commit was extracted from SVN r2027. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2027 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-29 schevill * configure.ac, tests-lib/tprintf.c: * The patch of revision 2024 broke configure in the case when a "--with-*" is passed to configure. This is a patch. Not sure that it is completely portable though. This commit was extracted from SVN r2026. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2026 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-29 schevill * configure.ac, doc/sollya.tex, doc/www/sollya.php: setting name of Sollya to 4.0-Release Candidate This commit was extracted from SVN r2025. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2025 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-29 schevill * configure.ac: * Added tests in configure to ensure that dynamic libraries are found at runtime. This commit was extracted from SVN r2024. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2024 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-28 schevill * AUTHORS, assignment.h, autodiff.c, autodiff.h, bitfields.h, chain.h, chebyshevform.c, chebyshevform.h, chebyshevformaux.c, chebyshevformaux.h, configure.ac, doc/conversionIntro.sh, doc/sollya.tex, doc/www/index.php, doc/www/sollya.php, double.h, execute.c, execute.h, expansion.h, expression.h, external.h, fpminimax.h, general.c, general.h, help.h, implement.h, implementconst.h, infnorm.h, integral.h, library.h, libsollyaexample.c, main.h, match.c, match.h, mpfi-compat.c, mpfi-compat.h, parser.y, plot.h, printf.h, proof.h, remez.h, signalhandling.h, sollya-library-wrappers.h, sollya-messages.h, sollya-messaging.h, sollya.h, sturm.c, sturm.h, supnorm.c, supnorm.h, taylor.h, taylorform.c, taylorform.h, worstcase.h, xml.h: * Copyright are now (hopefully) up to date. This commit was extracted from SVN r2022. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2022 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-28 schevill * assignment.c, assignment.h, autodiff.c, autodiff.h, bitfields.c, bitfields.h, chain.c, chebyshevform.c, chebyshevform.h, chebyshevformaux.c, chebyshevformaux.h, double.c, execute.c, execute.h, expansion.c, expansion.h, expression.c, expression.h, external.c, externalfun.c, externalproc.c, fpminimax.h, general.c, implement.c, implement.h, implementconst.c, implementconst.h, infnorm.c, infnorm.h, integral.c, integral.h, library.c, library.h, libsollyaexample.c, main.c, main.h, match.c, mpfi-compat.c, mpfi-compat.h, plot.c, plot.h, printf.c, proof.c, proof.h, remez.c, signalhandling.c, sollya-library-wrappers.c, sollya-library-wrappers.h, sollya-messages.h, sollya-messaging.c, sollya-messaging.h, sollya.h, sturm.c, sturm.h, supnorm.c, supnorm.h, taylor.c, taylor.h, taylorform.c, taylorform.h, worstcase.c, worstcase.h, xml.c, xml.h: * Removed trailing spaces. This commit was extracted from SVN r2021. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2021 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-28 schevill * assignment.c, autodiff.c, bitfields.c, chain.c, chebyshevform.c, chebyshevformaux.c, double.c, double.h, execute.c, execute.h, expansion.c, expression.c, external.c, externalfun.c, externalproc.c, general.c, general.h, help.h, implement.c, implementconst.c, infnorm.c, infnorm.h, integral.c, internlexer.l, internparser.y, lexer.l, library.c, libsollyaexample.c, main.c, match.c, minilexer.l, miniparser.y, mpfi-compat.c, mpfi-compat.h, parser.y, plot.c, printf.c, printf.h, proof.c, remez.c, signalhandling.c, sollya-library-wrappers.c, sollya-messages.h, sollya-messaging.c, sollya-messaging.h, sturm.c, sturm.h, supnorm.c, taylor.c, worstcase.c, xml.c: * First round of update for copyrights. This commit was extracted from SVN r2020. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2020 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-27 schevill * doc/checkinfnorm.shlp, doc/checkinfnorm.tex, doc/externalplot.shlp, doc/externalplot.tex, doc/fpminimax.shlp, doc/fpminimax.tex, doc/function.shlp, doc/function.tex, doc/guessdegree.shlp, doc/guessdegree.tex, doc/implementpoly.shlp, doc/implementpoly.tex, doc/library.shlp, doc/library.tex, doc/libraryconstant.shlp, doc/libraryconstant.tex, doc/remez.shlp, doc/remez.tex, doc/searchgal.shlp, doc/searchgal.tex, doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh, doc/sollya.tex, doc/supnorm.shlp, doc/supnorm.tex, doc/taylorform.shlp, doc/taylorform.tex, doc/worstcase.shlp, doc/worstcase.tex, doc/www/checkinfnorm.php, doc/www/externalplot.php, doc/www/fpminimax.php, doc/www/function.php, doc/www/guessdegree.php, doc/www/implementpoly.php, doc/www/library.php, doc/www/libraryconstant.php, doc/www/remez.php, doc/www/searchgal.php, doc/www/sollya.php, doc/www/supnorm.php, doc/www/taylorform.php, doc/www/worstcase.php, help.h, sollya-library-wrappers.c, sollya.h, tests-lib/Makefile.am, tests-lib/tdecompose_library_constant.c, tests-lib/tdecompose_library_constant.reference, tests-lib/tdecompose_library_function.c, tests-lib/tdecompose_library_function.reference, tests-lib/tdecompose_libraryconstant.c, tests-lib/tdecompose_libraryconstant.reference, tests-lib/tdecompose_libraryfunction.c, tests-lib/tdecompose_libraryfunction.reference, tests-lib/tdecompose_procedure_function.c, tests-lib/tdecompose_procedure_function.reference, tests-lib/tdecompose_procedurefunction.c, tests-lib/tdecompose_procedurefunction.reference: * Changed library_function to libraryfunction, etc., in the names of functions in libsollya. * Added some missing #LIBRARY directives in the doc. * Modified a bit the way #LIBRARY is interpreted, in order to allow for declarations of signatures on several lines. This commit was extracted from SVN r2019. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2019 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-27 schevill * tests-lib/tprintf.c: * Reverted unintentional commit of tprintf.c at revision 2015. This commit was extracted from SVN r2018. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2018 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-26 schevill * doc/conversionIntro.sh, doc/www/index.php, doc/www/sollya.php, doc/www/sollyacss.css: * HTML documentation is now completely synchronized with pdf documentation. It is valid HTML. Yet, last section of the documentation should be carefully read in order to check that there is no error left caused by the automatic conversion from LaTeX to html. This commit was extracted from SVN r2017. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2017 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-22 schevill * doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php: * Updated copyright notice in sollya.tex and sollya.php. * Updated sollya.php to reflect changes in sollya.tex since last release. All modifications have been reported except the Appendix documenting the library. This commit was extracted from SVN r2016. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2016 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-22 schevill * integral.c, sollya-library-wrappers.c, tests-lib/tcheckinfnorm.c, tests-lib/tconstant.c, tests-lib/tconstant_from_int.c, tests-lib/tconstant_from_int64.c, tests-lib/tconstant_from_uint64.c, tests-lib/tfpminimax.c, tests-lib/tget_bounds_from_range.c, tests-lib/tget_interval_from_range.c, tests-lib/tis_absolute.c, tests-lib/tis_binary.c, tests-lib/tis_decimal.c, tests-lib/tis_default.c, tests-lib/tis_double_double_obj.c, tests-lib/tis_double_obj.c, tests-lib/tis_doubleextended_obj.c, tests-lib/tis_dyadic.c, tests-lib/tis_false.c, tests-lib/tis_file.c, tests-lib/tis_fixed.c, tests-lib/tis_floating.c, tests-lib/tis_halfprecision_obj.c, tests-lib/tis_hexadecimal.c, tests-lib/tis_honorcoeffprec.c, tests-lib/tis_off.c, tests-lib/tis_on.c, tests-lib/tis_perturb.c, tests-lib/tis_pi.c, tests-lib/tis_postscript.c, tests-lib/tis_postscriptfile.c, tests-lib/tis_powers.c, tests-lib/tis_quad_obj.c, tests-lib/tis_relative.c, tests-lib/tis_round_down.c, tests-lib/tis_round_to_nearest.c, tests-lib/tis_round_towards_zero.c, tests-lib/tis_round_up.c, tests-lib/tis_single_obj.c, tests-lib/tis_triple_double_obj.c, tests-lib/tis_true.c, tests-lib/tis_void.c, tests-lib/tobj_is_end_elliptic_list.c, tests-lib/tobj_is_error.c, tests-lib/tobj_is_function.c, tests-lib/tobj_is_list.c, tests-lib/tobj_is_range.c, tests-lib/tobj_is_string.c, tests-lib/tobj_is_structure.c, tests-lib/tprintf.c, tests-lib/tremez.c, tests-lib/tv_fpminimax.c, tests-lib/tv_remez.c: * Removed memory leaks in the test of the lib and some memory leaks in the lib itself. This commit was extracted from SVN r2015. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2015 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-22 clauter * execute.c: Patched a warning seen with icc. This commit was extracted from SVN r2014. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2014 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-22 clauter * execute.c, supnorm.c: Remotely patching a problem with a warning seen with Wall on a machine where mp_prec_t is unsigned. This commit was extracted from SVN r2013. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2013 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-20 clauter * printf.c: Some more fascist option bugs solved. This commit was extracted from SVN r2012. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2012 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-20 clauter * printf.c: Patched a problem in sollya_lib_printf. This commit was extracted from SVN r2011. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2011 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-20 clauter * tests-tool/Makefile.am: Trying to patch the make check problem on Cygwin This commit was extracted from SVN r2010. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2010 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-20 schevill * doc/sollya.pdf, doc/sollya.tex: * Updated documentation for printf. This commit was extracted from SVN r2009. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2009 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-20 schevill * tests-lib/tprintf.c: * Now, it compiles. This commit was extracted from SVN r2008. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2008 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-20 schevill * tests-lib/tprintf.c: * Make compiler happy with fascist options. This commit was extracted from SVN r2007. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2007 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-20 schevill * tests-lib/tprintf.reference: * I forgot to update reference file. This commit was extracted from SVN r2006. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2006 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-20 schevill * doc/sollya.pdf, doc/sollya.tex: * Documented sollya_lib_get_element_in_list This commit was extracted from SVN r2005. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2005 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-20 schevill * tests-lib/tprintf.c: * Tests for sollya_lib_snprintf This commit was extracted from SVN r2004. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2004 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-18 schevill * tests-lib/tget_constant_as_int.c, tests-lib/tget_constant_as_int64.c, tests-lib/tget_constant_as_uint64.c, tests-lib/timplementpoly.c, tests-lib/tprintf.c, tests-lib/tv_implementpoly.c: * Better Wall casts. This commit was extracted from SVN r2003. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2003 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-18 clauter * tests-lib/libraryexample.c, tests-lib/tbuild_function_libraryfunction.c, tests-lib/tlibraryfunction.c: Made tests ansi compatible. This commit was extracted from SVN r2002. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2002 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-18 clauter * printf.c: Corrected something in printf. This commit was extracted from SVN r2001. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2001 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-18 clauter * printf.c, signalhandling.c: A small -Wall cast. This commit was extracted from SVN r2000. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2000 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-18 clauter * signalhandling.c, signalhandling.h: Forgotten files. This commit was extracted from SVN r1999. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1999 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-18 clauter * Makefile.am, execute.c, general.c, printf.c: Trying to get the signals working again. This commit was extracted from SVN r1998. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1998 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-17 clauter * execute.c, supnorm.c: Added some casts, trying to overcome some compiler warnings. This commit was extracted from SVN r1997. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1997 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-17 schevill * tests-lib/tand.c, tests-lib/tappend.c, tests-lib/tbuild_function_libraryconstant.c, tests-lib/tbuild_function_libraryfunction.c, tests-lib/tcheckinfnorm.c, tests-lib/tcmp_equal.c, tests-lib/tcmp_greater.c, tests-lib/tcmp_greater_equal.c, tests-lib/tcmp_in.c, tests-lib/tcmp_less.c, tests-lib/tcmp_less_equal.c, tests-lib/tcmp_not_equal.c, tests-lib/tconcat.c, tests-lib/tconstant.c, tests-lib/tconstant_from_double.c, tests-lib/tconstant_from_int.c, tests-lib/tconstant_from_int64.c, tests-lib/tconstant_from_uint64.c, tests-lib/tdecompose_function.c, tests-lib/tdecompose_library_constant.c, tests-lib/tdecompose_library_function.c, tests-lib/tdenominator.c, tests-lib/tdiff.c, tests-lib/tdirtyinfnorm.c, tests-lib/tdirtyintegral.c, tests-lib/tget_bounds_from_range.c, tests-lib/tget_constant_as_int.c, tests-lib/tget_constant_as_int64.c, tests-lib/tget_constant_as_uint64.c, tests-lib/tget_function_arity.c, tests-lib/tget_head_function.c, tests-lib/tget_interval_from_range.c, tests-lib/tget_subfunctions.c, tests-lib/thead.c, tests-lib/timplementpoly.c, tests-lib/tinf.c, tests-lib/tinit_with_custom_memory_functions.c, tests-lib/tintegral.c, tests-lib/tlength.c, tests-lib/tlibraryconstant.c, tests-lib/tlibraryfunction.c, tests-lib/tmacros_build_function.c, tests-lib/tmantissa_and_exponent.c, tests-lib/tmax.c, tests-lib/tmid.c, tests-lib/tmin.c, tests-lib/tnegate.c, tests-lib/tnumberroots.c, tests-lib/tnumerator.c, tests-lib/tor.c, tests-lib/tprecision.c, tests-lib/tprepend.c, tests-lib/tprintdouble.c, tests-lib/tprintexpansion.c, tests-lib/tprintf.c, tests-lib/tprintsingle.c, tests-lib/trange_from_bounds.c, tests-lib/trange_from_interval.c, tests-lib/trationalapprox.c, tests-lib/tremez.c, tests-lib/trevert.c, tests-lib/troundcoefficients.c, tests-lib/tsearchgal.c, tests-lib/tsort.c, tests-lib/tsup.c, tests-lib/ttail.c, tests-lib/tv_decompose_function.c, tests-lib/tv_get_subfunctions.c, tests-lib/tv_implementpoly.c, tests-lib/tv_max.c, tests-lib/tv_min.c, tests-lib/tv_remez.c: * Compiler happiness in tests-lib. This commit was extracted from SVN r1996. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1996 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-16 schevill * tests-lib/tget_element_in_list.reference: * The test committed at previous revision seems to work. Updating the reference file. This commit was extracted from SVN r1995. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1995 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-16 schevill * tests-lib/tget_element_in_list.c: * Attempt to make complexity test for get_element_in_list more robust. This commit was extracted from SVN r1994. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1994 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-15 clauter * sollya-library-wrappers.c: Patched a problem with random access to lists created in library mode and accessed in library mode. The complexity should now really be O(1). This commit was extracted from SVN r1993. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1993 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-15 schevill * remez.c: * Cosmetic modifications in comments of remez.c, following the changes made by Christoph. This commit was extracted from SVN r1992. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1992 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-15 schevill * doc/sollya.tex, tests-lib/Makefile.am, tests-lib/tbuild_end_elliptic_list.c, tests-lib/tbuild_end_elliptic_list.reference, tests-lib/tbuild_list.c, tests-lib/tbuild_list.reference, tests-lib/tend_elliptic_list.c, tests-lib/tend_elliptic_list.reference, tests-lib/tget_element_in_list.c, tests-lib/tget_element_in_list.reference, tests-lib/tget_list_elements.c, tests-lib/tget_list_elements.reference, tests-lib/tlist.c, tests-lib/tlist.reference, tests-lib/tv_build_end_elliptic_list.c, tests-lib/tv_build_end_elliptic_list.reference, tests-lib/tv_build_list.c, tests-lib/tv_build_list.reference: * Tests for list manipulation within the lib. This commit was extracted from SVN r1991. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1991 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-15 schevill * remez.c: * Removed a bug introduced by Christoph at previous revision This commit was extracted from SVN r1990. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1990 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-15 clauter * autodiff.c, bitfields.c, chain.c, chebyshevform.c, chebyshevformaux.c, configure.ac, double.c, execute.c, expression.c, external.c, fpminimax.cpp, general.c, implement.c, infnorm.c, infnorm.h, integral.c, internlexer.l, internparser.y, lexer.l, library.c, library.h, minilexer.l, miniparser.y, parser.y, plot.c, printf.c, printf.h, remez.c, sollya-library-wrappers.c, sturm.c, supnorm.c, taylorform.c, worstcase.c, xml.c: Made Sollya compile with -Wall -Wextra without (almost) no warnings, and in -std=c99 and -ansi modes. This commit was extracted from SVN r1989. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1989 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-15 clauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/introExample51.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/introExample51.php, doc/www/time.php, doc/www/timing.php, help.h: Recompiled the documentation. This commit was extracted from SVN r1988. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1988 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-11 clauter * Makefile.am: Trying to patch a bug on Christoph's system while the bug is apparent only on Sylvain's system. This commit was extracted from SVN r1987. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1987 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-08 clauter * Makefile.am, configure.ac: Set version of libsollya .so file correctmy. This commit was extracted from SVN r1986. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1986 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-08 schevill * tests-tool/Makefile.am, tests-tool/check023.sollya, tests-tool/check023.sollya.reference: * Checks for priorities between infix operators. This commit was extracted from SVN r1985. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1985 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-05 schevill * tests-lib/tdecompose_function.c, tests-lib/tdecompose_function.reference: * Cleaned up a little bit the TODO list. This commit was extracted from SVN r1984. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1984 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-05 clauter * tests-tool/timecheck.sollya: Updated a timecheck test that tended to fail on Cygwin where time measures do not have fine granularity. This commit was extracted from SVN r1983. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1983 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-05 clauter * tests-lib/timplementpoly.c, tests-lib/timplementpoly.reference, tests-lib/tv_implementpoly.c, tests-lib/tv_implementpoly.reference: Changed tests for implementpoly again. This commit was extracted from SVN r1982. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1982 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-04 clauter * configure.ac: Corrected configure. This commit was extracted from SVN r1981. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1981 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-04 clauter * tests-lib/timplementpoly.c, tests-lib/timplementpoly.reference, tests-lib/tv_implementpoly.c, tests-lib/tv_implementpoly.reference: Updated tests for implementpoly. This commit was extracted from SVN r1980. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1980 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-04 clauter * tests-lib/timplementpoly.c, tests-lib/timplementpoly.reference: Changed implementpoly tests for Cygwin. This commit was extracted from SVN r1979. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1979 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-04 schevill * tests-lib/tdecompose_function.c, tests-lib/tget_function_arity.c, tests-lib/tget_head_function.c, tests-lib/tget_subfunctions.c, tests-lib/tv_decompose_function.c, tests-lib/tv_get_subfunctions.c: * Patched a bug (false negative test) on systems when the name of a C function cannot be recovered. This commit was extracted from SVN r1978. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1978 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-04 clauter * configure.ac, fpminimax.cpp, tests-lib/Makefile.am: Making the tests compile under Cygwin with an old FPLLL. This commit was extracted from SVN r1977. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1977 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-03-04 schevill * tests-lib/Makefile.am: * Restored a line previously removed, because it is indeed useful for make dist. This commit was extracted from SVN r1976. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1976 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-27 schevill * tests-lib/Makefile.am: * Reversed order of libs when compiling libraryexample.a This commit was extracted from SVN r1975. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1975 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-27 schevill * tests-lib/check.proto: * Stupid error. This commit was extracted from SVN r1974. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1974 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-27 schevill * tests-lib/Makefile.am: * Forgotten to link against lmpfi. This commit was extracted from SVN r1973. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1973 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-27 schevill * tests-tool/check.proto: * Stupid error. This commit was extracted from SVN r1972. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1972 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-27 schevill * tests-lib/check.proto, tests-tool/check.proto: * Now produces output files for each test. The output file is removed whenever the test passes. This commit was extracted from SVN r1971. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1971 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-27 schevill * tests-lib/Makefile.am, tests-lib/tdecompose_library_constant.c, tests-lib/tdecompose_library_function.c: * Makefile.am compatible with Cygwin? This commit was extracted from SVN r1970. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1970 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-27 clauter * tests-lib/Makefile.am, tests-tool/timecheck.sollya: Synchronizing again. This commit was extracted from SVN r1969. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1969 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-27 clauter * tests-lib/Makefile.am, tests-tool/Makefile.am: Synchronizing with Cygwin. This commit was extracted from SVN r1968. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1968 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-27 clauter * execute.c: Changed the "useless" operation in nop(n) in order to get more stable yardsticks in the time checks. This commit was extracted from SVN r1967. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1967 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-26 clauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/dieonerrormode.tex, doc/getsuppressedmessages.tex, doc/introExample51.tex, doc/parse.tex, doc/suppressmessage.tex, doc/time.tex, doc/timing.tex, doc/unsuppressmessage.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/dieonerrormode.php, doc/www/getsuppressedmessages.php, doc/www/introExample51.php, doc/www/parse.php, doc/www/suppressmessage.php, doc/www/time.php, doc/www/timing.php, doc/www/unsuppressmessage.php, help.h: Recompiled the documentation. This commit was extracted from SVN r1966. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1966 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-26 schevill * : Merged branch optimLists onto the trunk with svn merge -r1941:HEAD svn+ssh://schevill@scm.gforge.inria.fr/svn/sollya/branches/optimListsThis commit was extracted from SVN r1964. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1964 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-26 schevill * internparser.y, miniparser.y, parser.y: Merged trunk onto the branch with svn merge -r1954:1961 svn+ssh://schevill@scm.gforge.inria.fr/svn/sollya/trunk This commit was extracted from SVN r1962. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/optimLists@1962 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-26 clauter * doc/introExample25.tex, doc/introExample51.tex, doc/www/introExample25.php, doc/www/introExample51.php, execute.c: Changed behavior of assignments to elements of end-elliptic list when the list needs to be expanded with explicit elements before the assignment can be done. This commit was extracted from SVN r1961. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/optimLists@1961 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-26 schevill * parser.y: * Removed deprecated keywords from help help list. This commit was extracted from SVN r1960. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1960 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-26 clauter * internparser.y, miniparser.y, parser.y: Changed the implicit parenthezation for prepends. This commit was extracted from SVN r1959. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1959 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-26 schevill * tests-tool/Makefile.am: Forgotten entry in Makefile.am This commit was extracted from SVN r1958. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/optimLists@1958 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-26 schevill * tests-tool/check022.sollya, tests-tool/check022.sollya.reference: * Added tests for list manipulations. The test currently fails, due to what I think is a bug. This commit was extracted from SVN r1957. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/optimLists@1957 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-25 clauter * execute.c: Corrected a segfault bug. This commit was extracted from SVN r1956. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/optimLists@1956 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-25 schevill * tests-tool/timecheck.sollya.reference: * Stupid error. This commit was extracted from SVN r1955. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/optimLists@1955 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-25 schevill * doc/sollya.tex, sollya-library-wrappers.c, tests-lib/Makefile.am, tests-lib/tdecompose_function.c, tests-lib/tdecompose_function.reference, tests-lib/tget_function_arity.c, tests-lib/tget_function_arity.reference, tests-lib/tget_head_function.c, tests-lib/tget_head_function.reference, tests-lib/tget_subfunctions.c, tests-lib/tget_subfunctions.reference, tests-lib/tv_decompose_function.c, tests-lib/tv_decompose_function.reference, tests-lib/tv_get_subfunctions.c, tests-lib/tv_get_subfunctions.reference, tests-tool/timecheck.sollya, tests-tool/timecheck.sollya.reference, tests/Makefile.am, tests/check.proto, tests/check001.sollya, tests/check001.sollya.reference, tests/check002.sollya, tests/check002.sollya.reference, tests/check003.sollya, tests/check003.sollya.reference, tests/check004.sollya, tests/check004.sollya.reference, tests/check005.sollya, tests/check005.sollya.reference, tests/check006.sollya, tests/check006.sollya.reference, tests/check007.sollya, tests/check007.sollya.reference, tests/check008.sollya, tests/check008.sollya.reference, tests/check009.sollya, tests/check009.sollya.reference, tests/check010.sollya, tests/check010.sollya.reference, tests/check011.sollya, tests/check011.sollya.reference, tests/check012.sollya, tests/check012.sollya.reference, tests/check013.sollya, tests/check013.sollya.reference, tests/check014.sollya, tests/check014.sollya.reference, tests/check015.sollya, tests/check015.sollya.reference, tests/check016.sollya, tests/check016.sollya.reference, tests/check017.sollya, tests/check017.sollya.reference, tests/check018.sollya, tests/check018.sollya.reference, tests/check019.sollya, tests/check019.sollya.reference, tests/check020.sollya, tests/check020.sollya.reference, tests/check021.sollya, tests/check021.sollya.reference, tests/memoryleaks.sollya, tests/timecheck.sollya, tests/timecheck.sollya.reference: Merged trunk onto the branch with svn merge -r1941:1953 svn+ssh://schevill@scm.gforge.inria.fr/svn/sollya/trunk This commit was extracted from SVN r1954. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/optimLists@1954 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-25 schevill * doc/sollya.tex, tests-lib/Makefile.am, tests-lib/tdecompose_function.c, tests-lib/tdecompose_function.reference, tests-lib/tv_decompose_function.c, tests-lib/tv_decompose_function.reference, tests-lib/tv_get_subfunctions.c, tests-lib/tv_get_subfunctions.reference, tests-tool/timecheck.sollya, tests-tool/timecheck.sollya.reference: * Updated the documentation to remove the mention about the complexity of list operations * Added non-regression tests for memory references optimization and list operations optimization. * Finished to test decomposition functions in the library. This commit was extracted from SVN r1953. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1953 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-22 clauter * sollya-library-wrappers.c: Optimized access to elements in lists in library mode thru int sollya_lib_get_element_in_list(sollya_obj_t *res, sollya_obj_t obj1, int n). This commit was extracted from SVN r1952. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/optimLists@1952 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-22 clauter * sollya-library-wrappers.c: Simplified library wrapper code a little bit. This commit was extracted from SVN r1951. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1951 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-13 schevill * doc/sollya.tex: * Precisions in the documentation regarding: i) NULL as a sollya_obj_t when passed to sollya_lib_clear_obj and sollya_lib_printf. ii) NULL as the arity argument in sollya_lib_get_subfunctions. iii) _x_ interpreted as Id(_x_) for all decomposition functions. This commit was extracted from SVN r1950. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1950 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-13 clauter * sollya-library-wrappers.c: Simplified library code a bit. This commit was extracted from SVN r1949. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1949 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-13 schevill * tests-lib/tget_function_arity.reference: * Stupid forgotten test. This commit was extracted from SVN r1948. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1948 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-13 clauter * sollya-library-wrappers.c: Correct behavior of sollya_lib_v_get_subfunctions and *_decompose_* for the free variable. This commit was extracted from SVN r1947. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1947 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-13 schevill * tests-lib/Makefile.am, tests-lib/tget_function_arity.c, tests-lib/tget_function_arity.reference, tests-lib/tget_head_function.c, tests-lib/tget_head_function.reference, tests-lib/tget_subfunctions.c, tests-lib/tget_subfunctions.reference: * Tests for decomposition functions. This commit was extracted from SVN r1946. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1946 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-13 schevill * tests/Makefile.am, tests/check.proto, tests/check001.sollya, tests/check001.sollya.reference, tests/check002.sollya, tests/check002.sollya.reference, tests/check003.sollya, tests/check003.sollya.reference, tests/check004.sollya, tests/check004.sollya.reference, tests/check005.sollya, tests/check005.sollya.reference, tests/check006.sollya, tests/check006.sollya.reference, tests/check007.sollya, tests/check007.sollya.reference, tests/check008.sollya, tests/check008.sollya.reference, tests/check009.sollya, tests/check009.sollya.reference, tests/check010.sollya, tests/check010.sollya.reference, tests/check011.sollya, tests/check011.sollya.reference, tests/check012.sollya, tests/check012.sollya.reference, tests/check013.sollya, tests/check013.sollya.reference, tests/check014.sollya, tests/check014.sollya.reference, tests/check015.sollya, tests/check015.sollya.reference, tests/check016.sollya, tests/check016.sollya.reference, tests/check017.sollya, tests/check017.sollya.reference, tests/check018.sollya, tests/check018.sollya.reference, tests/check019.sollya, tests/check019.sollya.reference, tests/check020.sollya, tests/check020.sollya.reference, tests/check021.sollya, tests/check021.sollya.reference, tests/memoryleaks.sollya, tests/timecheck.sollya, tests/timecheck.sollya.reference: * Removed all 'tests' directory, now useless. This commit was extracted from SVN r1945. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1945 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-12 clauter * assignment.c, execute.c, expression.h: Yet improved random access to elements of lists (when the list is used as an rvalue): if the list is has no memrefed copy and has already been annotated for random access, the annotation survives tail operations on a variable containing that list and, in most cases, prepend operations. This commit was extracted from SVN r1944. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/optimLists@1944 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-11 clauter * execute.c: Optimized random access to lists (and final-elliptic lists) when the access is used in an rvalue. This commit was extracted from SVN r1943. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/optimLists@1943 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-11 clauter * assignment.c, execute.c, expression.h: Made a first step toward optimization of random accesses into lists. This commit was extracted from SVN r1942. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/optimLists@1942 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-11 schevill * : New branch for optimizing random access to lists. Removed old memoryopt branch. This commit was extracted from SVN r1941. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/optimLists@1941 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-08 schevill * tests-tool/timecheck.sollya, tests-tool/timecheck.sollya.reference: * Added non-regression tests for bug #15363. This commit was extracted from SVN r1939. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1939 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-08 schevill * doc/sollya.pdf, doc/sollya.tex, tests-lib/tdecompose_library_constant.c, tests-lib/tdecompose_library_constant.reference: * Test fo decompose_library_constant now works. This commit was extracted from SVN r1938. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1938 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-08 clauter * minilexer.l, miniparser.y: Added forgotten libraryconstant binding to mini-lexer and mini-parser. This commit was extracted from SVN r1937. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1937 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-08 schevill * tests-lib/Makefile.am, tests-lib/libraryexample.c, tests-lib/tdecompose_library_constant.c, tests-lib/tdecompose_library_constant.reference, tests-lib/tdecompose_library_function.c, tests-lib/tdecompose_library_function.reference: * Some tests for decompose* This commit was extracted from SVN r1936. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1936 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-08 clauter * expression.c: Patched a bug in hornerization found while investigating on "[#15363] evaluate is unexpectedly slow" This commit was extracted from SVN r1935. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1935 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-08 clauter * execute.c: Patched the apparent side of the bug "[#15363] evaluate is unexpectedly slow" This commit was extracted from SVN r1934. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1934 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-01 schevill * tests-lib/tbuild_function_procedurefunction.reference: * Again This commit was extracted from SVN r1933. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1933 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-02-01 schevill * tests-lib/tbuild_function_procedurefunction.reference: * Small typo This commit was extracted from SVN r1932. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1932 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-31 schevill * tests-lib/tv_fpminimax.c: * Corrected a problem with the test for v_fpminimax that appeared with the recent changes in parse/parse_string. This commit was extracted from SVN r1931. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1931 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-31 schevill * tests-lib/tbuild_function_libraryconstant.c, tests-lib/tbuild_function_libraryconstant.reference, tests-lib/tbuild_function_libraryfunction.c, tests-lib/tbuild_function_libraryfunction.reference, tests-lib/tbuild_function_procedurefunction.reference, tests-lib/tdecompose_library_function.c, tests-lib/tlibraryconstant.c, tests-lib/tlibraryconstant.reference, tests-lib/tlibraryfunction.c, tests-lib/tlibraryfunction.reference, tests-lib/tprocedurefunction.c, tests-lib/tprocedurefunction.reference: * Added tests for libraryfunction, libraryconstant and procedurefunction. This commit was extracted from SVN r1930. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1930 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-31 schevill * execute.c: * Corrected typo in a message. This commit was extracted from SVN r1929. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1929 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-31 schevill * doc/sollya.pdf, doc/sollya.tex: * Updated the documentation with the new signature of sollya_library_decompose_library_* This commit was extracted from SVN r1928. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1928 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-31 schevill * tests-lib/tfpminimax.c: * Corrected a syntax error in a parse_string that became visible with the last changes to parse/parse_string This commit was extracted from SVN r1927. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1927 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-31 clauter * internparser.y, miniparser.y, parser.y: Unified Sollya syntax with respect to () representing (void) in some contexts. This commit was extracted from SVN r1926. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1926 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-30 clauter * execute.c, general.c, general.h, minilexer.l, miniparser.y: Corrected behavior of parse/ parse_string in order to correctly fail if the string to parse contains excess characters after an expression that conforms to the Sollya expression grammar. For some reason, the patch breaks the library tests for fpminimax. This needs to be investigated on. This commit was extracted from SVN r1925. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1925 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-30 clauter * miniparser.y, sollya-library-wrappers.c, sollya.h: Changed type from void** to pointer to pointer to function as C99 nevertheless allows this. This commit was extracted from SVN r1924. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1924 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-29 schevill * doc/sollya.pdf, doc/sollya.tex, tests-lib/Makefile.am, tests-lib/tbuild_function_procedurefunction.c, tests-lib/tdecompose_library_function.c, tests-lib/tdecompose_library_function.reference: * Documentation of sollya_lib_decompose_*(library|procedure)* * (Unsuccessful) attempt to write test code for sollya_lib_decompose_library_function. This commit was extracted from SVN r1923. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1923 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-29 clauter * execute.c, expression.c: Corrected a bug in displaying of procedure functions and library functions that are memref'ed. The bug might have yielded to a bug. This commit was extracted from SVN r1922. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1922 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-29 clauter * tests-lib/tbuild_function_procedurefunction.c: Corrected a copy/paste error in one of the tests. This commit was extracted from SVN r1921. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1921 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-28 schevill * tests-lib/Makefile.am, tests-lib/tbuild_function_libraryconstant.c, tests-lib/tbuild_function_libraryconstant.reference, tests-lib/tbuild_function_libraryfunction.c, tests-lib/tbuild_function_libraryfunction.reference, tests-lib/tbuild_function_procedurefunction.c, tests-lib/tbuild_function_procedurefunction.reference: * build_function_* variants of libraryfunction, libraryconstant and procedurefunction This commit was extracted from SVN r1920. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1920 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-28 schevill * doc/sollya.tex: * Corrected small typos. This commit was extracted from SVN r1919. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1919 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-28 schevill * tests-lib/tlibraryconstant.c, tests-lib/tlibraryconstant.reference, tests-lib/tlibraryfunction.c, tests-lib/tlibraryfunction.reference: * Tests of library* should now work even when dladdr is not available. This commit was extracted from SVN r1918. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1918 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-28 schevill * tests-lib/tlibraryconstant.c: * Test is now prepared for compatibility with architectures where dladdr is not available. This commit was extracted from SVN r1917. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1917 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-28 clauter * library.c: One forgotten occurrence This commit was extracted from SVN r1916. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1916 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-28 clauter * library.c: Patched a problem with function name unification in library function/ constant binding code and changed the base name for library constants to const instead of func. This commit was extracted from SVN r1915. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1915 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-28 schevill * tests-lib/tlibraryconstant.c: * Forgot an occurrence of func when replacing func by const everywhere. This commit was extracted from SVN r1914. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1914 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-28 schevill * tests-lib/Makefile.am, tests-lib/tlibraryconstant.c, tests-lib/tlibraryconstant.reference, tests-lib/tlibraryfunction.c, tests-lib/tlibraryfunction.reference, tests-lib/tprocedurefunction.c, tests-lib/tprocedurefunction.reference: * Tests for libraryconstantn libraryfunction and procedurefunction This commit was extracted from SVN r1913. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1913 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-28 schevill * infnorm.c: * Corrected memory leak. This commit was extracted from SVN r1912. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1912 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-28 clauter * doc/sollya.tex, library.c, library.h: Documented and improved the sollya library functions that construct library functions, library constants and procedure functions in library mode. This commit was extracted from SVN r1911. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1911 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-25 clauter * doc/sollya.tex: Corrected two typos in the documentation. This commit was extracted from SVN r1910. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1910 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-25 schevill * chebModels.c, chebModels.h, rigorousIntegralCM.c, tadiff.c, tadiff.h, taylorModel.c, taylorModel.h, testChebModels.sollya, testIntegralGoldstein.sollya, testIntegrals.sollya: * Cleaning-up: creation of a misc section to gather all files related to Sollya and its development, but which are not intended to be distributed in the trunk. * Suppression of the experimentalChebModels branch. This commit was extracted from SVN r1909. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1909 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-25 schevill * doc/sollya.tex: * Now with a recompiled PDF This commit was extracted from SVN r1908. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1908 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-25 schevill * doc/sollya.tex: Finished reworking the documentation of the ...get_subfunctions. This commit was extracted from SVN r1907. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1907 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-18 clauter * doc/sollya.tex: Added documentation for sollya_lib_apply. This commit was extracted from SVN r1906. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1906 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-11 schevill * doc/externalplot.shlp, doc/externalplot.tex, doc/sollya.tex: * First step towards a better documentation of sollya_lib_get_subfunctions. This commit was extracted from SVN r1904. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1904 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-11 clauter * sollya-library-wrappers.c, sollya.h: Added a way to decompose library functions, library constants and procedure functions with the Sollya library. This commit was extracted from SVN r1903. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1903 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-11 clauter * sollya-library-wrappers.c: Corrected behavior of Sollya lib functions intended to decompose function expressions containing procedure functions. This commit was extracted from SVN r1902. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1902 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-11 clauter * doc/accurateinfnorm.tex, doc/bashevaluate.tex, doc/bashexecute.tex, doc/floating.tex, doc/fpminimax.tex, doc/function.tex, doc/introExample37bis.tex, doc/introExample51.tex, doc/parse.tex, doc/printexpansion.tex, doc/remez.tex, doc/subpoly.tex, doc/supnorm.tex, doc/taylorrecursions.tex, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/introExample37bis.php, doc/www/introExample51.php, doc/www/time.php, doc/www/timing.php, help.h: Recompiled the whole documentation. This commit was extracted from SVN r1901. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1901 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-11 clauter * plot.c: Fixing bug [#14811] plot seems to enter an infinite loop whenever the interval is very small This commit was extracted from SVN r1900. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1900 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-11 clauter * execute.c: Fixing bug [#13944] dirtyfindzeros goes into an infinite loop on unbounded intervals This commit was extracted from SVN r1899. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1899 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-11 clauter * tests-tool/check018.sollya, tests-tool/check018.sollya.reference: Adding a non-regression test for tracker [#13943] Rationalapprox with low approximation accuracy makes MPFR assertion fail, killing the tool's execution This commit was extracted from SVN r1898. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1898 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-11 clauter * infnorm.c: Fixing bug [#15250] Incoherent behavior of Sollya This commit was extracted from SVN r1897. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1897 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-11 clauter * expression.c, expression.h, infnorm.c, tests-tool/check018.sollya, tests-tool/check018.sollya.reference: Still improved the behavior of pre-evaluation of mem-ref'ed constant expressions. This commit was extracted from SVN r1896. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1896 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-09 clauter * infnorm.c: Improved the usefulness of a warning message and added extra-pessimist code to constant term memref'ed interval pre-evaluation. This commit was extracted from SVN r1895. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1895 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-09 clauter * expansion.h: Corrected a typing issue in expansion.h. This commit was extracted from SVN r1894. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1894 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-09 clauter * execute.c: Fixing [#15249] Hornerisation and autoprint of a polynomial containing NaNs makes the tool exit with error This commit was extracted from SVN r1893. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1893 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-08 clauter * expression.c: Some small progress in debugging "p = (0 * x) / NaN + NaN; p;" This commit was extracted from SVN r1892. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1892 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-03 clauter * execute.c, expression.c, infnorm.c, infnorm.h, mpfi-compat.c, mpfi-compat.h: Improved performance on repeated evaluation of constant expressions. This commit was extracted from SVN r1891. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1891 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-03 clauter * expression.h: Added a line to allow for future extensions of MEMREF logic. This commit was extracted from SVN r1890. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1890 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2013-01-03 clauter * doc/sollya.tex: Added some explanations for the particular cases encountered with sollya_lib_decompose_function and library constants, library functions and procedure functions. This commit was extracted from SVN r1888. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1888 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-13 clauter * chebyshevform.c: Patched another memory leak in chebyshevform. This commit was extracted from SVN r1887. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1887 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-13 schevill * tests-lib/tprintf.c: * Implemented my own strnlen since it is only available on GNU systems. This commit was extracted from SVN r1886. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1886 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-13 schevill * tests-lib/tprintf.c: * Changed header defining ptrdiff_t by something more robust. This commit was extracted from SVN r1885. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1885 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-13 clauter * chebyshevformaux.c: Tried to patch a memory leak in chebushevform. This commit was extracted from SVN r1884. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1884 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-13 clauter * xml.c: Patched several memory leaks in readxml. This commit was extracted from SVN r1883. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1883 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-13 schevill * tests-lib/tprintf.c, tests-lib/tprintf.reference: * tprintf now tests all integer conversions. This commit was extracted from SVN r1882. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1882 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-12 clauter * printf.c: Added support for j,z,t modifiers in %n conversions of sollya_lib_(vs(n))printf. Support for j somehow makes sense, no guarantee is given for z and t. This commit was extracted from SVN r1881. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1881 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-12 clauter * doc/infnorm.shlp, doc/infnorm.tex, doc/www/infnorm.php, help.h: Corrected a typo in a help file. This commit was extracted from SVN r1880. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1880 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-11 schevill * doc/taylorform.shlp, doc/taylorform.tex, doc/www/taylorform.php, help.h: * Modified the doc of taylorform to make it less ambiguous about what is p. This commit was extracted from SVN r1877. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1877 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-11 schevill * tests-lib/tprintf.c: * Added a missing header, that should provide a definition for type ssize_t. This commit was extracted from SVN r1876. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1876 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-10 schevill * external.c, plot.c: * More robust choice for the names of temporary files in plot and externalplot. This commit was extracted from SVN r1875. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1875 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-10 clauter * general.c, general.h: Added functions getTempDir() and getUniqueId() to allow temporary files to be placed in the right directory and to have a unique name for a run of the tool. This commit was extracted from SVN r1874. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1874 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-10 schevill * external.c: * Patched a memory leak This commit was extracted from SVN r1873. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1873 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-10 clauter * internparser.y, miniparser.y: Patched a memory leak in the intern- and miniparser. This commit was extracted from SVN r1872. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1872 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-09 clauter * execute.c: Patched a memory leak. This commit was extracted from SVN r1871. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1871 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-09 schevill * tests-lib/tprintf.c, tests-lib/tprintf.reference: * Test file for printf. Still some work to do, even only for integer conversions. This commit was extracted from SVN r1870. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1870 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-07 clauter * configure.ac, expression.h: Added --enable-legacy-memory-management as option to configure. When enabled, legacy memory management will not use reference counting. This normally results in worse execution speed and higher memory consumption. The mode is needed for memory leak debugging, though. This commit was extracted from SVN r1869. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1869 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-06 clauter * execute.c, expression.c: Patched two possible memory leaks. This commit was extracted from SVN r1868. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1868 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-04 clauter * expansion.h: Added a complete new version of expansion.h used by metalibm for final compilation of the produced code and dynamic binding with Sollya. This commit was extracted from SVN r1867. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1867 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-04 clauter * expansion.h: Yet another forgotten line. This commit was extracted from SVN r1866. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1866 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-04 clauter * expansion.h, tests-tool/check017.sollya, tests-tool/check017.sollya.reference: Added a non-regression test for bug "[#15162] Comparison of accesses to structures yields a wrong result or segfaults", patched at revision 1864. This commit was extracted from SVN r1865. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1865 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-12-04 clauter * execute.c: Patched a bug with comparisons of structure accesses. This commit was extracted from SVN r1864. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1864 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-30 schevill * tests-tool/check009.sollya, tests-tool/check009.sollya.reference: * Added a non regression test for bug #15147. This commit was extracted from SVN r1863. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1863 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-30 clauter * assignment.c, chain.c: Fixed bug "[#15147] The first tail operation on a list passed in argument of a procedure reverts the list." This commit was extracted from SVN r1862. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1862 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-27 clauter * expansion.h: Started adding some macros to expansion.h that are needed by metalibm to perform periodic argument reduction. This commit was extracted from SVN r1861. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1861 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-26 clauter * expansion.c, proof.c, tests-lib/timplementpoly.reference, tests-lib/tv_implementpoly.reference: Made implementpoly compatible with newer versions of Gappa while trying to maintain backward compatibility; made metalibm test code compile again. This commit was extracted from SVN r1860. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1860 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-26 clauter * execute.c: Patched a bug found when running metalibm. This commit was extracted from SVN r1859. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1859 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-23 clauter * external.c, plot.c: Trying again to overcome what seems to be a bug in some recent versions of gnuplot, this time in a way that should not affecy the other users. This commit was extracted from SVN r1858. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1858 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-22 schevill * external.c, plot.c: Reverted change of the previous revision. The patch *is* a bug. Indeed, correcting it is easy: it suffices to change "%" into "%%". Moreover, "%g" would sound more appropriate to me than "%e" and would be conform to the behavior on the setting by default in my version of gnuplot. @Christoph: can you explain the nature of the "displaying error" that you mention? Would "%g" make bug recent versions of gnuplot? This commit was extracted from SVN r1857. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1857 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-22 clauter * external.c, plot.c: Fixed a displaying error with newer versions of gnuplot. This commit was extracted from SVN r1856. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1856 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-22 clauter * expression.c, tests-tool/check018.sollya, tests-tool/check018.sollya.reference: Fixed bug #14259 An overflow in GMP makes Sollya crash (on 64bit machines only) This commit was extracted from SVN r1855. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1855 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-22 clauter * configure.ac: Made Sollya compile and run through the tests with icc (and icpc) on at least one 64bit system and at least some version of icc. This commit was extracted from SVN r1854. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1854 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-21 schevill * tests-tool/check015.sollya, tests-tool/check015.sollya.reference: * Added some non-regression tests for bug #15109. This commit was extracted from SVN r1853. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1853 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-21 schevill * supnorm.c: * Fixed bug #15109 This commit was extracted from SVN r1852. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1852 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-20 clauter * printf.c: Highly simplified the Sollya-printf code. This commit was extracted from SVN r1851. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1851 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-19 clauter * printf.c: Changed printf again to get the right interpretation of "%-*b" when * means a negative number. This commit was extracted from SVN r1849. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1849 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-19 clauter * printf.c: Removed truncation code in sollyaPrintf after discussion with Sylvain. This commit was extracted from SVN r1848. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1848 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-19 clauter * printf.c: A small correction in the printf code. This commit was extracted from SVN r1847. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1847 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-18 clauter * printf.c: Added some (limited) support for the field width modifier in %v, %w, %r et %b conversions. The code is still to be tested. This commit was extracted from SVN r1846. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1846 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-14 clauter * supnorm.c: Understood and improved precision determination in supnorm. This commit was extracted from SVN r1843. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1843 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-14 clauter * sollya.h: A first proposal to implementation of solly_fp_result_t as a flagged type. This commit was extracted from SVN r1841. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1841 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-14 clauter * sollya.h: Changed the sollya.h header to make it compatible with Python/C++ as suggested by Nicolas Brunie. This commit was extracted from SVN r1839. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1839 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-13 clauter * doc/readfile.tex, doc/www/readfile.php, execute.c, help.h: Patched a bug in readfile. This commit was extracted from SVN r1838. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1838 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-13 schevill * doc/accurateinfnorm.tex, doc/bashevaluate.tex, doc/bashexecute.tex, doc/floating.tex, doc/fpminimax.tex, doc/function.tex, doc/parse.tex, doc/printexpansion.tex, doc/remez.tex, doc/subpoly.tex, doc/supnorm.tex, doc/taylorrecursions.tex, doc/time.tex, doc/timing.tex, help.h: * Recompiled the doc (WARNING: many unexpected changes). This commit was extracted from SVN r1836. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1836 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-13 schevill * fpminimax.cpp: * Reverted changes between revisions 1825 and 1827 in fpminimax.cpp This commit was extracted from SVN r1835. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1835 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-12 clauter * doc/implementconstant.tex, doc/introExample51.tex, doc/www/implementconstant.php, doc/www/introExample51.php, help.h, implementconst.c: Patched a segfault due to insufficient memory reference deferencing, as seen with bashexecute("gcc -fPIC -Wall -c ./doc/libraryconstantexample.c -I$HOME/.local/include"); bashexecute("gcc -shared -o libraryconstantexample libraryconstantexample.o -lgmp -lmpfr"); euler_gamma = libraryconstant("./libraryconstantexample"); implementconstant(euler_gamma^(1/3)); This commit was extracted from SVN r1833. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1833 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-12 clauter * doc/introExample51.tex, doc/www/introExample51.php, double.c, double.h, execute.c, help.h, sollya-messages.h, sollya-messaging.h, tests-lib/tconstant.reference, tests-lib/tmantissa_and_exponent.reference: Changed round in order to avoid any double rounding issue. round now takes a constant expression in argument and rounds it without evaluating it first to a faithful rounding. In cases when round cannot determine the correct rounding or the actual rounding direction (ternary value) a warning is displayed (at least in verbosity >= 2). This commit was extracted from SVN r1832. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1832 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-12 schevill * double.c: * Optimized the assignment of an mpq (I was looking for possible places where we would have forgotten to perform a mpq_canonicalize: there is no such place, but I discovered this small possible optimization). This commit was extracted from SVN r1831. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1831 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-12 clauter * double.c, double.h, execute.c: A small change in preparation of changing the double-rounding behavior of round(). This commit was extracted from SVN r1830. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1830 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-12 clauter * doc/accurateinfnorm.tex, doc/bashevaluate.tex, doc/bashexecute.tex, doc/dieonerrormode.tex, doc/doubleextended.tex, doc/floating.tex, doc/fpminimax.tex, doc/function.tex, doc/implementconstant.tex, doc/introExample12.tex, doc/introExample16.tex, doc/introExample17.tex, doc/introExample19.tex, doc/introExample32.tex, doc/introExample33.tex, doc/introExample34.tex, doc/introExample37bis.tex, doc/introExample38.tex, doc/introExample4.tex, doc/introExample40.tex, doc/introExample46.tex, doc/introExample47.tex, doc/introExample5.tex, doc/introExample51.tex, doc/introExample8.tex, doc/parse.tex, doc/pi.tex, doc/printdouble.tex, doc/printexpansion.tex, doc/printsingle.tex, doc/readfile.tex, doc/remez.tex, doc/roundingwarnings.tex, doc/sollya.pdf, doc/subpoly.tex, doc/supnorm.tex, doc/taylorform.tex, doc/taylorrecursions.tex, doc/time.tex, doc/timing.tex, doc/www/accurateinfnorm.php, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/dieonerrormode.php, doc/www/doubleextended.php, doc/www/floating.php, doc/www/fpminimax.php, doc/www/function.php, doc/www/implementconstant.php, doc/www/introExample12.php, doc/www/introExample16.php, doc/www/introExample17.php, doc/www/introExample19.php, doc/www/introExample32.php, doc/www/introExample33.php, doc/www/introExample34.php, doc/www/introExample37bis.php, doc/www/introExample38.php, doc/www/introExample4.php, doc/www/introExample40.php, doc/www/introExample46.php, doc/www/introExample47.php, doc/www/introExample5.php, doc/www/introExample51.php, doc/www/introExample8.php, doc/www/parse.php, doc/www/pi.php, doc/www/printdouble.php, doc/www/printexpansion.php, doc/www/printsingle.php, doc/www/readfile.php, doc/www/remez.php, doc/www/roundingwarnings.php, doc/www/subpoly.php, doc/www/supnorm.php, doc/www/taylorform.php, doc/www/taylorrecursions.php, doc/www/time.php, doc/www/timing.php, execute.c, help.h, sollya-library-wrappers.c, sturm.c, tests-tool/check001.sollya.reference: Implemented Florent de Dinechin's proposal to display the precision a faithful rounding has been done to when a faithful rounding is used instead of a constant expression. This commit was extracted from SVN r1829. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1829 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-09 clauter * execute.c: Added a TODO This commit was extracted from SVN r1828. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1828 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-08 clauter * fpminimax.cpp: Commented the debug messages added today. This commit was extracted from SVN r1827. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1827 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-08 schevill * fpminimax.cpp: Still a commit for sync purpose This commit was extracted from SVN r1826. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1826 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-08 clauter * fpminimax.cpp: Synchronization with Sylvain. This commit was extracted from SVN r1825. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1825 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-08 clauter * expression.c: Trying to overcome an apparent problem with some GMP versions. This commit was extracted from SVN r1823. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1823 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-07 clauter * taylorform.c: Trying to fix a bug on 32 bit systems introduced in revision 1775. This commit was extracted from SVN r1822. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1822 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-06 clauter * double.c: Fixed a problem seen with printsingle on armv6l devices (Raspberry Pi). This commit was extracted from SVN r1818. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1818 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-06 clauter * internlexer.l, lexer.l, minilexer.l: Avoided use of fprintf by generated lexer by pound-defining fprintf as sollyaFprintf in lexer files. This commit was extracted from SVN r1817. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1817 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-06 clauter * internparser.y, miniparser.y, parser.y, tests-lib/tprintf.reference: Added a missing reference file and defined a macro in the parser to use sollyaFPrintf instead of vanilla fprintf. This commit was extracted from SVN r1816. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1816 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-06 clauter * doc/CommandsAndFunctions.tex, doc/getsuppressedmessages.shlp, doc/getsuppressedmessages.tex, doc/sollya.pdf, doc/www/ListOfCommands.php, doc/www/getsuppressedmessages.php, help.h: Documented getsuppressedmessages(). This commit was extracted from SVN r1814. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1814 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-06 clauter * double.c, expansion.c, external.c, general.c, general.h, implement.c, plot.c, sollya-library-wrappers.c, tests-lib/tget_constant_as_double.reference, tests-lib/tprintdouble.reference, tests-lib/tprintsingle.reference, tests-tool/check001.sollya.reference, worstcase.c: Made double and single precision NaN generation bitwise compatible on all known types of systems. This commit was extracted from SVN r1813. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1813 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-06 clauter * tests-lib/tevaluate_function_at_constant_expression.c, tests-lib/tevaluate_function_at_constant_expression.reference, tests-lib/tevaluate_function_at_point.c, tests-lib/tevaluate_function_at_point.reference: Two small changes to the library test to overcome a problem with NaN display (w/ or w/o sign). This commit was extracted from SVN r1812. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1812 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-05 schevill * tests-lib/Makefile.am: * Removed double occurrence of tprintf.c in Makefile.am This commit was extracted from SVN r1811. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1811 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-05 schevill * tests-lib/tget_constant_as_int.c, tests-lib/tget_constant_as_int64.c, tests-lib/tget_constant_as_uint64.c: * Reverted change from revision 1807, for tget_constant_as* The change had been automatically applied by a script, and it was a mistake to apply it on these functions. Changes have been reverted by the following command: svn merge -r1807:1806 tget_constant_as*.c This commit was extracted from SVN r1810. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1810 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-05 clauter * printf.c, tests-lib/Makefile.am: Some enhancements to the Sollya printfs. This commit was extracted from SVN r1809. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1809 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-05 schevill * tests-lib/Makefile.am, tests-lib/tand.c, tests-lib/tcmp_equal.c, tests-lib/tcmp_greater.c, tests-lib/tcmp_greater_equal.c, tests-lib/tcmp_in.c, tests-lib/tcmp_less.c, tests-lib/tcmp_less_equal.c, tests-lib/tcmp_not_equal.c, tests-lib/tconstant.c, tests-lib/tconstant_from_double.c, tests-lib/tget_constant_as_int.c, tests-lib/tget_constant_as_int64.c, tests-lib/tget_constant_as_uint64.c, tests-lib/tinf.c, tests-lib/tlength.c, tests-lib/tmacros_build_function.c, tests-lib/tmax.c, tests-lib/tmid.c, tests-lib/tmin.c, tests-lib/tnegate.c, tests-lib/tor.c, tests-lib/tprintf.c, tests-lib/trange_from_bounds.c, tests-lib/trange_from_interval.c, tests-lib/tremez.c, tests-lib/tsup.c, tests-lib/tv_max.c, tests-lib/tv_min.c, tests-lib/tv_remez.c: * Removed unnecessary instances of sollya_lib_uninstall_msg_callback. * Added a skeleton for tprintf. No reference file currently however. This commit was extracted from SVN r1807. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1807 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-05 clauter * expression.c: Added a small memory optimization to hornerization. This commit was extracted from SVN r1806. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1806 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-05 clauter * doc/CommandsAndFunctions.tex, doc/sollya.pdf, doc/unsuppressmessage.shlp, doc/unsuppressmessage.tex, doc/www/ListOfCommands.php, doc/www/unsuppressmessage.php, help.h: Documented unsuppressmessage. This commit was extracted from SVN r1805. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1805 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-02 clauter * doc/showmessagenumbers.shlp, doc/showmessagenumbers.tex, doc/sollya.pdf, doc/www/showmessagenumbers.php, help.h: Forgot to save a file before the last commit. This commit was extracted from SVN r1804. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1804 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-11-02 clauter * doc/CommandsAndFunctions.tex, doc/sollya.pdf, doc/suppressmessage.shlp, doc/suppressmessage.tex, doc/www/ListOfCommands.php, doc/www/suppressmessage.php, help.h: Documented suppressmessage. This commit was extracted from SVN r1803. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1803 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-31 clauter * doc/showmessagenumbers.shlp, doc/showmessagenumbers.tex, doc/sollya.pdf, doc/www/showmessagenumbers.php, help.h: Updated documentation for showmessagenumbers for library names. This commit was extracted from SVN r1802. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1802 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-31 clauter * help.h: Documented showmessagenumbers. This commit was extracted from SVN r1801. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1801 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-31 clauter * doc/CommandsAndFunctions.tex, doc/keywords.def, doc/roundingwarnings.shlp, doc/roundingwarnings.tex, doc/showmessagenumbers.shlp, doc/showmessagenumbers.tex, doc/sollya.pdf, doc/verbosity.shlp, doc/verbosity.tex, doc/www/ListOfCommands.php, doc/www/roundingwarnings.php, doc/www/showmessagenumbers.php, doc/www/verbosity.php: Documented showmessagenumbers. This commit was extracted from SVN r1800. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1800 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-31 clauter * parser.y: Added a forgotten line to TODO. Added a couple of forgotten functions to help help. This commit was extracted from SVN r1799. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1799 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-31 clauter * doc/sollya.pdf, doc/sollya.tex: Added the sprintf family of functions to the doc and corrected some typos. This commit was extracted from SVN r1798. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1798 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-30 clauter * printf.c: Added an implementation for sollya_lib(_v)_s(n)printf. This commit was extracted from SVN r1793. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1793 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-30 clauter * printf.c, printf.h, sollya-library-wrappers.c, sollya.h: Started working on (v)s(n)printf. This commit was extracted from SVN r1792. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1792 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-30 clauter * execute.c, expression.c, expression.h: Improved degree (and sollya_lib_degree) to handle degrees larger than the largest int value. This commit was extracted from SVN r1791. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1791 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-30 clauter * execute.c, expression.c, expression.h: Still improved hornerization of expressions of high degree that are pretty sparse. This commit was extracted from SVN r1790. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1790 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-30 schevill * chain.c, remez.c: * Removed other possible dangerous casts. Some remain, for which I am not sure of what should be done. This commit was extracted from SVN r1788. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1788 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-29 clauter * expression.c: Added a last optimization for extracting the i-th coefficient of a polynomial given by an expression that is written a certain way. This commit was extracted from SVN r1786. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1786 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-29 clauter * expression.c, sollya-messages.h, sollya-messaging.h: Added again some optimization coefficient extraction code. This commit was extracted from SVN r1785. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1785 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-26 clauter * expression.c: Added an optimization to get the i-th coefficient of a polynomial fast if the polynomial given has some suitable form. This commit was extracted from SVN r1784. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1784 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-26 clauter * execute.c, expression.c, expression.h, general.h: Still some improvement with the issue with very sparse polynomials of very high degree. This commit was extracted from SVN r1783. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1783 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-26 clauter * expression.c: A simple patch to allow for differentiation of monomials with very high degree: diff(x^2147483647). This commit was extracted from SVN r1782. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1782 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-26 clauter * chebyshevform.c: Tried to add procedure functions to Chebyshev forms. The code seems to work (tested on exp) but I am not an expert with Chebyshev forms. This commit was extracted from SVN r1781. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1781 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-26 schevill * execute.c, expression.c, expression.h: * Fixed a possible silent rounding bug. This commit was extracted from SVN r1779. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1779 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-26 clauter * chebyshevform.c, chebyshevformaux.c, double.c, execute.c, sollya-messages.h, sollya-messaging.h: Corrected Chebyshev form code for printMessage and sollyaPrintf usage. Removed two memory leaks in Remez code found in execute.c. This commit was extracted from SVN r1778. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1778 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-26 schevill * sollya-library-wrappers.c: * Patched bug #15015: stupid error of copy-paste. This commit was extracted from SVN r1777. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1777 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-25 schevill * doc/sollya.tex, doc/www/ListOfCommands.php: * Integrated some of the remarks of Serge and Mark into sollya.tex (misusage and typos) * Updated TODO and Memo-release.txt * Patched a bug in ListOfCommands.php This commit was extracted from SVN r1776. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1776 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-24 clauter * : Reported memoryopt branch back onto trunk using svn merge -r 1758:HEAD svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt . This commit was extracted from SVN r1775. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1775 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-24 clauter * assignment.c: Yet another optimization for tail operations. This commit was extracted from SVN r1773. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1773 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-24 clauter * assignment.c, assignment.h, execute.c: Optimized l = tail(l) operations. This commit was extracted from SVN r1772. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1772 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-23 clauter * assignment.c, execute.c, expression.h: Yet another small optimization for evaluation of general objects, in particular long lists. This commit was extracted from SVN r1771. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1771 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-23 clauter * assignment.c, execute.c, execute.h: Finished optimizing list prepends on re-assignment, say l = a .: l; Also optimized comparison of lists, head operations and evaluation in general. This commit was extracted from SVN r1770. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1770 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-22 clauter * assignment.c, assignment.h, execute.c: Started working on optimizing list prepends. This commit was extracted from SVN r1769. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1769 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-22 clauter * execute.h, expression.c, expression.h: Made two functions static inline. This brings quite a performance increase (on my laptop at least). This finishes the next phase concerning memory optimization. This commit was extracted from SVN r1768. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1768 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-19 clauter * execute.c, expression.c: Finished the second phase of the work necessary for memory optimization. Memory reference counting for node*'s are now enabled. This commit was extracted from SVN r1767. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1767 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-19 clauter * autodiff.c, chebyshevform.c, chebyshevformaux.c, execute.c, expression.c, fpminimax.cpp, implement.c, implementconst.c, match.c, proof.c, sturm.c, supnorm.c, taylorform.c, xml.c: Finished the first phase of the work necessary for memory optimization. This commit was extracted from SVN r1766. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1766 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-18 clauter * double.c, sollya-library-wrappers.c: Still some progress with memory optimization. This commit was extracted from SVN r1765. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1765 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-18 clauter * expression.c, infnorm.c: Again progress with memory optimization. This commit was extracted from SVN r1764. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1764 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-17 clauter * execute.c, expression.c: Yet again some progress with memory optimization. This commit was extracted from SVN r1763. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1763 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-16 clauter * execute.c, expression.h: Again some progress with memory optimization. This commit was extracted from SVN r1762. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1762 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-15 clauter * execute.c: Some progress with memory optimization. This commit was extracted from SVN r1761. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1761 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-12 clauter * execute.c, execute.h, expression.c, expression.h: Some first progress with memory usage optimization. This commit was extracted from SVN r1760. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1760 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-10-12 clauter * : Opened a branch to work on memory optimization for some operations. This commit was extracted from SVN r1759. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/memoryopt@1759 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-06-26 schevill * tests-lib/tconstant_from_int64.c, tests-lib/tconstant_from_uint64.c, tests-lib/tmacros_build_function.c: * Should now be completely compliant with *int64_t types. This commit was extracted from SVN r1757. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1757 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-06-26 schevill * tests-lib/tmacros_build_function.c, tests-lib/tprintdouble.c, tests-lib/tprintsingle.c: * Patched the tests of the lib so that sollya_lib_constant_from_double is always really used with double numbers. This commit was extracted from SVN r1756. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1756 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-06-21 clauter * general.c, general.h, sollya-library-wrappers.c, sollya.h, tests-lib/tand.c, tests-lib/tappend.c, tests-lib/tcheckinfnorm.c, tests-lib/tcmp_equal.c, tests-lib/tcmp_greater.c, tests-lib/tcmp_greater_equal.c, tests-lib/tcmp_in.c, tests-lib/tcmp_less.c, tests-lib/tcmp_less_equal.c, tests-lib/tcmp_not_equal.c, tests-lib/tconcat.c, tests-lib/tconstant.c, tests-lib/tconstant_from_double.c, tests-lib/tdenominator.c, tests-lib/tdiff.c, tests-lib/tdirtyinfnorm.c, tests-lib/tdirtyintegral.c, tests-lib/tget_bounds_from_range.c, tests-lib/tget_constant_as_int.c, tests-lib/tget_constant_as_int64.c, tests-lib/tget_constant_as_uint64.c, tests-lib/tget_interval_from_range.c, tests-lib/thead.c, tests-lib/timplementpoly.c, tests-lib/tinf.c, tests-lib/tinit_with_custom_memory_functions.c, tests-lib/tintegral.c, tests-lib/tlength.c, tests-lib/tmacros_build_function.c, tests-lib/tmantissa_and_exponent.c, tests-lib/tmax.c, tests-lib/tmid.c, tests-lib/tmin.c, tests-lib/tnegate.c, tests-lib/tnumberroots.c, tests-lib/tnumerator.c, tests-lib/tor.c, tests-lib/tprecision.c, tests-lib/tprepend.c, tests-lib/tprintdouble.c, tests-lib/tprintexpansion.c, tests-lib/tprintsingle.c, tests-lib/trange_from_bounds.c, tests-lib/trange_from_interval.c, tests-lib/trationalapprox.c, tests-lib/tremez.c, tests-lib/trevert.c, tests-lib/troundcoefficients.c, tests-lib/tsearchgal.c, tests-lib/tsort.c, tests-lib/tsup.c, tests-lib/ttail.c, tests-lib/tv_implementpoly.c, tests-lib/tv_max.c, tests-lib/tv_min.c, tests-lib/tv_remez.c: Added a void *data field to the message callback mechanism as suggested by M. Mezzarobba. This commit was extracted from SVN r1755. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1755 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-05-24 schevill * execute.c: * Replaced a free by safeFree, forgotten by Christoph in previous revision. This commit was extracted from SVN r1754. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1754 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-05-23 clauter * Makefile.am, chebModelsAux.c, chebModelsAux.h, chebyshevform.c, chebyshevform.h, chebyshevformaux.c, chebyshevformaux.h, library.c, library.h, sollya-library-wrappers.c, sollya.h: Finished work on the sollya_lib_build_function... functions for library functions and constants and procedure functions. Added also versions that do not consume their sollya_obj_t argument(s). Moved all occurrences of calls to free() to safeFree(). Modified #include structure for Chebyshev Model code. This commit was extracted from SVN r1753. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1753 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-05-23 schevill * tests-lib/tdirtyinfnorm.c, tests-lib/tdirtyinfnorm.reference: * Patched a bug in the test of dirtyinfnorm. Since dirtyinfnorm perturbs the sampling points (as do remez and plot) it is affected by the old bug of mpfr_urandomb and it becomes apparent on one of the tests. I apply the same methodology as with remez: I test if one of the three expected behaviors appears or not. This commit was extracted from SVN r1752. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1752 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-05-23 clauter * configure.ac, execute.c, execute.h, library.c, sollya-library-wrappers.c: Some progress with sollya_lib_build for library functions and constants. This commit was extracted from SVN r1751. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1751 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-05-22 schevill * mpfi-compat.c: * Patched a bug that has been detected because check021 failed. The bug actually lies inside MPFI 1.5 and has been corrected in the most recent versions of MPFI. However, since MPFI 1.5 is still widely distributed (e.g., by Debian), it seems appropriate to patch the behavior directly in mpfi-compat.c instead of relying on the patch of MPFI. In consequence, we do not use mpfi_sub_fr anymore but reimplement it by ourself. As a consequence, we might (very marginally) loose performance. This commit was extracted from SVN r1750. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1750 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-05-21 clauter * parser.y, sollya-library-wrappers.c, sollya.h: Some progress with extending the sollya_lib_build_... functions. This commit was extracted from SVN r1749. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1749 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-05-04 schevill * doc/chebyshevform.tex, doc/sollya.pdf, doc/sollya.tex, doc/www/ListOfCommands.php, doc/www/chebyshevform.php, help.h: * Suppressed the remark about the fact that one should uninstall a callback before installing another one (in the future, if some day uninstalling a callback is really needed before installing a new one, in order to avoid memory leaks, then we would have to do it ourself by implementing the call to uninstall inside the function install). * Added missing generated help files for chebyshevform to the repository. This commit was extracted from SVN r1748. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1748 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-05-03 schevill * sollya-messages.h, sollya-messaging.h, tests-tool/Makefile.am, tests-tool/check021.sollya, tests-tool/check021.sollya.reference: * Updated sollya-messag*.h from branches/experimentalChebModels. For some cosmic reason, they had not been updated when I performed the svn merge at previous revision. * Added check021.sollya.* and updated Makefile.am in directory tests-lib. Mioara used to put them in the old 'tests' directory that does not exist anymore. As a consequence : the tests do not pass currently, because of check021.sollya. I suspect that Mioara always thought that her tests passed because her 'make check' was indeed not using her files. This commit was extracted from SVN r1747. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1747 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-05-03 schevill * : * Tentative to reintegrate branch experimentalChebModels into the trunk This commit was extracted from SVN r1746. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1746 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-18 jmio17 * chebyshevform.c: removed some more printfs. This commit was extracted from SVN r1744. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1744 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-17 clauter * configure.ac, doc/sollya.pdf, doc/sollya.tex, externalproc.c: A minimal change to the documentation. This commit was extracted from SVN r1743. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1743 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-16 clauter * configure.ac, doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php, externalproc.c: Added a forgotten line. This commit was extracted from SVN r1742. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1742 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-14 schevill * doc/sollya.pdf, doc/sollya.tex: * Updated the doc to account for the new return values of evaluate_functions_at*. However, this is still a bit confused and should be made better. This commit was extracted from SVN r1741. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1741 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-14 schevill * doc/abs.tex, doc/absolute.tex, doc/acos.tex, doc/acosh.tex, doc/and.tex, doc/append.tex, doc/approx.tex, doc/asciiplot.tex, doc/asin.tex, doc/asinh.tex, doc/atan.tex, doc/atanh.tex, doc/autodiff.tex, doc/autosimplify.tex, doc/bashevaluate.tex, doc/bashexecute.tex, doc/binary.tex, doc/bind.tex, doc/boolean.tex, doc/canonical.tex, doc/ceil.tex, doc/checkinfnorm.tex, doc/coeff.tex, doc/composepolynomials.tex, doc/concat.tex, doc/constant.tex, doc/cos.tex, doc/cosh.tex, doc/d.tex, doc/dd.tex, doc/de.tex, doc/decimal.tex, doc/default.tex, doc/degree.tex, doc/denominator.tex, doc/diam.tex, doc/dieonerrormode.tex, doc/diff.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/display.tex, doc/divide.tex, doc/double.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/dyadic.tex, doc/equal.tex, doc/erf.tex, doc/erfc.tex, doc/error.tex, doc/evaluate.tex, doc/execute.tex, doc/exp.tex, doc/expand.tex, doc/expm1.tex, doc/exponent.tex, doc/externalplot.tex, doc/externalproc.tex, doc/false.tex, doc/file.tex, doc/findzeros.tex, doc/fixed.tex, doc/floating.tex, doc/floor.tex, doc/fpminimax.tex, doc/fullparentheses.tex, doc/function.tex, doc/ge.tex, doc/gt.tex, doc/guessdegree.tex, doc/halfprecision.tex, doc/head.tex, doc/hexadecimal.tex, doc/honorcoeffprec.tex, doc/hopitalrecursions.tex, doc/horner.tex, doc/hp.tex, doc/implementconstant.tex, doc/implementpoly.tex, doc/in.tex, doc/inf.tex, doc/infnorm.tex, doc/integer.tex, doc/integral.tex, doc/isbound.tex, doc/le.tex, doc/length.tex, doc/library.tex, doc/libraryconstant.tex, doc/listof.tex, doc/log.tex, doc/log10.tex, doc/log1p.tex, doc/log2.tex, doc/lt.tex, doc/mantissa.tex, doc/max.tex, doc/mid.tex, doc/midpointmode.tex, doc/min.tex, doc/minus.tex, doc/mult.tex, doc/nearestint.tex, doc/neq.tex, doc/nop.tex, doc/not.tex, doc/numberroots.tex, doc/numerator.tex, doc/off.tex, doc/on.tex, doc/or.tex, doc/parse.tex, doc/perturb.tex, doc/pi.tex, doc/plot.tex, doc/plus.tex, doc/points.tex, doc/postscript.tex, doc/postscriptfile.tex, doc/power.tex, doc/powers.tex, doc/prec.tex, doc/precision.tex, doc/prepend.tex, doc/print.tex, doc/printdouble.tex, doc/printexpansion.tex, doc/printsingle.tex, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/qd.tex, doc/quad.tex, doc/quit.tex, doc/range.tex, doc/rationalapprox.tex, doc/rationalmode.tex, doc/rd.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/rn.tex, doc/round.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/roundingwarnings.tex, doc/ru.tex, doc/rz.tex, doc/searchgal.tex, doc/sg.tex, doc/simplify.tex, doc/simplifysafe.tex, doc/sin.tex, doc/single.tex, doc/sinh.tex, doc/sollya.pdf, doc/sort.tex, doc/sqrt.tex, doc/string.tex, doc/subpoly.tex, doc/substitute.tex, doc/sup.tex, doc/supnorm.tex, doc/tail.tex, doc/tan.tex, doc/tanh.tex, doc/taylor.tex, doc/taylorform.tex, doc/taylorrecursions.tex, doc/td.tex, doc/time.tex, doc/timing.tex, doc/tripledouble.tex, doc/true.tex, doc/var.tex, doc/verbosity.tex, doc/void.tex, doc/worstcase.tex, doc/write.tex, doc/www/abs.php, doc/www/absolute.php, doc/www/accurateinfnorm.php, doc/www/acos.php, doc/www/acosh.php, doc/www/and.php, doc/www/append.php, doc/www/approx.php, doc/www/asciiplot.php, doc/www/asin.php, doc/www/asinh.php, doc/www/atan.php, doc/www/atanh.php, doc/www/autodiff.php, doc/www/autosimplify.php, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/binary.php, doc/www/bind.php, doc/www/boolean.php, doc/www/canonical.php, doc/www/ceil.php, doc/www/checkinfnorm.php, doc/www/coeff.php, doc/www/composepolynomials.php, doc/www/concat.php, doc/www/constant.php, doc/www/cos.php, doc/www/cosh.php, doc/www/d.php, doc/www/dd.php, doc/www/de.php, doc/www/decimal.php, doc/www/default.php, doc/www/degree.php, doc/www/denominator.php, doc/www/diam.php, doc/www/dieonerrormode.php, doc/www/diff.php, doc/www/dirtyfindzeros.php, doc/www/dirtyinfnorm.php, doc/www/dirtyintegral.php, doc/www/display.php, doc/www/divide.php, doc/www/double.php, doc/www/doubledouble.php, doc/www/doubleextended.php, doc/www/dyadic.php, doc/www/equal.php, doc/www/erf.php, doc/www/erfc.php, doc/www/error.php, doc/www/evaluate.php, doc/www/execute.php, doc/www/exp.php, doc/www/expand.php, doc/www/expm1.php, doc/www/exponent.php, doc/www/externalplot.php, doc/www/externalproc.php, doc/www/false.php, doc/www/file.php, doc/www/findzeros.php, doc/www/fixed.php, doc/www/floating.php, doc/www/floor.php, doc/www/fpminimax.php, doc/www/fullparentheses.php, doc/www/function.php, doc/www/ge.php, doc/www/gt.php, doc/www/guessdegree.php, doc/www/halfprecision.php, doc/www/head.php, doc/www/hexadecimal.php, doc/www/honorcoeffprec.php, doc/www/hopitalrecursions.php, doc/www/horner.php, doc/www/hp.php, doc/www/implementconstant.php, doc/www/implementpoly.php, doc/www/in.php, doc/www/inf.php, doc/www/infnorm.php, doc/www/integer.php, doc/www/integral.php, doc/www/isbound.php, doc/www/isevaluable.php, doc/www/le.php, doc/www/length.php, doc/www/library.php, doc/www/libraryconstant.php, doc/www/listof.php, doc/www/log.php, doc/www/log10.php, doc/www/log1p.php, doc/www/log2.php, doc/www/lt.php, doc/www/mantissa.php, doc/www/max.php, doc/www/mid.php, doc/www/midpointmode.php, doc/www/min.php, doc/www/minus.php, doc/www/mult.php, doc/www/nearestint.php, doc/www/neq.php, doc/www/nop.php, doc/www/not.php, doc/www/numberroots.php, doc/www/numerator.php, doc/www/off.php, doc/www/on.php, doc/www/or.php, doc/www/parse.php, doc/www/perturb.php, doc/www/pi.php, doc/www/plot.php, doc/www/plus.php, doc/www/points.php, doc/www/postscript.php, doc/www/postscriptfile.php, doc/www/power.php, doc/www/powers.php, doc/www/prec.php, doc/www/precision.php, doc/www/prepend.php, doc/www/print.php, doc/www/printdouble.php, doc/www/printexpansion.php, doc/www/printsingle.php, doc/www/printxml.php, doc/www/proc.php, doc/www/procedure.php, doc/www/qd.php, doc/www/quad.php, doc/www/quit.php, doc/www/range.php, doc/www/rationalapprox.php, doc/www/rationalmode.php, doc/www/rd.php, doc/www/readfile.php, doc/www/readxml.php, doc/www/relative.php, doc/www/rename.php, doc/www/restart.php, doc/www/return.php, doc/www/revert.php, doc/www/rn.php, doc/www/round.php, doc/www/roundcoefficients.php, doc/www/roundcorrectly.php, doc/www/roundingwarnings.php, doc/www/ru.php, doc/www/rz.php, doc/www/searchgal.php, doc/www/sg.php, doc/www/simplify.php, doc/www/simplifysafe.php, doc/www/sin.php, doc/www/single.php, doc/www/sinh.php, doc/www/sort.php, doc/www/sqrt.php, doc/www/string.php, doc/www/subpoly.php, doc/www/substitute.php, doc/www/sup.php, doc/www/supnorm.php, doc/www/tail.php, doc/www/tan.php, doc/www/tanh.php, doc/www/taylor.php, doc/www/taylorform.php, doc/www/taylorrecursions.php, doc/www/td.php, doc/www/time.php, doc/www/timing.php, doc/www/tripledouble.php, doc/www/true.php, doc/www/var.php, doc/www/verbosity.php, doc/www/void.php, doc/www/worstcase.php, doc/www/write.php, help.h, sollya.h: * Recompiled the doc. This commit was extracted from SVN r1740. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1740 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-14 schevill * tests-lib/tevaluate_function_at_constant_expression.c, tests-lib/tevaluate_function_at_constant_expression.reference, tests-lib/tevaluate_function_at_point.c, tests-lib/tevaluate_function_at_point.reference: * Finally got tests for all cases of tevaluate_function_at_*. This commit was extracted from SVN r1739. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1739 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-14 schevill * tests-lib/tevaluate_function_at_constant_expression.c, tests-lib/tevaluate_function_at_point.c: * Not finished version of tevaluate_function* This commit was extracted from SVN r1738. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1738 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-13 schevill * doc/sollya.pdf, doc/sollya.tex: * Added explainations about the custom allocation mechanism provided by Sollya. This commit was extracted from SVN r1737. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1737 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-13 clauter * infnorm.c: Coded a shortcut in the faithful/ correct rounding loop in order to conclude faster on a faithful rounding in some cases. However, as the algorithm is coded in a way that prefers correct rounding over faithful rounding in all cases when correct rounding is sufficiently easy to get, faithfully rounded results will always stay rare with respect to correctly rounded ones. This commit was extracted from SVN r1736. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1736 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-13 jmio17 * chebyshevform.c, chebyshevform.h, message-numbers.h: changing printfs to printMessage This commit was extracted from SVN r1735. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1735 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-12 clauter * fpminimax.cpp, infnorm.c, remez.c, tests-lib/tevaluate_function_at_constant_expression.c, tests-lib/tevaluate_function_at_point.c: Finished the work that extends the FP evaluation status result again in order to include SOLLYA_FP_CORRECTLY_ROUNDED and SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT. Also corrected a small mistake in a test. This commit was extracted from SVN r1734. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1734 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-11 clauter * infnorm.c, sollya-library-wrappers.c, sollya.h: Started work in order to extend the FP evaluation status result again to include SOLLYA_FP_CORRECTLY_ROUNDED and SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT. This change also moves SOLLYA_FP_FAITHFUL_PROVEN_EXACT to SOLLYA_FP_PROVEN_EXACT. This commit was extracted from SVN r1733. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1733 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-11 schevill * tests-lib/tget_constant_as_int.c, tests-lib/tget_constant_as_int.reference, tests-lib/tget_constant_as_int64.c, tests-lib/tget_constant_as_int64.reference, tests-lib/tget_constant_as_uint64.c, tests-lib/tget_constant_as_uint64.reference: * Final update for tget_constant_as_*int* with a specialized test for the case of overflow detected or not depending on the initial working precision chosen by the algorithm. This commit was extracted from SVN r1732. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1732 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-11 schevill * tests-lib/tevaluate_function_at_constant_expression.c, tests-lib/tevaluate_function_at_constant_expression.reference, tests-lib/tevaluate_function_at_point.c, tests-lib/tevaluate_function_at_point.reference: * Updated tests to account for the new SOLLYA_FP_FAITHFUL_PROVEN_*EXACT values. This commit was extracted from SVN r1731. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1731 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-11 clauter * doc/isevaluable.shlp, doc/isevaluable.tex, doc/sollya.pdf: Corrected a small mistake in the documentation. This commit was extracted from SVN r1730. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1730 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-11 clauter * doc/accurateinfnorm.tex, doc/isevaluable.tex, doc/sollya.pdf: Recompiled a part of the documentation This commit was extracted from SVN r1729. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1729 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-11 schevill * doc/sollya.pdf, doc/sollya.tex: * Finished small corrections in the doc. * Note: cmp_obj_structurally still not documented, nor the customized allocation functions. This commit was extracted from SVN r1728. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1728 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-11 schevill * doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh: * LIBRARYNAME is indeed optional. This commit was extracted from SVN r1727. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1727 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-11 clauter * doc/accurateinfnorm.shlp, doc/isevaluable.shlp, doc/isevaluable.tex: Updated documentation for accurateinfnorm and isevaluable but could not re-compile because of a bug in the shlp2tex.sh script. This commit was extracted from SVN r1726. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1726 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-10 clauter * fpminimax.cpp, infnorm.c, remez.c, sollya-library-wrappers.c, sollya.h: Added the extended floating-point evaluation results SOLLYA_FP_FAITHFUL_PROVEN_EXACT and SOLLYA_FP_FAITHFUL_PROVEN_INEXACT. This destroys some tests and requires additional testing as well as a change in documentation. This commit was extracted from SVN r1725. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1725 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-10 schevill * doc/implementpoly.shlp, doc/isbound.shlp, doc/print.shlp, doc/rename.shlp, doc/sollya.pdf, doc/sollya.tex, doc/var.shlp, doc/verbosity.shlp: * Put again some SEEALSO that has disappeared in some .shlp files at rev 1721. * Removed unappropriate documentation is var and print. * Some modification in sollya.tex (unification of C signatures). Still in progress. This commit was extracted from SVN r1724. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1724 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-06 schevill * doc/abs.shlp, doc/absolute.shlp, doc/acos.shlp, doc/acosh.shlp, doc/and.shlp, doc/append.shlp, doc/approx.shlp, doc/asciiplot.shlp, doc/asin.shlp, doc/asinh.shlp, doc/atan.shlp, doc/atanh.shlp, doc/autodiff.shlp, doc/autosimplify.shlp, doc/bashevaluate.shlp, doc/bashexecute.shlp, doc/binary.shlp, doc/canonical.shlp, doc/ceil.shlp, doc/checkinfnorm.shlp, doc/coeff.shlp, doc/composepolynomials.shlp, doc/concat.shlp, doc/cos.shlp, doc/cosh.shlp, doc/decimal.shlp, doc/default.shlp, doc/degree.shlp, doc/denominator.shlp, doc/diam.shlp, doc/dieonerrormode.shlp, doc/diff.shlp, doc/dirtyfindzeros.shlp, doc/dirtyinfnorm.shlp, doc/dirtyintegral.shlp, doc/display.shlp, doc/divide.shlp, doc/double.shlp, doc/doubledouble.shlp, doc/doubleextended.shlp, doc/dyadic.shlp, doc/equal.shlp, doc/erf.shlp, doc/erfc.shlp, doc/error.shlp, doc/evaluate.shlp, doc/exp.shlp, doc/expand.shlp, doc/expm1.shlp, doc/exponent.shlp, doc/externalplot.shlp, doc/false.shlp, doc/file.shlp, doc/findzeros.shlp, doc/fixed.shlp, doc/floating.shlp, doc/floor.shlp, doc/fpminimax.shlp, doc/ge.shlp, doc/gt.shlp, doc/guessdegree.shlp, doc/halfprecision.shlp, doc/head.shlp, doc/hexadecimal.shlp, doc/honorcoeffprec.shlp, doc/hopitalrecursions.shlp, doc/horner.shlp, doc/implementpoly.shlp, doc/in.shlp, doc/inf.shlp, doc/infnorm.shlp, doc/integral.shlp, doc/isbound.shlp, doc/le.shlp, doc/length.shlp, doc/log.shlp, doc/log10.shlp, doc/log1p.shlp, doc/log2.shlp, doc/lt.shlp, doc/mantissa.shlp, doc/max.shlp, doc/mid.shlp, doc/midpointmode.shlp, doc/min.shlp, doc/minus.shlp, doc/mult.shlp, doc/nearestint.shlp, doc/neq.shlp, doc/not.shlp, doc/numberroots.shlp, doc/numerator.shlp, doc/off.shlp, doc/on.shlp, doc/or.shlp, doc/parse.shlp, doc/perturb.shlp, doc/pi.shlp, doc/plot.shlp, doc/plus.shlp, doc/points.shlp, doc/postscript.shlp, doc/postscriptfile.shlp, doc/power.shlp, doc/powers.shlp, doc/prec.shlp, doc/precision.shlp, doc/prepend.shlp, doc/print.shlp, doc/printdouble.shlp, doc/printexpansion.shlp, doc/printsingle.shlp, doc/printxml.shlp, doc/quad.shlp, doc/rationalapprox.shlp, doc/rationalmode.shlp, doc/rd.shlp, doc/readxml.shlp, doc/relative.shlp, doc/remez.shlp, doc/remez.tex, doc/rename.shlp, doc/revert.shlp, doc/rn.shlp, doc/round.shlp, doc/roundcoefficients.shlp, doc/roundcorrectly.shlp, doc/roundingwarnings.shlp, doc/ru.shlp, doc/rz.shlp, doc/searchgal.shlp, doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh, doc/simplify.shlp, doc/simplifysafe.shlp, doc/sin.shlp, doc/single.shlp, doc/sinh.shlp, doc/sort.shlp, doc/sqrt.shlp, doc/subpoly.shlp, doc/substitute.shlp, doc/sup.shlp, doc/supnorm.shlp, doc/tail.shlp, doc/tan.shlp, doc/tanh.shlp, doc/taylor.shlp, doc/taylorform.shlp, doc/taylorrecursions.shlp, doc/timing.shlp, doc/tripledouble.shlp, doc/true.shlp, doc/var.shlp, doc/verbosity.shlp, doc/void.shlp, doc/worstcase.shlp, doc/www/remez.php, doc/www/sollyacss.css: * Added "#LIBRARYNAME" keyword to shlp syntax. * Proposition of update for the shlp files, with this new keyword. Some points should be discussed (what do we want to do for mathematical functions for instance). * Doc is not yet recompiled with this novelties. This commit was extracted from SVN r1721. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1721 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-05 schevill * tests-lib/tget_constant_as_double.c, tests-lib/tget_constant_as_double.reference, tests-lib/tget_constant_as_int.c, tests-lib/tget_constant_as_int.reference, tests-lib/tget_constant_as_int64.c, tests-lib/tget_constant_as_int64.reference, tests-lib/tget_constant_as_uint64.c, tests-lib/tget_constant_as_uint64.reference, tests-lib/tremez.c, tests-lib/tv_remez.c, tests-tool/check020.sollya: * Corrected tests for Remez algorithm. * Yet another step towards succeeding tests for tget_constant* This commit was extracted from SVN r1720. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1720 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-03 schevill * tests-tool/check003.sollya.reference, tests-tool/check012.sollya.reference, tests-tool/check020.sollya: * Updated reference files. This commit was extracted from SVN r1719. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1719 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-04-03 clauter * doc/sollya.pdf, doc/sollya.tex: Some small changes to the documentation of sollya_lib_printf. This commit was extracted from SVN r1718. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1718 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-30 clauter * sollya-library-wrappers.c: Still better ? This commit was extracted from SVN r1717. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1717 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-30 clauter * sollya-library-wrappers.c: Change a warning message. This commit was extracted from SVN r1716. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1716 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-30 clauter * sollya-library-wrappers.c: Still better get constants. This commit was extracted from SVN r1715. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1715 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-30 clauter * sollya-library-wrappers.c: A still better version for the get constants. This commit was extracted from SVN r1714. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1714 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-30 clauter * expression.c, infnorm.c, sollya-library-wrappers.c: Tried to get the get_constants right. This commit was extracted from SVN r1713. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1713 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-30 schevill * doc/sollya.pdf, doc/sollya.tex: * Added a section about formatted display of sollya objects. This commit was extracted from SVN r1712. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1712 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-29 schevill * tests-lib/tget_constant_as_double.c, tests-lib/tget_constant_as_double.reference, tests-lib/tget_constant_as_int.c, tests-lib/tget_constant_as_int.reference, tests-lib/tget_constant_as_int64.c, tests-lib/tget_constant_as_int64.reference, tests-lib/tget_constant_as_uint64.c, tests-lib/tget_constant_as_uint64.reference: * Updated test files for get_constant_as_*. This commit was extracted from SVN r1711. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1711 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-29 clauter * infnorm.c: Corrected a couple of huge mistakes in the algorithm for faithful evaluation. The algorithm and its implementation should be fine now. This commit was extracted from SVN r1710. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1710 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-28 clauter * infnorm.c, infnorm.h: Removed a couple of evaluate*With/Without* function that were no longer in use. Changed the behavior of evaluateFaithful, making quite a few tests fail. The new evaluateFaithful returns the correct rounding to the nearest as a faithful rounding wherever possible (if the proof interval is sufficiently small) and returns the correct rounding to the nearest (ties to even) of the midpoint of both possible answers otherwise. This change in behavior should remove any biais on the rounding direction of faithful evaluations. If this change in behavior does not satisfy the users (and test suite), it may be reverted back in the future. This commit was extracted from SVN r1709. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1709 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-28 clauter * sollya-library-wrappers.c: Corrected the warnings for NaN handling in the sollya_lib_get_constant_as_?in* functions. This commit was extracted from SVN r1708. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1708 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-28 clauter * sollya-library-wrappers.c, sollya-messages.h, sollya-messaging.h: Patched a couple of problems with the sollya_lib_get_constant_as_* functions. This commit was extracted from SVN r1707. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1707 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-28 schevill * tests-lib/tget_bounds_from_range.c, tests-lib/tget_bounds_from_range.reference, tests-lib/tget_interval_from_range.c, tests-lib/tget_interval_from_range.reference: * Patched the test files for tget_*_from_range according to the patch committed by Christoph in a previous revision. This commit was extracted from SVN r1706. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1706 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-28 clauter * tests-lib/tcheckinfnorm.c, tests-lib/tcheckinfnorm.reference: Patched a test in tcheckinfnorm.c This commit was extracted from SVN r1705. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1705 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-27 clauter * execute.c: Proposing a change to evaluation of ranges that might please some of Sollya's developers. The change can be reverted back at some point if it does not get adopted. This commit was extracted from SVN r1704. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1704 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-26 schevill * tests-lib/Makefile.am, tests-lib/tget_bounds_from_range.c, tests-lib/tget_bounds_from_range.reference, tests-lib/tget_constant_as_double.c, tests-lib/tget_constant_as_double.reference, tests-lib/tget_constant_as_int.c, tests-lib/tget_constant_as_int.reference, tests-lib/tget_constant_as_int64.c, tests-lib/tget_constant_as_int64.reference, tests-lib/tget_constant_as_uint64.c, tests-lib/tget_constant_as_uint64.reference, tests-lib/tget_interval_from_range.c, tests-lib/tget_interval_from_range.reference, tests-lib/tget_string.c, tests-lib/tget_string.reference: * Added tests fot tget_constant_as_* This commit was extracted from SVN r1703. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1703 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-26 clauter * doc/sollya.pdf, doc/sollya.tex: Re-read the Section about the Sollya library and corrected most of the issues found. This commit was extracted from SVN r1702. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1702 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-26 clauter * doc/sollya.pdf, doc/sollya.tex: Some progress with the documentation. This commit was extracted from SVN r1701. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1701 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-19 clauter * doc/sollya.pdf, doc/sollya.tex: Worked on the documentation. Work is still in progress. This commit was extracted from SVN r1700. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1700 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-12 clauter * general.c, sollya-messaging.c, sollya-messaging.h, sollya.h: Made the sollya_msg_t type opaque again in sollya.h: it has become a pointer type that is allocated on the stack. There is no need for the user to free (or clear) that pointer type. This commit was extracted from SVN r1699. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1699 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-09 schevill * sollya.h, tests-lib/tand.c, tests-lib/tappend.c, tests-lib/tcheckinfnorm.c, tests-lib/tcmp_equal.c, tests-lib/tcmp_greater.c, tests-lib/tcmp_greater_equal.c, tests-lib/tcmp_in.c, tests-lib/tcmp_less.c, tests-lib/tcmp_less_equal.c, tests-lib/tcmp_not_equal.c, tests-lib/tconcat.c, tests-lib/tconstant.c, tests-lib/tconstant_from_double.c, tests-lib/tdenominator.c, tests-lib/tdiff.c, tests-lib/tdirtyinfnorm.c, tests-lib/tdirtyintegral.c, tests-lib/thead.c, tests-lib/timplementpoly.c, tests-lib/tinf.c, tests-lib/tinit_with_custom_memory_functions.c, tests-lib/tintegral.c, tests-lib/tlength.c, tests-lib/tmacros_build_function.c, tests-lib/tmantissa_and_exponent.c, tests-lib/tmax.c, tests-lib/tmid.c, tests-lib/tmin.c, tests-lib/tnegate.c, tests-lib/tnumberroots.c, tests-lib/tnumerator.c, tests-lib/tor.c, tests-lib/tprecision.c, tests-lib/tprepend.c, tests-lib/tprintdouble.c, tests-lib/tprintexpansion.c, tests-lib/tprintsingle.c, tests-lib/trange_from_bounds.c, tests-lib/trange_from_interval.c, tests-lib/trationalapprox.c, tests-lib/tremez.c, tests-lib/trevert.c, tests-lib/troundcoefficients.c, tests-lib/tsearchgal.c, tests-lib/tsort.c, tests-lib/tsup.c, tests-lib/ttail.c, tests-lib/tv_implementpoly.c, tests-lib/tv_max.c, tests-lib/tv_min.c, tests-lib/tv_remez.c: * Updated the tests of the library, to be compliant with the new signature of the message callbacks. IMPORTANT NOTE: @Christoph: I had to add a definition to sollya.h to make it pass. Please have a look at the diff. It concerns the incomplete definition of sollya_msg_t. This commit was extracted from SVN r1698. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1698 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-09 schevill * doc/sollya.pdf, doc/sollya.tex: * Yet another step towards a complete documentation of the library. Still missing: printf, cmp_objs_structurally, autoprint and customed memory functions. This commit was extracted from SVN r1697. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1697 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-09 clauter * general.c, general.h, sollya-library-wrappers.c, sollya-messaging.c, sollya-messaging.h, sollya.h: Finished converting the message callback to sollya_msg_t. The signatures of the functions given as message callbacks in the test files still need to be converted. This means this revision might not compile on all systems. Sylvain agreed to do that conversion. This commit was extracted from SVN r1696. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1696 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-09 clauter * execute.c, sollya-library-wrappers.c, sollya-library-wrappers.h, sollya-messaging.h, sollya.h, tests-lib/tevaluate_function_at_constant_expression.c, tests-lib/tevaluate_function_at_constant_expression.reference, tests-lib/tevaluate_function_at_point.c, tests-lib/tevaluate_function_at_point.reference: Change the signature of sollya_lib_evaluate_function_over_interval to int sollya_lib_eva luate_function_over_interval(mpfi_t, sollya_obj_t, mpfi_t); Changed a couple of typedefs in order to opaquify them. The changes are not yet complete; please wait for the next commit. This commit was extracted from SVN r1695. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1695 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-07 schevill * doc/sollya.pdf, doc/sollya.tex: * Yet another step towards a complete documentation of the library. This commit was extracted from SVN r1694. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1694 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-07 clauter * general.h, sollya-library-wrappers.c, sollya.h: Added the functions sollya_lib_malloc, sollya_lib_calloc and sollya_lib_realloc to the Sollya library. This commit was extracted from SVN r1693. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1693 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-06 clauter * sollya-library-wrappers.c, sollya.h: Added a new function to the Sollya library: int sollya_lib_get_prec_of_range(mp_prec_t *, sollya_obj_t); This commit was extracted from SVN r1692. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1692 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-05 clauter * sollya-library-wrappers.c: Corrected a mistake due to a change in behavior in sollya_lib_get_constant. This commit was extracted from SVN r1691. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1691 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-05 clauter * sollya-library-wrappers.c, sollya.h, tests-lib/Makefile.am, tests-lib/tassign_in_structure.c, tests-lib/tassign_in_structure.reference, tests-lib/tcreate_structure.c, tests-lib/tcreate_structure.reference: Changed name of the library function allowing elements to be assigned in structures: the name now is sollya_lib_create_structure. This commit was extracted from SVN r1690. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1690 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-05 clauter * sollya.h: Corrected a mistake in a comment in sollya.h This commit was extracted from SVN r1689. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1689 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-05 schevill * tests-lib/Makefile.am, tests-tool/Makefile.am: * Patched a bug appearing when trying to perform make dist (tries to compile force_compilation from an unexisting force_compilation.c). This commit was extracted from SVN r1688. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1688 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-02 schevill * doc/sollya.pdf, doc/sollya.tex: * Prototype of doc for the library. It is still work in progress. This commit was extracted from SVN r1687. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1687 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-02 clauter * tests-lib/Makefile.am, tests-lib/tsimplify.c, tests-lib/tsimplify.reference: Added a test for sollya_lib_simplify. This commit was extracted from SVN r1686. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1686 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-01 schevill * double.c, tests-lib/trationalapprox.reference, tests-tool/check009.sollya.reference: * Improved rationalapprox by returning a smaller fraction whenever possible. This commit was extracted from SVN r1685. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1685 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-01 schevill * tests-tool/check001.sollya, tests-tool/check001.sollya.reference, tests-tool/check009.sollya, tests-tool/check009.sollya.reference: * Reorganized the tests for rationalapprox. This commit was extracted from SVN r1684. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1684 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-01 clauter * double.c, execute.c, sollya-messages.h, sollya-messaging.h, tests-tool/check001.sollya.reference, tests-tool/check009.sollya.reference: Patched round and updated a couple of tests. This commit was extracted from SVN r1683. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1683 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-01 schevill * sollya-messages.h, tests-lib/trationalapprox.c: * Changed SOLLYA_MSG_RATIONALAPPROX_SECOND_ARG_MUST_BE_GREATER_THAN_TWO into SOLLYA_MSG_RATIONALAPPROX_SECOND_ARG_MUST_BE_GREATER_THAN_ONE. This commit was extracted from SVN r1682. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1682 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-03-01 schevill * tests-lib/trationalapprox.c, tests-lib/trationalapprox.reference: * Added non-regression test for the bug patched in the previous revision, and updated the reference file according to the new behavior of rationalapprox after previous revision. This commit was extracted from SVN r1681. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1681 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-29 schevill * double.c: * Corrected a bug that occurred in rationalapprox when the target precision was small. Actually, the target precision was used as working precision, which lead to undesired loss of accuracy in the computations, particularly visible for small precisions. This commit was extracted from SVN r1680. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1680 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-29 schevill * double.c, execute.c, sollya-messages.h, sollya-messaging.h: * Added an error message for the case when rationapprox is called with a precision <= 1. This commit was extracted from SVN r1679. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1679 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-29 clauter * expression.c, tests-lib/tdiff.reference: Unified the behavior of diff for acos, asin, tan and tanh. Updated the tests for the library; the ones for the tool have not been updated, yet. This commit was extracted from SVN r1678. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1678 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-29 clauter * tests-lib/trationalapprox.c, tests-lib/trationalapprox.reference: Updated the tests for sollya_lib_rationalapprox. This commit was extracted from SVN r1677. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1677 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-29 schevill * double.c, double.h, execute.c: * Corrected bug #13943 Rationalapprox with low approximation accuracy makes MPFR assertion fail, killing the tool's execution. * Changed a bit the internal algorithm of rationalapprox in order to really (yet heuristically) ensure that the result has the required accuracy * Reintroduced warning messages in remez and fpminimax when constant expressions are given instead of constants (the warnings disappeared by mistake at revision 1438). This commit was extracted from SVN r1676. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1676 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-29 clauter * tests-lib/Makefile.am, tests-lib/trationalapprox.c, tests-lib/trationalapprox.reference: Added tests for sollya_lib_rationalapprox which are incomplete and failing at the moment. This commit was extracted from SVN r1675. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1675 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-29 clauter * tests-lib/Makefile.am, tests-lib/tdiff.c, tests-lib/tdiff.reference: Added tests for sollya_lib_diff. This commit was extracted from SVN r1674. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1674 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-28 clauter * general.c, tests-lib/tinit_with_custom_memory_functions.c, tests-lib/tinit_with_custom_memory_functions.reference: Completed tests for sollya_lib_init_with_custom_memory_functions. This commit was extracted from SVN r1673. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1673 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-28 clauter * general.c, tests-lib/Makefile.am, tests-lib/tinit_with_custom_memory_functions.c: Added tests for sollya_lib_init_with_custom_memory_functions. This commit was extracted from SVN r1672. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1672 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-28 schevill * tests-lib/tremez.c: * Patched a memory leak. This commit was extracted from SVN r1671. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1671 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-28 clauter * tests-lib/Makefile.am, tests-lib/tappend.c, tests-lib/tappend.reference, tests-lib/tprepend.c, tests-lib/tprepend.reference: Added tests for sollya_lib_prepend. This commit was extracted from SVN r1670. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1670 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-28 schevill * tests-lib/tevaluate_function_at_constant_expression.c, tests-lib/tevaluate_function_at_constant_expression.reference, tests-lib/tevaluate_function_at_point.c, tests-lib/tevaluate_function_at_point.reference: * Corrected copy-paste errors. This commit was extracted from SVN r1669. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1669 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-27 clauter * tests-lib/Makefile.am, tests-lib/tappend.c, tests-lib/tappend.reference: Added tests for sollya_lib_append. This commit was extracted from SVN r1668. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1668 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-27 clauter * tests-lib/Makefile.am, tests-lib/tconcat.c, tests-lib/tconcat.reference: Added tests for sollya_lib_concat. This commit was extracted from SVN r1667. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1667 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-24 clauter * tests-lib/tcheckinfnorm.c, tests-lib/tcheckinfnorm.reference: Finally completed the tests for checkinfnorm. This commit was extracted from SVN r1665. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1665 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-24 clauter * expression.c, sollya-messages.h, sollya-messaging.h, tests-tool/check018.sollya, tests-tool/check018.sollya.reference: Patched bug "[#13930] Sollya crashes unexpectedly with message Error: getMaxPowerDividerUnsafe: an error occurred. The exponent in a power operator is not constant." and added a regression test for it. This commit was extracted from SVN r1664. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1664 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-23 clauter * : Ported the branch for sollya_lib back onto the trunk. This commit was extracted from SVN r1663. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1663 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-23 clauter * tests-lib/tget_free_variable_name.c, tests-lib/tget_structure_elements.c, tests-lib/tsearchgal.c: Changed the tests to use the new sollya_lib_free instead of the system free. This commit was extracted from SVN r1660. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1660 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-23 clauter * sollya-library-wrappers.c, sollya.h: Added a sollya_lib_free(void *) function to the Sollya library. This commit was extracted from SVN r1659. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1659 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-22 clauter * general.c, general.h, sollya-library-wrappers.c, sollya.h: Finished implementing the custom memory management functions. Testing is really required for that. This commit was extracted from SVN r1658. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1658 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-22 clauter * execute.c, general.c, implementconst.c, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y: Moved all occurrences of free to safeFree. Verified (with objdump) that the only occurrence left is in the implementation of safeFree. This commit was extracted from SVN r1657. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1657 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-22 schevill * assignment.c, autodiff.c, bitfields.c, chain.c, double.c, execute.c, expression.c, external.c, fpminimax.cpp, general.c, implement.c, implementconst.c, infnorm.c, internlexer.l, internparser.y, lexer.l, library.c, libsollyaexample.c, match.c, minilexer.l, miniparser.y, parser.y, plot.c, printf.c, proof.c, remez.c, sollya-library-wrappers.c, sollya-messaging.c, sturm.c, supnorm.c, tadiff.c, taylorModel.c, taylorform.c, xml.c: * Changed all the occurences of free by the new wrapper safeFree. This commit was extracted from SVN r1656. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1656 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-22 clauter * general.c, general.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y: Working on the memory functions. This commit was extracted from SVN r1655. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1655 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-22 clauter * tests-lib/Makefile.am, tests-lib/tcheckinfnorm.c, tests-lib/tcheckinfnorm.reference: Added some first test for checkinfnorm. Other tests will be added later. This commit was extracted from SVN r1654. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1654 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-22 schevill * tests-lib/Makefile.am, tests-lib/tevaluate_function_at_constant_expression.c, tests-lib/tevaluate_function_at_constant_expression.reference, tests-lib/tevaluate_function_at_point.c, tests-lib/tevaluate_function_at_point.reference: * Corrected tests for evaluate_function_at_point and new test files for evaluate_function_at_constant_expression. This commit was extracted from SVN r1653. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1653 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-22 clauter * infnorm.c, infnorm.h, sollya-library-wrappers.c: Added implementation for the new evaluation function that evaluates a function f at an abscissa point given by a constant expression c. This commit was extracted from SVN r1652. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1652 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-22 clauter * sollya.h: Added a function to evaluate at a constant expression. This commit was extracted from SVN r1651. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1651 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-20 schevill * tests-lib/tevaluate_function_at_point.c, tests-lib/tevaluate_function_at_point.reference: * Completed test for tevaluate_function_at_point. This commit was extracted from SVN r1650. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1650 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-20 schevill * tests-lib/Makefile.am, tests-lib/tevaluate_function_at_point.c: * Add test for evaluate_function_at_point (without reference file for now). This commit was extracted from SVN r1649. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1649 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-17 schevill * tests/check001.sollya, tests/check001.sollya.reference: * Added non regression test for bug [#13902] Faithful rounding does not occur as it should This commit was extracted from SVN r1648. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1648 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-17 clauter * sollya-library-wrappers.c, sollya.h: Changed behavior of floating-point evaluation function in the Sollya library (including the return values indicating the status of the result). This commit was extracted from SVN r1647. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1647 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-17 clauter * tests-lib/Makefile.am, tests-lib/timplementpoly.c, tests-lib/timplementpoly.reference, tests-lib/tv_implementpoly.c, tests-lib/tv_implementpoly.reference: Added tests for sollya_lib_implementpoly and sollya_lib_v_implementpoly. This commit was extracted from SVN r1646. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1646 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-16 schevill * tests/check001.sollya.reference, tests/check013.sollya, tests/check013.sollya.reference, tests/timecheck.sollya, tests/timecheck.sollya.reference: * Moved timing tests from check013.sollya to timecheck.sollya This commit was extracted from SVN r1645. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1645 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-16 clauter * tests-lib/Makefile.am, tests-lib/tsearchgal.c, tests-lib/tsearchgal.reference: Added tests for sollya_lib_searchgal. This commit was extracted from SVN r1644. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1644 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-15 clauter * sollya-library-wrappers.c: Corrected the last change with sollya_lib_searchgal. This commit was extracted from SVN r1643. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1643 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-15 clauter * sollya-library-wrappers.c, sollya.h: Corrected signature of function sollya_lib_searchgal and removed sollya_lib_v_searchgal. This commit was extracted from SVN r1642. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1642 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-15 clauter * tests-lib/tdirtyintegral.c, tests-lib/tdirtyintegral.reference, tests-lib/tintegral.reference: Updated tests for integral and dirtyintegral. This commit was extracted from SVN r1641. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1641 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-15 schevill * integral.c: * Patched bug #9821: integral and dirtyintegral do not refuse to work on intervals containing infinities This commit was extracted from SVN r1640. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1640 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-15 clauter * tests-lib/tdirtyintegral.c, tests-lib/tdirtyintegral.reference, tests-lib/tintegral.c, tests-lib/tintegral.reference: Added tests to integral and dirtyintegral and changed reference values. This commit was extracted from SVN r1639. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1639 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-15 clauter * tests-lib/Makefile.am, tests-lib/tintegral.c, tests-lib/tintegral.reference: Added tests for sollya_lib_integral. Up to now, the tests fail. This commit was extracted from SVN r1638. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1638 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-15 clauter * tests-lib/Makefile.am, tests-lib/tdirtyintegral.c, tests-lib/tdirtyintegral.reference: Added tests for sollya_lib_dirtyintegral. Up to now, the tests fail. This commit was extracted from SVN r1637. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1637 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-15 clauter * tests-lib/Makefile.am, tests-lib/tnumberroots.c, tests-lib/tnumberroots.reference: Added tests for sollya_lib_numberroots. This commit was extracted from SVN r1636. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1636 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-15 clauter * tests-lib/Makefile.am, tests-lib/tdirtyinfnorm.c, tests-lib/tdirtyinfnorm.reference: Added tests for sollya_lib_dirtyinfnorm. This commit was extracted from SVN r1635. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1635 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-14 schevill * tests-lib/Makefile.am, tests-lib/tfpminimax.c, tests-lib/tfpminimax.reference, tests-lib/tv_fpminimax.c, tests-lib/tv_fpminimax.reference: * Tests for fpminimax and v_fpminimax. This commit was extracted from SVN r1634. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1634 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-14 schevill * tests-lib/Makefile.am, tests-lib/tv_max.c, tests-lib/tv_remez.c, tests-lib/tv_remez.reference: * Added tests for tv_remez and corrected a stupid copy-paste error in tv_max. This commit was extracted from SVN r1633. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1633 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-14 schevill * tests-lib/Makefile.am, tests-lib/tremez.c, tests-lib/tremez.reference: * Added tests for remez. This commit was extracted from SVN r1632. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1632 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-14 schevill * tests-tool/check020.sollya: * Corrected a bug in the tests apeeared when patching the behavior of [expr] in a previous revision. That correction indeed changed the intervals on which remez was called. I just hard coded the previous intervals. This commit was extracted from SVN r1631. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1631 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-13 clauter * tests-lib/tsort.c, tests-lib/tsort.reference: Added a test for sollya_lib_sort. (forgotten files) This commit was extracted from SVN r1630. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1630 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-13 clauter * tests-lib/Makefile.am: Added a test for sollya_lib_sort. This commit was extracted from SVN r1629. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1629 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-10 clauter * sollya-library-wrappers.c, sollya.h, tests-lib/Makefile.am, tests-lib/tprecision.c, tests-lib/tprecision.reference: Added sollya_lib_precision and tests for it. This commit was extracted from SVN r1628. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1628 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-10 schevill * tests-tool/check014.sollya.reference: * Changed reference file according to the new behavior after revision 1623 (bug when computing point-interval with the syntax [expr];) This commit was extracted from SVN r1627. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1627 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-10 clauter * tests-tool/check013.sollya.reference: Finally changed the reference values for power computation in corner cases. This commit was extracted from SVN r1626. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1626 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-10 jmio17 * tests/check021.sollya.reference: added reference file for tests Chebyshev Models This commit was extracted from SVN r1625. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1625 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-09 clauter * execute.c: Correcting my own last correction. This commit was extracted from SVN r1624. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1624 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-09 clauter * execute.c: Corrected a pretty huge bug found by Sylvain. The tests don't pass no more as we have to double- and triple-check them again. The original bug message was (sorry for the French): "Voici une session Sollya que je trouve déconcertante : > d = [sin(pi/6)*(1-1b-40)]; Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. > log2(sup(d)-inf(d)); -40 Bon, j'ai jamais trop bien compris à quel point c'était censé être sharp quand on faisait [expr] pour obtenir un encadrement de expr. Cela étant, lorsqu'un warning m'informe qu'une évaluation fidèle va être utilisée, je m'attends à ce que la taille de mon intervalle à la sortie soit de l'ordre de quelques ulps de la précision courante. Donc y a un truc qui déconne là je trouve. Sylvain" This commit was extracted from SVN r1623. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1623 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-09 clauter * tests-lib/Makefile.am, tests-lib/trevert.c, tests-lib/trevert.reference: Added a test for sollya_lib_revert. This commit was extracted from SVN r1622. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1622 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-09 clauter * tests-lib/Makefile.am, tests-lib/ttail.c, tests-lib/ttail.reference: Added a test for sollya_lib_tail. This commit was extracted from SVN r1621. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1621 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-09 clauter * tests-lib/Makefile.am, tests-lib/thead.c, tests-lib/thead.reference: Added a test for sollya_lib_head. This commit was extracted from SVN r1620. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1620 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-09 clauter * plot.c, tests-lib/tasciiplot.reference: Slightly changed asciiplot to avoid problems in testing with 32bit/64bit machines with new/old versions of MPFR. This commit was extracted from SVN r1619. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1619 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-09 clauter * tests-lib/Makefile.am, tests-lib/troundcoefficients.c, tests-lib/troundcoefficients.reference: Added a test for sollya_lib_roundcoefficients. This commit was extracted from SVN r1618. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1618 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-09 clauter * tests-lib/tprintdouble.c: Try to overcome a problem with some 32bit compilers seen in tprintdouble.c. This commit was extracted from SVN r1617. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1617 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-08 schevill * tests-lib/tv_max.c, tests-lib/tv_max.reference, tests-lib/tv_min.c, tests-lib/tv_min.reference: * Updated tv_min and tv_max This commit was extracted from SVN r1616. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1616 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-08 schevill * tests-lib/tcmp_equal.c, tests-lib/tcmp_equal.reference, tests-lib/tcmp_greater.c, tests-lib/tcmp_greater.reference, tests-lib/tcmp_greater_equal.c, tests-lib/tcmp_greater_equal.reference, tests-lib/tcmp_in.c, tests-lib/tcmp_in.reference, tests-lib/tcmp_less.c, tests-lib/tcmp_less.reference, tests-lib/tcmp_less_equal.c, tests-lib/tcmp_less_equal.reference, tests-lib/tcmp_not_equal.c, tests-lib/tcmp_not_equal.reference: * Updated reference files for comparison operators. This commit was extracted from SVN r1615. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1615 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-08 clauter * execute.c, tests-lib/Makefile.am, tests-lib/tmantissa_and_exponent.c, tests-lib/tmantissa_and_exponent.reference: Changed behavior (in messaging) of the comparisons and added tests for mantissa and exponent. This commit was extracted from SVN r1614. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1614 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-08 schevill * tests-lib/tmax.c, tests-lib/tmax.reference, tests-lib/tmin.c, tests-lib/tmin.reference: * Up-to-date tmin and tmax. This commit was extracted from SVN r1613. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1613 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-08 clauter * tests-lib/tstring_list_ops.c: Again a mistake. This commit was extracted from SVN r1612. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1612 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-08 clauter * tests-lib/tstring_list_ops.c: Correcting a stupid bug. This commit was extracted from SVN r1611. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1611 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-08 schevill * tests-tool/check013.sollya.reference: * Restore old check013.sollya.reference This commit was extracted from SVN r1610. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1610 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-08 schevill * tests-lib/tmax.reference, tests-lib/tmin.reference: * Restore previous tmin.reference and tmax.reference This commit was extracted from SVN r1609. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1609 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-08 clauter * execute.c, execute.h, fpminimax.cpp, match.c, sollya-library-wrappers.c: Yet another version for min and max. This commit was extracted from SVN r1608. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1608 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-08 clauter * execute.c, tests-lib/tmax.reference, tests-lib/tv_max.reference, tests-tool/check013.sollya.reference: Some improvements to max. This commit was extracted from SVN r1607. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1607 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-07 clauter * execute.c, sollya-library-wrappers.c, sollya-messages.h, sollya-messaging.h, sollya.h, tests-tool/check013.sollya.reference: Improved behavior of evaluations when expression evaluation ends up in resulting to infinity. This commit was extracted from SVN r1606. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1606 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-07 clauter * execute.c, tests-lib/Makefile.am: Improved behavior of "in" comparisons for cases where trivial evaluation of the two differences suffices to decide the comparison. This commit was extracted from SVN r1605. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1605 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-07 clauter * execute.c, tests-lib/tmax.reference, tests-lib/tmin.reference, tests-lib/tv_max.reference, tests-tool/check013.sollya.reference: Corrected warning behavior of min and max in order to avoid spurious warnings and adapted the test files. This commit was extracted from SVN r1604. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1604 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-07 schevill * tests/check001.sollya, tests/check001.sollya.reference: * Added non regression test for revision 1596 This commit was extracted from SVN r1603. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1603 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-07 schevill * doc/inf.shlp, doc/mid.shlp, doc/sup.shlp, tests-lib/Makefile.am, tests-lib/tinf.c, tests-lib/tinf.reference, tests-lib/tlength.c, tests-lib/tlength.reference, tests-lib/tmid.c, tests-lib/tmid.reference, tests-lib/tsup.c, tests-lib/tsup.reference: * Modified doc of mid, inf and sup to make them clearer. * Added tests for length, mid, inf and sup This commit was extracted from SVN r1602. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1602 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-07 clauter * execute.c: Slightly changed behavior of inf, sup and mid to make them compliant with the documentation. This commit was extracted from SVN r1601. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1601 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-06 jmio17 * doc/CommandsAndFunctions.tex, doc/bashevaluate.tex, doc/bashexecute.tex, doc/implementconstant.tex, doc/parse.tex, doc/printsingle.tex, doc/readxml.tex, doc/remez.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, help.h: work on help chebyshevform This commit was extracted from SVN r1600. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1600 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-06 jmio17 * Makefile.am, autodiff.c, chebyshevform.c, configure.ac, double.c, execute.c, expression.c, external.c, fpminimax.cpp, general.c, general.h, implement.c, implementconst.c, infnorm.c, infnorm.h, integral.c, internlexer.l, internparser.y, lexer.l, library.c, match.c, message-numbers.h, minilexer.l, miniparser.y, mpfi-compat.c, mpfi-compat.h, parser.y, plot.c, printf.c, printf.h, remez.c, sollya.h, sturm.c, sturm.h, supnorm.c, taylor.c, taylorform.c, worstcase.c, xml.c: "kind of" merged trunk into branch experimental chebmodels; branch compiles; I get the following warnings though: printf.c: In function ‘sollyaInternalVfprintf’: printf.c:1436: warning: format not a string literal and no format arguments printf.c:1564: warning: format not a string literal and no format arguments (files printf.c and printf.h are identical on both trunk and branch) This commit was extracted from SVN r1599. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1599 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-06 schevill * tests-lib/Makefile.am, tests-lib/tcmp_equal.c, tests-lib/tcmp_equal.reference, tests-lib/tcmp_greater.c, tests-lib/tcmp_greater.reference, tests-lib/tcmp_greater_equal.c, tests-lib/tcmp_greater_equal.reference, tests-lib/tcmp_in.c, tests-lib/tcmp_in.reference, tests-lib/tcmp_less.c, tests-lib/tcmp_less.reference, tests-lib/tcmp_less_equal.c, tests-lib/tcmp_less_equal.reference, tests-lib/tcmp_not_equal.c, tests-lib/tcmp_not_equal.reference, tests-lib/tmax.c, tests-lib/tmax.reference, tests-lib/tmin.c, tests-lib/tmin.reference: * Improved tests and added new ones for sollya_lib_cmp_* This commit was extracted from SVN r1598. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1598 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-03 clauter * tests-lib/Makefile.am, tests-lib/tsubpoly.c, tests-lib/tsubpoly.reference: Added some tests for sollya_lib_subpoly. This commit was extracted from SVN r1597. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1597 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-03 clauter * execute.c, tests-lib/Makefile.am, tests-lib/tcoeff.c, tests-lib/tcoeff.reference: Added some tests for sollya_lib_coeff and corrected a bug in the evaluator. This commit was extracted from SVN r1596. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1596 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-03 clauter * tests-lib/Makefile.am, tests-lib/tsubstitute.c, tests-lib/tsubstitute.reference: Added tests for sollya_lib_substitute. This commit was extracted from SVN r1595. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1595 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-03 clauter * tests-lib/tprintsingle.c: Corrected a problem with x87 code on 32bit x86 systems This commit was extracted from SVN r1594. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1594 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-02 clauter * execute.c: Could finally unify the warnings emitted for comparisons involving NaNs or Infs. This commit was extracted from SVN r1593. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1593 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-02 clauter * execute.c, sollya-messages.h, sollya-messaging.h, tests-lib/tcmp_equal.c, tests-lib/tmax.reference, tests-lib/tmin.reference, tests-lib/tv_max.reference, tests-lib/tv_min.reference, tests-tool/check013.sollya.reference: Improved behavior of comparisons in cases when faithful evaluation does not allow the boolean value to be decided. Now both sides of the comparison are considered equal in this case. This commit was extracted from SVN r1592. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1592 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-02 clauter * tests-lib/tassign_in_structure.c, tests-lib/tcanonical.c, tests-lib/tcmp_equal.c, tests-lib/tcmp_in.c, tests-lib/tcmp_objs_structurally.c, tests-lib/tconstant.c, tests-lib/tconstant_from_double.c, tests-lib/tdenominator.c, tests-lib/texpand.c, tests-lib/tget_element_in_structure.c, tests-lib/tget_structure_elements.c, tests-lib/thorner.c, tests-lib/tis_absolute.c, tests-lib/tis_binary.c, tests-lib/tis_decimal.c, tests-lib/tis_default.c, tests-lib/tis_double_double_obj.c, tests-lib/tis_double_obj.c, tests-lib/tis_doubleextended_obj.c, tests-lib/tis_dyadic.c, tests-lib/tis_false.c, tests-lib/tis_file.c, tests-lib/tis_fixed.c, tests-lib/tis_floating.c, tests-lib/tis_halfprecision_obj.c, tests-lib/tis_hexadecimal.c, tests-lib/tis_honorcoeffprec.c, tests-lib/tis_off.c, tests-lib/tis_on.c, tests-lib/tis_perturb.c, tests-lib/tis_pi.c, tests-lib/tis_postscript.c, tests-lib/tis_postscriptfile.c, tests-lib/tis_powers.c, tests-lib/tis_quad_obj.c, tests-lib/tis_relative.c, tests-lib/tis_round_down.c, tests-lib/tis_round_to_nearest.c, tests-lib/tis_round_towards_zero.c, tests-lib/tis_round_up.c, tests-lib/tis_single_obj.c, tests-lib/tis_triple_double_obj.c, tests-lib/tis_true.c, tests-lib/tis_void.c, tests-lib/tmacros_build_function.c, tests-lib/tmax.c, tests-lib/tmin.c, tests-lib/tnumerator.c, tests-lib/tobj_is_end_elliptic_list.c, tests-lib/tobj_is_error.c, tests-lib/tobj_is_function.c, tests-lib/tobj_is_list.c, tests-lib/tobj_is_range.c, tests-lib/tobj_is_string.c, tests-lib/tobj_is_structure.c, tests-lib/tobject_list_ops.c, tests-lib/tprintexpansion.c, tests-lib/tprintsingle.c, tests-lib/trange_from_bounds.c, tests-lib/trange_from_interval.c, tests-lib/tsimplifysafe.c, tests-lib/tv_max.c, tests-lib/tv_min.c: Again removed the semicolons at the end of the strings given to sollya_lib_parse_string. This commit was extracted from SVN r1591. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1591 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-02 schevill * doc/equal.shlp, tests-lib/Makefile.am, tests-lib/tand.c, tests-lib/tand.reference, tests-lib/tcanonical.c, tests-lib/tcmp_equal.c, tests-lib/tcmp_equal.reference, tests-lib/tcmp_in.c, tests-lib/tcmp_in.reference, tests-lib/tcmp_objs_structurally.c, tests-lib/tnegate.c, tests-lib/tnegate.reference, tests-lib/tor.c, tests-lib/tor.reference: * Slightly modified some examples in the doc to make them more illustrative. * Added new tests for the library. This commit was extracted from SVN r1590. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1590 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-01 schevill * tests-lib/tcmp_objs_structurally.c, tests-lib/tcmp_objs_structurally.reference: * Forgotten to add new test files. This commit was extracted from SVN r1589. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1589 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-01 schevill * tests-lib/Makefile.am, tests-lib/tassign_in_structure.c, tests-lib/tcanonical.c, tests-lib/tcanonical.reference, tests-lib/tdegree.c, tests-lib/tdegree.reference, tests-lib/tdenominator.c, tests-lib/tdenominator.reference, tests-lib/texpand.c, tests-lib/texpand.reference, tests-lib/tget_element_in_structure.c, tests-lib/tget_element_in_structure.reference, tests-lib/tget_structure_elements.c, tests-lib/thorner.c, tests-lib/thorner.reference, tests-lib/tnumerator.c, tests-lib/tnumerator.reference, tests-lib/tobject_list_ops.c, tests-lib/tobject_list_ops.reference, tests-lib/tprintexpansion.c, tests-lib/tprintsingle.c, tests-lib/tsimplifysafe.c: * Modified several tests: - systematically put ";" at the end of parse_string - added test cases for cases that were untested - made warning messages to be displayed near the actual tests This commit was extracted from SVN r1588. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1588 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-01 clauter * sollya.h: Corrected a typo. This commit was extracted from SVN r1587. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1587 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-01 clauter * tests-lib/Makefile.am, tests-lib/tdenominator.c, tests-lib/tdenominator.reference: Added tests for sollya_lib_denominator. This commit was extracted from SVN r1586. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1586 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-01 clauter * tests-lib/Makefile.am, tests-lib/tnumerator.c, tests-lib/tnumerator.reference: Added tests for sollya_lib_numerator. This commit was extracted from SVN r1585. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1585 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-02-01 clauter * tests-lib/Makefile.am, tests-lib/tdegree.c, tests-lib/tdegree.reference: Added tests for sollya_lib_degree. This commit was extracted from SVN r1584. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1584 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-31 clauter * tests-lib/Makefile.am, tests-lib/tsimplifysafe.c, tests-lib/tsimplifysafe.reference: Added a test for sollya_lib_simplifysafe. This commit was extracted from SVN r1583. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1583 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-31 clauter * tests-lib/Makefile.am, tests-lib/texpand.c, tests-lib/texpand.reference: Added a test for sollya_lib_expand. This commit was extracted from SVN r1582. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1582 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-31 clauter * tests-lib/Makefile.am, tests-lib/tcanonical.c, tests-lib/tcanonical.reference: Added a test for sollya_lib_canonical. This commit was extracted from SVN r1581. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1581 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-31 clauter * tests-lib/Makefile.am, tests-lib/thorner.c, tests-lib/thorner.reference: Added tests for sollya_lib_horner. This commit was extracted from SVN r1580. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1580 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-31 clauter * plot.c, tests-lib/Makefile.am, tests-lib/tasciiplot.c, tests-lib/tasciiplot.reference: Added a test for sollya_lib_asciiplot and corrected a bug in asciiplot affecting library mode. This commit was extracted from SVN r1579. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1579 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-30 clauter * plot.c: The ioctl to get the terminal size seems to work also on stdout, which is more logical. Changing it to stdout, thus. This commit was extracted from SVN r1578. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1578 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-30 clauter * tests-lib/check.proto: Made test script for the library pipe /dev/null *into* the test executables This commit was extracted from SVN r1577. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1577 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-30 schevill * sollya.h, tests-lib/tmacros_build_function.c, tests-lib/tmacros_build_function.reference, tests-lib/tprintexpansion.c: * Added constructors SOLLYA_LIB_CONST, SOLLYA_LIB_CONST_UI64 AND SOLLYA_LIB_CONST_SI64 and changed tests accordingly. * Removed the parentheses in SOLLYA_LIB_PI This commit was extracted from SVN r1576. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1576 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-30 clauter * plot.c: Changed behavior of asciiplot in library mode again. This commit was extracted from SVN r1575. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1575 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-30 clauter * tests-lib/Makefile.am, tests-lib/tbashexecute.c, tests-lib/tbashexecute.reference: Added a test for sollya_lib_bashexecute. This commit was extracted from SVN r1574. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1574 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-30 clauter * tests-lib/Makefile.am, tests-lib/tprintexpansion.c, tests-lib/tprintexpansion.reference: Added a test for sollya_lib_printexpansion. This commit was extracted from SVN r1573. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1573 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-30 clauter * general.h, plot.c: A small change to asciiplot to adapt it to use in a library. This commit was extracted from SVN r1572. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1572 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-30 clauter * tests-lib/Makefile.am, tests-lib/tprintsingle.c, tests-lib/tprintsingle.reference: Added a test for sollya_lib_printsingle. This commit was extracted from SVN r1571. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1571 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-30 clauter * tests-lib/Makefile.am, tests-lib/tprintdouble.c, tests-lib/tprintdouble.reference: Added a test for printdouble. This commit was extracted from SVN r1570. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1570 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-27 clauter * tests-lib/Makefile.am, tests-lib/tboolean_list_ops.c, tests-lib/tboolean_list_ops.reference, tests-lib/tconstant_list_ops.c, tests-lib/tint_list_ops.c, tests-lib/tint_list_ops.reference, tests-lib/tinterval_list_ops.c, tests-lib/tinterval_list_ops.reference, tests-lib/tstring_list_ops.c, tests-lib/tstring_list_ops.reference: Added tests for the functions working on sollya_int_list_t, sollya_string_list_t, sollya_boolean_list_t. Corrected mistakes in the tests for the other list types. This commit was extracted from SVN r1569. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1569 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-27 clauter * tests-lib/Makefile.am, tests-lib/tinterval_list_ops.c, tests-lib/tinterval_list_ops.reference: Added tests for the functions working on sollya_interval_list_t. This commit was extracted from SVN r1568. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1568 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-27 clauter * tests-lib/Makefile.am, tests-lib/tconstant_list_ops.c, tests-lib/tconstant_list_ops.reference: Added tests for the functions working on sollya_constant_list_t. This commit was extracted from SVN r1567. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1567 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-27 clauter * general.c: Corrected a problem in library mode which induced the setup of signal handlers even when the Sollya core was used for a library. This commit was extracted from SVN r1566. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1566 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-27 clauter * sollya-library-wrappers.c, tests-lib/Makefile.am, tests-lib/tobject_list_ops.c, tests-lib/tobject_list_ops.reference: Added tests for the functions working on sollya_object_list_t, corrected several small bugs. This commit was extracted from SVN r1565. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1565 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-27 schevill * sollya-library-wrappers.c, tests-lib/Makefile.am, tests-lib/tconstant_from_uint64.c, tests-lib/tconstant_from_uint64.reference: * Added test for constant_from_uint64 and corrected a bug (same bug as with constant_from_int64: double free) This commit was extracted from SVN r1564. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1564 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-27 schevill * tests-lib/tis_absolute.c, tests-lib/tis_binary.c, tests-lib/tis_decimal.c, tests-lib/tis_default.c, tests-lib/tis_double_double_obj.c, tests-lib/tis_double_obj.c, tests-lib/tis_doubleextended_obj.c, tests-lib/tis_dyadic.c, tests-lib/tis_false.c, tests-lib/tis_file.c, tests-lib/tis_fixed.c, tests-lib/tis_floating.c, tests-lib/tis_halfprecision_obj.c, tests-lib/tis_hexadecimal.c, tests-lib/tis_honorcoeffprec.c, tests-lib/tis_off.c, tests-lib/tis_on.c, tests-lib/tis_perturb.c, tests-lib/tis_pi.c, tests-lib/tis_postscript.c, tests-lib/tis_postscriptfile.c, tests-lib/tis_powers.c, tests-lib/tis_quad_obj.c, tests-lib/tis_relative.c, tests-lib/tis_round_down.c, tests-lib/tis_round_to_nearest.c, tests-lib/tis_round_towards_zero.c, tests-lib/tis_round_up.c, tests-lib/tis_single_obj.c, tests-lib/tis_triple_double_obj.c, tests-lib/tis_true.c, tests-lib/tis_void.c, tests-lib/tobj_is_end_elliptic_list.c, tests-lib/tobj_is_error.c, tests-lib/tobj_is_function.c, tests-lib/tobj_is_list.c, tests-lib/tobj_is_range.c, tests-lib/tobj_is_string.c, tests-lib/tobj_is_structure.c: * Updated tests tis_* and tobj_is* in order to test for structures. This commit was extracted from SVN r1563. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1563 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-27 clauter * sollya-library-wrappers.c, sollya.h, tests-lib/tget_element_in_structure.c: Removed a const and corrected a mistake This commit was extracted from SVN r1562. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1562 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-27 clauter * sollya-library-wrappers.c, sollya.h: Added some functions to the library that allow lists to be checked for emptyness. This commit was extracted from SVN r1561. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1561 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-26 clauter * tests-lib/Makefile.am, tests-lib/tassign_in_structure.c, tests-lib/tassign_in_structure.reference: Added a test for sollya_lib_assign_in_structure This commit was extracted from SVN r1560. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1560 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-26 clauter * tests-lib/Makefile.am, tests-lib/tget_element_in_structure.c, tests-lib/tget_element_in_structure.reference: Added a test for sollya_lib_get_element_in_structure. This commit was extracted from SVN r1559. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1559 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-25 schevill * tests-lib/Makefile.am, tests-lib/tconstant_from_double.c, tests-lib/tconstant_from_int.c, tests-lib/tconstant_from_int.reference, tests-lib/tconstant_from_int64.c, tests-lib/tconstant_from_int64.reference: * Two new tests. * Modified tconstant_from_double in order to avoid GCC warning. This commit was extracted from SVN r1558. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1558 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-25 clauter * tests-lib/tget_structure_elements.reference: Forgot to commit the right .reference This commit was extracted from SVN r1557. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1557 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-25 clauter * tests-lib/Makefile.am, tests-lib/tget_structure_elements.c, tests-lib/tget_structure_elements.reference, tests-lib/tobj_is_structure.c, tests-lib/tobj_is_structure.reference: Added tests for sollya_lib_obj_is_structure and sollya_lib_get_structure_elements. This commit was extracted from SVN r1556. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1556 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-25 schevill * sollya-library-wrappers.c: * Corrected a bug (double free). This commit was extracted from SVN r1555. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1555 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-25 clauter * tests-lib/Makefile.am, tests-lib/check.proto, tests-tool/Makefile.am, tests-tool/check.proto: Some improvements to the check scripts and Makefiles. This commit was extracted from SVN r1554. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1554 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-25 schevill * tests-lib/Makefile.am, tests-lib/tconstant_from_double.c, tests-lib/tconstant_from_double.reference, tests-lib/trange_from_bounds.c, tests-lib/trange_from_bounds.reference, tests-lib/trange_from_interval.c, tests-lib/trange_from_interval.reference: * Corrected test for trange_from* according to what Christoph did in the previous revisions. * Added a test for constant_from_double. This commit was extracted from SVN r1553. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1553 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-25 clauter * sollya-library-wrappers.c: Corrected a stupid extra message left over from debugging. This commit was extracted from SVN r1552. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1552 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-25 clauter * Makefile.am, general.c, general.h, message-numbers.c, message-numbers.h, mpfi-compat.c, sollya-messages.h, sollya-messaging.c, sollya-messaging.h, sollya.h, tests-lib/tconstant.c, tests-lib/trange_from_bounds.c, tests-lib/trange_from_interval.c: Factored out the definitions of the symbolic constants for the Sollya messages into an extra file that gets includes both when compiling Sollya and when using the Sollya library. The user of the Sollya library does not need to include any other header file but sollya.h to get the symbolic constants for the message numbers. This commit was extracted from SVN r1551. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1551 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-25 clauter * mpfi-compat.c: Improved sollya_lib_range_from_interval to emit the same warnings that are emit by sollya_lib_range_from_bounds. This commit was extracted from SVN r1550. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1550 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-25 clauter * sollya-library-wrappers.c, tests-lib/trange_from_bounds.c: Corrected sollya_lib_range_from_bounds. The test still fails because the test is incorrect. This commit was extracted from SVN r1549. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1549 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-24 clauter * sollya-library-wrappers.c: Some improvements to sollya_lib_range_from_bounds, the check does not run through though. This commit was extracted from SVN r1548. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1548 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-24 schevill * tests-lib/Makefile.am, tests-lib/tconstant.c, tests-lib/tconstant.reference, tests-lib/trange_from_bounds.c, tests-lib/trange_from_interval.c: * Slight modification in the tests for range_from_bounds and range_from_interval, in order to ensure that no unexpected message is caught by the callback. * Test for sollya_lib_constant. This commit was extracted from SVN r1547. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1547 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-24 schevill * tests-lib/Makefile.am, tests-lib/trange_from_bounds.c, tests-lib/trange_from_bounds.reference: * Test for trange_from_bounds. It currently *FAILS*. This commit was extracted from SVN r1546. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1546 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-24 schevill * tests-lib/trange_from_interval.c, tests-lib/trange_from_interval.reference: * Updated test for range_from_interval This commit was extracted from SVN r1545. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1545 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-24 schevill * tests-lib/trange_from_interval.c, tests-lib/trange_from_interval.reference: * Forgotten files. This commit was extracted from SVN r1544. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1544 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-24 clauter * autodiff.c, execute.c, expression.c, infnorm.c, library.h, mpfi-compat.c, mpfi-compat.h, sollya-library-wrappers.c: Finished converting the outside-looking interface of Sollya (library, library functions, external procedures) to mpfi_t instead of sollya_mpfi_t. Now all mpfi_t coming from the outside world are checked for consistency inside Sollya (no empty intervals, both bounds NaN if one is NaN etc.) This commit was extracted from SVN r1543. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1543 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-24 schevill * tests-lib/Makefile.am, tests-lib/tget_free_variable_name.c, tests-lib/tget_free_variable_name.reference, tests-lib/tmacros_build_function.c, tests-lib/tmacros_build_function.reference, tests-lib/tname_free_variable.c, tests-lib/tname_free_variable.reference, tests-lib/tstring.c, tests-lib/tstring.reference: * Some other tests. This commit was extracted from SVN r1542. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1542 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-24 clauter * Makefile.am, doc/externalproc.shlp, doc/externalproc.tex, doc/sollya.pdf, doc/www/externalproc.php, externalproc.c, help.h, message-numbers.h, sollya-library-wrappers.c, sollya.h: Changed behavior of sollya_lib_get_constant, added sollya_lib_get_prec_of_constant, changed type of functions working on intervals from sollya_mpfi_t to mpfi_t in sollya.h (code underneath to be adjusted yet) This commit was extracted from SVN r1541. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1541 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-19 clauter * sollya-library-wrappers.c, sollya.h: Changed behavior of function to get the name of the free mathematical variable in order to be closer to overall behavior of the Sollya library. The returned pointer must now be freed by the user and the function returns "_x_" as a name as long as the variable has not been named. This commit was extracted from SVN r1540. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1540 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-19 schevill * tests-tool/Makefile.am: * Oups forgot to remove temporary test instructions in my previous commit. This commit was extracted from SVN r1539. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1539 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-19 schevill * tests-tool/Makefile.am: * Smarter Makefile that does not run 'make all' but only rebuild sollya binary. This commit was extracted from SVN r1538. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1538 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-19 schevill * tests-lib/Makefile.am, tests-lib/tget_autosimplify.c, tests-lib/tget_autosimplify.reference, tests-lib/tget_canonical.c, tests-lib/tget_canonical.reference, tests-lib/tget_diam.c, tests-lib/tget_diam.reference, tests-lib/tget_dieonerrormode.c, tests-lib/tget_dieonerrormode.reference, tests-lib/tget_display.c, tests-lib/tget_display.reference, tests-lib/tget_hopitalrecursions.c, tests-lib/tget_hopitalrecursions.reference, tests-lib/tget_midpointmode.c, tests-lib/tget_midpointmode.reference, tests-lib/tget_points.c, tests-lib/tget_points.reference, tests-lib/tget_prec.c, tests-lib/tget_prec.reference, tests-lib/tget_rationalmode.c, tests-lib/tget_rationalmode.reference, tests-lib/tget_roundingwarnings.c, tests-lib/tget_roundingwarnings.reference, tests-lib/tget_showmessagenumbers.c, tests-lib/tget_showmessagenumbers.reference, tests-lib/tget_taylorrecursions.c, tests-lib/tget_taylorrecursions.reference, tests-lib/tget_timing.c, tests-lib/tget_timing.reference, tests-lib/tget_verbosity.c, tests-lib/tget_verbosity.reference, tests-lib/tset_autosimplify.c, tests-lib/tset_autosimplify.reference, tests-lib/tset_autosimplify_and_print.c, tests-lib/tset_autosimplify_and_print.reference, tests-lib/tset_canonical.c, tests-lib/tset_canonical.reference, tests-lib/tset_canonical_and_print.c, tests-lib/tset_canonical_and_print.reference, tests-lib/tset_diam.c, tests-lib/tset_diam.reference, tests-lib/tset_diam_and_print.c, tests-lib/tset_diam_and_print.reference, tests-lib/tset_dieonerrormode.c, tests-lib/tset_dieonerrormode.reference, tests-lib/tset_dieonerrormode_and_print.c, tests-lib/tset_dieonerrormode_and_print.reference, tests-lib/tset_display.c, tests-lib/tset_display.reference, tests-lib/tset_display_and_print.c, tests-lib/tset_display_and_print.reference, tests-lib/tset_hopitalrecursions.c, tests-lib/tset_hopitalrecursions.reference, tests-lib/tset_hopitalrecursions_and_print.c, tests-lib/tset_hopitalrecursions_and_print.reference, tests-lib/tset_midpointmode.c, tests-lib/tset_midpointmode.reference, tests-lib/tset_midpointmode_and_print.c, tests-lib/tset_midpointmode_and_print.reference, tests-lib/tset_points.c, tests-lib/tset_points.reference, tests-lib/tset_points_and_print.c, tests-lib/tset_points_and_print.reference, tests-lib/tset_prec.c, tests-lib/tset_prec.reference, tests-lib/tset_prec_and_print.c, tests-lib/tset_prec_and_print.reference, tests-lib/tset_rationalmode.c, tests-lib/tset_rationalmode.reference, tests-lib/tset_rationalmode_and_print.c, tests-lib/tset_rationalmode_and_print.reference, tests-lib/tset_roundingwarnings.c, tests-lib/tset_roundingwarnings.reference, tests-lib/tset_roundingwarnings_and_print.c, tests-lib/tset_roundingwarnings_and_print.reference, tests-lib/tset_showmessagenumbers.c, tests-lib/tset_showmessagenumbers.reference, tests-lib/tset_showmessagenumbers_and_print.c, tests-lib/tset_showmessagenumbers_and_print.reference, tests-lib/tset_taylorrecursions.c, tests-lib/tset_taylorrecursions.reference, tests-lib/tset_taylorrecursions_and_print.c, tests-lib/tset_taylorrecursions_and_print.reference, tests-lib/tset_timing.c, tests-lib/tset_timing.reference, tests-lib/tset_timing_and_print.c, tests-lib/tset_timing_and_print.reference, tests-lib/tset_verbosity.c, tests-lib/tset_verbosity.reference, tests-lib/tset_verbosity_and_print.c, tests-lib/tset_verbosity_and_print.reference: * Tests for set_MODES, set_MODES_and_print and get_MODES. This commit was extracted from SVN r1537. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1537 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-18 clauter * sollya-library-wrappers.c, sollya.h: Added functions to name the free mathematical variable and to get its name in the Sollya library. This commit was extracted from SVN r1536. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1536 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 clauter * general.c, general.h, sollya-library-wrappers.c, sollya.h: Added a function that allows the last installed message callback function pointer to be retrieved. This commit was extracted from SVN r1535. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1535 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 schevill * sollya.h: * Added short macros to allow a quick access to sollya_lib_build_function_* This commit was extracted from SVN r1534. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1534 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 schevill * tests-lib/tmax.c, tests-lib/tmin.c, tests-lib/tv_max.c, tests-lib/tv_min.c: * Added ";" at the end of every parse_string This commit was extracted from SVN r1533. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1533 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 schevill * sollya-library-wrappers.c, sollya.h, tests-lib/Makefile.am, tests-lib/tminus.c, tests-lib/tminus.reference, tests-lib/tneg.c, tests-lib/tneg.reference: * Replaced sollya_lib_minus by sollya_lib_neg. This commit was extracted from SVN r1532. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1532 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 clauter * general.c: Changed a comment slightly This commit was extracted from SVN r1531. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1531 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 clauter * sollya-library-wrappers.c, sollya.h: Changed the silent versions of the set_*_ functions to the normal ones and changed the others to *_and_print. This commit was extracted from SVN r1530. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1530 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 schevill * tests-lib/Makefile.am, tests-lib/tmax.c, tests-lib/tmin.c, tests-lib/tv_max.c, tests-lib/tv_max.reference, tests-lib/tv_min.c, tests-lib/tv_min.reference: * Added tests for v_min and v_max and removed useless header to min and max. This commit was extracted from SVN r1529. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1529 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 clauter * sollya-library-wrappers.c, sollya.h: Added functions for building Sollya objects representing lists without copying the arguments. This commit was extracted from SVN r1528. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1528 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 schevill * tests-lib/tmax.c, tests-lib/tmax.reference, tests-lib/tmin.c, tests-lib/tmin.reference, tests-tool/check013.sollya, tests-tool/check013.sollya.reference: * Updated tests for min and max. This commit was extracted from SVN r1527. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1527 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 clauter * execute.c: Corrected behavior of min and max if more than one argument (or element in a list) is given. This commit was extracted from SVN r1526. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1526 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 schevill * tests-lib/Makefile.am, tests-lib/tmax.c, tests-lib/tmax.reference: * Test files for max. This commit was extracted from SVN r1525. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1525 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 schevill * tests-lib/tmin.c, tests-lib/tmin.reference, tests-lib/tobj_is_end_elliptic_list.reference, tests-lib/tobj_is_error.reference, tests-lib/tobj_is_list.reference: * Corrected reference files for error, is_list and is_end_elliptic_list to account for the fact that sollya_lib_end_elliptic_list(NULL, 0) now returns an error. * test files for min. This commit was extracted from SVN r1524. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1524 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 clauter * doc/max.shlp, doc/max.tex, doc/min.shlp, doc/min.tex, doc/sollya.pdf, doc/www/max.php, doc/www/min.php, help.h: Updated documentation for min and max with respect to a better wording of the IEEE 754-2008 rule for NaNs when several arguments are given. This commit was extracted from SVN r1523. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1523 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 clauter * sollya-library-wrappers.c: Changed semantic of sollya_lib_end_elliptic_list This commit was extracted from SVN r1522. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1522 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 schevill * tests-lib/Makefile.am, tests-lib/tis_absolute.c, tests-lib/tis_absolute.reference, tests-lib/tis_binary.c, tests-lib/tis_binary.reference, tests-lib/tis_decimal.c, tests-lib/tis_decimal.reference, tests-lib/tis_default.c, tests-lib/tis_default.reference, tests-lib/tis_double_double_obj.c, tests-lib/tis_double_double_obj.reference, tests-lib/tis_double_obj.c, tests-lib/tis_double_obj.reference, tests-lib/tis_doubleextended_obj.c, tests-lib/tis_doubleextended_obj.reference, tests-lib/tis_dyadic.c, tests-lib/tis_dyadic.reference, tests-lib/tis_false.c, tests-lib/tis_false.reference, tests-lib/tis_file.c, tests-lib/tis_file.reference, tests-lib/tis_fixed.c, tests-lib/tis_fixed.reference, tests-lib/tis_floating.c, tests-lib/tis_floating.reference, tests-lib/tis_halfprecision_obj.c, tests-lib/tis_halfprecision_obj.reference, tests-lib/tis_hexadecimal.c, tests-lib/tis_hexadecimal.reference, tests-lib/tis_honorcoeffprec.c, tests-lib/tis_honorcoeffprec.reference, tests-lib/tis_off.c, tests-lib/tis_off.reference, tests-lib/tis_on.c, tests-lib/tis_on.reference, tests-lib/tis_perturb.c, tests-lib/tis_perturb.reference, tests-lib/tis_pi.c, tests-lib/tis_pi.reference, tests-lib/tis_postscript.c, tests-lib/tis_postscript.reference, tests-lib/tis_postscriptfile.c, tests-lib/tis_postscriptfile.reference, tests-lib/tis_powers.c, tests-lib/tis_powers.reference, tests-lib/tis_quad_obj.c, tests-lib/tis_quad_obj.reference, tests-lib/tis_relative.c, tests-lib/tis_relative.reference, tests-lib/tis_round_down.c, tests-lib/tis_round_down.reference, tests-lib/tis_round_to_nearest.c, tests-lib/tis_round_to_nearest.reference, tests-lib/tis_round_towards_zero.c, tests-lib/tis_round_towards_zero.reference, tests-lib/tis_round_up.c, tests-lib/tis_round_up.reference, tests-lib/tis_single_obj.c, tests-lib/tis_single_obj.reference, tests-lib/tis_triple_double_obj.c, tests-lib/tis_triple_double_obj.reference, tests-lib/tis_true.c, tests-lib/tis_true.reference, tests-lib/tis_void.c, tests-lib/tis_void.reference, tests-lib/tobj_is_end_elliptic_list.c, tests-lib/tobj_is_end_elliptic_list.reference, tests-lib/tobj_is_error.c, tests-lib/tobj_is_error.reference, tests-lib/tobj_is_function.c, tests-lib/tobj_is_function.reference, tests-lib/tobj_is_list.c, tests-lib/tobj_is_list.reference, tests-lib/tobj_is_range.c, tests-lib/tobj_is_range.reference, tests-lib/tobj_is_string.c, tests-lib/tobj_is_string.reference: * And hop, 38 new tests. This commit was extracted from SVN r1521. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1521 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 clauter * tests-lib/tmin.c: Slightly changed library test for min This commit was extracted from SVN r1520. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1520 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-17 schevill * tests-lib/tabs.c, tests-lib/tabsolute.c, tests-lib/tacos.c, tests-lib/tacosh.c, tests-lib/tadd.c, tests-lib/tasin.c, tests-lib/tasinh.c, tests-lib/tatan.c, tests-lib/tatanh.c, tests-lib/tbinary.c, tests-lib/tbuild_function_abs.c, tests-lib/tbuild_function_acos.c, tests-lib/tbuild_function_acosh.c, tests-lib/tbuild_function_add.c, tests-lib/tbuild_function_asin.c, tests-lib/tbuild_function_asinh.c, tests-lib/tbuild_function_atan.c, tests-lib/tbuild_function_atanh.c, tests-lib/tbuild_function_ceil.c, tests-lib/tbuild_function_cos.c, tests-lib/tbuild_function_cosh.c, tests-lib/tbuild_function_div.c, tests-lib/tbuild_function_double.c, tests-lib/tbuild_function_double_double.c, tests-lib/tbuild_function_doubleextended.c, tests-lib/tbuild_function_erf.c, tests-lib/tbuild_function_erfc.c, tests-lib/tbuild_function_exp.c, tests-lib/tbuild_function_expm1.c, tests-lib/tbuild_function_floor.c, tests-lib/tbuild_function_free_variable.c, tests-lib/tbuild_function_halfprecision.c, tests-lib/tbuild_function_log.c, tests-lib/tbuild_function_log10.c, tests-lib/tbuild_function_log1p.c, tests-lib/tbuild_function_log2.c, tests-lib/tbuild_function_mul.c, tests-lib/tbuild_function_nearestint.c, tests-lib/tbuild_function_neg.c, tests-lib/tbuild_function_pi.c, tests-lib/tbuild_function_pow.c, tests-lib/tbuild_function_quad.c, tests-lib/tbuild_function_sin.c, tests-lib/tbuild_function_single.c, tests-lib/tbuild_function_sinh.c, tests-lib/tbuild_function_sqrt.c, tests-lib/tbuild_function_sub.c, tests-lib/tbuild_function_tan.c, tests-lib/tbuild_function_tanh.c, tests-lib/tbuild_function_triple_double.c, tests-lib/tceil.c, tests-lib/tcos.c, tests-lib/tcosh.c, tests-lib/tdecimal.c, tests-lib/tdefault.c, tests-lib/tdiv.c, tests-lib/tdouble.c, tests-lib/tdouble_double.c, tests-lib/tdouble_double_obj.c, tests-lib/tdouble_obj.c, tests-lib/tdoubleextended.c, tests-lib/tdoubleextended_obj.c, tests-lib/tdyadic.c, tests-lib/terf.c, tests-lib/terfc.c, tests-lib/terror.c, tests-lib/texp.c, tests-lib/texpm1.c, tests-lib/tfalse.c, tests-lib/tfile.c, tests-lib/tfixed.c, tests-lib/tfloating.c, tests-lib/tfloor.c, tests-lib/tfree_variable.c, tests-lib/thalfprecision.c, tests-lib/thalfprecision_obj.c, tests-lib/thexadecimal.c, tests-lib/thonorcoeffprec.c, tests-lib/tlog.c, tests-lib/tlog10.c, tests-lib/tlog1p.c, tests-lib/tlog2.c, tests-lib/tmin.c, tests-lib/tminus.c, tests-lib/tmul.c, tests-lib/tnearestint.c, tests-lib/toff.c, tests-lib/ton.c, tests-lib/tperturb.c, tests-lib/tpi.c, tests-lib/tpostscript.c, tests-lib/tpostscriptfile.c, tests-lib/tpow.c, tests-lib/tpowers.c, tests-lib/tquad.c, tests-lib/tquad_obj.c, tests-lib/trelative.c, tests-lib/tround_down.c, tests-lib/tround_to_nearest.c, tests-lib/tround_towards_zero.c, tests-lib/tround_up.c, tests-lib/tsin.c, tests-lib/tsingle.c, tests-lib/tsingle_obj.c, tests-lib/tsinh.c, tests-lib/tsqrt.c, tests-lib/tsub.c, tests-lib/ttan.c, tests-lib/ttanh.c, tests-lib/ttriple_double.c, tests-lib/ttriple_double_obj.c, tests-lib/ttrue.c, tests-lib/tvoid.c: * Removed a stupid error of copy-paste. This commit was extracted from SVN r1519. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1519 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 clauter * sollya-library-wrappers.c: Corrected like 10000 stupid copy-paste errors in the library wrapper code. This commit was extracted from SVN r1518. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1518 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 schevill * tests-lib/Makefile.am, tests-lib/tabsolute.c, tests-lib/tabsolute.reference, tests-lib/tbinary.c, tests-lib/tbinary.reference, tests-lib/tbuild_function_free_variable.c, tests-lib/tbuild_function_pi.c, tests-lib/tbuild_function_pi.reference, tests-lib/tdecimal.c, tests-lib/tdecimal.reference, tests-lib/tdefault.c, tests-lib/tdefault.reference, tests-lib/tdouble_double_obj.c, tests-lib/tdouble_double_obj.reference, tests-lib/tdouble_obj.c, tests-lib/tdouble_obj.reference, tests-lib/tdoubleextended_obj.c, tests-lib/tdoubleextended_obj.reference, tests-lib/tdyadic.c, tests-lib/tdyadic.reference, tests-lib/terror.c, tests-lib/terror.reference, tests-lib/tfalse.c, tests-lib/tfalse.reference, tests-lib/tfile.c, tests-lib/tfile.reference, tests-lib/tfixed.c, tests-lib/tfixed.reference, tests-lib/tfloating.c, tests-lib/tfloating.reference, tests-lib/tfree_variable.c, tests-lib/thalfprecision_obj.c, tests-lib/thalfprecision_obj.reference, tests-lib/thexadecimal.c, tests-lib/thexadecimal.reference, tests-lib/thonorcoeffprec.c, tests-lib/thonorcoeffprec.reference, tests-lib/tmin.c, tests-lib/tmin.reference, tests-lib/toff.c, tests-lib/toff.reference, tests-lib/ton.c, tests-lib/ton.reference, tests-lib/tperturb.c, tests-lib/tperturb.reference, tests-lib/tpi.c, tests-lib/tpostscript.c, tests-lib/tpostscript.reference, tests-lib/tpostscriptfile.c, tests-lib/tpostscriptfile.reference, tests-lib/tpowers.c, tests-lib/tpowers.reference, tests-lib/tquad_obj.c, tests-lib/tquad_obj.reference, tests-lib/trelative.c, tests-lib/trelative.reference, tests-lib/tround_down.c, tests-lib/tround_down.reference, tests-lib/tround_to_nearest.c, tests-lib/tround_to_nearest.reference, tests-lib/tround_towards_zero.c, tests-lib/tround_towards_zero.reference, tests-lib/tround_up.c, tests-lib/tround_up.reference, tests-lib/tsingle_obj.c, tests-lib/tsingle_obj.reference, tests-lib/ttriple_double_obj.c, tests-lib/ttriple_double_obj.reference, tests-lib/ttrue.c, tests-lib/ttrue.reference, tests-lib/tvoid.c, tests-lib/tvoid.reference: * Other tests... This commit was extracted from SVN r1517. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1517 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 schevill * tests-lib/tbuild_function_pi.reference, tests-lib/tpi.reference: * Added corrected references for pi. This commit was extracted from SVN r1516. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1516 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 schevill * tests-lib/Makefile.am, tests-lib/tabs.c, tests-lib/tabs.reference, tests-lib/tacos.c, tests-lib/tacos.reference, tests-lib/tacosh.c, tests-lib/tacosh.reference, tests-lib/tadd.c, tests-lib/tadd.reference, tests-lib/tasin.c, tests-lib/tasin.reference, tests-lib/tasinh.c, tests-lib/tasinh.reference, tests-lib/tatan.c, tests-lib/tatan.reference, tests-lib/tatanh.c, tests-lib/tatanh.reference, tests-lib/tceil.c, tests-lib/tceil.reference, tests-lib/tcos.c, tests-lib/tcos.reference, tests-lib/tcosh.c, tests-lib/tcosh.reference, tests-lib/tdiv.c, tests-lib/tdiv.reference, tests-lib/tdouble.c, tests-lib/tdouble.reference, tests-lib/tdouble_double.c, tests-lib/tdouble_double.reference, tests-lib/tdoubleextended.c, tests-lib/tdoubleextended.reference, tests-lib/terf.c, tests-lib/terf.reference, tests-lib/terfc.c, tests-lib/terfc.reference, tests-lib/texp.c, tests-lib/texp.reference, tests-lib/texpm1.c, tests-lib/texpm1.reference, tests-lib/tfloor.c, tests-lib/tfloor.reference, tests-lib/tfree_variable.c, tests-lib/tfree_variable.reference, tests-lib/thalfprecision.c, tests-lib/thalfprecision.reference, tests-lib/tlog.c, tests-lib/tlog.reference, tests-lib/tlog10.c, tests-lib/tlog10.reference, tests-lib/tlog1p.c, tests-lib/tlog1p.reference, tests-lib/tlog2.c, tests-lib/tlog2.reference, tests-lib/tminus.c, tests-lib/tminus.reference, tests-lib/tmul.c, tests-lib/tmul.reference, tests-lib/tnearestint.c, tests-lib/tnearestint.reference, tests-lib/tpi.c, tests-lib/tpi.reference, tests-lib/tpow.c, tests-lib/tpow.reference, tests-lib/tquad.c, tests-lib/tquad.reference, tests-lib/tsin.c, tests-lib/tsin.reference, tests-lib/tsingle.c, tests-lib/tsingle.reference, tests-lib/tsinh.c, tests-lib/tsinh.reference, tests-lib/tsqrt.c, tests-lib/tsqrt.reference, tests-lib/tsub.c, tests-lib/tsub.reference, tests-lib/ttan.c, tests-lib/ttan.reference, tests-lib/ttanh.c, tests-lib/ttanh.reference, tests-lib/ttriple_double.c, tests-lib/ttriple_double.reference: * Some other tests. This commit was extracted from SVN r1515. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1515 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 schevill * tests-lib/Makefile.am, tests-lib/check.proto, tests-lib/check00.c, tests-lib/check01.c, tests-lib/tbuild_function_abs.c, tests-lib/tbuild_function_abs.reference, tests-lib/tbuild_function_acos.c, tests-lib/tbuild_function_acos.reference, tests-lib/tbuild_function_acosh.c, tests-lib/tbuild_function_acosh.reference, tests-lib/tbuild_function_add.c, tests-lib/tbuild_function_add.reference, tests-lib/tbuild_function_asin.c, tests-lib/tbuild_function_asin.reference, tests-lib/tbuild_function_asinh.c, tests-lib/tbuild_function_asinh.reference, tests-lib/tbuild_function_atan.c, tests-lib/tbuild_function_atan.reference, tests-lib/tbuild_function_atanh.c, tests-lib/tbuild_function_atanh.reference, tests-lib/tbuild_function_ceil.c, tests-lib/tbuild_function_ceil.reference, tests-lib/tbuild_function_cos.c, tests-lib/tbuild_function_cos.reference, tests-lib/tbuild_function_cosh.c, tests-lib/tbuild_function_cosh.reference, tests-lib/tbuild_function_div.c, tests-lib/tbuild_function_div.reference, tests-lib/tbuild_function_double.c, tests-lib/tbuild_function_double.reference, tests-lib/tbuild_function_double_double.c, tests-lib/tbuild_function_double_double.reference, tests-lib/tbuild_function_doubleextended.c, tests-lib/tbuild_function_doubleextended.reference, tests-lib/tbuild_function_erf.c, tests-lib/tbuild_function_erf.reference, tests-lib/tbuild_function_erfc.c, tests-lib/tbuild_function_erfc.reference, tests-lib/tbuild_function_exp.c, tests-lib/tbuild_function_exp.reference, tests-lib/tbuild_function_expm1.c, tests-lib/tbuild_function_expm1.reference, tests-lib/tbuild_function_floor.c, tests-lib/tbuild_function_floor.reference, tests-lib/tbuild_function_free_variable.c, tests-lib/tbuild_function_free_variable.reference, tests-lib/tbuild_function_halfprecision.c, tests-lib/tbuild_function_halfprecision.reference, tests-lib/tbuild_function_log.c, tests-lib/tbuild_function_log.reference, tests-lib/tbuild_function_log10.c, tests-lib/tbuild_function_log10.reference, tests-lib/tbuild_function_log1p.c, tests-lib/tbuild_function_log1p.reference, tests-lib/tbuild_function_log2.c, tests-lib/tbuild_function_log2.reference, tests-lib/tbuild_function_mul.c, tests-lib/tbuild_function_mul.reference, tests-lib/tbuild_function_nearestint.c, tests-lib/tbuild_function_nearestint.reference, tests-lib/tbuild_function_neg.c, tests-lib/tbuild_function_neg.reference, tests-lib/tbuild_function_pi.c, tests-lib/tbuild_function_pi.reference, tests-lib/tbuild_function_pow.c, tests-lib/tbuild_function_pow.reference, tests-lib/tbuild_function_quad.c, tests-lib/tbuild_function_quad.reference, tests-lib/tbuild_function_sin.c, tests-lib/tbuild_function_sin.reference, tests-lib/tbuild_function_single.c, tests-lib/tbuild_function_single.reference, tests-lib/tbuild_function_sinh.c, tests-lib/tbuild_function_sinh.reference, tests-lib/tbuild_function_sqrt.c, tests-lib/tbuild_function_sqrt.reference, tests-lib/tbuild_function_sub.c, tests-lib/tbuild_function_sub.reference, tests-lib/tbuild_function_tan.c, tests-lib/tbuild_function_tan.reference, tests-lib/tbuild_function_tanh.c, tests-lib/tbuild_function_tanh.reference, tests-lib/tbuild_function_triple_double.c, tests-lib/tbuild_function_triple_double.reference: * New system of tests for the lib. Each file foo.c *must* come with a file foo.reference. If foo.reference is missing, this will generate an error message on stderr when make check will be run. If foo.reference is empty, foo will be run and it exit code determines if the test succeeds or not. If foo.reference is not empty, the test succeeds if and only if the exit code of foo is 0 *and* the output of foo is the same as in foo.reference * First checks. This commit was extracted from SVN r1514. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1514 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 clauter * configure.ac: Converted tests in configure script to 'if test ...' instead of 'if [[ ... ]]' This commit was extracted from SVN r1513. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1513 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 clauter * configure.ac: Added check in configure script that tries to avoid the case when FPLLL is just a header file and just a static version of libsollya is built. This commit was extracted from SVN r1512. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1512 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 schevill * tests-lib/Makefile.am, tests-tool/Makefile.am: * Eventually found a way to force compilation of sollya without recompiling test files. This commit was extracted from SVN r1511. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1511 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 schevill * tests-tool/Makefile.am, tests-tool/toto.sollya, tests-tool/toto.sollya.reference, tests-tool/toto2.sollya, tests-tool/toto2.sollya.reference: * Removed temporary test files and restored previous tests. This commit was extracted from SVN r1510. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1510 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 clauter * tests-lib/Makefile.am, tests-tool/Makefile.am: Added two newlines to Makefiles This commit was extracted from SVN r1509. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1509 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 schevill * tests-lib/Makefile.am: * Removed unnecessary targets for the reconstruction of sollya tool during check of the lib This commit was extracted from SVN r1508. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1508 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 schevill * tests-lib/check01.c: * Added missing file This commit was extracted from SVN r1507. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1507 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-16 schevill * tests-tool/toto.sollya, tests-tool/toto.sollya.reference, tests-tool/toto2.sollya, tests-tool/toto2.sollya.reference: * Added missing temporary files. This commit was extracted from SVN r1506. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1506 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-15 schevill * tests-tool/check005.sollya, tests-tool/check005.sollya.reference: * Corrected a typo introduced a year ago when splitting check.sollya into several files (rev 1304). This commit was extracted from SVN r1505. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1505 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-15 schevill * Makefile.am, configure.ac, tests-lib/Makefile.am, tests-lib/check00.c, tests-tool/Makefile.am, tests-tool/check.proto, tests-tool/check001.sollya, tests-tool/check001.sollya.reference, tests-tool/check002.sollya, tests-tool/check002.sollya.reference, tests-tool/check003.sollya, tests-tool/check003.sollya.reference, tests-tool/check004.sollya, tests-tool/check004.sollya.reference, tests-tool/check005.sollya, tests-tool/check005.sollya.reference, tests-tool/check006.sollya, tests-tool/check006.sollya.reference, tests-tool/check007.sollya, tests-tool/check007.sollya.reference, tests-tool/check008.sollya, tests-tool/check008.sollya.reference, tests-tool/check009.sollya, tests-tool/check009.sollya.reference, tests-tool/check010.sollya, tests-tool/check010.sollya.reference, tests-tool/check011.sollya, tests-tool/check011.sollya.reference, tests-tool/check012.sollya, tests-tool/check012.sollya.reference, tests-tool/check013.sollya, tests-tool/check013.sollya.reference, tests-tool/check014.sollya, tests-tool/check014.sollya.reference, tests-tool/check015.sollya, tests-tool/check015.sollya.reference, tests-tool/check016.sollya, tests-tool/check016.sollya.reference, tests-tool/check017.sollya, tests-tool/check017.sollya.reference, tests-tool/check018.sollya, tests-tool/check018.sollya.reference, tests-tool/check019.sollya, tests-tool/check019.sollya.reference, tests-tool/check020.sollya, tests-tool/check020.sollya.reference, tests-tool/memoryleaks.sollya, tests-tool/timecheck.sollya, tests-tool/timecheck.sollya.reference, tests/Makefile.am, tests/check.proto, tests/check001.sollya, tests/check001.sollya.reference, tests/check002.sollya, tests/check002.sollya.reference, tests/check003.sollya, tests/check003.sollya.reference, tests/check004.sollya, tests/check004.sollya.reference, tests/check005.sollya, tests/check005.sollya.reference, tests/check006.sollya, tests/check006.sollya.reference, tests/check007.sollya, tests/check007.sollya.reference, tests/check008.sollya, tests/check008.sollya.reference, tests/check009.sollya, tests/check009.sollya.reference, tests/check010.sollya, tests/check010.sollya.reference, tests/check011.sollya, tests/check011.sollya.reference, tests/check012.sollya, tests/check012.sollya.reference, tests/check013.sollya, tests/check013.sollya.reference, tests/check014.sollya, tests/check014.sollya.reference, tests/check015.sollya, tests/check015.sollya.reference, tests/check016.sollya, tests/check016.sollya.reference, tests/check017.sollya, tests/check017.sollya.reference, tests/check018.sollya, tests/check018.sollya.reference, tests/check019.sollya, tests/check019.sollya.reference, tests/check020.sollya, tests/check020.sollya.reference, tests/memoryleaks.sollya, tests/timecheck.sollya, tests/timecheck.sollya.reference: * Some progress on having a check system for both the tool and the library. This commit was extracted from SVN r1504. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1504 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-14 schevill * tests-lib/Makefile.am, tests-lib/check00.c: * Forgotten new directory. This commit was extracted from SVN r1503. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1503 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-13 schevill * Makefile.am, configure.ac, doc/Makefile.am, tests/Makefile.am, tests/check.proto: * Still testing things with make check without understanding precisely what happens. This commit was extracted from SVN r1502. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1502 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-13 clauter * bitfields.c, bitfields.h, execute.c, execute.h, general.c, general.h, internlexer.l, internparser.y, lexer.l, message-numbers.c, message-numbers.h, minilexer.l, miniparser.y, parser.y, sollya-library-wrappers.c, sollya.h: Added commands suppressmessage and unsuppressmessage, procedure getsuppressedmessages and mode showmessagenumbers to both the interactive mode and to the new Sollya library. The new features still lack documentation and tests. This commit was extracted from SVN r1500. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1500 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-13 clauter * message-numbers.c: Added forgotten file This commit was extracted from SVN r1499. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1499 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-13 clauter * execute.c, execute.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y, sollya-library-wrappers.c, sollya.h: Added showmessagenumbers mode that allows the numbers of the different warning messages to be displayed or not. This commit was extracted from SVN r1498. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1498 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-12 clauter * bitfields.c, bitfields.h: Committing some forgotten files: Added some code implementing bitfields. This will allow implementation of a suppresswarningnumber mode to be done. This commit was extracted from SVN r1496. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1496 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-12 clauter * Makefile.am: Added some code implementing bitfields. This will allow implementation of a suppresswarningnumber mode to be done. This commit was extracted from SVN r1495. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1495 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-12 clauter * configure.ac, general.c, general.h: Started working on a mode where messages can be filtered by type This commit was extracted from SVN r1494. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1494 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-12 clauter * execute.c, general.c, general.h: Cleaned up the left-overs from recoverFromError This commit was extracted from SVN r1492. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1492 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-09 clauter * configure.ac, execute.c: Merged trunk into branch sollya_lib using command "svn merge -r 1460:HEAD svn+ssh://clauter@scm.gforge.inria.fr/svn/sollya/trunk ." This commit was extracted from SVN r1490. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1490 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-09 clauter * configure.ac: Added some additional checks to automake (configure) script as recommended by autoscan This commit was extracted from SVN r1489. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1489 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-09 clauter * configure.ac: Trying to patch bug #13702 This commit was extracted from SVN r1488. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1488 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-09 clauter * execute.c: Changed a warning message in order to patch bug #10317 This commit was extracted from SVN r1487. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1487 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-06 clauter * sollya-library-wrappers.c, sollya.h: Completed support for structures in the new Sollya library. This commit was extracted from SVN r1485. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1485 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-06 clauter * sollya-library-wrappers.c, sollya.h: Started working on support for structures in the new Sollya library. This commit was extracted from SVN r1483. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1483 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-06 clauter * execute.c, externalproc.c, sollya-library-wrappers.c, sollya.h: Finished updating externalproc for use with the new Sollya library. This commit was extracted from SVN r1480. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1480 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-05 clauter * execute.c, internlexer.l, internparser.y, lexer.l, library.h, minilexer.l, miniparser.y, parser.y: Some progress with extending externalproc to plain Sollya objects. Work is unfinished and not yet tested. This commit was extracted from SVN r1479. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1479 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-05 clauter * sollya-library-wrappers.c, sollya.h: Added functions to the Sollya library to allow Sollya objects to be tested against particular constant values, like on, off, dyadic etc. This commit was extracted from SVN r1478. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1478 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-05 clauter * sollya-library-wrappers.c: Corrected a small mistake in the library code. This commit was extracted from SVN r1477. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1477 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-05 clauter * sollya-library-wrappers.c, sollya.h: Added a couple of functions to the Sollya to allow mathematical functions to be recursively decomposed. This commit was extracted from SVN r1476. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1476 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-05 clauter * general.c, libsollyaexample.c: Change example for using the Sollya library. This commit was extracted from SVN r1475. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1475 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-05 clauter * execute.c, general.c, message-numbers.h, remez.c: Removed the last recoverFromError: Sylvain please check if I correctly performed that change. Improved signal handling. This commit was extracted from SVN r1474. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1474 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-05 clauter * general.c, general.h, sollya-library-wrappers.c: Added some preliminary (untested) code for initializing and finalizing the new Sollya library. This commit was extracted from SVN r1473. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1473 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-05 clauter * double.c, expression.c, plot.c: Removed a couple of calls to recoverFromError. Only one call in remez.c seems to remain. This commit was extracted from SVN r1472. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1472 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-04 clauter * Makefile.am, message-numbers.h, sollya-library-wrappers.c, sollya.h: Added a feature that allows message numbers (as received by the message call-back function) to be translated to texts. This commit was extracted from SVN r1471. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1471 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-04 clauter * general.c, general.h, message-numbers.h, sollya-library-wrappers.c: Again some progress with the new Sollya library This commit was extracted from SVN r1470. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1470 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-03 clauter * sollya-library-wrappers.c: Yet some more progress with the new Sollya library This commit was extracted from SVN r1469. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1469 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2012-01-03 clauter * Makefile.am, sollya-library-wrappers.c, sollya-library-wrappers.h, sollya.h: Some progress with the new Sollya library. The sollya.h header should now be complete. This commit was extracted from SVN r1468. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1468 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-12-02 clauter * execute.h, sollya-library-wrappers.c, sollya-library-wrappers.h: Added a forgotten function to the new Sollya library This commit was extracted from SVN r1467. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1467 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-12-01 clauter * sollya-library-wrappers.c, sollya-library-wrappers.h: Some progress with implementing the new Sollya library This commit was extracted from SVN r1466. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1466 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-11-16 clauter * sollya-library-wrappers.c, sollya-library-wrappers.h: Added declaration (and definition) of a forgotten Sollya lib wrapper function and change the name of another one This commit was extracted from SVN r1465. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1465 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-11-16 clauter * execute.h, general.c, general.h, sollya-library-wrappers.c, sollya-library-wrappers.h: Some progress implementing the new Sollya library This commit was extracted from SVN r1464. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1464 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-11-15 clauter * sollya-library-wrappers.c, sollya-library-wrappers.h: Stubbed out the functions needed for the new Sollya lib This commit was extracted from SVN r1463. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1463 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-11-15 clauter * Makefile.am: Stubbed out the functions needed for the new Sollya lib This commit was extracted from SVN r1462. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1462 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-11-14 schevill * sollya.h: * Added forgotten declaration @rev 1370 in sollya.h. guessDegree now takes an integer argument 'bound' which is a stopping criterion for the algorithm. In Sollya, the default value is 1024. In practice, the algorithm aborts if it does not achieve to prove that the degree you are looking for is smaller than bound. This commit was extracted from SVN r1461. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1461 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-11-10 clauter * : Added a branch for the development of a Sollya librry with a real interface This commit was extracted from SVN r1460. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/sollya_lib@1460 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-11-02 clauter * execute.c: Wrapped parseString to handle cases when a syntax error occurs This commit was extracted from SVN r1458. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1458 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-11-02 clauter * remez.c: Finished converting everything to printMessage using the new format specifiers This commit was extracted from SVN r1457. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1457 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-10-28 clauter * external.c, implement.c, infnorm.c, mpfi-compat.c, mpfi-compat.h, plot.c, printf.c, remez.c, sturm.c, worstcase.c: Changed the argument type for the new Sollya printf format specifiers: %v now takes an mpfr_t directly (not a pointer to an mpfr_t), %w takes a sollya_mpfi_t, %r takes a mpq_t. However, %b still takes a node *. Converted all the code to these new (cleaner) types. This commit was extracted from SVN r1456. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1456 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-10-28 clauter * printf.c, remez.c: Continued working on extended Sollya printf with format specifiers for MPFR, MPFI and node* types This commit was extracted from SVN r1455. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1455 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-10-26 clauter * printf.c, sturm.c, sturm.h: Added format specifier %r for mpq values to sollyaPrintf and converted sturm.c to printMessage, using that new format specifier This commit was extracted from SVN r1454. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1454 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-10-26 clauter * execute.c, expression.c, external.c, implement.c, infnorm.c, lexer.l, plot.c, remez.c, worstcase.c: Started converting all occurrences of "if (verbosity >= foo) { changeMode(); sollyaPrintf(...) ... }" to printMessages, using the new %v, %w and %b format specifiers. Files remez.c and sturm.c still need to be converted: for sturm.c, we need a format specifier for GMP rationals, for remez.c, we need support for a precision modifier that works with %v. This commit was extracted from SVN r1453. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1453 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-10-26 clauter * Makefile.am, general.c, infnorm.c, infnorm.h, printf.c, printf.h: Started working on a sollyaPrintf that supports format specifiers for MPFR, MPFI values and Sollya node trees. This commit was extracted from SVN r1452. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1452 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-10-20 clauter * general.c: Corrected a long lasting bug in printMessage occuring with the use of va_start. This might be in relation with the "Contact with Houston lost"-phenomenon This commit was extracted from SVN r1451. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1451 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-09-17 jmio17 * tests/check021.sollya: more examples from my thesis This commit was extracted from SVN r1450. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1450 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-09-17 jmio17 * doc/chebyshevform.shlp, doc/keywords.def: added a little bit of documentation for chebyshevform This commit was extracted from SVN r1449. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1449 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-09-17 jmio17 * chebyshevform.c, rigorousIntegralCM.c: removed one unused var in chebyshevform; added and "external procedure" file for testing purposes: computes rigorous integrals using cms. This commit was extracted from SVN r1448. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1448 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-09-17 jmio17 * chebModelsAux.c, tests/check021.sollya: added check file for chebyshevform; patched one bug in chebModelsAux.c; tests similar to taylorform pass; TODO:more tests needed to be added. This commit was extracted from SVN r1447. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1447 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-09-17 jmio17 * chebyshevform.c, mpfi-compat.c, mpfi-compat.h: added in mpfi-compat the wrapper sollya_mpfi_add_fr for mpfi_add_fr; added in chebyshevform.c a test whether the domain is a point interval. This commit was extracted from SVN r1446. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1446 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-09-15 clauter * NEWS, chain.c, chain.h, chebyshevform.c, doc/CommandsAndFunctions.tex, doc/bind.shlp, doc/bind.tex, doc/composepolynomials.shlp, doc/composepolynomials.tex, doc/concat.shlp, doc/concat.tex, doc/fpminimax.shlp, doc/fpminimax.tex, doc/introExample37bis.sollya, doc/introExample37bis.tex, doc/introExample3bis.sollya, doc/introExample3bis.tex, doc/introExample50.sollya, doc/introExample50.tex, doc/keywords.def, doc/proc.shlp, doc/proc.tex, doc/procedure.shlp, doc/procedure.tex, doc/remez.shlp, doc/remez.tex, doc/rename.shlp, doc/rename.tex, doc/sollya.pdf, doc/sollya.tex, doc/substitute.shlp, doc/substitute.tex, doc/types.def, doc/www/ListOfCommands.php, doc/www/bind.php, doc/www/composepolynomials.php, doc/www/concat.php, doc/www/fpminimax.php, doc/www/introExample37bis.php, doc/www/introExample3bis.php, doc/www/introExample50.php, doc/www/proc.php, doc/www/procedure.php, doc/www/remez.php, doc/www/sollya.php, doc/www/substitute.php, double.c, execute.c, execute.h, expression.c, expression.h, external.c, fpminimax.cpp, help.h, implement.c, implementconst.c, infnorm.c, infnorm.h, internlexer.l, internparser.y, lexer.l, match.c, minilexer.l, miniparser.y, parser.y, plot.c, proof.c, remez.c, remez.h, sollya.h, supnorm.c, taylor.c, taylorform.h, tests/Makefile.am, tests/check001.sollya, tests/check008.sollya, tests/check009.sollya, tests/check009.sollya.reference, tests/check010.sollya.reference, tests/check011.sollya, tests/check012.sollya, tests/check012.sollya.reference, tests/check013.sollya, tests/check013.sollya.reference, tests/check015.sollya, tests/check015.sollya.reference, tests/check018.sollya, tests/check018.sollya.reference, tests/check019.sollya, tests/check019.sollya.reference, tests/check020.sollya, tests/check020.sollya.reference, tests/memoryleaks.sollya, worstcase.c, xml.c: Merged trunk into branch, manually modifying a couple of places in execute.c to get preevaluation on matching to work on taylorforms This commit was extracted from SVN r1445. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1445 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-09-15 jmio17 * chebModelsAux.c, chebyshevform.c: ready for beta-testing. more valgrind done (seems to be ok now). This commit was extracted from SVN r1444. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1444 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-09-14 jmio17 * chebModelsAux.c, chebModelsAux.h, chebyshevform.c, chebyshevform.h: checked code, added comments, cleaned, valgrinded; TODO: interface to monomial basis; a little mode valgrind. This commit was extracted from SVN r1443. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1443 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-09-13 jmio17 * chebModelsAux.c, chebModelsAux.h: checked code, added comments This commit was extracted from SVN r1442. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1442 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-09-05 schevill * tests/check010.sollya.reference: * Update of check010.sollya.reference because Sollya now prints a message when rename(something,y) is used while the free variable does not yet have a name. This commit was extracted from SVN r1441. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1441 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-09-01 schevill * doc/introExample37bis.sollya, doc/introExample37bis.tex, doc/introExample3bis.sollya, doc/introExample3bis.tex, doc/introExample50.sollya, doc/introExample50.tex, doc/rename.shlp, doc/rename.tex, doc/sollya.pdf, doc/sollya.tex, doc/www/fpminimax.php, doc/www/introExample37bis.php, doc/www/introExample3bis.php, doc/www/introExample50.php, doc/www/remez.php, doc/www/sollya.php, execute.c, help.h: * Added documentation for the new keyword _x_. This commit was extracted from SVN r1440. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1440 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-08-31 clauter * double.c, execute.c, expression.c, external.c, implement.c, internlexer.l, internparser.y, lexer.l, match.c, minilexer.l, miniparser.y, parser.y, plot.c, proof.c, taylor.c, worstcase.c, xml.c: Added support for a default free variable _x_ that works everywhere and during the whole run of a Sollya session. Documentation and tests are still missing (and required ;-) This commit was extracted from SVN r1439. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1439 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-08-25 schevill * chain.c, chain.h, doc/fpminimax.shlp, doc/fpminimax.tex, doc/remez.shlp, doc/remez.tex, doc/sollya.pdf, execute.c, fpminimax.cpp, help.h, remez.c, remez.h, sollya.h, tests/memoryleaks.sollya: * Change in remez and fpminimax commands syntax: the second argument can now be any list of functions, and allows the user to compute approximation in any basis. * IMPORTANT NOTE: the signature of the internal functions remez and remezAux changed. This might affect users of the library. The signature of the internal functions FPminimax and FPminimaxMain did not change; however the meaning of the chain *monomials argument changed: it used to be a list of integers and is now a list of pure trees. * remez now returns a non-hornerized polynomial. However, it is not hard to maintain compatibility with the old behavior, if needed. * memoryleaks checks have been added, and the new functionnalities are documented. However, no test case has been added yet. This commit was extracted from SVN r1438. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1438 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-08-24 schevill * tests/check020.sollya, tests/check020.sollya.reference: * This time, check020 should really pass on all known architectures. This commit was extracted from SVN r1437. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1437 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-08-24 schevill * ChangeLog, configure.ac: * Bad manipulation with the previous commit (clearly, I am tired). I committed by mistake files of the weekly that should not have been committed. Reverting. This commit was extracted from SVN r1436. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1436 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-08-24 schevill * ChangeLog, configure.ac, tests/check020.sollya: * Error in the test file for remez. For some reason, I mixed up cases that were different on 32bit and 64bit machines. (the previous revision was a mistake and had nothing to do with 32bit and 64bit machines). This commit was extracted from SVN r1435. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1435 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-08-24 schevill * tests/check020.sollya: * Error in the test file for remez. For some reason, I mixed up cases that were different on 32bit and 64bit machines. This commit was extracted from SVN r1434. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1434 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-08-24 schevill * tests/Makefile.am: * Forgot to add check020 in the Makefile. This commit was extracted from SVN r1433. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1433 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-08-06 schevill * tests/check012.sollya.reference: * One of the fpminimax instances seems to give different results on 32 bit and 64 bits computers, due to a difference of the behavior of FPLLL. This must still be confirmed. Meanwhile, I reset the reference with the previous value, that works on 64 bit computers. This commit was extracted from SVN r1432. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1432 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-08-06 schevill * tests/check012.sollya, tests/check012.sollya.reference, tests/check015.sollya, tests/check015.sollya.reference, tests/check020.sollya, tests/check020.sollya.reference: * Last changes in the test files, to account for the fact that remez does not produce the same results with recent versions of MPFR, as with older versions. Actually, this also affected fpminimax. The tests are now correct also for fpminimax. This commit was extracted from SVN r1431. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1431 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-08-05 schevill * tests/check001.sollya, tests/check008.sollya, tests/check009.sollya, tests/check009.sollya.reference, tests/check011.sollya, tests/check012.sollya, tests/check012.sollya.reference, tests/check013.sollya, tests/check013.sollya.reference, tests/check015.sollya, tests/check015.sollya.reference, tests/check019.sollya, tests/check019.sollya.reference, tests/check020.sollya, tests/check020.sollya.reference: * Many tests were broken with recent versions of MPFR, due to the correction of the problem affecting mpfr_urandom (see commit message of revision 1270). As a consequence polynomials computed by remez algorithm were different with recent versions of MPFR compared to older versions and the tests were broken. The set of tests should now pass both with old and recent MPFR libraries. A problem might still remain with check012 (it is FPminimax). I have to investigate if it is just due to the remez thing or if there is something deeper. This commit was extracted from SVN r1430. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1430 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-08-03 schevill * tests/check015.sollya, tests/check015.sollya.reference: * Patched bug related to the fact that, in old versions of MPFR, mpfr_urandom was architecture dependent. The same thing had already been discovered in check013 and a patched produced at revision 1270. This commit was extracted from SVN r1429. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1429 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-08-01 clauter * doc/CommandsAndFunctions.tex, doc/bind.shlp, doc/bind.tex, doc/concat.shlp, doc/concat.tex, doc/keywords.def, doc/proc.shlp, doc/proc.tex, doc/procedure.shlp, doc/procedure.tex, doc/sollya.pdf, doc/www/ListOfCommands.php, doc/www/bind.php, doc/www/concat.php, doc/www/proc.php, doc/www/procedure.php, help.h: Documented bind This commit was extracted from SVN r1428. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1428 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-25 clauter * tests/check019.sollya, tests/check019.sollya.reference: Corrected tests for composepolynomials in order not to depend on the version of MPFI This commit was extracted from SVN r1427. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1427 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-25 schevill * NEWS, tests/check015.sollya, tests/check015.sollya.reference: * Added non-regression tests for the bug discovered by Florent de Dinechin, and fixed in revision 1425. This commit was extracted from SVN r1426. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1426 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-25 clauter * execute.c, supnorm.c: Corrected a bug in supnorm found by F2D - no regression test added, yet This commit was extracted from SVN r1425. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1425 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-24 clauter * tests/Makefile.am: Corrected the wrong extra-dist entry for check019.sollya This commit was extracted from SVN r1424. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1424 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-22 schevill * remez.c: * Just removed weird symbols in the comment and messages in remez.c This commit was extracted from SVN r1423. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1423 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-22 clauter * expression.c: Made substitute try to evaluate expressions that would become constant in result of the substitution and replace them by their value where possible (representable). This commit was extracted from SVN r1422. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1422 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-21 clauter * execute.c: Made faithful floating-point evaluation at the prompt and for := and ~ recognize cases where a function is applied to a constant and evaluate that function at that point instead of evaluating the constant tree obtained by substituting the constant into the tree at some arbitrary point. This resolves an issue seen with expressions that stay defined by continuity at some point but that involve procedure-base functions for which the tool cannot perform meaningful simplifications. This commit was extracted from SVN r1421. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1421 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-21 clauter * execute.c, expression.c: Patched a bug in error-free simplification of divisions occurring when the numerator evaluates to 0 and the denominator is constant zero but does not evaluate to constant zero. This commit was extracted from SVN r1420. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1420 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-20 schevill * implementconst.c: * Corrected a small bug in the algorithm (that had been corrected in the final version of the ARITH20 paper, without being modified accordingly in the code). This commit was extracted from SVN r1419. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1419 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-19 clauter * execute.c: Added a missing break statement that provoked a segfault on rare occasions. The occasions were that rare that the bug had stayed undiscovered at least since revision 525. This commit was extracted from SVN r1418. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1418 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-19 clauter * execute.c, execute.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y: Added a command bind that allows procedure to be partially applied ("a la Curry") This commit was extracted from SVN r1417. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1417 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-18 clauter * doc/CommandsAndFunctions.tex, doc/composepolynomials.shlp, doc/composepolynomials.tex, doc/keywords.def, doc/sollya.pdf, doc/substitute.shlp, doc/substitute.tex, doc/types.def, doc/www/ListOfCommands.php, doc/www/composepolynomials.php, doc/www/substitute.php, help.h: Added doc for composepolynomials This commit was extracted from SVN r1416. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1416 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-18 clauter * tests/check019.sollya, tests/check019.sollya.reference: Added forgotten test files This commit was extracted from SVN r1415. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1415 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-18 clauter * execute.c: Improved quality of displayed output when print or write get used on structures that contain polynomials This commit was extracted from SVN r1414. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1414 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-18 clauter * tests/Makefile.am: Tests for new command composepolynomials This commit was extracted from SVN r1413. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1413 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-13 schevill * expression.c: * Corrected a memory leak and added a comment about the new wrapper makePolynomial. This commit was extracted from SVN r1412. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1412 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-13 clauter * expression.c: Improved behavior of general function building up polynomial trees from an array of MPFR coefficients. The sparsity of the polynomials is now taken into account. This commit was extracted from SVN r1411. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1411 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-12 clauter * infnorm.c: Corrected a small mistake with a usage of evaluateFaithful This commit was extracted from SVN r1410. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1410 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-12 clauter * execute.c, execute.h, expression.c, expression.h, infnorm.c, infnorm.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y: Added a new command composepolynomials. Documentation and tests are still missing This commit was extracted from SVN r1409. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1409 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-07 clauter * expression.c, tests/check018.sollya, tests/check018.sollya.reference: Patched a nasty bug with substitution of a polynomial into another This commit was extracted from SVN r1408. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1408 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-07-07 jmio17 * : syncro with trunk This commit was extracted from SVN r1407. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1407 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-06-22 schevill * execute.c, fpminimax.cpp, remez.c, remez.h: * Added a sixth optional parameter to remez command. This parameter is currently *DEPRECATED* because we do not guarantee to support it in the future. The behavior of this sixth parameter may change without any warning in the future. Currently the sixth parameter is an interval [satisfying_err, target_err] with the following behavior: - if, during the algorithm, we manage to prove that target_err is unreachable, we stop the algorithm returning the last computed polynomial. - if, during the algorithm, we obtain a polynomial with an error smaller than satisfying_err, we stop the algorithm returning that polynomial. - otherwise we loop until we find an optimal polynomial with the required quality, as usual. The default is [0, +Inf] ('default' keyword is supported). Examples of use: [0, +Inf] -> whatever happens, compute the optimal polynomial with the required quality (same behavior as before). [target_err] -> my target error is target_err. If you manage to prove that it is not reachable stop computing immediately (I do not care the optimal polynomial: it is worst than what I need anyway). On the contrary, if you manage to find a polynomial with that error, do not continue further (that one is sufficient for my needs). [0, target_err] -> I am interested by the optimal polynomial, except if it is not even able to provide me target_err (typically: I absolutely need an error smaller than target_err, but any extra bit of accuracy would be welcome, so I am interested by the optimal polynomial nonetheless) [satisfying_err, +Inf] -> I am happy with any polynomial with an error better than satisfying_error (so, stop the computation as soon as such a polynomial is found). However, if such a polynomial does not exist, I would like to use the optimal polynomial (typically: I have the constraint that I cannot use a degree larger than a given n. Under this constraint, I would like to achieve satisfying_error, or if not possible, keep my constraint but get the best possible approximation) [target_err/4, target_err] -> My target error is target_err, so I would like to immediately stop the computation if it is not achievable. Moreover, I need some room (maybe because I will use my remez polynomial as the input of fpminimax, and this will make me loose accuracy). So, 2 extra bits are enough (do not compute further if you already have the two extra bits), and if this goal is not achievable, give me the closest to my 2 extra bits (i.e. the optimal polynomial). This commit was extracted from SVN r1405. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1405 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-06-22 clauter * execute.c, general.c, general.h: Changed behavior of autoprint for void when verbosity >= 2 This commit was extracted from SVN r1404. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1404 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-06-16 clauter * compile.sh: Synchronize metalibm and sollya This commit was extracted from SVN r1403. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1403 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-06-15 clauter * compile.sh, expansion.c: Synchronized Sollya with latest version of metalibm This commit was extracted from SVN r1402. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1402 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-06-15 clauter * compile.sh, expansion.h, general.c, remez.c: Patched a rare bug on output getting mixed up that occurs when remez fails to converge and warnings are redirected into a pipe This commit was extracted from SVN r1401. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1401 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-24 schevill * doc/www/index.php: * Updated the web page to make it link to Sollya 3.0. This commit was extracted from SVN r1400. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1400 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-24 schevill * NEWS: * Added a word in NEWS about the bug discovered yesterday. This commit was extracted from SVN r1398. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1398 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-23 schevill * doc/bashevaluate.tex, doc/bashexecute.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/time.php, doc/www/timing.php, help.h: * Recompiled the doc. This commit was extracted from SVN r1397. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1397 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-23 schevill * tests/check013.sollya, tests/check013.sollya.reference: * Corrected a typo in check013.sollya This commit was extracted from SVN r1396. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1396 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-23 schevill * tests/check013.sollya, tests/check013.sollya.reference, tests/memoryleaks.sollya: * Added new tests for taylorform. This commit was extracted from SVN r1395. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1395 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-23 schevill * taylorform.c: * Patched (huge) bug #12711. This commit was extracted from SVN r1394. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1394 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-23 schevill * doc/sollya.pdf, doc/taylorform.shlp, doc/taylorform.tex, doc/www/taylorform.php, help.h: * Modified the help of taylorform command to make it match reality (i.e. n is the degree of the returned polynomial, and not the degree+1) This commit was extracted from SVN r1393. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1393 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-23 schevill * doc/sollya.pdf, doc/taylor.shlp, doc/taylor.tex, doc/www/taylor.php, help.h: * Patched the doc of taylor command. This commit was extracted from SVN r1392. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1392 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-23 clauter * external.c: Patched a pointer problem in bashevaluate: a byte one before a malloc'ed block was read if the result of bashevaluate was the empty string This commit was extracted from SVN r1391. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1391 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-20 schevill * taylorform.c: * Reviewed and modified a little bit Mioara's patch. In principle I agree with it. It remains to carefully check on examples that everything seems to be OK, and change check013.sollya.reference This commit was extracted from SVN r1390. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1390 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-20 clauter * NEWS: Small addition to the NEWS file This commit was extracted from SVN r1389. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1389 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-20 clauter * doc/sollya.pdf, execute.c, external.c, match.c, tests/check016.sollya, tests/check016.sollya.reference, tests/memoryleaks.sollya: Patched a problem with matching with default on the concat operator ("@") and on bounds of ranges ("match [1;2] with [default;2] : (1);") Corrected a possible bug in bashevaluate if ever the pipe from the child process that gets forked off to run the bash command gets closed once before the child process ends, then filled up again and is eventually closed after child process ends. Recompiled the PDF documentation from the sources as it was not up-to-date. Added additional test lines in the check files and in the memoryleak check files to test the behavior on default described above. This commit was extracted from SVN r1388. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1388 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-20 schevill * configure.ac, doc/sollya.tex, doc/www/sollya.php: * Updated the version number of Sollya to 3.0. This commit was extracted from SVN r1387. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1387 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-20 schevill * autodiff.c, double.c, double.h, execute.c, expansion.c, expression.c, expression.h, external.c, external.h, fpminimax.cpp, general.c, general.h, help.h, implementconst.c, infnorm.c, match.c, match.h, remez.c, remez.h, taylorform.c, xml.c: * Updated copyrights. This commit was extracted from SVN r1386. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1386 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-20 schevill * NEWS: * Proposition of NEWS file for 3.0 This commit was extracted from SVN r1385. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1385 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-20 schevill * tests/memoryleaks.sollya: * Updated memoryleaks.sollya with the new tests added since last release. This commit was extracted from SVN r1384. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1384 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-20 schevill * execute.c: * Patched a memory leak in guessdegree. This commit was extracted from SVN r1383. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1383 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-20 jmio17 * taylorform.c: patched taylorform in the case of using Zumkeller remark for absolute case and added Zumk remark for relative case This commit was extracted from SVN r1382. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1382 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-20 clauter * doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/time.php, doc/www/timing.php, help.h: Recompiled the documentation This commit was extracted from SVN r1381. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1381 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-19 schevill * tests/Makefile.am: * Added forgotten files check018* to Makefile.am This commit was extracted from SVN r1380. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1380 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-19 schevill * double.c, tests/check018.sollya, tests/check018.sollya.reference: * Reviewed mpfr_round_to_ieee_format and added test cases for it. This commit was extracted from SVN r1379. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1379 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-18 schevill * doc/fpminimax.shlp, doc/fpminimax.tex, doc/guessdegree.shlp, doc/guessdegree.tex, doc/sollya.pdf, doc/www/fpminimax.php, doc/www/guessdegree.php, execute.c, help.h: * Patched guessdegree to support the default keyword. * Added a test in guessdegree, to guarantee that bound is positive. * Patched the doc of guessdegree accordingly. * Patched the doc of fpminimax. This commit was extracted from SVN r1378. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1378 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-18 schevill * doc/bashevaluate.shlp, doc/bashevaluate.tex, doc/fpminimax.shlp, doc/fpminimax.tex, doc/halfprecision.shlp, doc/halfprecision.tex, doc/quad.shlp, doc/quad.tex, doc/sollya.pdf, doc/www/bashevaluate.php, doc/www/fpminimax.php, doc/www/halfprecision.php, doc/www/quad.php, double.c, help.h: * Small corrections in the doc. This commit was extracted from SVN r1377. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1377 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-18 schevill * doc/publishwww.sh, doc/sollya.pdf, doc/sollya.tex, doc/www/sollya.php: * Read the documentation of pattern matching and performed minor corrections. I updated sollya.php accordingly. * Modified publishwww.sh to support an optional argument that is the username used to perform the scp on gforge. This commit was extracted from SVN r1376. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1376 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-16 clauter * doc/roundcoefficients.shlp, doc/roundcoefficients.tex, doc/sollya.pdf, doc/www/roundcoefficients.php, help.h: Added a forgotten comma to the doc This commit was extracted from SVN r1375. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1375 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-16 clauter * doc/round.shlp, doc/round.tex, doc/searchgal.tex, doc/sollya.pdf, doc/types.def, doc/www/round.php, doc/www/searchgal.php, help.h: Corrected the documentation concerning some issues with format indications in fpminimax, round, implementpoly, searchgal, roundcoefficients This commit was extracted from SVN r1374. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1374 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-16 clauter * doc/bashevaluate.tex, doc/bashexecute.tex, doc/fpminimax.shlp, doc/fpminimax.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, doc/www/bashevaluate.php, doc/www/bashexecute.php, doc/www/fpminimax.php, doc/www/time.php, doc/www/timing.php, help.h: Corrected a typo in the documentation and recompiled it This commit was extracted from SVN r1373. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1373 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-16 clauter * autodiff.c, doc/CommandsAndFunctions.tex, doc/double.shlp, doc/double.tex, doc/doubledouble.shlp, doc/doubledouble.tex, doc/doubleextended.shlp, doc/doubleextended.tex, doc/fpminimax.shlp, doc/fpminimax.tex, doc/halfprecision.shlp, doc/halfprecision.tex, doc/hp.shlp, doc/hp.tex, doc/implementconstant.shlp, doc/implementconstant.tex, doc/keywords.def, doc/qd.shlp, doc/qd.tex, doc/quad.shlp, doc/quad.tex, doc/round.shlp, doc/round.tex, doc/roundcoefficients.shlp, doc/roundcoefficients.tex, doc/single.shlp, doc/single.tex, doc/sollya.pdf, doc/sollya.tex, doc/tripledouble.shlp, doc/tripledouble.tex, doc/www/ListOfCommands.php, doc/www/double.php, doc/www/doubledouble.php, doc/www/doubleextended.php, doc/www/fpminimax.php, doc/www/halfprecision.php, doc/www/hp.php, doc/www/implementconstant.php, doc/www/qd.php, doc/www/quad.php, doc/www/round.php, doc/www/roundcoefficients.php, doc/www/single.php, doc/www/sollya.php, doc/www/tripledouble.php, double.c, double.h, execute.c, execute.h, expression.c, expression.h, help.h, implementconst.c, infnorm.c, internlexer.l, internparser.y, lexer.l, match.c, minilexer.l, miniparser.y, parser.y, taylorform.c, xml.c: Added operators halfprecision and quad. This commit was extracted from SVN r1372. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1372 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-13 clauter * double.c: Started working on support for half-precision and quad This commit was extracted from SVN r1371. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1371 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-13 schevill * execute.c, remez.c, remez.h: * Added a fitfth optional argument to guessdegree that is used as a maximal allowed degree. In case no degree smaller that this bound is proved suitable, a range of the form [*, +Inf] is returned. Still needs to be intensively tested. This commit was extracted from SVN r1370. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1370 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-13 clauter * external.c: Patched a huge memory leak in bashevaluate This commit was extracted from SVN r1369. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1369 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-09 schevill * tests/check015.sollya.reference: * Yet another fix for make check with the new fpminimax. This commit was extracted from SVN r1368. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1368 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-09 schevill * tests/check012.sollya.reference: * Corrected check012.sollya.reference to account for the modification of fpminimax performed last week. This commit was extracted from SVN r1367. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1367 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-08 clauter * tests/Makefile.am: Added forgotten files check016.sollya and check017.sollya to the EXTRA_DIST files This commit was extracted from SVN r1366. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1366 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-07 clauter * execute.c, execute.h, match.c: Got over some warnings found with an older gcc on a 32 bit system This commit was extracted from SVN r1365. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1365 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-04 clauter * compile.sh: Adapted compile script to new metalibm structure This commit was extracted from SVN r1364. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1364 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-04 schevill * execute.c: * Removed a warning in fpminimax that was raised by mistake. * Standardized the error messages of fpminimax. This commit was extracted from SVN r1363. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1363 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-04 schevill * execute.c, fpminimax.cpp: * Patched fpminimax, when precision less or equal than 1 are desired in floating mode. This commit was extracted from SVN r1362. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1362 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-03 clauter * compile.sh, expansion.c: Adapted Sollya to new metalibm This commit was extracted from SVN r1361. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1361 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-03 clauter * doc/CommandsAndFunctions.tex, doc/bashevaluate.shlp, doc/bashevaluate.tex, doc/bashexecute.shlp, doc/bashexecute.tex, doc/keywords.def, doc/sollya.pdf, doc/www/ListOfCommands.php, doc/www/bashevaluate.php, doc/www/bashexecute.php, help.h: Documented bashevaluate This commit was extracted from SVN r1360. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1360 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-03 schevill * doc/shlp2html.sh, doc/shlp2txt.sh: * Corrected a bug in shlp2txt and shlp2html: backslashes were eaten by the script. This commit was extracted from SVN r1359. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1359 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-03 clauter * doc/help.php, doc/www/help.php: Moved a forgotten php file to www This commit was extracted from SVN r1358. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1358 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-03 clauter * external.c: Improved behavior of bashevaluate for commands awaiting EOF on their stdin This commit was extracted from SVN r1357. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1357 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-02 clauter * execute.c, execute.h, external.c, external.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y, tests/Makefile.am, tests/check017.sollya, tests/check017.sollya.reference: Added function bashevaluate to the tool. Documentation is still missing. This commit was extracted from SVN r1356. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1356 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-02 clauter * doc/bashexecute.tex, doc/compileExamples.sh, doc/introExample51.tex, doc/publishwww.sh, doc/shlp2html.sh, doc/sollya.pdf, doc/sollya.php, doc/time.tex, doc/timing.tex, doc/www/ListOfCommands.php, doc/www/abs.php, doc/www/absolute.php, doc/www/accurateinfnorm.php, doc/www/acos.php, doc/www/acosh.php, doc/www/and.php, doc/www/append.php, doc/www/approx.php, doc/www/asciiplot.php, doc/www/asin.php, doc/www/asinh.php, doc/www/atan.php, doc/www/atanh.php, doc/www/autodiff.php, doc/www/autosimplify.php, doc/www/bashexecute.php, doc/www/binary.php, doc/www/boolean.php, doc/www/canonical.php, doc/www/ceil.php, doc/www/checkinfnorm.php, doc/www/coeff.php, doc/www/concat.php, doc/www/constant.php, doc/www/cos.php, doc/www/cosh.php, doc/www/d.php, doc/www/dd.php, doc/www/de.php, doc/www/decimal.php, doc/www/default.php, doc/www/degree.php, doc/www/denominator.php, doc/www/diam.php, doc/www/dieonerrormode.php, doc/www/diff.php, doc/www/dirtyfindzeros.php, doc/www/dirtyinfnorm.php, doc/www/dirtyintegral.php, doc/www/display.php, doc/www/divide.php, doc/www/double.php, doc/www/doubledouble.php, doc/www/doubleextended.php, doc/www/dyadic.php, doc/www/equal.php, doc/www/erf.php, doc/www/erfc.php, doc/www/error.php, doc/www/evaluate.php, doc/www/execute.php, doc/www/exp.php, doc/www/expand.php, doc/www/expm1.php, doc/www/exponent.php, doc/www/externalplot.php, doc/www/externalproc.php, doc/www/false.php, doc/www/file.php, doc/www/findzeros.php, doc/www/fixed.php, doc/www/floating.php, doc/www/floor.php, doc/www/fpminimax.php, doc/www/fullparentheses.php, doc/www/function.php, doc/www/ge.php, doc/www/gt.php, doc/www/guessdegree.php, doc/www/head.php, doc/www/hexadecimal.php, doc/www/honorcoeffprec.php, doc/www/hopitalrecursions.php, doc/www/horner.php, doc/www/implementconstant.php, doc/www/implementpoly.php, doc/www/in.php, doc/www/index.php, doc/www/inf.php, doc/www/infnorm.php, doc/www/integer.php, doc/www/integral.php, doc/www/introExample1.php, doc/www/introExample10.php, doc/www/introExample11.php, doc/www/introExample12.php, doc/www/introExample13.php, doc/www/introExample14.php, doc/www/introExample15.php, doc/www/introExample16.php, doc/www/introExample17.php, doc/www/introExample18.php, doc/www/introExample19.php, doc/www/introExample2.php, doc/www/introExample20.php, doc/www/introExample21.php, doc/www/introExample22.php, doc/www/introExample23.php, doc/www/introExample24.php, doc/www/introExample25.php, doc/www/introExample26.php, doc/www/introExample27.php, doc/www/introExample28.php, doc/www/introExample29.php, doc/www/introExample3.php, doc/www/introExample30.php, doc/www/introExample31.php, doc/www/introExample32.php, doc/www/introExample33.php, doc/www/introExample34.php, doc/www/introExample35.php, doc/www/introExample36.php, doc/www/introExample37.php, doc/www/introExample38.php, doc/www/introExample39.php, doc/www/introExample4.php, doc/www/introExample40.php, doc/www/introExample41.php, doc/www/introExample42.php, doc/www/introExample43.php, doc/www/introExample44.php, doc/www/introExample45.php, doc/www/introExample46.php, doc/www/introExample47.php, doc/www/introExample48.php, doc/www/introExample49.php, doc/www/introExample5.php, doc/www/introExample50.php, doc/www/introExample51.php, doc/www/introExample52.php, doc/www/introExample53.php, doc/www/introExample54.php, doc/www/introExample55.php, doc/www/introExample56.php, doc/www/introExample57.php, doc/www/introExample58.php, doc/www/introExample59.php, doc/www/introExample6.php, doc/www/introExample7.php, doc/www/introExample8.php, doc/www/introExample9.php, doc/www/isbound.php, doc/www/isevaluable.php, doc/www/le.php, doc/www/length.php, doc/www/library.php, doc/www/libraryconstant.php, doc/www/listof.php, doc/www/log.php, doc/www/log10.php, doc/www/log1p.php, doc/www/log2.php, doc/www/lt.php, doc/www/mantissa.php, doc/www/max.php, doc/www/mid.php, doc/www/midpointmode.php, doc/www/min.php, doc/www/minus.php, doc/www/mult.php, doc/www/nearestint.php, doc/www/neq.php, doc/www/nop.php, doc/www/not.php, doc/www/numberroots.php, doc/www/numerator.php, doc/www/off.php, doc/www/on.php, doc/www/or.php, doc/www/parse.php, doc/www/perturb.php, doc/www/pi.php, doc/www/plot.php, doc/www/plus.php, doc/www/points.php, doc/www/postscript.php, doc/www/postscriptfile.php, doc/www/power.php, doc/www/powers.php, doc/www/prec.php, doc/www/precision.php, doc/www/prepend.php, doc/www/print.php, doc/www/printdouble.php, doc/www/printexpansion.php, doc/www/printsingle.php, doc/www/printxml.php, doc/www/proc.php, doc/www/procedure.php, doc/www/quit.php, doc/www/range.php, doc/www/rationalapprox.php, doc/www/rationalmode.php, doc/www/rd.php, doc/www/readfile.php, doc/www/readxml.php, doc/www/relative.php, doc/www/remez.php, doc/www/rename.php, doc/www/restart.php, doc/www/return.php, doc/www/revert.php, doc/www/rn.php, doc/www/round.php, doc/www/roundcoefficients.php, doc/www/roundcorrectly.php, doc/www/roundingwarnings.php, doc/www/ru.php, doc/www/rz.php, doc/www/searchgal.php, doc/www/sg.php, doc/www/simplify.php, doc/www/simplifysafe.php, doc/www/sin.php, doc/www/single.php, doc/www/sinh.php, doc/www/sollya.php, doc/www/sollyacss.css, doc/www/sort.php, doc/www/sqrt.php, doc/www/string.php, doc/www/subpoly.php, doc/www/substitute.php, doc/www/sup.php, doc/www/supnorm.php, doc/www/tail.php, doc/www/tan.php, doc/www/tanh.php, doc/www/taylor.php, doc/www/taylorform.php, doc/www/taylorrecursions.php, doc/www/td.php, doc/www/time.php, doc/www/timing.php, doc/www/tripledouble.php, doc/www/true.php, doc/www/var.php, doc/www/verbosity.php, doc/www/void.php, doc/www/worstcase.php, doc/www/write.php, help.h: Added HTML version of the documentation to the repository. Added a publish script for the HTML version to the repository. (The scp's are better than the rsync stuff as the INRIA server doesn't go into "stubborn" mode after publishing with scp) Recompiled the documentation. This commit was extracted from SVN r1354. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1354 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-05-01 clauter * : Ported back branch expressionMatchingSupport into the trunk, using "svn merge -r 1314:HEAD svn+ssh://clauter@scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport . ", recompiled the whole documentationThis commit was extracted from SVN r1353. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1353 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-20 schevill * doc/introExample51.tex, doc/sollya.pdf, doc/sollya.php: * sollya.php is up to date with respect to current version of sollya.tex. Though, it should still be carefully read, in order to be sure that I did not forget some obscure LaTeX symbol in the php version. * Recompiled the doc. This commit was extracted from SVN r1351. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1351 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-20 schevill * doc/conversionIntro.sh: * Added conversion feature for LaTeX {\it ...} and {\tt ...} constructs This commit was extracted from SVN r1350. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1350 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-20 clauter * tests/check016.sollya, tests/check016.sollya.reference: Extended the check file for the pattern matching support This commit was extracted from SVN r1349. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1349 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-20 clauter * doc/sollya.pdf, doc/sollya.tex: Finished the documentation for pattern matching support in the tex file This commit was extracted from SVN r1348. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1348 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-20 clauter * doc/introExample50.tex, doc/introExample51.tex, doc/introExample52.tex, doc/introExample53.tex, doc/introExample54.tex, doc/introExample55.tex, doc/introExample56.tex, doc/introExample57.tex, doc/introExample58.tex, doc/sollya.pdf: Recompiled a part of the documentation This commit was extracted from SVN r1347. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1347 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-20 clauter * doc/compileExamples.sh, doc/introExample8.tex, doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh: Merged trunk into branch revisions 1343:HEAD using svn merge -r 1343:HEAD svn://scm.gforge.inria.fr/svn/sollya/trunk . This commit was extracted from SVN r1346. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1346 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-20 clauter * doc/introExample51.tex, doc/introExample54.sollya, doc/introExample54.tex, doc/introExample55.sollya, doc/introExample55.tex, doc/introExample56.sollya, doc/introExample56.tex, doc/introExample57.sollya, doc/introExample57.tex, doc/introExample58.sollya, doc/introExample58.tex, doc/introExample59.sollya, doc/sollya.pdf, doc/sollya.tex, execute.c: Patched a bug in pattern matching and finished a first version of the documentation for this new feature This commit was extracted from SVN r1345. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1345 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-20 schevill * doc/compileExamples.sh, doc/introExample8.tex, doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh: * The documentation scripts now take advantage of the new feature introduced in revision #1342 (Sollya has now meaningful exit codes). Hence, it is now possible to write commands on several lines in the example of the documentation, and this will be properly rendered (i.e. without extra ">"). This commit was extracted from SVN r1344. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1344 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-20 clauter * general.c, general.h, parser.y: Merged trunk into branch revisions 1341:HEAD using svn merge -r 1341:HEAD svn://scm.gforge.inria.fr/svn/sollya/trunk . This commit was extracted from SVN r1343. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1343 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-20 clauter * general.c, general.h, parser.y: Add support for sensible error codes at the end of a Sollya run: 0 - the tool has been quit with a "quit;", 1 - the tool has died because of an internal error that should never happen, 2 - the tool has died because it was in "dieonerrormode = on" and an error has occurred, 3 - the tool has been quit without a "quit;" but the last command was syntactically correct and got correctly executed, 4 - the tool has been quit on an incomplete input This commit was extracted from SVN r1342. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1342 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-20 clauter * external.c: Merged trunk into branch revisions 1337:HEAD using svn merge -r 1337:HEAD svn://scm.gforge.inria.fr/svn/sollya/trunk . This commit was extracted from SVN r1341. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1341 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-19 clauter * external.c: This patch seems to solve "[12512] Strange permutation of the output of Sollya when redirected into a file" - Sylvain, please confirm This commit was extracted from SVN r1340. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1340 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-19 clauter * doc/introExample51.sollya, doc/introExample51.tex, doc/introExample52.sollya, doc/introExample52.tex, doc/introExample53.sollya, doc/introExample53.tex, doc/sollya.pdf, doc/sollya.tex: Some progress with the documentation for pattern matching This commit was extracted from SVN r1339. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1339 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-19 clauter * doc/introExample50.sollya, doc/introExample50.tex, doc/introExample51.sollya, doc/introExample51.tex, doc/sollya.pdf, doc/sollya.tex: Some progress with the documentation of the new match... with construct This commit was extracted from SVN r1338. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1338 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-19 clauter * README, configure.ac, double.c, general.c, parser.y: Merged trunk into branch revisions 1314:HEAD using svn merge -r 1314:HEAD svn://scm.gforge.inria.fr/svn/sollya/trunk . This commit was extracted from SVN r1337. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1337 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-19 clauter * match.c, tests/Makefile.am, tests/check016.sollya, tests/check016.sollya.reference: Added tests for pattern matching support. Patched two memory leaks. This commit was extracted from SVN r1336. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1336 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-18 clauter * execute.c: Made evaluation of constant expressions as bounds of ranges work for pattern matching This commit was extracted from SVN r1335. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1335 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-18 clauter * execute.c: Some progress with pre-evaluation in ranges. Still one segfault left.... ;-( This commit was extracted from SVN r1334. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1334 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-18 schevill * double.c: * Removed some trailing spaces. This commit was extracted from SVN r1333. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1333 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-18 schevill * README: * Removed comment about the possible case when fplll is not found by configure, though possibly correctly installed (this message is now out of date, sine the case cannot happen anymore). This commit was extracted from SVN r1332. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1332 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-18 clauter * configure.ac: Removed a special case from the configure script that detected if a with-*** line was given and FPLLL failed to get detected. I am committing these lines against my will and only because Sylvain agrees to pay me 10 euros the day we have to put this check back in. This commit was extracted from SVN r1331. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1331 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-18 clauter * configure.ac, general.c, parser.y: Trying to patch bugs: - [#12498] Sollya fails to compile with the new fplll 3.1.1 (see description in the bug tracker). - [#11283] On systems where no C++ compiler is available, the configure does stop with a misleading error message concerning FPLLL (just added a test if the C++ compiler works) This commit was extracted from SVN r1330. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1330 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-04-18 clauter * execute.c, match.c: Patched a bug when matching lists that a final elliptic with operator @, added support for matching default in functional expressions This commit was extracted from SVN r1329. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1329 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-03-25 clauter * execute.c: Patched a mistake with pre-evaluation of ranges This commit was extracted from SVN r1328. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1328 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-03-24 clauter * execute.h, match.c: Added support for expression matching on literate structures This commit was extracted from SVN r1327. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1327 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-03-23 clauter * execute.c: Will support pattern matching nevertheless This commit was extracted from SVN r1326. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1326 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-03-23 clauter * internlexer.l, internparser.y, minilexer.l, miniparser.y, parser.y: Synchronized the three parsers for expression matching support This commit was extracted from SVN r1325. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1325 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-03-23 clauter * execute.c, match.c: Serious progress with expression matching This commit was extracted from SVN r1324. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1324 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-03-22 clauter * execute.c, execute.h, match.c: Some non-trivial progress with expression matching support: the only case that is planned and missing is for the concat operator on lists This commit was extracted from SVN r1323. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1323 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-03-21 clauter * execute.c, execute.h, match.c: Made serious progress with expression matching support This commit was extracted from SVN r1322. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1322 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-03-18 clauter * execute.c, execute.h, match.c, match.h: Made some (non-negligable) progress with expression matching support This commit was extracted from SVN r1321. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1321 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-03-17 clauter * execute.c: Minimal step towards expression matching This commit was extracted from SVN r1320. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1320 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-25 clauter * execute.c: Some progress with expression matching This commit was extracted from SVN r1319. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1319 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-24 jmio17 * chebModels.c, testIntegrals.sollya: small changes + test file for some integral This commit was extracted from SVN r1318. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1318 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-24 clauter * execute.c: Minimal step towards pattern matching This commit was extracted from SVN r1317. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1317 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-21 clauter * Makefile.am, execute.c, match.c, match.h: Some progress with the match-with construct This commit was extracted from SVN r1316. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1316 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-18 clauter * execute.c, execute.h, lexer.l, parser.y: Started working on support for a "match ... with" construct This commit was extracted from SVN r1315. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1315 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-18 clauter * : Added a branch for starting to implement expression matching support This commit was extracted from SVN r1314. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/expressionMatchingSupport@1314 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-14 jmio17 * chebModels.c, chebModels.h, chebModelsAux.c, chebModelsAux.h, testIntegralGoldstein.sollya: added first version of tightBounding - uses showPositivity(sturm based) and cheb->monomial basis transformation This commit was extracted from SVN r1312. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1312 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-12 jmio17 * : sync branch experimentalChebModels with trunk This commit was extracted from SVN r1311. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1311 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-11 schevill * tests/check013.sollya, tests/check013.sollya.reference: * Attempt to fix the problem with make check and check013 (does not seem to work yet). This commit was extracted from SVN r1308. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1308 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-11 clauter * general.c: Added a call to mpfr_free_cache on a Sollya restart This commit was extracted from SVN r1307. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1307 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-11 clauter * doc/sollya.pdf: Recompiled the doc This commit was extracted from SVN r1306. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1306 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-10 clauter * tests/check001.sollya.reference, tests/check002.sollya.reference, tests/check003.sollya.reference, tests/check004.sollya.reference, tests/check005.sollya.reference, tests/check006.sollya.reference, tests/check007.sollya.reference, tests/check008.sollya.reference, tests/check009.sollya.reference, tests/check010.sollya.reference, tests/check011.sollya.reference, tests/check012.sollya.reference, tests/check013.sollya.reference, tests/check014.sollya.reference, tests/check015.sollya.reference: Recompiled reference values for the new check files This commit was extracted from SVN r1305. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1305 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-10 schevill * tests/check.sollya, tests/check.sollya.reference, tests/check001.sollya, tests/check002.sollya, tests/check003.sollya, tests/check004.sollya, tests/check005.sollya, tests/check006.sollya, tests/check007.sollya, tests/check008.sollya, tests/check009.sollya, tests/check010.sollya, tests/check011.sollya, tests/check012.sollya, tests/check013.sollya, tests/check014.sollya, tests/check015.sollya, tests/checkSupnorm.sollya, tests/checkTMandAD.sollya: * Cut check.sollya into several files. This commit was extracted from SVN r1304. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1304 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-10 clauter * tests/Makefile.am: Changed check system to work with small files This commit was extracted from SVN r1303. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1303 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-10 clauter * NEWS: Reformatted NEWS to a bounded number of colums This commit was extracted from SVN r1302. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1302 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-10 clauter * general.c, parser.y: Added three commas that had been forgotten in the copyright statements in version and --help This commit was extracted from SVN r1301. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1301 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-10 clauter * NEWS: Worked a little bit on the NEWS files announcing the new features in Sollya 2.9 This commit was extracted from SVN r1300. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1300 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-09 schevill * NEWS: * Proposition for the NEWS file for release 2.9 This commit was extracted from SVN r1299. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1299 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-09 clauter * tests/Makefile.am, tests/check.proto, tests/check.sollya.output, tests/check.sollya.reference, tests/timecheck.sollya.output, tests/timecheck.sollya.reference: Moved reference output files from .output to .reference This commit was extracted from SVN r1298. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1298 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-09 clauter * doc/bashexecute.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, help.h: Recompiled the whole doc This commit was extracted from SVN r1297. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1297 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-09 clauter * doc/accurateinfnorm.shlp, doc/accurateinfnorm.tex, doc/infnorm.shlp, doc/infnorm.tex, doc/sollya.pdf, help.h: Added disclaimer and reference to supnorm in accurateinfnorm and infnorm This commit was extracted from SVN r1296. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1296 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-08 schevill * doc/sollya.pdf, doc/supnorm.shlp, doc/supnorm.tex, execute.c, help.h: * Patched a bug introduced while replacing 0 by ABSOLUTE in the specif of supremumnorm (see one of the previous commits). I had forgotten to change the specif in execute.c as well. * Reworked the doc of supnorm a little. This commit was extracted from SVN r1295. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1295 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-08 clauter * doc/sollya.pdf, doc/supnorm.shlp, doc/supnorm.tex, help.h: Reworked the doc on supnorm again a little bit This commit was extracted from SVN r1294. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1294 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-08 schevill * supnorm.c: * Finished (roughly in the end) reviewing supnorm.c This commit was extracted from SVN r1293. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1293 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-08 clauter * doc/sollya.pdf, doc/supnorm.shlp, doc/supnorm.tex, help.h: Reworked the doc for supnorm This commit was extracted from SVN r1292. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1292 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-08 clauter * supnorm.c: Added some comments in supnorm: how the second least zero is found in a list of approximate zeros This commit was extracted from SVN r1291. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1291 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-04 clauter * supnorm.c: Added a TODO for SYlvian This commit was extracted from SVN r1290. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1290 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-04 schevill * chain.c, chain.h, supnorm.c: * Began to review supnorm code. Detected one bug, and considerably simplified the code of computeTaylorModelOfLeastDegree. * Also moved function freeNoPointer ni chain.h and chain.c where it is better to be for such a function. This commit was extracted from SVN r1289. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1289 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-04 clauter * tests/check.sollya.output: Corrected the test output values after having patched a copy/paste bug in max This commit was extracted from SVN r1288. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1288 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-04 schevill * execute.c, execute.h, expression.c, fpminimax.cpp, infnorm.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, mpfi-compat.c, sollya.h, sturm.c, sturm.h, supnorm.c: * All copyright and affiliations should be up-to-date now. This commit was extracted from SVN r1287. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1287 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-03 schevill * expression.h, general.c, help.h, implement.c, infnorm.c, internlexer.l, parser.y: * Yet other updates of copyrights and affiliations. This commit was extracted from SVN r1286. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1286 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-03 clauter * doc/max.shlp, doc/max.tex, doc/min.shlp, doc/min.tex, doc/sollya.pdf, help.h: Corrected a typo in the doc This commit was extracted from SVN r1285. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1285 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-02 schevill * assignment.c, assignment.h, autodiff.c, autodiff.h, chain.c, chain.h, doc/sollya.php, double.c, double.h, execute.c, execute.h, expansion.c, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.cpp, fpminimax.h, general.c, general.h, help.h, implement.c, implement.h, implementconst.c, implementconst.h, infnorm.c, infnorm.h, integral.c, integral.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, libsollyaexample.c, main.c, main.h, minilexer.l, miniparser.y, mpfi-compat.c, mpfi-compat.h, parser.y, plot.c, plot.h, proof.c, proof.h, remez.c, remez.h, sollya.h, sturm.c, sturm.h, supnorm.c, supnorm.h, taylor.c, taylor.h, taylorform.c, taylorform.h, worstcase.c, worstcase.h, xml.c, xml.h: * Updated some copyrights. * Changed Parallélisme to Parallelisme everywhere. This commit was extracted from SVN r1284. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1284 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-02 schevill * remez.c: * Reverted changes of revision 1256. This commit was extracted from SVN r1283. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1283 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-02 schevill * doc/help.php, doc/infnorm.shlp, doc/shlp2html.sh, doc/sollya.php: * Removed warning errors signaled by the W3C validator. Some of them were minor, other were more important. Here is a summary. * In sollya.php: some without
  • . They came from the fact that large parts of sollya.php have been auto-generated from sollya.tex and not carefully re-read. * In sollya.php: missing

    at some places. * In sollya.php: links in php were of the form help.php?field1=foo&field2=bar instead of help.php?field1=foo&field2=bar. I was just not aware of this subtility. * In the html code produced by shlp2html: there remained many '<' and '>' that should normally have been protected as < and > This was a fairly big issue in my opinion, and I am even surprised that the HTML has been correctly rendered by Iceweasel. Correcting this made me modify things in shlp2html.sh. Hope I did not break anything (I checked and it seems not, but I can have missed something). * Corrected a typo in the way infnorm.shlp was formatted, that prevented shlp2html.sh to correctly generate items. This commit was extracted from SVN r1282. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1282 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-02 clauter * doc/max.shlp, doc/max.tex, doc/min.shlp, doc/min.tex, doc/sollya.pdf, help.h: Added notice of strange IEEE 754-2008 compliant NaN behavior of main/max to the doc. This commit was extracted from SVN r1281. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1281 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-02 schevill * doc/function.shlp, doc/function.tex, doc/sollya.pdf, help.h: * Added a small precision in the documentation of function. This commit was extracted from SVN r1280. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1280 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-02 clauter * execute.c: Corrected a copy-paste problem This commit was extracted from SVN r1279. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1279 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-02 clauter * doc/sollya.pdf, help.h: Recompiled the doc for round This commit was extracted from SVN r1278. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1278 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-02 clauter * doc/sollya.pdf, help.h: Some doc recompilation This commit was extracted from SVN r1277. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1277 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-02 schevill * doc/round.shlp, doc/round.tex: Corrected a small mistake in the type declaration of round (always use a predefined type whenever possible) This commit was extracted from SVN r1276. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1276 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-02 schevill * doc/CommandsAndFunctions.tex, doc/D.shlp, doc/D.tex, doc/DD.shlp, doc/DD.tex, doc/DE.shlp, doc/DE.tex, doc/SG.shlp, doc/SG.tex, doc/TD.shlp, doc/TD.tex, doc/d.shlp, doc/d.tex, doc/dd.shlp, doc/dd.tex, doc/de.shlp, doc/de.tex, doc/keywords.def, doc/proc.shlp, doc/proc.tex, doc/procedure.shlp, doc/procedure.tex, doc/sg.shlp, doc/sg.tex, doc/td.shlp, doc/td.tex, help.h: * Renamed some files (no capital letters are allowed) and updated the doc accordingly. This commit was extracted from SVN r1275. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1275 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-02 clauter * doc/D.php, doc/DD.php, doc/SG.php, doc/TD.php: Removed generated php files from repository This commit was extracted from SVN r1274. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1274 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-02 clauter * supnorm.c: Added documentation for a function in supnorm This commit was extracted from SVN r1273. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1273 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-01 clauter * doc/CommandsAndFunctions.tex, doc/D.php, doc/D.shlp, doc/D.tex, doc/DD.php, doc/DD.shlp, doc/DD.tex, doc/DE.shlp, doc/DE.tex, doc/SG.php, doc/SG.shlp, doc/SG.tex, doc/TD.php, doc/TD.shlp, doc/TD.tex, doc/sollya.pdf, help.h: Added seealso references for the commands that have two names This commit was extracted from SVN r1272. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1272 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-01 clauter * help.h: Updated a copyright header This commit was extracted from SVN r1271. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1271 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-01 schevill * tests/check.sollya, tests/check.sollya.output, tests/checkSupnorm.sollya: * Due to a bug in MPFR, mpfr_urandom used to give different results on 32-bit and 64-bit computers. Since remez perturbs the initial points in order to avoid undesirable regularity effects, this bug has an influence on the result of the remez command. The result is fine in any case, but not bit-per-bit the same on all computers. This was detected by make check. As a matter of fact, we do not claim to have totally reproductible results on every platform; we only claim to give correct results (i.e. with an error bounded by what the user has asked for). However, the reproductibility is desirable, e.g. because it eases debugging. Hence, we find desirable that make check detects whenever Sollya has a platform-dependent behavior. In this revision, I patched check.sollya in order to make it pass, despite the bug. But I also added a test that checks that we have one of the three expected behavior: either with a 32-bit architecture with an old MPFR, or with a 64-bit architecture with an old MPFR, or any architecture with a recent version (i.e. today, a SVN one) of MPFR. This commit was extracted from SVN r1270. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1270 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-01 clauter * doc/proc.shlp, doc/proc.tex, doc/sollya.pdf, help.h: Corrected a typo in the doc for proc This commit was extracted from SVN r1269. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1269 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-01 clauter * configure.ac, doc/introExample8.sollya, doc/introExample8.tex, doc/sollya.pdf, doc/sollya.php, doc/sollya.tex: Still working on the doc This commit was extracted from SVN r1268. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1268 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-01 clauter * doc/diam.shlp, doc/diam.tex, doc/sollya.pdf, help.h: Yet a better doc This commit was extracted from SVN r1267. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1267 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-01 clauter * doc/diam.shlp, doc/diam.tex, doc/sollya.pdf, doc/supnorm.shlp, doc/supnorm.tex, help.h: The best doc ever This commit was extracted from SVN r1266. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1266 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-01 clauter * doc/accurateinfnorm.shlp, doc/accurateinfnorm.tex, doc/checkinfnorm.shlp, doc/checkinfnorm.tex, doc/sollya.pdf, help.h: Still a better doc This commit was extracted from SVN r1265. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1265 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-01 clauter * doc/introExample12.tex, doc/introExample2.tex, doc/introExample43.tex, doc/introExample45.tex, doc/introExample8.tex: Recompiled introductory examples This commit was extracted from SVN r1264. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1264 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-01 clauter * doc/dieonerrormode.shlp, doc/dieonerrormode.tex, doc/dirtyinfnorm.shlp, doc/dirtyinfnorm.tex, doc/infnorm.shlp, doc/infnorm.tex, doc/sollya.pdf, doc/sollya.php, help.h: Corrected three bugs in the doc This commit was extracted from SVN r1263. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1263 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-01 clauter * doc/relative.shlp, doc/relative.tex, doc/sollya.pdf, help.h: Recorrected the doc again This commit was extracted from SVN r1262. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1262 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-02-01 clauter * doc/absolute.shlp, doc/absolute.tex, doc/relative.shlp, doc/relative.tex, doc/sollya.pdf, doc/supnorm.shlp, doc/supnorm.tex, help.h: Slightly changed documentation for absolute, relative and supnorm This commit was extracted from SVN r1261. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1261 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-31 clauter * doc/bashexecute.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, help.h: Recompiled the complete doc This commit was extracted from SVN r1260. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1260 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-31 clauter * execute.c, supnorm.c: Patched a couple of memory leaks This commit was extracted from SVN r1259. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1259 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-31 clauter * supnorm.c: Synch This commit was extracted from SVN r1258. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1258 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-31 clauter * parser.y: Added a forgotten keyword to the complete list of keywords available through "help help" This commit was extracted from SVN r1257. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1257 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-31 schevill * remez.c: * Trying to change the random initialization method of GMP, in order to get similar results on 32-bit and 64-bit computers. This commit was extracted from SVN r1256. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1256 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-31 clauter * doc/sollya.pdf, help.h: Recompiled the doc for supnorm This commit was extracted from SVN r1255. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1255 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-31 schevill * autodiff.c: * Removed an mpfi that was initialised but never used nor cleared. This commit was extracted from SVN r1254. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1254 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-31 clauter * tests/check.sollya, tests/check.sollya.output, tests/memoryleaks.sollya: Extended the tests This commit was extracted from SVN r1253. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1253 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-31 schevill * tests/timecheck.sollya: * Adjusted the threshold of test 2 in timecheck. This commit was extracted from SVN r1251. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1251 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-31 schevill * tests/timecheck.sollya: * Changed check 2 in timecheck in order to make it pass on Cygwin (in fact, make it slower, because under Cygwin time under a given threshold cannot be measured). This commit was extracted from SVN r1250. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1250 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-31 schevill * doc/implementconstant.shlp, doc/implementconstant.tex, doc/sollya.pdf, help.h: * Added a mention in the doc of implementconstant about the fact that non-differentiable functions are not handled. Also corrected the text explaining what happens if a subexpression exactly evaluates to 0. * Corrected a few typos in the doc of implementconstant. This commit was extracted from SVN r1249. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1249 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-31 schevill * general.c, general.h, implementconst.c: * Removed an occurrence of mpfr_sprintf that prevented sollya to compile with old versions of mpfr. This maked me write a function mpfr_to_binary_str that converts an mpfr_t to a string representing it in binary and that can be parsed by mpfr_set_str. I put this new function in general.c, as it seemed to me to be the best place for it. This commit was extracted from SVN r1248. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1248 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-28 clauter * doc/sollya.pdf: Recompiled the doc This commit was extracted from SVN r1247. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1247 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-28 schevill * : Backported branch finishingSupnorm onto the trunk This commit was extracted from SVN r1246. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1246 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-28 schevill * autodiff.c, infnorm.c, mpfi-compat.c, mpfi-compat.h, sturm.c: * Removed occurrences of sollya_mpfi_is_pos. The only problematic ones were in sturm.c: indeed, in the current implementation, the case when we have an exact zero (point-interval) is ignored for counting the chanes of sign, and the case when 0 is a bound leads to an error (result=1 returned by the function). This commit was extracted from SVN r1244. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1244 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-28 clauter * doc/sollya.pdf: Recompiled the doc This commit was extracted from SVN r1243. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1243 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-28 schevill * doc/CommandsAndFunctions.tex, doc/sollya.pdf, doc/supnorm.tex, supnorm.c: * Corrected a typo in the code of supnorm (an if statement with = instead of ==) * added supnorm.tex to the repository. This commit was extracted from SVN r1242. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1242 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-28 clauter * doc/CommandsAndFunctions.tex, doc/bashexecute.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, help.h: Recompiled the doc This commit was extracted from SVN r1241. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1241 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-28 schevill * doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh: * Use LC_ALL=C in the scripts, in order to avoid language-specific behaviors when compiling the doc/ * Use -d option of sort This commit was extracted from SVN r1239. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1239 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-28 clauter * supnorm.c: Corrected a small bug in supnorm, added a TODO (I don't know if this is a bug), and reindented the code This commit was extracted from SVN r1238. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1238 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-27 clauter * Makefile.am, autodiff.c, doc/CommandsAndFunctions.tex, doc/bashexecute.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/implementconstant.shlp, doc/implementconstant.tex, doc/implementpoly.shlp, doc/implementpoly.tex, doc/keywords.def, doc/library.shlp, doc/library.tex, doc/libraryconstant.shlp, doc/libraryconstant.tex, doc/libraryconstantexample.c, doc/pi.shlp, doc/pi.tex, doc/sollya.pdf, doc/sollya.php, doc/sollya.tex, doc/time.tex, doc/timing.tex, execute.c, execute.h, expression.c, expression.h, general.c, help.h, implementconst.c, implementconst.h, infnorm.c, infnorm.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, minilexer.l, miniparser.y, mpfi-compat.c, parser.y, sollya.h, taylorform.c: Backported trunk onto the branch finishingSupnorm This commit was extracted from SVN r1237. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1237 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-27 schevill * implementconst.c: * Removed warnings of gcc -O2 -Wall This commit was extracted from SVN r1236. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1236 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-27 clauter * execute.c, library.c: Removed some compiler warnings This commit was extracted from SVN r1235. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1235 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-27 clauter * doc/bashexecute.tex, doc/libraryconstant.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, expression.c, help.h: Patched a problem that had arised with the last merge This commit was extracted from SVN r1234. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1234 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-27 clauter * : Tried to backport branch experimental-sylvain onto the trunk This commit was extracted from SVN r1233. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1233 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-26 jmio17 * doc/supnorm.shlp: added paragraph about removable discontinuities This commit was extracted from SVN r1231. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1231 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-26 jmio17 * supnorm.c, tests/checkSupnorm.sollya: all tests pass This commit was extracted from SVN r1230. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1230 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-26 clauter * doc/libraryconstant.shlp, doc/libraryconstant.tex, doc/sollya.pdf, doc/sollya.php, doc/sollya.tex, help.h: Backported trunk onto experimental-sylvain -r1221:1228 This commit was extracted from SVN r1229. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1229 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-26 clauter * doc/implementconstant.shlp, doc/implementconstant.tex, doc/sollya.pdf, execute.c, help.h: Extended documentation for implementconstant This commit was extracted from SVN r1228. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1228 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-26 schevill * implementconst.c: * Added "#include " to the code produced by implementconstant. This commit was extracted from SVN r1227. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1227 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-26 clauter * doc/sollya.pdf: Recompiled the PDF This commit was extracted from SVN r1226. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1226 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 jmio17 * supnorm.c: added test to increase precision in case that the accuracy is close to the working precision This commit was extracted from SVN r1225. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1225 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 schevill * supnorm.c: * Removed the occurrences of function assignNaNInterval and replaced them by sollya_mpfi_set_nan This commit was extracted from SVN r1224. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1224 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 schevill * doc/sollya.php, doc/sollya.tex: * Updated sollya.php in order to reflect the changes of these last days. * Added a note about the fact that, in Sollya's philosphy, NaN and empty sets are propagated. This commit was extracted from SVN r1223. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1223 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * mpfi-compat.c: Backported trunk onto experimental-sylvain -r1219:1221 This commit was extracted from SVN r1222. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1222 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * mpfi-compat.c: Removed spaces before use of ## preprocessor token as C99 and some compilers do not come along with them This commit was extracted from SVN r1221. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1221 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * assignment.c, assignment.h, autodiff.c, autodiff.h, chain.c, chain.h, configure.ac, doc/bashexecute.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/library.shlp, doc/library.tex, doc/print.tex, doc/sollya.pdf, doc/sollya.php, doc/sollya.tex, doc/time.tex, doc/timing.tex, doc/write.tex, double.c, double.h, execute.c, execute.h, expansion.c, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.cpp, fpminimax.h, general.c, general.h, help.h, implement.c, implement.h, infnorm.c, infnorm.h, integral.c, integral.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, libsollyaexample.c, main.c, main.h, minilexer.l, miniparser.y, mpfi-compat.c, mpfi-compat.h, parser.y, plot.c, plot.h, proof.c, proof.h, remez.c, remez.h, sollya.h, sturm.c, sturm.h, supnorm.c, supnorm.h, taylor.c, taylor.h, taylorform.c, taylorform.h, tests/check.sollya, tests/check.sollya.output, tests/timecheck.sollya, worstcase.c, worstcase.h, xml.c, xml.h: Backported trunk onto experimental-sylvain -r1168:1219 This commit was extracted from SVN r1220. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1220 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * assignment.c, assignment.h, autodiff.c, autodiff.h, chain.c, chain.h, configure.ac, doc/bashexecute.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/library.shlp, doc/library.tex, doc/print.tex, doc/sollya.pdf, doc/sollya.php, doc/sollya.tex, doc/time.tex, doc/timing.tex, doc/write.tex, double.c, double.h, execute.c, execute.h, expansion.c, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.cpp, fpminimax.h, general.c, general.h, help.h, implement.c, implement.h, infnorm.c, infnorm.h, integral.c, integral.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, libsollyaexample.c, main.c, main.h, minilexer.l, miniparser.y, mpfi-compat.c, mpfi-compat.h, parser.y, plot.c, plot.h, proof.c, proof.h, remez.c, remez.h, sollya.h, sturm.c, sturm.h, supnorm.c, taylor.c, taylor.h, taylorform.c, taylorform.h, tests/check.sollya, tests/check.sollya.output, tests/timecheck.sollya, worstcase.c, worstcase.h, xml.c, xml.h: Backported 1162:1218 from trunk This commit was extracted from SVN r1219. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1219 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * execute.c: And eliminated yet another warning, found only with gcc (Debian 4.3.3-10) 4.3.3 and -Wall -g -O2 This commit was extracted from SVN r1218. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1218 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * supnorm.c, supnorm.h: Changed copyright message, here, too This commit was extracted from SVN r1217. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1217 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * remez.c: Eliminated yet some warnings, found only with '-Wall -g -O2' This commit was extracted from SVN r1216. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1216 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * supnorm.c: Eliminated yet some warnings, found only with '-Wall -g -O2' This commit was extracted from SVN r1216. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1216 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * minilexer.l: Eliminated yet another warning. This commit was extracted from SVN r1215. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1215 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * supnorm.c: Getting around some warnings displayed when compiling with -Wall. This commit was extracted from SVN r1214. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1214 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * autodiff.c, execute.c, expression.c, general.c, infnorm.c, infnorm.h, mpfi-compat.c, mpfi-compat.h, remez.h, taylorform.c: Getting around some warnings displayed when compiling with -Wall. This commit was extracted from SVN r1214. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1214 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * implementconst.c, implementconst.h: Added a "no warranty" line to the copyright notices in all files and version indications. This commit was extracted from SVN r1213. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1213 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * assignment.c, assignment.h, autodiff.c, autodiff.h, chain.c, chain.h, doc/sollya.pdf, doc/sollya.php, doc/sollya.tex, double.c, double.h, execute.c, execute.h, expansion.c, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.cpp, fpminimax.h, general.c, general.h, help.h, implement.c, implement.h, infnorm.c, infnorm.h, integral.c, integral.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, libsollyaexample.c, main.c, main.h, minilexer.l, miniparser.y, mpfi-compat.c, mpfi-compat.h, parser.y, plot.c, plot.h, proof.c, proof.h, remez.c, remez.h, sollya.h, sturm.c, sturm.h, supnorm.c, supnorm.h, taylor.c, taylor.h, taylorform.c, taylorform.h, worstcase.c, worstcase.h, xml.c, xml.h: Added a "no warranty" line to the copyright notices in all files and version indications. This commit was extracted from SVN r1213. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1213 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-25 clauter * doc/sollya.pdf, doc/sollya.tex: Corrected two small typos in the doc This commit was extracted from SVN r1212. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1212 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-24 schevill * doc/sollya.pdf, doc/sollya.tex: * Added a technical description of the interval arithmetic philosophy of Sollya in the doc. This commit was extracted from SVN r1211. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1211 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-24 jmio17 * tests/checkSupnorm.sollya: added a bunch of tests (some taken from the article). There are still bugs regarding relative error. Absolute errors seems ok. This commit was extracted from SVN r1210. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1210 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-24 schevill * tests/check.sollya, tests/check.sollya.output: * Slight modification of the output of check.sollya (without changing the set of tests itself) This commit was extracted from SVN r1209. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1209 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-24 schevill * mpfi-compat.c, tests/check.sollya, tests/check.sollya.output: * Patched the behavior of sollya_mpfi_mul in the case [@Inf@]*[0,1] (used to return [-@Inf@, @Inf@] instead of [0, @Inf@]) * I discovered that I introduced a bug when I worked on mpfi-compat a few days ago: sollya_mpfi_is_zero had a bad behavior: it was returning true when at least one of the bounds was zero. I patched this bug and introduced new checks in order to avoid a regression on this subject (previously, make check was not able to discover the bug). This commit was extracted from SVN r1208. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1208 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-24 schevill * execute.c, implementconst.c, implementconst.h: * Added headers. * The implementer now returns an integer value (0 means OK, non-zero means a problem). * Removed recoverFromError because Christoph does not like me using it. * Unsupported expressions are now correctly handled (an error message is displayed; no code is produced) * The name of the produced function is now really a parameter that the user can choose. This commit was extracted from SVN r1207. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1207 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-24 jmio17 * doc/keywords.def, doc/supnorm.shlp: first small draft for supnorm doc This commit was extracted from SVN r1206. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1206 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-23 jmio17 * supnorm.c: Supnorm seems to work now in the absolute case (did not check/touch relative case yet). Modified computeTaylorModel, checkDegreeTaylorModel, computeTaylorModelofLeastDegree to handle correctly the translation of the polynomial given by taylorform This commit was extracted from SVN r1205. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1205 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-21 clauter * execute.c: Synch This commit was extracted from SVN r1204. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1204 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-21 clauter * tests/check.sollya, tests/check.sollya.output: Corrected an IEEE 754-2008 value for pow This commit was extracted from SVN r1203. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1203 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-21 schevill * mpfi-compat.c: * Ensured that sollya_mpfi_diam_abs([Inf]) returns 0. This commit was extracted from SVN r1202. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1202 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-21 schevill * infnorm.c: * sollya_mpfi_pow rewritten. In particular removed an old obscure test regarding the case y*log(x)=0. This commit was extracted from SVN r1201. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1201 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-21 clauter * tests/check.sollya, tests/check.sollya.output: Added tests for power in comparison with the IEEE 754-2008 mandated values This commit was extracted from SVN r1200. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1200 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-21 schevill * infnorm.c, mpfi-compat.c, mpfi-compat.h: * Finished checking the mpfi_interv* and revert_if_needed This commit was extracted from SVN r1199. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1199 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-21 schevill * infnorm.c: coorected a mistake (previous revision did not compile) This commit was extracted from SVN r1198. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1198 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-21 schevill * infnorm.c: * checked some mpfi_interv_* This commit was extracted from SVN r1197. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1197 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-21 schevill * double.c, execute.c, mpfi-compat.c: * Patched behavior of rationalapprox on 0, NaN and Inf. * added a missing include file * checked a mpfi_interv_* in execute.c (TODO of a previous commit) This commit was extracted from SVN r1196. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1196 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-21 clauter * execute.c: Checked all uses of "sollya_mpfi_interv_*_fr" in execute.c but one; see TODO This commit was extracted from SVN r1195. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1195 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-21 clauter * mpfi-compat.c: Added a forgotten #include This commit was extracted from SVN r1194. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1194 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-21 schevill * execute.c, mpfi-compat.c, mpfi-compat.h: * New sollya_mpfi_interv_*_safe functions. * Began to change mpfi_interv_* into mpfi_interv_*_safe. This commit was extracted from SVN r1193. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1193 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-20 schevill * infnorm.c: Partially deleted mpfi_revert_if_needed from the code This commit was extracted from SVN r1192. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1192 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-20 schevill * infnorm.c: Partially deleted mpfi_revert_if_needed from the code This commit was extracted from SVN r1191. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1191 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-20 clauter * execute.c: Removed a sollya_mpfi_revert_if_needed in execute.c This commit was extracted from SVN r1190. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1190 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-20 schevill * tests/timecheck.sollya: Changed the reference time for coeff in timecheck (that has been improved during last summer) This commit was extracted from SVN r1189. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1189 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-20 schevill * mpfi-compat.c, mpfi-compat.h: * Made many corrections and simplifications in mpfi-compat layer This commit was extracted from SVN r1188. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1188 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-20 clauter * configure.ac: Enabled building a dynamic version of libsollya by default - to be double-checked by Sylvain This commit was extracted from SVN r1187. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1187 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-20 clauter * general.c, general.h, libsollyaexample.c, sollya.h: Finally updated libsollya and sollya.h to reflect the recent (and not so recent) changes in Sollya This commit was extracted from SVN r1186. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1186 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-20 clauter * doc/bashexecute.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/library.shlp, doc/library.tex, doc/print.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, doc/write.tex, help.h: Modified the doc to remove any reference to mpfi_t (and MPFI in general) and replace it with sollya_mpfi_t (or the corresponding references where appropriate); recompiled This commit was extracted from SVN r1185. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1185 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-20 clauter * expression.c, implement.c, infnorm.c: Checked all occurrences of ' & ' in the code and corrected some, when used in logical expressions This commit was extracted from SVN r1184. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1184 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-20 clauter * sturm.c: Added value normalization (!!) for xors used in logical tests This commit was extracted from SVN r1183. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1183 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-19 clauter * infnorm.c: Corrected a small bug in checkinfnorm This commit was extracted from SVN r1182. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1182 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-19 clauter * execute.c, execute.h, implementconst.c, internparser.y, miniparser.y, parser.y: Change the syntax of implementconstant to allow for a output file and a function name to be chosen -- left some TODOs for Sylvain in implementconst.c This commit was extracted from SVN r1181. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1181 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-18 schevill * doc/sollya.pdf, doc/sollya.php, doc/sollya.tex: * Improved the documentation about using the notation a.b.c.d as the left side of an assignment. This commit was extracted from SVN r1180. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1180 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-18 clauter * execute.c, execute.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y: Added implementconst to the miniparser/lexer This commit was extracted from SVN r1179. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1179 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-18 clauter * infnorm.c, infnorm.h, library.c, library.h: Moved libraryConstantToInterval This commit was extracted from SVN r1178. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1178 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-18 clauter * Makefile.am, execute.c, execute.h, implement-cste.c, implement-cste.h, implementconst.c, implementconst.h, sollya.h: Moved implement-cste to implementconst, changed its signature (stub) This commit was extracted from SVN r1177. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1177 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-18 clauter * doc/implementconstant.shlp, doc/implementconstant.tex, doc/sollya.pdf, help.h: Added the phrase in the doc for implementconstant that makes Christoph feel sufficiently comfortable to sleep at nights This commit was extracted from SVN r1176. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1176 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-18 clauter * doc/implementconstant.shlp, doc/implementconstant.tex, doc/sollya.pdf: Some small changes This commit was extracted from SVN r1175. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1175 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-18 clauter * execute.c, expression.c, infnorm.c, library.c: Some small changes This commit was extracted from SVN r1174. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1174 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-18 clauter * doc/sollya.pdf, doc/sollya.php, doc/sollya.tex, general.c, parser.y: Updated the user-visible copyright notes and affiliations of our contributors This commit was extracted from SVN r1173. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1173 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-18 clauter * doc/sollya.pdf, doc/sollya.php, doc/sollya.tex, sollya.h: Some small changes to the doc This commit was extracted from SVN r1172. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1172 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-18 clauter * doc/sollya.php, doc/sollya.tex: Some first, small changes to the doc This commit was extracted from SVN r1171. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1171 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-17 schevill * help.h: Recompiled the doc to avoid the double definition of the help text for the library command. This commit was extracted from SVN r1170. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1170 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-17 schevill * mpfi-compat.c, mpfi-compat.h: Backported trunk onto experimental-sylvain -r1167:1168 This commit was extracted from SVN r1169. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1169 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-17 schevill * mpfi-compat.c, mpfi-compat.h: Mistake in the signature of mpfi_get_fr. This commit was extracted from SVN r1168. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1168 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-17 schevill * mpfi-compat.c, mpfi-compat.h: Backported trunk onto experimental-sylvain -r1159:1166 This commit was extracted from SVN r1167. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1167 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-17 schevill * mpfi-compat.c, mpfi-compat.h: Added sollya_mpfi_get_fr to mpfi-compat. This commit was extracted from SVN r1166. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1166 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-17 clauter * doc/introExample46.sollya, doc/introExample46.tex, doc/introExample47.sollya, doc/introExample47.tex, doc/introExample48.sollya, doc/introExample48.tex, doc/introExample49.sollya, doc/introExample49.tex, doc/sollya.pdf, doc/sollya.php, doc/sollya.tex, execute.c, execute.h, fpminimax.cpp, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y, tests/check.sollya, tests/check.sollya.output: Backported -r1134:1164 - One conflit solved manually This commit was extracted from SVN r1165. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1165 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-17 clauter * Makefile.am, chebyshevform.c, chebyshevform.h, execute.c, execute.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y: Added chebyshevform command to lexer, parser and evaluator. Added files chebyshevform.h and chebyshevform.c with stubs to the repository. This commit was extracted from SVN r1164. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1164 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-17 clauter * doc/introExample46.sollya, doc/introExample46.tex, doc/introExample47.sollya, doc/introExample47.tex, doc/introExample48.sollya, doc/introExample48.tex, doc/introExample49.sollya, doc/introExample49.tex, doc/sollya.pdf, doc/sollya.php, doc/sollya.tex, execute.c, execute.h, fpminimax.cpp, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y, tests/check.sollya, tests/check.sollya.output: Backported -r1150:1162 This commit was extracted from SVN r1163. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1163 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-14 clauter * supnorm.c: Supnorm in both absolute and relative mode, with singularities between p and f seems to work now. This commit was extracted from SVN r1162. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1162 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-13 clauter * supnorm.c: Some progress with the relative error case of the supnorm; the code compiles but does not work This commit was extracted from SVN r1161. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1161 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-13 schevill * autodiff.c, expression.c, implement-cste.c, infnorm.c, library.c, library.h: * removed occurrences of mpfi_* and replaced them by sollya_mpfi_* This commit was extracted from SVN r1160. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1160 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-13 schevill * fpminimax.cpp: Backported trunk onto this branch -r1155:1158 This commit was extracted from SVN r1159. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1159 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-13 schevill * expression.c, implement-cste.c, library.c, parser.y: * removed occurrences of printf and fprintf This commit was extracted from SVN r1158. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1158 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-13 schevill * fpminimax.cpp: * changed *printf into sollya*printf (Christoph forgot when he performed the replacement everywhere) This commit was extracted from SVN r1157. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1157 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-13 clauter * supnorm.c: Some progress with the supnorm implementation This commit was extracted from SVN r1156. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1156 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-13 schevill * Makefile.am, autodiff.c, autodiff.h, chain.c, configure.ac, doc/CommandsAndFunctions.tex, doc/bashexecute.tex, doc/function.shlp, doc/function.tex, doc/ge.shlp, doc/ge.tex, doc/gt.shlp, doc/gt.tex, doc/inf.shlp, doc/inf.tex, doc/introExample46.sollya, doc/introExample46.tex, doc/introExample47.sollya, doc/introExample47.tex, doc/introExample48.sollya, doc/introExample48.tex, doc/introExample49.sollya, doc/introExample49.tex, doc/keywords.def, doc/le.shlp, doc/le.tex, doc/library.shlp, doc/library.tex, doc/lt.shlp, doc/lt.tex, doc/max.shlp, doc/max.tex, doc/min.shlp, doc/min.tex, doc/sollya.pdf, doc/sollya.php, doc/sollya.tex, doc/sup.shlp, doc/sup.tex, doc/time.tex, doc/timing.tex, double.c, execute.c, execute.h, expression.c, expression.h, external.c, general.c, general.h, help.h, implement.c, infnorm.c, infnorm.h, integral.c, internlexer.l, internparser.y, lexer.l, library.c, library.h, minilexer.l, miniparser.y, mpfi-compat.c, mpfi-compat.h, parser.y, plot.c, proof.c, proof.h, remez.c, sollya.h, sturm.c, sturm.h, supnorm.c, supnorm.h, taylorform.c, taylorform.h, tests/check.sollya, tests/check.sollya.output, tests/checkTMandAD.sollya, tests/timecheck.sollya, tests/timecheck.sollya.output, worstcase.c, xml.c: Backported trunk onto this branch -r1065:1154 This commit was extracted from SVN r1155. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1155 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-13 clauter * doc/sollya.pdf: Recompiled the doc This commit was extracted from SVN r1154. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1154 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-13 schevill * : * Backported branch composedTypeSupport onto the trunk. * Removed branch composedTypeSupport (become useless). * Removed old branch workMioaraAndSylvain (if I remember well, it has been created to work on an ancestor of the Cheb Models; they now have their own branch). This commit was extracted from SVN r1153. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1153 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-12 clauter * sollya.h: Backported -r1134:1150 This commit was extracted from SVN r1151. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1151 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-12 clauter * : Added a branch for finishing the supnorm implementation without interference with the other developpers This commit was extracted from SVN r1150. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/finishingSupnorm@1150 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-11 clauter * doc/introExample46.php, doc/introExample47.php, doc/introExample48.php, doc/introExample49.php, doc/sollya.php: Added the php version for the documentation of structures This commit was extracted from SVN r1148. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1148 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-11 jmio17 * chebModels.c, chebModels.h, sollya.h: added small compat for newer gcc versions; cleared few bugs This commit was extracted from SVN r1147. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1147 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-11 clauter * doc/introExample46.sollya, doc/introExample46.tex, doc/introExample47.sollya, doc/introExample47.tex, doc/introExample48.sollya, doc/introExample48.tex, doc/introExample49.sollya, doc/introExample49.tex, doc/sollya.pdf, doc/sollya.tex: Added documentation for structures in the main sollya.tex document. Added a couple of introductory examples. Report to the php version still needed. This commit was extracted from SVN r1146. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1146 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-11 jmio17 * chebModels.c, sollya.h, taylorform.c, testChebModels.sollya, testIntegralGoldstein.sollya: added certified integral function, added file for computing Goldstein integral This commit was extracted from SVN r1145. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1145 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-11 clauter * tests/check.sollya, tests/check.sollya.output: Added test cases for the support of composed types This commit was extracted from SVN r1144. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1144 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-11 jmio17 * chebModels.c, chebModels.h, chebModelsAux.c, chebModelsAux.h, testChebModels.sollya: fixed some bugs, added some examples This commit was extracted from SVN r1143. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1143 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-10 jmio17 * chebModels.c, chebModels.h, chebModelsAux.c, testChebModels.sollya: chebmodels seem to work. added integration and derivation procedures. This commit was extracted from SVN r1142. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1142 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-10 clauter * execute.c: Finished basic support for composed types. Still lacks documentation, tests and valgrinding ;-) This commit was extracted from SVN r1141. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1141 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-10 jmio17 * chebModels.c, chebModels.h, chebModelsAux.c, chebModelsAux.h, testChebModels.sollya: Code fot chebModels (currently it compiles, but the composition does not work well) This commit was extracted from SVN r1140. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1140 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-10 jmio17 * sollya.h: Creation of the branch experimentalChebModels This commit was extracted from SVN r1139. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1139 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2011-01-10 jmio17 * sollya.h: Creation of the branch experimentalChebModels This commit was extracted from SVN r1139. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimentalChebModels@1139 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-09 clauter * execute.c: Continued working on support for structured types. This commit was extracted from SVN r1138. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1138 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-07 clauter * execute.c: Continued working on support for structured types: for assignments having an access to a structured type as a left-hand side, the syntax tree is correctly rewritten into a special symbol having the recursive accesses as a chain and a child with the thing to be assigned to the element of the structured type. This commit was extracted from SVN r1137. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1137 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-07 clauter * minilexer.l, miniparser.y: Finished work in all three parsers necessary for support of structured types This commit was extracted from SVN r1136. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1136 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-07 clauter * internlexer.l, internparser.y: Adapted intern parser for complete support of structured types This commit was extracted from SVN r1135. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1135 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-07 clauter * execute.c, execute.h, lexer.l, parser.y: Continued working on support for structured types This commit was extracted from SVN r1134. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1134 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-03 clauter * execute.c, general.c, general.h, tests/check.sollya.output, tests/timecheck.sollya: Reported trunk to branch. This commit was extracted from SVN r1133. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1133 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-03 clauter * execute.c, general.c, general.h, tests/check.sollya.output, tests/timecheck.sollya: Patched a bug with printing of strings in procedures when these strings contain characters that must be masked. Recompiled expected test results. This commit was extracted from SVN r1132. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1132 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-03 clauter * doc/bashexecute.tex, doc/sollya.pdf, doc/sollya.php, doc/sollya.tex, doc/time.tex, doc/timing.tex, general.c, help.h: Reported the trunk onto the branch. This commit was extracted from SVN r1131. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1131 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-03 clauter * internparser.y, miniparser.y, parser.y: Corrected a small parsing problem in the three parsers This commit was extracted from SVN r1130. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1130 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-03 clauter * internlexer.l, internparser.y, minilexer.l, miniparser.y: Continued working on supported for structures - the three parsers are now synchronized This commit was extracted from SVN r1129. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1129 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-02 clauter * execute.c, execute.h, lexer.l, parser.y: Started working on support for structures This commit was extracted from SVN r1128. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1128 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-02 clauter * doc/bashexecute.tex, doc/sollya.pdf, doc/sollya.php, doc/time.tex, doc/timing.tex, help.h: Recompiled and corrected the documentation This commit was extracted from SVN r1127. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1127 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-12-02 clauter * doc/sollya.pdf, doc/sollya.php, doc/sollya.tex, general.c: Worked on documentation of the new command line options. This commit was extracted from SVN r1126. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1126 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-30 clauter * : Added a branch for developing support for composed types This commit was extracted from SVN r1125. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/composedTypeSupport@1125 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-25 clauter * doc/bashexecute.tex, doc/function.shlp, doc/function.tex, doc/library.shlp, doc/library.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, help.h: Documented 'function' This commit was extracted from SVN r1123. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1123 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-25 clauter * doc/max.shlp, doc/max.tex, doc/min.shlp, doc/min.tex: Forgotten adds for the new help texts. This commit was extracted from SVN r1122. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1122 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-25 clauter * doc/CommandsAndFunctions.tex, doc/bashexecute.tex, doc/ge.shlp, doc/ge.tex, doc/gt.shlp, doc/gt.tex, doc/inf.shlp, doc/inf.tex, doc/keywords.def, doc/le.shlp, doc/le.tex, doc/lt.shlp, doc/lt.tex, doc/sollya.pdf, doc/sup.shlp, doc/sup.tex, doc/time.tex, doc/timing.tex, help.h: New help texts. This commit was extracted from SVN r1121. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1121 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-12 clauter * mpfi-compat.c, supnorm.c: Continued on supnorm. Passing the flame to Mioara, now. NOTHING'S DEBUGGED!!! SORRY. This commit was extracted from SVN r1120. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1120 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-10 clauter * supnorm.c: Continued working on supnorm. This commit was extracted from SVN r1119. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1119 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-10 clauter * supnorm.c: Continued working on supnorm. This commit was extracted from SVN r1118. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1118 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-09 clauter * supnorm.c: Continued on supnorm. This commit was extracted from SVN r1117. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1117 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-08 clauter * supnorm.c: Worked a little on the supnorm. This commit was extracted from SVN r1116. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1116 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-05 clauter * execute.c, sturm.c, sturm.h, supnorm.c: Continued working on supnorm. This commit was extracted from SVN r1115. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1115 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-04 clauter * supnorm.c: Added some comments to supnorm file. This commit was extracted from SVN r1114. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1114 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-04 clauter * execute.c, infnorm.h, internparser.y, miniparser.y, parser.y, supnorm.c, supnorm.h: Continued working on supnorm integration. This commit was extracted from SVN r1113. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1113 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-11-04 clauter * Makefile.am, execute.c, execute.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y, supnorm.c, supnorm.h: Started working on supnorm integration. This commit was extracted from SVN r1112. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1112 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-30 schevill * implement-cste.c: Errors are slightly better balanced in sums. This commit was extracted from SVN r1111. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1111 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-30 schevill * doc/implementconstant.shlp, doc/implementconstant.tex, doc/libraryconstant.shlp, doc/libraryconstant.tex, doc/sollya.pdf, help.h, implement-cste.c: Changed the signature of the code produced by implementconstant: now, y is supposed to be already initialized (this allows for recursive use of the implementer, where variables are already initialized). This commit was extracted from SVN r1110. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1110 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-29 clauter * mpfi-compat.c, tests/check.sollya.output: Completed MPFI compatibility wrap layer, computed and checked a new check output file. This commit was extracted from SVN r1109. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1109 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-26 schevill * implement-cste.c: Corrected a bug in add/sub: there was subtle bug in my proof when the sufficient precision for the intermediate results was negative. Probably, this had no influence on the code since the negative precision was replaced by MPFR_PREC_MIN anyway. But it was safer to have a code corresponding to the proof. Moreover, the patch is an interesting optimization: if the sufficient precision is negative, we can avoid computing the corresponding expression: "(some complicated expr)+exp(100)" can be simplified to "exp(100)" up to a fairly big precision: there is no need to evaluate the complicated expr in precision MPFR_PREC_MIN as we did before. Interestingly, this led me to implement the if-then-else instruction: it is possible to write formal programs containing branches. I also added a formal indentation mechanism for correctly displaying embedded blocks. The code seems to be correct and no memory leak was observed. I did not perform intensive tests though. This commit was extracted from SVN r1108. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1108 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-25 schevill * doc/libraryconstantexample.c, implement-cste.c: Corrected a bug in the addition/subtraction case in implementconstant. The bug possibly affected any addition/subtraction; however, it was particularly visible when the result of the addition was an exact zero. Now, implementconstant complains (and aborts) whenever a subexpression is exactly zero at a place where we cannot handle it. WARNING: currently, this is very dirty, we raise an exception without freeing anything. Also added an example for libraryconstant (forgot from a previous commit). This commit was extracted from SVN r1107. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1107 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-22 schevill * mpfi-compat.c: Try to exhaustively list all possible cases in the division and multiplication of two intervals. This commit was extracted from SVN r1106. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1106 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-22 clauter * execute.c, infnorm.c, infnorm.h, mpfi-compat.c: New division rules This commit was extracted from SVN r1105. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1105 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-20 schevill * execute.c, infnorm.c: Wrappers sollya_mpfr_min and sollya_mpfr_max: contrary to their mpfr homolgues, they propagate NaNs, which is the expected behavior when used in Sollya. This commit was extracted from SVN r1104. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1104 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-20 clauter * mpfi-compat.c: Some remarks This commit was extracted from SVN r1103. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1103 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-20 schevill * mpfi-compat.c: Explain the rule for div a little more. This commit was extracted from SVN r1102. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1102 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-20 clauter * mpfi-compat.c: Worked on MPFI compatibility wrapper This commit was extracted from SVN r1101. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1101 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-20 clauter * general.c, mpfi-compat.c, mpfi-compat.h, parser.y: Updated copyright notice. This commit was extracted from SVN r1100. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1100 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-19 clauter * execute.c, mpfi-compat.c: Added NaN normalization for intervals (ranges). This commit was extracted from SVN r1099. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1099 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-15 schevill * mpfi-compat.c: TODOs on MPFI wrapper. This commit was extracted from SVN r1098. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1098 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-14 clauter * Makefile.am, autodiff.c, autodiff.h, chain.c, double.c, execute.c, execute.h, expression.c, general.c, help.h, infnorm.c, infnorm.h, integral.c, library.c, library.h, mpfi-compat.c, mpfi-compat.h, parser.y, proof.c, proof.h, sollya.h, sturm.c, sturm.h, taylorform.c, taylorform.h, xml.c: Added a compatibility wrapper around all MPFI calls. Developers: please remember that we have to use sollya_mpfi_* now instead of mpfi_*. This commit was extracted from SVN r1097. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1097 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-13 clauter * configure.ac, general.c, parser.y, tests/timecheck.sollya: Added MPFR, GMP and MPFI version printing to version and --help and changed timecheck again to lower the variance everywhere unless necessary This commit was extracted from SVN r1096. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1096 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-10-13 clauter * tests/timecheck.sollya, tests/timecheck.sollya.output: Reworked a time check This commit was extracted from SVN r1095. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1095 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-25 clauter * general.c: Small correction This commit was extracted from SVN r1094. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1094 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-24 clauter * autodiff.c, chain.c, double.c, execute.c, expression.c, external.c, general.c, general.h, implement.c, infnorm.c, lexer.l, library.c, parser.y, plot.c, proof.c, remez.c, sturm.c, taylorform.c, worstcase.c, xml.c: Added additional modes for warning message printing: --warnonstderr prints all warnings on stderr instead of stdout, --warninfile and --warninfileappend print all warnings in a file (or a named pipe). For the developer the change means that printf and fprintf must no longer be used in the code. The functions sollyaPrintf and sollyaFprintf, which behave exactly the same, must be used instead. This commit was extracted from SVN r1093. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1093 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-21 clauter * tests/check.sollya.output: New test output reflecting the recent changes This commit was extracted from SVN r1092. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1092 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-21 clauter * execute.c: Patched yet another bug in the procedure-based functions This commit was extracted from SVN r1091. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1091 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-21 clauter * execute.c: Corrected a bug in the procedure-based functions This commit was extracted from SVN r1090. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1090 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-21 clauter * execute.c, expression.c: Corrected displaying of differentiated library functions and procedure-based functions This commit was extracted from SVN r1089. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1089 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-21 clauter * autodiff.c, autodiff.h, chain.c, execute.c, execute.h, expression.c, expression.h, infnorm.c, internparser.y, miniparser.y, parser.y, proof.c, proof.h, taylorform.c, xml.c: Started adding procedure-based functions with a technique similar to library functions. There is still a bug in the displaying of differentiated procedure-based functions (as well as for library functions - we just never saw it). This commit was extracted from SVN r1088. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1088 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-18 schevill * tests/checkTMandAD.sollya: Added labels for the tests in checkTMandAD.sollya This commit was extracted from SVN r1087. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1087 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-17 clauter * execute.c: Corrected a small mistake in the code analysing the correctness of the arguments to fpminimax. This commit was extracted from SVN r1086. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1086 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-16 schevill * taylorform.c, tests/check.sollya, tests/timecheck.sollya, tests/timecheck.sollya.output: Reverted change of revision 1079 in taylorform.c since Christoph corrected the bug #10657. Added a test case. This commit was extracted from SVN r1085. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1085 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-12 clauter * execute.c, infnorm.c, infnorm.h: Added optimisation for equality and inequality tests when simple interval evaluation without precision adjustments already allows the result to be decided upon. This commit was extracted from SVN r1084. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1084 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-12 clauter * execute.c: Added minimum/maximum computation on lists This commit was extracted from SVN r1083. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1083 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-12 clauter * parser.y: Added help text target in parser for min and max This commit was extracted from SVN r1082. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1082 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-08-11 clauter * execute.c, execute.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y: Added min/max operators. This commit was extracted from SVN r1081. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1081 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-07-24 clauter * execute.c, execute.h, expression.c, expression.h: Tried to address the bug "[#10657] Shifting a polynomial in Horner form consumes all the memory" The code runs through the test and seems to be much faster but a lot of optimisations are still possible. Some algorithms are really naive (but much less naive than what we had). This commit was extracted from SVN r1080. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1080 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-06-30 schevill * taylorform.c: Reverted a bug introduced in revision 1008. Indeed, makePolynomial seems to create a polynomial expression p such that p(x-x0) is very long to evalute with Sollya, while constructPoly perfectly does the trick. This commit was extracted from SVN r1079. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1079 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-06-22 schevill * doc/CommandsAndFunctions.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/implementconstant.shlp, doc/implementconstant.tex, doc/implementpoly.shlp, doc/keywords.def, doc/library.shlp, doc/library.tex, doc/libraryconstant.shlp, doc/libraryconstant.tex, doc/pi.shlp, doc/pi.tex, doc/sollya.pdf, expression.c, help.h, parser.y: * Corrected a bug in isSyntacticallyEqual when the trees are equal and of type libraryconstant. * Added documentation for implementconstant and libraryconstant. This commit was extracted from SVN r1078. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1078 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-06-16 schevill * execute.c: Removed useless warning when a library constant is used whereas the free variable symbol has not beed defined. Note: it would be a good thing that Christoph double-checks my modifications introducing libraryconstant. This commit was extracted from SVN r1077. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1077 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-06-16 schevill * autodiff.c, execute.c, execute.h, expression.c, expression.h, general.c, implement-cste.c, infnorm.c, internlexer.l, internparser.y, lexer.l, library.c, library.h, parser.y, sollya.h, taylorform.c: * Added new command libraryconstant for externally loaded constants. |__ in particular, it is supported by implementconstant * Simplified "switch ... cases" in expression.c * Removed many useless trailing spaces in parser* and lexer* This commit was extracted from SVN r1076. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1076 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-06-09 schevill * implement-cste.c: Many bug fixes. The command begins to be in a fairly stable state. No known bug or memory leak. Extensive tests are required however. Power function is still not completely well handled. Optimizations such as mul_ui are currently not implemented. This commit was extracted from SVN r1075. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1075 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-06-04 schevill * implement-cste.c: It compiles again. The transition to the new structures is almost completed. However: * Currently, it does not work at all: a serious debugging session should be foreseen. * It should not contain memory leaks, but extensive tests should be performed. This commit was extracted from SVN r1074. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1074 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-06-03 schevill * implement-cste.c: Began to clean the structure of this code. Now, the program is constructed through a dedicated struct. It will only be printed in the end. Currently it does not compile any more. This commit was extracted from SVN r1073. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1073 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-05-28 schevill * implement-cste.c: First support of integer roots. This commit was extracted from SVN r1072. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1072 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-05-28 schevill * implement-cste.c: Implementation of the addition/subtraction and first implementation of pow. This commit was extracted from SVN r1071. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1071 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-05-27 schevill * implement-cste.c: Just corrected a warning and began to implement the add/sub case. But I still do not have clear ideas on how to do it. This commit was extracted from SVN r1070. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1070 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-05-26 schevill * implement-cste.c, implement-cste.h: * I forgot to add the essential files... * The multiplication/division seems to be working. This commit was extracted from SVN r1069. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1069 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-05-25 schevill * execute.c: First implementation of the mul/div case. It is still bugged: > implementconstant(sin(1)*cos(exp(2)*log(3))); is not correct for instance. I also implemented the constant case and debugged the case of unary functions. Several minor updates such as numbering the temporary variables. This commit was extracted from SVN r1068. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1068 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-05-21 clauter * infnorm.c: Slight enhancement to interval evaluation This commit was extracted from SVN r1067. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1067 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-05-21 schevill * Makefile.am, execute.c, execute.h, expression.h, internlexer.l, internparser.y, lexer.l, parser.y, sollya.h: First step towards an implementation of implementconstant. Currently, it compiles but does not work at all. It is work in progress. This commit was extracted from SVN r1066. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1066 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-05-20 schevill * : * Added a branch for Sylvain's own work. This commit was extracted from SVN r1065. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/experimental-sylvain@1065 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 schevill * tests/Makefile.am: Put back timing checks. This commit was extracted from SVN r1063. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1063 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 clauter * ChangeLog: New ChangeLog This commit was extracted from SVN r1061. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1061 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 clauter * NEWS: Changed NEWS This commit was extracted from SVN r1060. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1060 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 schevill * INSTALL, NEWS: Updated NEWS. This commit was extracted from SVN r1059. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1059 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 clauter * README: Slightly changed the READMe This commit was extracted from SVN r1058. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1058 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 schevill * README, tests/Makefile.am: * Removed timecheck from Makefile.am for the release * Updated README This commit was extracted from SVN r1057. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1057 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 clauter * README: Updated README This commit was extracted from SVN r1056. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1056 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 clauter * autogen.sh: Changed autogen.sh to get new situation supported This commit was extracted from SVN r1055. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1055 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 schevill * tests/Makefile.am: Added the file for testing autodiff and taylorform into Makefile.am This commit was extracted from SVN r1054. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1054 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 schevill * doc/bashexecute.tex, doc/introExample33.tex, doc/introExample38.tex, doc/introExample40.tex, doc/introExample8.tex, doc/numberroots.tex, doc/sollya.pdf, doc/sollya.php, doc/time.tex, doc/timing.tex, help.h, tests/check.sollya: * changed "read" to execute in check.sollya * Recompiled all the doc This commit was extracted from SVN r1053. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1053 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 schevill * tests/check.sollya.output: Updated output for the tests. This commit was extracted from SVN r1052. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1052 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 schevill * tests/check.sollya, tests/checkTMandAD.sollya: Added test cases for taylorform and autodiff This commit was extracted from SVN r1051. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1051 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 schevill * autodiff.c, taylorform.c: * Corrected typos * Added missing cases. This commit was extracted from SVN r1050. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1050 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-20 schevill * configure.ac, doc/sollya.php, doc/sollya.tex: Changed the '2.0alpha' into '2.0'. The release is on the way. This commit was extracted from SVN r1049. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1049 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-19 schevill * tests/timecheck.sollya, tests/timecheck.sollya.output: Added timing tests related to bug #10069 This commit was extracted from SVN r1044. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1044 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-19 clauter * tests/timecheck.sollya, tests/timecheck.sollya.output: Time test for "[#9120] dirtyinfnorm is unexpectedly slow" This commit was extracted from SVN r1043. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1043 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-19 clauter * execute.c, expression.c: Possible fix for "[#10069] Remez algorithm is too slow" This commit was extracted from SVN r1042. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1042 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-19 jmio17 * tests/check.sollya, tests/check.sollya.output: added test #253 for bug #8079 - NaN behaviour This commit was extracted from SVN r1041. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1041 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-18 clauter * doc/error.shlp, doc/error.tex, doc/sollya.pdf, help.h, tests/check.sollya, tests/check.sollya.output: Worked again on "[#8079] Testing if something is NaN is impossible/ NaN behaviour is not IEEE 754 compliant" and added a test case for numberrots where the fall-back MPQ code is getting used. This commit was extracted from SVN r1040. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1040 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-18 clauter * execute.c: Final (?) patch for "[#8079] Testing if something is NaN is impossible/ NaN behaviour is not IEEE 754 compliant" This commit was extracted from SVN r1039. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1039 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-18 jmio17 * tests/check.sollya, tests/check.sollya.output: added test for bug #9859 This commit was extracted from SVN r1038. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1038 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-16 clauter * expression.c, sturm.c: Tried to fix issues with NaNs simplified to ones. This commit was extracted from SVN r1037. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1037 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-16 schevill * taylorform.c: * library functions should now work in taylorform. This commit was extracted from SVN r1036. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1036 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-16 schevill * autodiff.c, autodiff.h, doc/CommandsAndFunctions.tex, doc/autodiff.tex, doc/bashexecute.tex, doc/diff.tex, doc/double.shlp, doc/double.tex, doc/evaluate.tex, doc/keywords.def, doc/numberroots.tex, doc/print.shlp, doc/print.tex, doc/printdouble.shlp, doc/printdouble.tex, doc/printexpansion.shlp, doc/printexpansion.tex, doc/printfloat.shlp, doc/printfloat.tex, doc/printhexa.shlp, doc/printhexa.tex, doc/printsingle.shlp, doc/printsingle.tex, doc/remez.tex, doc/round.shlp, doc/round.tex, doc/single.shlp, doc/single.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, doc/write.shlp, doc/write.tex, help.h, taylorform.c: * Changed printhexa and printfloat in keywords.def etc. * Recompiled the doc. * Patched a bug in taylorform that caused it to print the same warning message many times. This commit was extracted from SVN r1035. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1035 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-16 schevill * doc/sollya.php: * Added file sollya.php (it corresponds to the introduction of the documentation in html). * The content of sollya.php is a direct translation of the current version of sollya.tex. This commit was extracted from SVN r1034. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1034 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-16 schevill * doc/sollya.pdf, doc/taylorform.shlp, doc/taylorform.tex, help.h: Improved help on taylorform. This commit was extracted from SVN r1033. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1033 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-16 schevill * doc/autodiff.shlp, doc/autodiff.tex, doc/sollya.pdf, help.h: * Documented autodiff. This commit was extracted from SVN r1032. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1032 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-16 schevill * INSTALL, doc/autodiff.shlp, doc/diff.shlp, doc/evaluate.shlp, doc/numberroots.shlp, doc/numberroots.tex, doc/remez.shlp, doc/sollya.pdf, doc/taylorform.shlp, doc/taylorform.tex, help.h: Improved help of taylorform a little bit (it renders now well in text mode) Proposed a complete documentation for numberroots. This commit was extracted from SVN r1031. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1031 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-16 clauter * doc/autodiff.tex, doc/bashexecute.tex, doc/diff.tex, doc/dirtyfindzeros.tex, doc/evaluate.tex, doc/findzeros.tex, doc/infnorm.tex, doc/remez.tex, doc/sollya.pdf, doc/taylor.tex, doc/taylorform.tex, doc/time.tex, doc/timing.tex, help.h: Updated doc This commit was extracted from SVN r1030. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1030 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-16 clauter * doc/CommandsAndFunctions.tex, doc/autodiff.shlp, doc/diff.shlp, doc/dirtyfindzeros.shlp, doc/evaluate.shlp, doc/findzeros.shlp, doc/infnorm.shlp, doc/keywords.def, doc/numberroots.shlp, doc/numberroots.tex, doc/remez.shlp, doc/sollya.pdf, doc/taylor.shlp, doc/taylorform.shlp: Added placeholders for documentation of numberroots This commit was extracted from SVN r1029. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1029 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-16 clauter * doc/autodiff.tex: Added file forgotten by Sylvain This commit was extracted from SVN r1028. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1028 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-16 clauter * doc/CommandsAndFunctions.tex, doc/bashexecute.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, help.h: Recompiled the doc This commit was extracted from SVN r1027. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1027 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 schevill * doc/autodiff.shlp, doc/keywords.def, doc/sollya.pdf, doc/sollya.tex, doc/taylorform.shlp, doc/taylorform.tex: * Improved the doc of taylorform a little bit. It may still look bad in text mode. This commit was extracted from SVN r1026. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1026 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 clauter * configure.ac: Tried again to do something for '[#9349] libmpfi.so is not found by configure' This commit was extracted from SVN r1025. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1025 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 schevill * configure.ac: Changed an error message into a warning, regarding the availability of fplll on strange systems. This commit was extracted from SVN r1024. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1024 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 clauter * configure.ac: Tried to do something for '[#9349] libmpfi.so is not found by configure' This commit was extracted from SVN r1023. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1023 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 clauter * configure.ac: Small change in configure. This commit was extracted from SVN r1022. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1022 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 clauter * plot.c: Made Sollya compile under Cygwin again This commit was extracted from SVN r1021. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1021 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 schevill * fpminimax.cpp: Patched the second bug mentioned in bug report #10073. This is not completely satisfying though, since fplll will use a non-GNU version of malloc and realloc in some cases. However, taken into account what mess libfplll is, the patch can be considered as quite good. This commit was extracted from SVN r1020. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1020 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 clauter * general.h: Again trying to patch bug Nr 1 in '[#10073] Sollya fails to compile in some cases.' This commit was extracted from SVN r1019. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1019 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 clauter * general.c: Trying to patch bug Nr 1 in '[#10073] Sollya fails to compile in some cases.' This commit was extracted from SVN r1018. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1018 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 schevill * tests/check.sollya, tests/check.sollya.output: Added test cases for bug #10062. This commit was extracted from SVN r1017. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1017 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 jmio17 * tests/check.sollya, tests/check.sollya.output: added tests #247, #248, #249 for bug [#7216]. Testing was ok. This commit was extracted from SVN r1016. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1016 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 clauter * INSTALL, sturm.c: Patched memory leaks in sturm This commit was extracted from SVN r1015. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1015 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 clauter * expression.c, plot.c, worstcase.c: Made Sollya compile with tcc as the C compiler - g++ is used for the C++ part This commit was extracted from SVN r1014. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1014 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-15 clauter * external.c, fpminimax.cpp, general.h, parser.y, plot.c, xml.c: Final (?) patch for "[#9782] Configure should detect if include file structure of libfplll follows tarball releases or Debian" - Sylvain to double-check This commit was extracted from SVN r1013. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1013 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-14 clauter * doc/bashexecute.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, help.h: Recompiled the doc This commit was extracted from SVN r1012. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1012 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-14 schevill * INSTALL, configure.ac: * Removed a bug that used to prevent one to perform a "make dist" This commit was extracted from SVN r1011. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1011 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-14 clauter * configure.ac, fpminimax.cpp: Some kind of fix for '[#9782] Configure should detect if include file structure of libfplll follows tarball releases or Debian' (untested) This commit was extracted from SVN r1010. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1010 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-14 clauter * execute.c: Fix for '[#10062] A test gives a wrond result without printing any warning.' This commit was extracted from SVN r1009. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1009 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-14 jmio17 * taylorform.c: removed function ConstructPoly, now we use makePolynomial from expression.c (its header is available in sollya.h) This commit was extracted from SVN r1008. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1008 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-14 clauter * INSTALL, execute.c, taylorform.c: Corrected a type error and patched a memory leak This commit was extracted from SVN r1007. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1007 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-14 schevill * doc/CommandsAndFunctions.tex, doc/sollya.pdf, doc/taylorform.shlp, doc/taylorform.tex, help.h: Slightly modified the documentation of taylorform, in order to make it more complete. This commit was extracted from SVN r1006. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1006 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-14 schevill * taylorform.c: Patched a memory leak. This commit was extracted from SVN r1005. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1005 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-14 schevill * : Merge the branch taylorform back into the trunk (817:1002) (note that nothing happened in the trunk between rev 994 and 2002) This commit was extracted from SVN r1003. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1003 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-13 clauter * tests/check.sollya.output: Updated check vector results This commit was extracted from SVN r1001. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@1001 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-13 clauter * INSTALL, configure.ac, execute.c: Patched a problem with very high degrees for taylorforms that became negative This commit was extracted from SVN r1000. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@1000 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-13 schevill * INSTALL, autodiff.c, autodiff.h: * Patched a bug concerning library functions in autodiff. This commit was extracted from SVN r999. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@999 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-13 clauter * INSTALL, autodiff.c, taylorform.c: Patched a segfault in autodiff This commit was extracted from SVN r998. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@998 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-13 clauter * execute.c: Patched problem related to reversed order of intervals in autodiff and extended autodiff syntax to take also a point as a 'development' point This commit was extracted from SVN r997. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@997 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-13 jmio17 * doc/keywords.def, doc/taylorform.shlp: added some doc for taylorform. This commit was extracted from SVN r996. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@996 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-13 schevill * autodiff.h: I forgot to add autodiff.h This commit was extracted from SVN r995. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@995 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-13 schevill * ChangeLog, assignment.c, assignment.h, autodiff.c, chain.c, chain.h, configure.ac, doc/CommandsAndFunctions.tex, doc/asciiplot.shlp, doc/asciiplot.tex, doc/bashexecute.shlp, doc/bashexecute.tex, doc/binary.shlp, doc/binary.tex, doc/canonical.shlp, doc/canonical.tex, doc/ceil.shlp, doc/ceil.tex, doc/coeff.shlp, doc/coeff.tex, doc/compileExamples.sh, doc/concat.shlp, doc/concat.tex, doc/decimal.shlp, doc/decimal.tex, doc/degree.shlp, doc/degree.tex, doc/denominator.shlp, doc/denominator.tex, doc/dieonerrormode.shlp, doc/dieonerrormode.tex, doc/dirtyfindzeros.shlp, doc/dirtyfindzeros.tex, doc/divide.shlp, doc/divide.tex, doc/double.tex, doc/dyadic.shlp, doc/dyadic.tex, doc/equal.shlp, doc/equal.tex, doc/error.shlp, doc/error.tex, doc/execute.shlp, doc/execute.tex, doc/expand.shlp, doc/expand.tex, doc/floor.shlp, doc/floor.tex, doc/fpminimax.shlp, doc/fpminimax.tex, doc/ge.shlp, doc/ge.tex, doc/gt.shlp, doc/gt.tex, doc/guessdegree.shlp, doc/guessdegree.tex, doc/hexadecimal.shlp, doc/hexadecimal.tex, doc/honorcoeffprec.shlp, doc/honorcoeffprec.tex, doc/hopitalrecursions.shlp, doc/hopitalrecursions.tex, doc/horner.shlp, doc/horner.tex, doc/implementpoly.shlp, doc/implementpoly.tex, doc/in.shlp, doc/in.tex, doc/infnorm.shlp, doc/infnorm.tex, doc/integral.shlp, doc/integral.tex, doc/introExample11.sollya, doc/introExample11.tex, doc/introExample14.sollya, doc/introExample14.tex, doc/introExample16.sollya, doc/introExample16.tex, doc/introExample21.sollya, doc/introExample21.tex, doc/introExample22.sollya, doc/introExample22.tex, doc/introExample24.sollya, doc/introExample24.tex, doc/introExample25.sollya, doc/introExample25.tex, doc/introExample29.sollya, doc/introExample29.tex, doc/introExample31.sollya, doc/introExample31.tex, doc/introExample32.sollya, doc/introExample32.tex, doc/introExample33.sollya, doc/introExample33.tex, doc/introExample34.sollya, doc/introExample34.tex, doc/introExample35.sollya, doc/introExample35.tex, doc/introExample36.sollya, doc/introExample36.tex, doc/introExample37.sollya, doc/introExample37.tex, doc/introExample38.sollya, doc/introExample38.tex, doc/introExample39.sollya, doc/introExample39.tex, doc/introExample40.sollya, doc/introExample40.tex, doc/introExample41.sollya, doc/introExample41.tex, doc/introExample42.sollya, doc/introExample42.tex, doc/introExample43.sollya, doc/introExample43.tex, doc/introExample44.sollya, doc/introExample44.tex, doc/introExample45.sollya, doc/introExample45.tex, doc/keywords.def, doc/le.shlp, doc/le.tex, doc/library.shlp, doc/library.tex, doc/listof.tex, doc/lt.shlp, doc/lt.tex, doc/midpointmode.shlp, doc/midpointmode.tex, doc/minus.shlp, doc/minus.tex, doc/mult.shlp, doc/mult.tex, doc/nearestint.shlp, doc/nearestint.tex, doc/neq.shlp, doc/neq.tex, doc/nop.shlp, doc/nop.tex, doc/numerator.shlp, doc/numerator.tex, doc/off.shlp, doc/off.tex, doc/on.shlp, doc/on.tex, doc/parse.shlp, doc/parse.tex, doc/pi.shlp, doc/pi.tex, doc/plus.shlp, doc/plus.tex, doc/points.shlp, doc/points.tex, doc/power.shlp, doc/power.tex, doc/powers.shlp, doc/powers.tex, doc/prec.shlp, doc/prec.tex, doc/precision.shlp, doc/precision.tex, doc/print.shlp, doc/print.tex, doc/printexpansion.shlp, doc/printexpansion.tex, doc/printfloat.shlp, doc/printfloat.tex, doc/printhexa.shlp, doc/printhexa.tex, doc/printxml.tex, doc/proc.shlp, doc/proc.tex, doc/procedure.shlp, doc/procedure.tex, doc/quit.shlp, doc/quit.tex, doc/rationalapprox.shlp, doc/rationalapprox.tex, doc/rationalmode.shlp, doc/rationalmode.tex, doc/rd.shlp, doc/rd.tex, doc/readfile.shlp, doc/readfile.tex, doc/readxml.shlp, doc/readxml.tex, doc/remez.shlp, doc/remez.tex, doc/return.tex, doc/rn.shlp, doc/rn.tex, doc/round.shlp, doc/round.tex, doc/roundcoefficients.shlp, doc/roundcoefficients.tex, doc/roundcorrectly.shlp, doc/roundcorrectly.tex, doc/ru.shlp, doc/ru.tex, doc/rz.shlp, doc/rz.tex, doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh, doc/simplify.shlp, doc/simplify.tex, doc/simplifysafe.shlp, doc/simplifysafe.tex, doc/single.tex, doc/sollya.pdf, doc/sollya.tex, doc/subpoly.shlp, doc/subpoly.tex, doc/substitute.shlp, doc/substitute.tex, doc/taylor.shlp, doc/taylor.tex, doc/taylorrecursions.shlp, doc/taylorrecursions.tex, doc/time.shlp, doc/time.tex, doc/timing.tex, doc/tripledouble.shlp, doc/tripledouble.tex, doc/var.shlp, doc/var.tex, doc/void.shlp, doc/void.tex, doc/write.shlp, doc/write.tex, double.c, double.h, execute.c, execute.h, expansion.c, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.h, general.c, general.h, help.h, implement.c, implement.h, infnorm.c, infnorm.h, integral.c, integral.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, libsollyaexample.c, main.c, main.h, minilexer.l, miniparser.y, parser.y, plot.c, plot.h, proof.c, proof.h, remez.c, remez.h, sollya.h, sos.sollya, supnormtest.sollya, taylor.c, taylor.h, tests/Makefile.am, tests/check.sollya.output, tests/timecheck.sollya, tests/timecheck.sollya.output, worstcase.c, worstcase.h, xml.c, xml.h: Backport from trunk, 931:993 This commit was extracted from SVN r994. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@994 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-13 schevill * Makefile.am, execute.c, infnorm.h, taylorform.c, taylorform.h: * Taylorform is now almost completely reviewed. * Non-dummy autodiff command added. * Now, autodiff internally computes f^(i)/i! instead of f^(i). * Some checks (consistency and memory leaks) remain to do. This commit was extracted from SVN r993. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@993 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-11 clauter * execute.c: Corrected an error in a moved freeThing This commit was extracted from SVN r992. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@992 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-09 clauter * execute.c: Patched a memory leak in fpminimax with list of degrees and not a degree This commit was extracted from SVN r991. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@991 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-09 clauter * expression.c: Patched a memory leak This commit was extracted from SVN r990. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@990 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-09 clauter * expression.c: Patched a memory leak This commit was extracted from SVN r989. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@989 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-08 clauter * execute.c: Patched yet another memory leak This commit was extracted from SVN r988. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@988 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-08 clauter * execute.c: Patched a memory leak This commit was extracted from SVN r987. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@987 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-08 clauter * doc/asciiplot.shlp, doc/asciiplot.tex, doc/bashexecute.tex, doc/binary.shlp, doc/binary.tex, doc/canonical.shlp, doc/canonical.tex, doc/ceil.shlp, doc/ceil.tex, doc/coeff.shlp, doc/coeff.tex, doc/decimal.shlp, doc/decimal.tex, doc/degree.shlp, doc/degree.tex, doc/denominator.shlp, doc/denominator.tex, doc/dirtyfindzeros.shlp, doc/dirtyfindzeros.tex, doc/dyadic.shlp, doc/dyadic.tex, doc/error.shlp, doc/error.tex, doc/execute.shlp, doc/execute.tex, doc/expand.shlp, doc/expand.tex, doc/floor.shlp, doc/floor.tex, doc/fpminimax.shlp, doc/fpminimax.tex, doc/guessdegree.shlp, doc/guessdegree.tex, doc/hexadecimal.shlp, doc/hexadecimal.tex, doc/honorcoeffprec.shlp, doc/honorcoeffprec.tex, doc/hopitalrecursions.shlp, doc/hopitalrecursions.tex, doc/horner.shlp, doc/horner.tex, doc/implementpoly.shlp, doc/implementpoly.tex, doc/infnorm.shlp, doc/infnorm.tex, doc/integral.shlp, doc/integral.tex, doc/library.shlp, doc/library.tex, doc/midpointmode.shlp, doc/midpointmode.tex, doc/nearestint.shlp, doc/nearestint.tex, doc/nop.shlp, doc/nop.tex, doc/numerator.shlp, doc/numerator.tex, doc/parse.shlp, doc/parse.tex, doc/pi.shlp, doc/pi.tex, doc/points.shlp, doc/points.tex, doc/powers.shlp, doc/powers.tex, doc/prec.shlp, doc/prec.tex, doc/precision.shlp, doc/precision.tex, doc/print.shlp, doc/print.tex, doc/printexpansion.shlp, doc/printexpansion.tex, doc/printfloat.shlp, doc/printfloat.tex, doc/printhexa.shlp, doc/printhexa.tex, doc/printxml.tex, doc/proc.shlp, doc/proc.tex, doc/quit.shlp, doc/quit.tex, doc/rationalapprox.shlp, doc/rationalapprox.tex, doc/rationalmode.shlp, doc/rationalmode.tex, doc/rd.shlp, doc/rd.tex, doc/readfile.shlp, doc/readfile.tex, doc/readxml.shlp, doc/readxml.tex, doc/remez.shlp, doc/remez.tex, doc/rn.shlp, doc/rn.tex, doc/round.shlp, doc/round.tex, doc/roundcoefficients.shlp, doc/roundcoefficients.tex, doc/roundcorrectly.shlp, doc/roundcorrectly.tex, doc/ru.shlp, doc/ru.tex, doc/rz.shlp, doc/rz.tex, doc/simplify.shlp, doc/simplify.tex, doc/simplifysafe.shlp, doc/simplifysafe.tex, doc/sollya.pdf, doc/subpoly.shlp, doc/subpoly.tex, doc/substitute.shlp, doc/substitute.tex, doc/taylor.shlp, doc/taylor.tex, doc/taylorrecursions.shlp, doc/taylorrecursions.tex, doc/time.shlp, doc/time.tex, doc/timing.tex, doc/tripledouble.shlp, doc/tripledouble.tex, doc/var.shlp, doc/var.tex, doc/write.shlp, doc/write.tex, help.h: Added seealsos in the help files and recompiled the doc This commit was extracted from SVN r986. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@986 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-08 clauter * execute.c, execute.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y: Added stuff in parser and evaluator for adding autodiff This commit was extracted from SVN r985. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@985 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-08 schevill * autodiff.c, infnorm.c, taylorform.c, taylorform.h: We kept reviewing (and simplifying) the code of taylorforms. It is not finished yet. This commit was extracted from SVN r984. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@984 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-08 clauter * execute.h: Prepared trunk This commit was extracted from SVN r983. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@983 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-08 clauter * doc/sollya.pdf, doc/sollya.tex, general.c, parser.y: Updated copyright year in generally displayed versions This commit was extracted from SVN r982. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@982 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-07 clauter * assignment.c, assignment.h, chain.c, chain.h, double.c, double.h, execute.c, execute.h, expansion.c, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.h, general.c, general.h, help.h, implement.c, implement.h, infnorm.c, infnorm.h, integral.c, integral.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, libsollyaexample.c, main.c, main.h, minilexer.l, miniparser.y, parser.y, plot.c, plot.h, proof.c, proof.h, remez.c, remez.h, sollya.h, taylor.c, taylor.h, worstcase.c, worstcase.h, xml.c, xml.h: Updated copyright notices This commit was extracted from SVN r981. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@981 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-07 schevill * taylorform.c, taylorform.h: We began to review the code of taylorform with Mioara (currently, only the part about autodiff). We simplified the code. The tests that we did seem to show that everything we did until now is correct. This commit was extracted from SVN r980. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@980 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-07 clauter * INSTALL, tests/check.sollya.output, tests/timecheck.sollya: Corrected tests to make them pass again This commit was extracted from SVN r979. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@979 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-07 clauter * configure.ac, tests/Makefile.am, tests/timecheck.sollya, tests/timecheck.sollya.output: Added beginning of a timing check and run autoscan This commit was extracted from SVN r978. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@978 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-07 clauter * configure.ac: Corrected a small bug in configure This commit was extracted from SVN r977. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@977 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-07 clauter * configure.ac: Tried to patch '[#9349] libmpfi.so is not found by configure' and '[#9350] configure option --with-xml2 is broken' This commit was extracted from SVN r976. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@976 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-07 clauter * configure.ac, plot.c: Changed precision in plot to 64 bits. This patches '[#9720] The plot command has a strange choice of precision' somehow... This commit was extracted from SVN r975. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@975 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-07 clauter * INSTALL, doc/CommandsAndFunctions.tex, doc/equal.shlp, doc/equal.tex, doc/ge.shlp, doc/ge.tex, doc/gt.shlp, doc/gt.tex, doc/in.shlp, doc/in.tex, doc/keywords.def, doc/le.shlp, doc/le.tex, doc/lt.shlp, doc/lt.tex, doc/neq.shlp, doc/neq.tex, doc/sollya.pdf, execute.c, execute.h, help.h, internparser.y, miniparser.y, parser.y: Added containment operator (in) This commit was extracted from SVN r974. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@974 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-06 clauter * doc/bashexecute.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, help.h: Recompiled the doc This commit was extracted from SVN r973. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@973 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-06 clauter * configure.ac, general.c, parser.y: Reworked and updated copyright messages This commit was extracted from SVN r972. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@972 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-06 clauter * doc/bashexecute.tex, doc/double.tex, doc/introExample11.tex, doc/keywords.def, doc/print.tex, doc/printexpansion.tex, doc/printfloat.shlp, doc/printfloat.tex, doc/printhexa.shlp, doc/printhexa.tex, doc/round.tex, doc/single.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, doc/write.tex, help.h: Recompiled teh doc with new names for printdouble and printsingle This commit was extracted from SVN r971. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@971 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-06 clauter * parser.y: Updated list of supported keywords. To be updated again when new functionality is ported from the branch to the trunk. This commit was extracted from SVN r970. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@970 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-04-06 clauter * ChangeLog, doc/introExample11.sollya, doc/sollya.pdf, doc/sollya.tex: Corrected some small mistakes in the introductory doc. This commit was extracted from SVN r969. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@969 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-26 schevill * execute.c, help.h, remez.c: Corrected a few typos in warning messages. Recompiled the doc. This commit was extracted from SVN r968. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@968 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-26 schevill * doc/concat.shlp, doc/concat.tex, doc/introExample14.sollya, doc/introExample14.tex, doc/introExample16.sollya, doc/introExample16.tex, doc/introExample21.sollya, doc/introExample21.tex, doc/introExample22.sollya, doc/introExample22.tex, doc/introExample24.sollya, doc/introExample24.tex, doc/introExample25.sollya, doc/introExample25.tex, doc/introExample29.sollya, doc/introExample29.tex, doc/introExample32.tex, doc/introExample39.tex, doc/introExample41.sollya, doc/introExample41.tex, doc/introExample45.sollya, doc/introExample45.tex, doc/proc.shlp, doc/proc.tex, doc/procedure.shlp, doc/procedure.tex, doc/sollya.pdf, doc/sollya.tex, doc/void.shlp, doc/void.tex: * Some modifications in the introduction of the doc (in particular, I added a new example). This commit was extracted from SVN r967. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@967 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-25 clauter * doc/introExample44.sollya, doc/introExample44.tex, doc/sollya.pdf: Finished the example on % notation with the fix in compileExamples.sh that Sylvain just committed and recompiled the doc This commit was extracted from SVN r966. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@966 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-25 schevill * doc/compileExamples.sh, doc/introExample44.tex: Corrected a bug in compileExamples.sh when the example contains the character "%" This commit was extracted from SVN r965. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@965 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-25 clauter * doc/introExample41.sollya, doc/introExample41.tex, doc/introExample44.sollya, doc/introExample44.tex, doc/sollya.pdf, doc/sollya.tex: Worked on doc. New example usign % does not compile This commit was extracted from SVN r964. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@964 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-25 clauter * doc/bashexecute.tex, doc/introExample31.tex, doc/introExample35.tex, doc/introExample36.tex, doc/introExample37.tex, doc/nop.tex, doc/proc.tex, doc/procedure.tex, doc/return.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, doc/void.tex, execute.c, help.h, internlexer.l, lexer.l, minilexer.l: Changed syntax printed back and recompiled doc This commit was extracted from SVN r963. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@963 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-24 clauter * ChangeLog: Got latest ChangeLog This commit was extracted from SVN r962. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@962 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-24 clauter * doc/CommandsAndFunctions.tex, doc/dieonerrormode.shlp, doc/dieonerrormode.tex, doc/off.shlp, doc/off.tex, doc/on.shlp, doc/on.tex, doc/sollya.pdf, help.h: Corrected and recompiled the doc for dieonerrormode and the attached help files This commit was extracted from SVN r961. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@961 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-24 clauter * doc/dieonerrormode.shlp, doc/dieonerrormode.tex, doc/keywords.def, execute.c, execute.h, general.c, general.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y: Implemented dieonerrormode This commit was extracted from SVN r960. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@960 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-24 schevill * doc/sollya.pdf, doc/sollya.tex, help.h: Corrected a few typos in sollya.tex. Recompiled the doc. This commit was extracted from SVN r959. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@959 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-24 schevill * doc/midpointmode.shlp, doc/midpointmode.tex, doc/off.shlp, doc/off.tex, doc/on.shlp, doc/on.tex, doc/sollya.pdf: Added missing SEEALSO about on/off modes. This commit was extracted from SVN r958. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@958 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-24 schevill * doc/bashexecute.tex, doc/divide.tex, doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh, doc/sollya.pdf, doc/time.tex, doc/timing.tex: * Replaced all occurences to printf "%s" by printf "%b"in shlp2*.sh * Corrected the bug with the name of the section for the division in LaTeX mode. This commit was extracted from SVN r957. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@957 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-24 clauter * sollya.h: Added extern "C" stuff into sollya.h for the C++ people. This commit was extracted from SVN r956. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@956 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-20 schevill * doc/shlp2html.sh: Corrected a bug when updating ListOfCommands.php: the trailing commas used to disappear. This commit was extracted from SVN r955. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@955 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-19 clauter * expression.c, internlexer.l, lexer.l, minilexer.l: Patched bug [#9859] Sollya hexadecimal input not fully C99/IEEE 754-2008 compliant. This commit was extracted from SVN r954. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@954 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-19 clauter * doc/bashexecute.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, help.h: Recompiled doc with patched shlp2* scripts. This commit was extracted from SVN r953. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@953 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-19 schevill * doc/bashexecute.tex, doc/concat.tex, doc/print.tex, doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh, doc/sollya.pdf, doc/time.tex, doc/timing.tex, doc/write.tex: The previous commits reintroduced a bug when "\n" are present in the code of examples. This is now patched. Doc is up to date. This commit was extracted from SVN r952. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@952 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-19 clauter * doc/abs.tex, doc/absolute.tex, doc/accurateinfnorm.tex, doc/acos.tex, doc/acosh.tex, doc/and.tex, doc/append.tex, doc/approx.tex, doc/asciiplot.tex, doc/asin.tex, doc/asinh.tex, doc/atan.tex, doc/atanh.tex, doc/autosimplify.tex, doc/bashexecute.tex, doc/binary.tex, doc/boolean.tex, doc/canonical.tex, doc/ceil.tex, doc/checkinfnorm.tex, doc/coeff.tex, doc/concat.tex, doc/constant.tex, doc/cos.tex, doc/cosh.tex, doc/decimal.tex, doc/default.tex, doc/degree.tex, doc/denominator.tex, doc/diam.tex, doc/diff.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/display.tex, doc/divide.tex, doc/double.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/dyadic.tex, doc/equal.tex, doc/erf.tex, doc/erfc.tex, doc/error.tex, doc/evaluate.tex, doc/execute.tex, doc/exp.tex, doc/expand.tex, doc/expm1.tex, doc/exponent.tex, doc/externalplot.tex, doc/externalproc.tex, doc/false.tex, doc/file.tex, doc/findzeros.tex, doc/fixed.tex, doc/floating.tex, doc/floor.tex, doc/fpminimax.tex, doc/fullparentheses.tex, doc/function.tex, doc/ge.tex, doc/gt.tex, doc/guessdegree.tex, doc/head.tex, doc/hexadecimal.tex, doc/honorcoeffprec.tex, doc/hopitalrecursions.tex, doc/horner.tex, doc/implementpoly.tex, doc/inf.tex, doc/infnorm.tex, doc/integer.tex, doc/integral.tex, doc/isbound.tex, doc/isevaluable.tex, doc/le.tex, doc/length.tex, doc/library.tex, doc/listof.tex, doc/log.tex, doc/log10.tex, doc/log1p.tex, doc/log2.tex, doc/lt.tex, doc/mantissa.tex, doc/mid.tex, doc/midpointmode.tex, doc/minus.tex, doc/mult.tex, doc/nearestint.tex, doc/neq.tex, doc/nop.tex, doc/not.tex, doc/numerator.tex, doc/off.tex, doc/on.tex, doc/or.tex, doc/parse.tex, doc/perturb.tex, doc/pi.tex, doc/plot.tex, doc/plus.tex, doc/points.tex, doc/postscript.tex, doc/postscriptfile.tex, doc/power.tex, doc/powers.tex, doc/prec.tex, doc/precision.tex, doc/prepend.tex, doc/print.tex, doc/printexpansion.tex, doc/printfloat.tex, doc/printhexa.tex, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/quit.tex, doc/range.tex, doc/rationalapprox.tex, doc/rationalmode.tex, doc/rd.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.tex, doc/remez.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/rn.tex, doc/round.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/roundingwarnings.tex, doc/ru.tex, doc/rz.tex, doc/searchgal.tex, doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh, doc/simplify.tex, doc/simplifysafe.tex, doc/sin.tex, doc/single.tex, doc/sinh.tex, doc/sollya.pdf, doc/sort.tex, doc/sqrt.tex, doc/string.tex, doc/subpoly.tex, doc/substitute.tex, doc/sup.tex, doc/tail.tex, doc/tan.tex, doc/tanh.tex, doc/taylor.tex, doc/taylorrecursions.tex, doc/time.tex, doc/timing.tex, doc/tripledouble.tex, doc/true.tex, doc/var.tex, doc/verbosity.tex, doc/void.tex, doc/worstcase.tex, doc/write.tex, help.h: Repared doc somehow. We have again problems with examples containing backslash sequences This commit was extracted from SVN r951. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@951 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-19 clauter * doc/abs.tex, doc/absolute.tex, doc/accurateinfnorm.tex, doc/acos.tex, doc/acosh.tex, doc/and.tex, doc/append.tex, doc/approx.tex, doc/asciiplot.tex, doc/asin.tex, doc/asinh.tex, doc/atan.tex, doc/atanh.tex, doc/autosimplify.tex, doc/bashexecute.tex, doc/binary.tex, doc/boolean.tex, doc/canonical.tex, doc/ceil.tex, doc/checkinfnorm.tex, doc/coeff.tex, doc/concat.tex, doc/constant.tex, doc/cos.tex, doc/cosh.tex, doc/decimal.tex, doc/default.tex, doc/degree.tex, doc/denominator.tex, doc/diam.tex, doc/diff.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/display.tex, doc/divide.tex, doc/double.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/dyadic.tex, doc/equal.tex, doc/erf.tex, doc/erfc.tex, doc/error.tex, doc/evaluate.tex, doc/execute.tex, doc/exp.tex, doc/expand.tex, doc/expm1.tex, doc/exponent.tex, doc/externalplot.tex, doc/externalproc.tex, doc/false.tex, doc/file.tex, doc/findzeros.tex, doc/fixed.tex, doc/floating.tex, doc/floor.tex, doc/fpminimax.tex, doc/fullparentheses.tex, doc/function.tex, doc/ge.tex, doc/gt.tex, doc/guessdegree.tex, doc/head.tex, doc/hexadecimal.tex, doc/honorcoeffprec.tex, doc/hopitalrecursions.tex, doc/horner.tex, doc/implementpoly.tex, doc/inf.tex, doc/infnorm.tex, doc/integer.tex, doc/integral.tex, doc/isbound.tex, doc/isevaluable.tex, doc/le.tex, doc/length.tex, doc/library.tex, doc/listof.tex, doc/log.tex, doc/log10.tex, doc/log1p.tex, doc/log2.tex, doc/lt.tex, doc/mantissa.tex, doc/mid.tex, doc/midpointmode.tex, doc/minus.tex, doc/mult.tex, doc/nearestint.tex, doc/neq.tex, doc/nop.tex, doc/not.tex, doc/numerator.tex, doc/off.tex, doc/on.tex, doc/or.tex, doc/parse.tex, doc/perturb.tex, doc/pi.tex, doc/plot.tex, doc/plus.tex, doc/points.tex, doc/postscript.tex, doc/postscriptfile.tex, doc/power.tex, doc/powers.tex, doc/prec.tex, doc/precision.tex, doc/prepend.tex, doc/print.tex, doc/printexpansion.tex, doc/printfloat.tex, doc/printhexa.tex, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/quit.tex, doc/range.tex, doc/rationalapprox.tex, doc/rationalmode.tex, doc/rd.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.tex, doc/remez.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/rn.tex, doc/round.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/roundingwarnings.tex, doc/ru.tex, doc/rz.tex, doc/searchgal.tex, doc/simplify.tex, doc/simplifysafe.tex, doc/sin.tex, doc/single.tex, doc/sinh.tex, doc/sort.tex, doc/sqrt.tex, doc/string.tex, doc/subpoly.tex, doc/substitute.tex, doc/sup.tex, doc/tail.tex, doc/tan.tex, doc/tanh.tex, doc/taylor.tex, doc/taylorrecursions.tex, doc/time.tex, doc/timing.tex, doc/tripledouble.tex, doc/true.tex, doc/var.tex, doc/verbosity.tex, doc/void.tex, doc/worstcase.tex, doc/write.tex, help.h: Recompiled the shlp - does not compile completely This commit was extracted from SVN r950. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@950 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-18 schevill * doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh: Bug of printf "$line" should be completely removed. This commit was extracted from SVN r949. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@949 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-18 schevill * doc/shlp2html.sh: Finally corrected the bug of printf "$ligne" (thanks to Christoph) This commit was extracted from SVN r948. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@948 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-18 schevill * doc/shlp2html.sh, doc/shlp2tex.sh: Corrected the bug mentioned in the commit log of revision 946. This commit was extracted from SVN r947. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@947 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-18 clauter * doc/bashexecute.tex, doc/divide.shlp, doc/divide.tex, doc/floor.shlp, doc/floor.tex, doc/introExample38.tex, doc/introExample40.tex, doc/minus.shlp, doc/minus.tex, doc/mult.shlp, doc/mult.tex, doc/off.shlp, doc/off.tex, doc/on.shlp, doc/on.tex, doc/plus.shlp, doc/plus.tex, doc/power.shlp, doc/power.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, help.h: Reworked some help topics and recompiled the doc. There is a compilation error This commit was extracted from SVN r946. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@946 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-16 clauter * minilexer.l, miniparser.y, parser.y, taylorform.c: Some additions for taylorform and numberroots to bring them up to speed w.r.t. to the trunk This commit was extracted from SVN r945. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@945 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-16 schevill * doc/sollya.pdf, doc/sollya.tex: Corrected a few typos in the introduction. This commit was extracted from SVN r944. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@944 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-16 schevill * doc/bashexecute.tex, doc/compileExamples.sh, doc/introExample38.tex, doc/introExample40.tex, doc/listof.tex, doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh, doc/sollya.pdf, doc/time.tex, doc/timing.tex: * All scripts should now be fully compatible with standard sh (at least, they behave the same way with dash and bash) * Many bugs corrected in shlp2* * recompiled all the doc This commit was extracted from SVN r943. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@943 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-16 clauter * doc/introExample32.sollya, doc/introExample32.tex, doc/sollya.pdf, doc/sollya.tex: Final corrections to introductory doc by Christoph before release This commit was extracted from SVN r942. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@942 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-15 clauter * doc/bashexecute.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, help.h: Recompiled the whole documentation after change in code This commit was extracted from SVN r941. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@941 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-15 clauter * doc/introExample38.sollya, doc/introExample38.tex, doc/introExample39.sollya, doc/introExample39.tex, doc/introExample40.sollya, doc/introExample40.tex, doc/introExample41.sollya, doc/introExample41.tex, doc/introExample42.sollya, doc/introExample42.tex, doc/introExample43.sollya, doc/introExample43.tex, doc/sollya.pdf, doc/sollya.tex, execute.c: Worked on doc, fixed a small problem in interval evaluation This commit was extracted from SVN r940. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@940 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-15 clauter * ChangeLog, doc/introExample31.sollya, doc/introExample31.tex, doc/introExample34.sollya, doc/introExample34.tex, doc/introExample35.sollya, doc/introExample35.tex, doc/introExample36.sollya, doc/introExample36.tex, doc/introExample37.sollya, doc/introExample37.tex, doc/sollya.pdf, doc/sollya.tex: Worked on introductory documentation. This commit was extracted from SVN r939. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@939 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-13 clauter * doc/bashexecute.tex, doc/floor.shlp, doc/floor.tex, doc/sollya.pdf, doc/time.tex, doc/timing.tex, help.h: Recompiled the doc This commit was extracted from SVN r938. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@938 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-13 clauter * doc/introExample32.sollya, doc/introExample32.tex, doc/introExample33.sollya, doc/introExample33.tex, doc/sollya.pdf, doc/sollya.tex: Added a section on infinities and NaNs in general doc. This commit was extracted from SVN r937. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@937 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-12 clauter * doc/sollya.pdf, doc/tripledouble.shlp, help.h: Corrected tripledouble This commit was extracted from SVN r936. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@936 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-12 clauter * doc/sollya.pdf: Recompiled sollya.pdf This commit was extracted from SVN r935. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@935 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-12 clauter * doc/nearestint.tex, doc/rationalmode.tex, doc/single.tex, doc/time.tex, help.h: Added forgotten tex file This commit was extracted from SVN r934. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@934 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-12 schevill * doc/bashexecute.shlp, doc/bashexecute.tex, help.h: Changed 'ls' to 'date' in the example of bashexecute. This commit was extracted from SVN r933. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@933 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-12 schevill * doc/bashexecute.tex, doc/library.shlp, doc/library.tex, doc/sollya.pdf, doc/timing.tex, help.h: Recompiled the doc This commit was extracted from SVN r932. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@932 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-12 schevill * autodiff.c, doc/CommandsAndFunctions.tex, doc/absolute.shlp, doc/absolute.tex, doc/accurateinfnorm.tex, doc/acos.shlp, doc/acos.tex, doc/and.tex, doc/append.shlp, doc/append.tex, doc/approx.tex, doc/asciiplot.shlp, doc/asciiplot.tex, doc/asin.shlp, doc/asin.tex, doc/asinh.shlp, doc/asinh.tex, doc/atan.shlp, doc/atan.tex, doc/atanh.shlp, doc/atanh.tex, doc/autosimplify.shlp, doc/autosimplify.tex, doc/bashexecute.tex, doc/binary.shlp, doc/binary.tex, doc/boolean.tex, doc/canonical.tex, doc/ceil.shlp, doc/ceil.tex, doc/checkinfnorm.shlp, doc/checkinfnorm.tex, doc/coeff.shlp, doc/coeff.tex, doc/compileExamples.sh, doc/concat.shlp, doc/concat.tex, doc/constant.shlp, doc/constant.tex, doc/conversionIntro.sh, doc/cos.shlp, doc/cos.tex, doc/cosh.shlp, doc/cosh.tex, doc/decimal.tex, doc/degree.tex, doc/denominator.tex, doc/diam.shlp, doc/diam.tex, doc/diff.tex, doc/dirtyfindzeros.shlp, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.shlp, doc/dirtyinfnorm.tex, doc/dirtyintegral.shlp, doc/dirtyintegral.tex, doc/display.shlp, doc/display.tex, doc/divide.tex, doc/double.shlp, doc/double.tex, doc/doubledouble.shlp, doc/doubledouble.tex, doc/doubleextended.shlp, doc/doubleextended.tex, doc/dyadic.tex, doc/equal.shlp, doc/equal.tex, doc/erfc.shlp, doc/erfc.tex, doc/error.shlp, doc/error.tex, doc/evaluate.shlp, doc/evaluate.tex, doc/execute.tex, doc/exp.shlp, doc/exp.tex, doc/expand.tex, doc/expm1.shlp, doc/expm1.tex, doc/exponent.shlp, doc/exponent.tex, doc/externalplot.shlp, doc/externalplot.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/file.tex, doc/findzeros.shlp, doc/findzeros.tex, doc/fixed.shlp, doc/fixed.tex, doc/floating.shlp, doc/floating.tex, doc/floor.shlp, doc/floor.tex, doc/fpminimax.shlp, doc/fpminimax.tex, doc/fullparentheses.tex, doc/function.tex, doc/ge.tex, doc/gt.tex, doc/guessdegree.shlp, doc/guessdegree.tex, doc/head.tex, doc/hexadecimal.shlp, doc/hexadecimal.tex, doc/honorcoeffprec.tex, doc/hopitalrecursions.shlp, doc/hopitalrecursions.tex, doc/horner.tex, doc/implementpoly.shlp, doc/implementpoly.tex, doc/inf.shlp, doc/inf.tex, doc/infnorm.shlp, doc/infnorm.tex, doc/integer.shlp, doc/integer.tex, doc/integral.shlp, doc/integral.tex, doc/introExample17.tex, doc/introExample6.sollya, doc/introExample6.tex, doc/isbound.tex, doc/isevaluable.shlp, doc/isevaluable.tex, doc/keywords.def, doc/le.tex, doc/length.tex, doc/library.shlp, doc/library.tex, doc/listof.tex, doc/lt.tex, doc/mantissa.shlp, doc/mantissa.tex, doc/mid.shlp, doc/mid.tex, doc/midpointmode.shlp, doc/midpointmode.tex, doc/minus.tex, doc/mult.tex, doc/nearestint.shlp, doc/neq.tex, doc/nop.shlp, doc/nop.tex, doc/not.tex, doc/numerator.tex, doc/or.shlp, doc/or.tex, doc/parse.shlp, doc/parse.tex, doc/perturb.tex, doc/pi.shlp, doc/pi.tex, doc/plot.shlp, doc/plot.tex, doc/plus.tex, doc/points.shlp, doc/points.tex, doc/postscript.tex, doc/postscriptfile.tex, doc/power.tex, doc/powers.tex, doc/prec.shlp, doc/prec.tex, doc/precision.shlp, doc/precision.tex, doc/prepend.tex, doc/print.shlp, doc/print.tex, doc/printexpansion.shlp, doc/printexpansion.tex, doc/printfloat.shlp, doc/printfloat.tex, doc/printhexa.tex, doc/printxml.tex, doc/proc.shlp, doc/proc.tex, doc/procedure.shlp, doc/procedure.tex, doc/quit.shlp, doc/quit.tex, doc/range.tex, doc/rationalapprox.shlp, doc/rationalapprox.tex, doc/rationalmode.shlp, doc/rd.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.tex, doc/remez.tex, doc/rename.shlp, doc/rename.tex, doc/restart.shlp, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/rn.tex, doc/round.shlp, doc/round.tex, doc/roundcoefficients.shlp, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/roundingwarnings.shlp, doc/roundingwarnings.tex, doc/ru.tex, doc/rz.shlp, doc/rz.tex, doc/searchgal.shlp, doc/searchgal.tex, doc/shlp2html.sh, doc/shlp2tex.sh, doc/simplify.shlp, doc/simplify.tex, doc/simplifysafe.shlp, doc/simplifysafe.tex, doc/sin.shlp, doc/sin.tex, doc/single.shlp, doc/sinh.shlp, doc/sinh.tex, doc/sollya.pdf, doc/sollya.tex, doc/sort.shlp, doc/sort.tex, doc/string.tex, doc/subpoly.shlp, doc/subpoly.tex, doc/substitute.shlp, doc/substitute.tex, doc/sup.shlp, doc/sup.tex, doc/tail.tex, doc/tan.shlp, doc/tan.tex, doc/tanh.shlp, doc/tanh.tex, doc/taylor.tex, doc/taylorrecursions.shlp, doc/taylorrecursions.tex, doc/time.shlp, doc/timing.shlp, doc/timing.tex, doc/tripledouble.shlp, doc/tripledouble.tex, doc/types.def, doc/var.tex, doc/verbosity.shlp, doc/verbosity.tex, doc/void.shlp, doc/void.tex, doc/worstcase.shlp, doc/worstcase.tex, doc/write.shlp, doc/write.tex, execute.c, execute.h, expression.c, expression.h, general.c, general.h, help.h, infnorm.c, infnorm.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y, sollya.h, sos.sollya, supnorm.sollya, supnormtest.sollya, tadiff.c, taylorModel.c, tests/check.sollya.output, xml.c: Backport from trunk, 887:930 This commit was extracted from SVN r931. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@931 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-12 clauter * doc/sollya.pdf, doc/time.shlp, help.h: Recompiled time This commit was extracted from SVN r930. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@930 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-12 clauter * doc/CommandsAndFunctions.tex, doc/ceil.shlp, doc/ceil.tex, doc/checkinfnorm.tex, doc/double.shlp, doc/double.tex, doc/doubledouble.shlp, doc/doubledouble.tex, doc/doubleextended.shlp, doc/doubleextended.tex, doc/floor.shlp, doc/floor.tex, doc/hopitalrecursions.shlp, doc/hopitalrecursions.tex, doc/keywords.def, doc/nearestint.shlp, doc/rationalmode.shlp, doc/round.shlp, doc/round.tex, doc/roundcoefficients.shlp, doc/roundcoefficients.tex, doc/roundingwarnings.shlp, doc/roundingwarnings.tex, doc/simplifysafe.shlp, doc/simplifysafe.tex, doc/single.shlp, doc/sollya.pdf, doc/taylorrecursions.shlp, doc/taylorrecursions.tex, doc/time.shlp, doc/timing.shlp, doc/timing.tex, doc/tripledouble.shlp, doc/tripledouble.tex, doc/types.def, doc/verbosity.shlp, doc/verbosity.tex, help.h: Recompiled the doc This commit was extracted from SVN r929. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@929 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-12 clauter * parser.y: Added a way to find out which help texts are missing (#define in parser.y) This commit was extracted from SVN r928. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@928 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-11 schevill * doc/checkinfnorm.shlp, doc/compileExamples.sh, doc/conversionIntro.sh, doc/shlp2html.sh: * Added support for help on a multiple pages. * Corrected the bug when displaying the help of printxml in html mode * Modified compileExamples.sh in order to generate php files as well * Wrote a small tool called conversionIntro.sh. Its purpose it to help us translating the introduction of the help to HTML THIS IS NOT an automatic conversion tool. It just simplifies the work. This commit was extracted from SVN r927. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@927 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-11 clauter * doc/sollya.pdf: Recompiled the doc. This commit was extracted from SVN r926. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@926 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-11 clauter * doc/introExample6.sollya, doc/introExample6.tex, doc/sollya.pdf, doc/sollya.tex: Worked a little on the introductory doc. This commit was extracted from SVN r925. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@925 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-11 clauter * doc/autosimplify.shlp, doc/autosimplify.tex, doc/binary.shlp, doc/binary.tex, doc/diam.shlp, doc/diam.tex, doc/dirtyfindzeros.shlp, doc/dirtyfindzeros.tex, doc/display.shlp, doc/display.tex, doc/externalplot.shlp, doc/externalplot.tex, doc/fpminimax.shlp, doc/fpminimax.tex, doc/guessdegree.shlp, doc/guessdegree.tex, doc/hopitalrecursions.shlp, doc/hopitalrecursions.tex, doc/infnorm.shlp, doc/infnorm.tex, doc/integral.shlp, doc/integral.tex, doc/library.shlp, doc/library.tex, doc/pi.shlp, doc/pi.tex, doc/plot.shlp, doc/plot.tex, doc/points.shlp, doc/points.tex, doc/proc.shlp, doc/proc.tex, doc/procedure.shlp, doc/procedure.tex, doc/round.shlp, doc/round.tex, doc/searchgal.shlp, doc/searchgal.tex, doc/simplify.shlp, doc/simplify.tex, doc/sollya.pdf, doc/sort.shlp, doc/sort.tex, doc/taylorrecursions.shlp, doc/taylorrecursions.tex, doc/timing.tex, doc/tripledouble.shlp, doc/tripledouble.tex, doc/verbosity.shlp, doc/verbosity.tex, doc/void.shlp, doc/void.tex, help.h: Corrected and recompiled the doc This commit was extracted from SVN r924. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@924 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-10 clauter * doc/sollya.pdf, doc/timing.tex: Recompiled the doc This commit was extracted from SVN r923. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@923 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-10 clauter * doc/bashexecute.tex, doc/library.tex: Recompiled the doc This commit was extracted from SVN r922. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@922 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-10 schevill * doc/absolute.tex, doc/accurateinfnorm.tex, doc/and.tex, doc/append.tex, doc/approx.tex, doc/asciiplot.tex, doc/autosimplify.tex, doc/bashexecute.tex, doc/binary.tex, doc/boolean.tex, doc/canonical.tex, doc/checkinfnorm.tex, doc/coeff.tex, doc/concat.tex, doc/constant.tex, doc/degree.tex, doc/denominator.tex, doc/diff.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/display.tex, doc/divide.tex, doc/equal.tex, doc/error.tex, doc/evaluate.tex, doc/execute.tex, doc/expand.tex, doc/exponent.tex, doc/externalplot.tex, doc/externalproc.tex, doc/findzeros.tex, doc/fixed.tex, doc/floating.tex, doc/fpminimax.tex, doc/fullparentheses.tex, doc/function.tex, doc/ge.tex, doc/gt.tex, doc/guessdegree.tex, doc/head.tex, doc/honorcoeffprec.tex, doc/horner.tex, doc/implementpoly.tex, doc/inf.tex, doc/infnorm.tex, doc/integer.tex, doc/integral.tex, doc/isbound.tex, doc/isevaluable.tex, doc/le.tex, doc/length.tex, doc/library.tex, doc/listof.tex, doc/lt.tex, doc/mantissa.tex, doc/mid.tex, doc/minus.tex, doc/mult.tex, doc/neq.tex, doc/nop.tex, doc/not.tex, doc/numerator.tex, doc/or.tex, doc/parse.tex, doc/perturb.tex, doc/plot.tex, doc/plus.tex, doc/power.tex, doc/precision.tex, doc/prepend.tex, doc/print.tex, doc/printexpansion.tex, doc/printfloat.tex, doc/printhexa.tex, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/quit.tex, doc/range.tex, doc/rationalapprox.tex, doc/rd.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.tex, doc/remez.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/rn.tex, doc/round.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/ru.tex, doc/rz.tex, doc/searchgal.tex, doc/simplify.tex, doc/simplifysafe.tex, doc/sollya.pdf, doc/sort.tex, doc/string.tex, doc/subpoly.tex, doc/substitute.tex, doc/sup.tex, doc/tail.tex, doc/taylor.tex, doc/timing.tex, doc/var.tex, doc/void.tex, doc/worstcase.tex, doc/write.tex: Doc in LaTeX is up to date. This commit was extracted from SVN r921. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@921 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-10 schevill * doc/keywords.def, doc/shlp2html.sh, doc/shlp2tex.sh: Patched bugs concerning the backslashes. Now commands such as "+" are listed at "+" in sollya.pdf and not at "plus" any more. This commit was extracted from SVN r920. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@920 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-10 schevill * doc/shlp2tex.sh: Good news: shlp2tex.sh seems to be fully portable (i.e. has the same behavior with dash and bash). It does not seem to remain bugs. This commit was extracted from SVN r919. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@919 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-10 clauter * doc/prec.shlp, doc/prec.tex, doc/precision.shlp, doc/precision.tex, doc/print.shlp, doc/print.tex, doc/printexpansion.shlp, doc/printexpansion.tex, doc/printfloat.shlp, doc/printfloat.tex, doc/proc.shlp, doc/proc.tex, doc/procedure.shlp, doc/procedure.tex, doc/quit.shlp, doc/quit.tex, doc/rationalapprox.shlp, doc/rationalapprox.tex, doc/rename.shlp, doc/rename.tex, doc/restart.shlp, doc/restart.tex, doc/round.shlp, doc/round.tex, doc/roundcoefficients.shlp, doc/roundcoefficients.tex, doc/roundingwarnings.shlp, doc/roundingwarnings.tex, doc/rz.shlp, doc/rz.tex, doc/searchgal.shlp, doc/searchgal.tex, doc/sin.shlp, doc/sin.tex, doc/sinh.shlp, doc/sinh.tex, doc/sollya.pdf, doc/subpoly.shlp, doc/subpoly.tex, doc/substitute.shlp, doc/substitute.tex, doc/sup.shlp, doc/sup.tex, doc/tan.shlp, doc/tan.tex, doc/tanh.shlp, doc/tanh.tex, doc/taylorrecursions.shlp, doc/taylorrecursions.tex, doc/timing.tex, doc/tripledouble.shlp, doc/tripledouble.tex, doc/verbosity.shlp, doc/verbosity.tex, doc/void.shlp, doc/void.tex, doc/worstcase.shlp, doc/worstcase.tex, doc/write.shlp, doc/write.tex, help.h: Corrected and recompiled the doc This commit was extracted from SVN r918. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@918 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-10 clauter * general.c: Made Sollya return the error status of the last parsing attempt as a process return value. This commit was extracted from SVN r917. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@917 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-10 clauter * doc/externalproc.shlp, doc/externalproc.tex, doc/findzeros.shlp, doc/findzeros.tex, doc/fixed.shlp, doc/fixed.tex, doc/floating.shlp, doc/floating.tex, doc/floor.shlp, doc/floor.tex, doc/fpminimax.shlp, doc/fpminimax.tex, doc/hexadecimal.shlp, doc/hexadecimal.tex, doc/hopitalrecursions.shlp, doc/hopitalrecursions.tex, doc/implementpoly.shlp, doc/implementpoly.tex, doc/inf.shlp, doc/inf.tex, doc/infnorm.shlp, doc/infnorm.tex, doc/integer.shlp, doc/integer.tex, doc/isevaluable.shlp, doc/isevaluable.tex, doc/library.shlp, doc/library.tex, doc/mantissa.shlp, doc/mantissa.tex, doc/mid.shlp, doc/mid.tex, doc/midpointmode.shlp, doc/midpointmode.tex, doc/nop.shlp, doc/nop.tex, doc/or.shlp, doc/or.tex, doc/parse.shlp, doc/parse.tex, doc/plot.shlp, doc/plot.tex, doc/sollya.pdf, doc/timing.tex, help.h: Reworked and recompiled agian some part of the doc This commit was extracted from SVN r916. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@916 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-10 clauter * doc/absolute.shlp, doc/absolute.tex, doc/acos.shlp, doc/acos.tex, doc/append.shlp, doc/append.tex, doc/asciiplot.shlp, doc/asciiplot.tex, doc/asin.shlp, doc/asin.tex, doc/asinh.shlp, doc/asinh.tex, doc/atan.shlp, doc/atan.tex, doc/atanh.shlp, doc/atanh.tex, doc/autosimplify.shlp, doc/autosimplify.tex, doc/ceil.shlp, doc/ceil.tex, doc/coeff.shlp, doc/coeff.tex, doc/concat.shlp, doc/concat.tex, doc/constant.shlp, doc/constant.tex, doc/cos.shlp, doc/cos.tex, doc/cosh.shlp, doc/cosh.tex, doc/diam.shlp, doc/diam.tex, doc/dirtyfindzeros.shlp, doc/dirtyfindzeros.tex, doc/dirtyintegral.shlp, doc/dirtyintegral.tex, doc/display.shlp, doc/display.tex, doc/double.shlp, doc/double.tex, doc/doubledouble.shlp, doc/doubledouble.tex, doc/doubleextended.shlp, doc/doubleextended.tex, doc/equal.shlp, doc/equal.tex, doc/erfc.shlp, doc/erfc.tex, doc/error.shlp, doc/error.tex, doc/evaluate.shlp, doc/evaluate.tex, doc/exp.shlp, doc/exp.tex, doc/expm1.shlp, doc/expm1.tex, doc/exponent.shlp, doc/exponent.tex, doc/externalplot.shlp, doc/externalplot.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/sollya.pdf, doc/timing.tex, help.h: Recompiled doc. Corrected some mistakes. This commit was extracted from SVN r915. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@915 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-06 clauter * doc/absolute.tex, doc/accurateinfnorm.tex, doc/and.tex, doc/append.tex, doc/approx.tex, doc/asciiplot.tex, doc/autosimplify.tex, doc/bashexecute.tex, doc/binary.tex, doc/boolean.tex, doc/canonical.tex, doc/checkinfnorm.tex, doc/coeff.tex, doc/concat.tex, doc/constant.tex, doc/decimal.tex, doc/degree.tex, doc/denominator.tex, doc/diff.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/display.tex, doc/divide.tex, doc/dyadic.tex, doc/equal.tex, doc/error.tex, doc/evaluate.tex, doc/execute.tex, doc/expand.tex, doc/exponent.tex, doc/externalplot.tex, doc/externalproc.tex, doc/file.tex, doc/findzeros.tex, doc/fixed.tex, doc/floating.tex, doc/fpminimax.tex, doc/fullparentheses.tex, doc/function.tex, doc/ge.tex, doc/gt.tex, doc/guessdegree.tex, doc/head.tex, doc/hexadecimal.tex, doc/honorcoeffprec.tex, doc/horner.tex, doc/implementpoly.tex, doc/inf.tex, doc/infnorm.tex, doc/integer.tex, doc/integral.tex, doc/isbound.tex, doc/isevaluable.tex, doc/le.tex, doc/length.tex, doc/library.tex, doc/lt.tex, doc/mantissa.tex, doc/mid.tex, doc/minus.tex, doc/mult.tex, doc/neq.tex, doc/nop.tex, doc/not.tex, doc/numerator.tex, doc/or.tex, doc/parse.tex, doc/perturb.tex, doc/plot.tex, doc/plus.tex, doc/postscript.tex, doc/postscriptfile.tex, doc/power.tex, doc/powers.tex, doc/precision.tex, doc/prepend.tex, doc/print.tex, doc/printexpansion.tex, doc/printfloat.tex, doc/printhexa.tex, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/quit.tex, doc/range.tex, doc/rationalapprox.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.tex, doc/remez.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/round.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/searchgal.tex, doc/simplify.tex, doc/simplifysafe.tex, doc/sollya.pdf, doc/sort.tex, doc/string.tex, doc/subpoly.tex, doc/substitute.tex, doc/sup.tex, doc/tail.tex, doc/taylor.tex, doc/timing.tex, doc/var.tex, doc/void.tex, doc/worstcase.tex, doc/write.tex: Recompiled doc, new shlp2tex.sh This commit was extracted from SVN r914. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@914 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-06 clauter * doc/shlp2tex.sh: Patched some compilation errors This commit was extracted from SVN r913. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@913 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-06 clauter * doc/dirtyinfnorm.tex, doc/introExample17.tex, doc/sollya.pdf, doc/timing.tex, help.h: Recompiled doc This commit was extracted from SVN r912. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@912 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-05 schevill * doc/dirtyinfnorm.shlp, doc/shlp2html.sh: * Patched a bug when the file ListOfCommands.php does not exist. This commit was extracted from SVN r911. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@911 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-04 clauter * INSTALL, doc/accurateinfnorm.tex, doc/asciiplot.tex, doc/bashexecute.tex, doc/dirtyfindzeros.tex, doc/fpminimax.tex, doc/points.tex, doc/printexpansion.tex, doc/proc.tex, doc/remez.tex, doc/sollya.pdf, doc/subpoly.tex, doc/timing.tex, help.h: Recompiled the doc. This commit was extracted from SVN r910. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@910 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-03-01 clauter * general.c: Worked around a bug in setrlimit under Cygwin. The workaround may happen not to work at all. This commit was extracted from SVN r909. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@909 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-02-28 clauter * execute.c, expression.c, general.c, general.h: Some kind of fix for "[#7549] Deep recursion causes segfault on Cygwin" This commit was extracted from SVN r908. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@908 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-02-26 clauter * execute.c: Fix for "[#8079] Testing if something is NaN is impossible/ NaN behaviour is not IEEE 754 compliant" This commit was extracted from SVN r907. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@907 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-02-26 clauter * execute.c, expression.c, expression.h, infnorm.c, tests/check.sollya.output: Fix for [#8078] Infinity and minus infinity do not behave the same This commit was extracted from SVN r906. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@906 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-02-26 clauter * execute.c: Patch for "[#7370] Warning is displayed twice where it should be displayed once " This commit was extracted from SVN r905. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@905 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-02-01 clauter * autodiff.c, execute.c, expression.c, expression.h, infnorm.c, infnorm.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y, sollya.h, tadiff.c, taylorModel.c, xml.c: Corrected bug #9530 "A test hides a warning message". Added nearestint function. This commit was extracted from SVN r904. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@904 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2010-01-29 clauter * execute.c, execute.h, internparser.y, miniparser.y, parser.y: Added support for procedures with an arbitrary number of arguments This commit was extracted from SVN r903. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@903 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-29 clauter * sos.sollya, supnormtest.sollya: Added SOS output for John's HOL tests. This commit was extracted from SVN r902. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@902 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-28 schevill * sos.sollya, supnormtest.sollya: Revert the previous commit of sos.sollya and supnormtest.sollya that has been done by mistake. This commit was extracted from SVN r901. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@901 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-28 schevill * sos.sollya, supnorm.sollya, supnormtest.sollya: Revert Mioara's last commit which was a mistake This commit was extracted from SVN r900. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@900 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-28 jmio17 * supnorm.sollya: small modifications by Mioara and Sylvain made during reviewing Christoph's code This commit was extracted from SVN r899. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@899 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-24 jmio17 * taylorform.c: Corrected POW case p^f, when p is constant. This commit was extracted from SVN r896. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@896 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-23 clauter * unisos.gp: Added a new version of unisos, adding an extra check on the sign of the polynomial. This commit was extracted from SVN r895. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@895 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-23 clauter * supnorm.sollya, supnormtest.sollya: Added some comments for the code, making it clearer. The supnorm code is now ready for review. This commit was extracted from SVN r894. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@894 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-23 clauter * supnorm.sollya, supnormtest.sollya: Still a better implementation, just as I always said: "Never compute, just check". RUNS FASTER AS A DIRTYINFNORM ON SOME INSTANCES! This commit was extracted from SVN r893. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@893 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-23 clauter * supnorm.sollya, supnormtest.sollya: Reworked and improved supremum norm algorithm. There are still some experiments possible for the absolute error case but we could also publish this one. This commit was extracted from SVN r892. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@892 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-21 clauter * sos.sollya, supnormtest.sollya, unisos.gp: Added John Harrison's SOS routines written in PARI/GP. Interfaced the GP SOS code with Sollya and the Supremum norm. This commit was extracted from SVN r891. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@891 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-21 clauter * sos.sollya, supnorm.sollya, supnormtest.sollya: New, corrected version of supnorm. This commit was extracted from SVN r890. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@890 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-21 schevill * doc/remez.shlp, execute.c, execute.h, general.c, general.h, infnorm.c, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y, plot.c, proof.c, remez.c, tests/check.sollya, tests/check.sollya.output: Backport from trunk 867:886 This commit was extracted from SVN r887. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@887 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-20 clauter * supnorm.sollya, supnormtest.sollya: Updated supnorm and supnormtest driver for new dirtyinfnorm. This commit was extracted from SVN r886. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@886 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-15 schevill * doc/remez.shlp: Corrected bug #8774 relative to a phrase not completely clear in the doc of remez algorithm. This commit was extracted from SVN r885. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@885 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-13 clauter * general.c, general.h: Added flushing option in order to be able to use Sollya over nameless pipes. This commit was extracted from SVN r884. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@884 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-09 clauter * execute.c: Removed annoying warning about floating-point evaluation for ~ operator, which is known to do a floating-point evaluation. This commit was extracted from SVN r883. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@883 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-06 schevill * proof.c, remez.c: Corrected conflict between two functions named doNothing. This commit was extracted from SVN r882. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@882 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-06 clauter * execute.c, execute.h, internparser.y, miniparser.y, parser.y: Implemented nop(integer) for relative timing purposes. This commit was extracted from SVN r881. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@881 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-04 clauter * infnorm.c, tests/check.sollya.output: rewrote evaluateFaithful and speeded it up by 50% This commit was extracted from SVN r880. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@880 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-04 schevill * plot.c: Patched asciiplot to make it use random sampling. This commit was extracted from SVN r879. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@879 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-04 schevill * infnorm.c, plot.c: Partially corrected bug #8666 by randomizing a little bit the sampling in plot. Note that the same issue as the one described in bug #8666 can be observed with dirtyinfnorm, e.g.: > f = sin(x * 2 * pi * points) + 3; > dirtyinfnorm(f,[1;2]); 3.0000000000000000000000000000000000000000000167935 (example proposed by Christoph). I applied the same randomization strategy to dirtyinfnorm as well. This commit was extracted from SVN r878. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@878 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-02 schevill * infnorm.c: Patched dirtyinfnorm in order to take rigorously into account cases such as f = log(x)/log(2) - log10(x)/log10(2) + 3 where the function is constant but f' cannot be proven to be 0. This commit was extracted from SVN r877. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@877 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-02 schevill * infnorm.c: Reverted a modification by Christoph which introduced a possible bug when computing ||f|| where f is almost constant. This a is a short-term patch, while we are thinkning of a way of dealing with examples such as: f = log(x)/log(2) - log10(x)/log10(2) + 3; dirtyinfnorm(f,[1;2]); I also corrected a small mistake: there is no need to run Newton's algorithm where either f'(x1) or f'(x3)=0 since it means that either x1 or x3 is the local extremum. These points are tken into account anyway. This commit was extracted from SVN r876. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@876 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-01 clauter * compile.sh, configure.ac: Reverted back the wrong commit on compile.sh and configure.ac This commit was extracted from SVN r875. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@875 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-01 clauter * compile.sh, configure.ac, infnorm.c: Reviewed Sylvain's reimplementation of dirtyinfnorm and performed two patches. This commit was extracted from SVN r874. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@874 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-01 clauter * execute.c: Patched execute.c in order to get Sollya build under Cygwin This commit was extracted from SVN r873. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@873 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-01 schevill * infnorm.c, remez.c, tests/check.sollya, tests/check.sollya.output: * This is an attempt to patch bug #8330 about the accuracy of dirtyinfnorm. I propose a new implementation of uncertifiedInfnorm. This implementation does mainly the same as before but avoid evaluating the derivative of f as much as possible. It uses evaluateFaithfulWithCutOffFast and my implementation of Newton's algorithm. * I made some modifications to evaluateFaithfulWithCutOffFast: startprec is now really used as the initial precision. This code should be read carefully by someone else than me since it is a critical code for Sollya. However, the tests of check.sollya all pass. * I modified check.sollya: I corrected some syntax errors and added a test case for the byg #8330. This commit was extracted from SVN r872. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@872 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-10-01 clauter * execute.c, execute.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y: Added high-level time command This commit was extracted from SVN r871. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@871 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-09-25 schevill * INSTALL, doc/abs.tex, doc/absolute.shlp, doc/absolute.tex, doc/accurateinfnorm.tex, doc/acos.tex, doc/acosh.tex, doc/and.tex, doc/append.tex, doc/approx.tex, doc/asciiplot.tex, doc/asin.tex, doc/asinh.tex, doc/atan.tex, doc/atanh.tex, doc/autosimplify.tex, doc/bashexecute.tex, doc/binary.tex, doc/boolean.tex, doc/canonical.tex, doc/ceil.tex, doc/checkinfnorm.tex, doc/coeff.tex, doc/concat.tex, doc/constant.tex, doc/cos.tex, doc/cosh.tex, doc/decimal.tex, doc/default.tex, doc/degree.tex, doc/denominator.tex, doc/diam.tex, doc/diff.tex, doc/dirtyfindzeros.shlp, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/display.tex, doc/divide.tex, doc/double.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/dyadic.tex, doc/equal.tex, doc/erf.tex, doc/erfc.tex, doc/error.tex, doc/evaluate.tex, doc/execute.tex, doc/exp.tex, doc/expand.tex, doc/expm1.tex, doc/exponent.tex, doc/externalplot.tex, doc/externalproc.tex, doc/false.tex, doc/file.tex, doc/findzeros.tex, doc/fixed.tex, doc/floating.tex, doc/floor.tex, doc/fpminimax.tex, doc/fullparentheses.tex, doc/function.tex, doc/ge.tex, doc/gt.tex, doc/guessdegree.tex, doc/head.tex, doc/hexadecimal.tex, doc/honorcoeffprec.tex, doc/hopitalrecursions.tex, doc/horner.tex, doc/implementpoly.tex, doc/inf.tex, doc/infnorm.tex, doc/integer.tex, doc/integral.tex, doc/isbound.tex, doc/isevaluable.tex, doc/le.tex, doc/length.tex, doc/library.tex, doc/listof.tex, doc/log.tex, doc/log10.tex, doc/log1p.tex, doc/log2.tex, doc/lt.tex, doc/mantissa.tex, doc/mid.tex, doc/midpointmode.tex, doc/minus.tex, doc/mult.tex, doc/neq.tex, doc/nop.tex, doc/not.tex, doc/numerator.tex, doc/off.tex, doc/on.tex, doc/or.tex, doc/parse.tex, doc/perturb.tex, doc/pi.tex, doc/plot.tex, doc/plus.tex, doc/points.tex, doc/postscript.tex, doc/postscriptfile.tex, doc/power.tex, doc/powers.tex, doc/prec.tex, doc/precision.tex, doc/prepend.tex, doc/print.tex, doc/printexpansion.tex, doc/printfloat.tex, doc/printhexa.tex, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/quit.tex, doc/range.tex, doc/rationalapprox.tex, doc/rd.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.shlp, doc/relative.tex, doc/remez.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/rn.tex, doc/round.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/roundingwarnings.tex, doc/ru.tex, doc/rz.tex, doc/searchgal.tex, doc/shlp2html.sh, doc/shlp2tex.sh, doc/shlp2txt.sh, doc/simplify.tex, doc/simplifysafe.tex, doc/sin.tex, doc/sinh.tex, doc/sollya.pdf, doc/sort.tex, doc/sqrt.tex, doc/string.tex, doc/subpoly.tex, doc/substitute.tex, doc/sup.tex, doc/tail.tex, doc/tan.tex, doc/tanh.tex, doc/taylor.tex, doc/taylorrecursions.tex, doc/timing.tex, doc/tripledouble.tex, doc/true.tex, doc/var.tex, doc/verbosity.tex, doc/void.tex, doc/worstcase.tex, doc/write.tex, help.h, infnorm.c, remez.c, tests/check.sollya, tests/check.sollya.output: Backport from trunk 852:866 This commit was extracted from SVN r867. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@867 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-09-25 schevill * infnorm.c, remez.c, tests/check.sollya, tests/check.sollya.output: * Patched Newton's algorithm: except if there is a bug in the patch, the algorithm should be more stable now. In particular, there was a bug when searching for the zero of f in [a,b] where a<0 * help.h: Recompiled doc. This commit was extracted from SVN r865. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@865 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-08-28 schevill * doc/abs.tex, doc/absolute.shlp, doc/absolute.tex, doc/accurateinfnorm.tex, doc/acos.tex, doc/acosh.tex, doc/and.tex, doc/append.tex, doc/approx.tex, doc/asciiplot.tex, doc/asin.tex, doc/asinh.tex, doc/atan.tex, doc/atanh.tex, doc/autosimplify.tex, doc/bashexecute.tex, doc/binary.tex, doc/boolean.tex, doc/canonical.tex, doc/ceil.tex, doc/checkinfnorm.tex, doc/coeff.tex, doc/concat.tex, doc/constant.tex, doc/cos.tex, doc/cosh.tex, doc/decimal.tex, doc/default.tex, doc/degree.tex, doc/denominator.tex, doc/diam.tex, doc/diff.tex, doc/dirtyfindzeros.shlp, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/display.tex, doc/divide.tex, doc/double.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/dyadic.tex, doc/equal.tex, doc/erf.tex, doc/erfc.tex, doc/error.tex, doc/evaluate.tex, doc/execute.tex, doc/exp.tex, doc/expand.tex, doc/expm1.tex, doc/exponent.tex, doc/externalplot.tex, doc/externalproc.tex, doc/false.tex, doc/file.tex, doc/findzeros.tex, doc/fixed.tex, doc/floating.tex, doc/floor.tex, doc/fpminimax.tex, doc/fullparentheses.tex, doc/function.tex, doc/ge.tex, doc/gt.tex, doc/guessdegree.tex, doc/head.tex, doc/hexadecimal.tex, doc/honorcoeffprec.tex, doc/hopitalrecursions.tex, doc/horner.tex, doc/implementpoly.tex, doc/inf.tex, doc/infnorm.tex, doc/integer.tex, doc/integral.tex, doc/isbound.tex, doc/isevaluable.tex, doc/le.tex, doc/length.tex, doc/library.tex, doc/listof.tex, doc/log.tex, doc/log10.tex, doc/log1p.tex, doc/log2.tex, doc/lt.tex, doc/mantissa.tex, doc/mid.tex, doc/midpointmode.tex, doc/minus.tex, doc/mult.tex, doc/neq.tex, doc/nop.tex, doc/not.tex, doc/numerator.tex, doc/off.tex, doc/on.tex, doc/or.tex, doc/parse.tex, doc/perturb.tex, doc/pi.tex, doc/plot.tex, doc/plus.tex, doc/points.tex, doc/postscript.tex, doc/postscriptfile.tex, doc/power.tex, doc/powers.tex, doc/prec.tex, doc/precision.tex, doc/prepend.tex, doc/print.tex, doc/printexpansion.tex, doc/printfloat.tex, doc/printhexa.tex, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/quit.tex, doc/range.tex, doc/rationalapprox.tex, doc/rd.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.shlp, doc/relative.tex, doc/remez.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/rn.tex, doc/round.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/roundingwarnings.tex, doc/ru.tex, doc/rz.tex, doc/searchgal.tex, doc/simplify.tex, doc/simplifysafe.tex, doc/sin.tex, doc/sinh.tex, doc/sollya.pdf, doc/sort.tex, doc/sqrt.tex, doc/string.tex, doc/subpoly.tex, doc/substitute.tex, doc/sup.tex, doc/tail.tex, doc/tan.tex, doc/tanh.tex, doc/taylor.tex, doc/taylorrecursions.tex, doc/timing.tex, doc/tripledouble.tex, doc/true.tex, doc/var.tex, doc/verbosity.tex, doc/void.tex, doc/worstcase.tex, doc/write.tex: Recompiled the doc. Minor patches in some .shlp files. This commit was extracted from SVN r864. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@864 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-08-28 schevill * doc/shlp2html.sh: Improved version of shlp2html. Many bugs patched. It is almost completely functional. This commit was extracted from SVN r863. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@863 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-08-28 schevill * doc/shlp2tex.sh, doc/shlp2txt.sh: The scripts were bugged for architectures where sh is a link to dash. This is now corrected. They are proven to work with both dash and bash. This commit was extracted from SVN r862. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@862 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-08-27 schevill * doc/absolute.shlp, doc/relative.shlp: The help text in relative.shlp was wrong from the first version of the doc: it was just copied-pasted from perturb.shlp. I corrected it and updated absolute.shlp in the same time. This commit was extracted from SVN r861. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@861 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-31 clauter * supnorm.sollya, supnormtest.sollya: Added first Sollya based implementation of new infnorm algorithm. This commit was extracted from SVN r860. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@860 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-31 clauter * sturm.c: Added a test that the given function is a polynomial for numberroots. This commit was extracted from SVN r859. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@859 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-31 clauter * Makefile.am, execute.c, execute.h, expression.c, expression.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y, sturm.c, sturm.h: Added Sturm sequence code directly to the tool. The code is accessible through the command "numberroots(p,I)". This commit was extracted from SVN r858. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@858 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-30 clauter * execute.c: This is a working (compiling) version. This commit was extracted from SVN r857. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@857 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-30 clauter * infnorm.c, remez.c, remez.h: Tried to improve the accuracy of dirtyinfnorm. This commit was extracted from SVN r856. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@856 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-30 clauter * infnorm.c, remez.c, remez.h: Tried to improve accuracy of dirtyinfnorm. This commit was extracted from SVN r855. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@855 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-29 schevill * execute.c: this version really compiles. I am affraid execute.c is a mess between r851 in trunk and taylorform This commit was extracted from SVN r854. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@854 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-29 schevill * INSTALL, execute.c, expression.c: reported patch of bug #8312 (that was initially commited in the branch taylorform) into the trunk This commit was extracted from SVN r853. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@853 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-29 schevill * INSTALL, compile.sh, configure.ac, execute.c, external.c, library.c, tests/check.sollya.output: Backport from trunk, 841:851 This commit was extracted from SVN r852. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@852 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-28 clauter * INSTALL, execute.c, expression.c, taylorform.c: Corrected bug #8312 Cannot evaluate x raised to a computed integer power over an interval Extended and corrected the Taylorform code for corner cases NOBODY CARES ABOUT BUT ME. This commit was extracted from SVN r851. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@851 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-28 clauter * compile.sh, configure.ac: Fixed wrong commit just one revision ago. This commit was extracted from SVN r850. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@850 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-28 clauter * INSTALL, compile.sh, configure.ac, execute.c, library.c: Patched a segfault on parse This commit was extracted from SVN r849. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@849 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-27 clauter * execute.c, tests/check.sollya.output: Patched bug #8306 Parsing of non-representable decimal constants in point-interval notation may give FP point intervals. The patch still has to be confirmed. This commit was extracted from SVN r848. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@848 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-12 jmio17 * taylorform.c: bugs corrected in zumkeller technique and in tm composition in the absolute case This commit was extracted from SVN r847. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@847 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-08 jmio17 * taylorform.c: small bugs related to zumkeller technique corrected This commit was extracted from SVN r846. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@846 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-08 jmio17 * taylorform.c: zumkeller method integrated in the case of absolute error. Not completely tested. This commit was extracted from SVN r845. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@845 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-07-01 clauter * execute.c, external.c: Patched bug tracker [#8199] options file, postscript and postscriptfile do not work in externalplot All old checks pass. No new checks have been added (I can't think of any). Code needs confirmation for the tracker to be closed. This commit was extracted from SVN r844. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@844 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-22 jmio17 * execute.c, taylorform.c, taylorform.h: modified in execute.c, so that we can use an interval for x0 - horrible patch, just for the sake of trying. apologies to Christoph ;) This commit was extracted from SVN r843. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@843 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-22 jmio17 * taylorform.c: pointers deallocation revisited This commit was extracted from SVN r842. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@842 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-19 schevill * AUTHORS, Makefile.am, assignment.c, assignment.h, chain.c, chain.h, configure.ac, doc/dirtyintegral.shlp, doc/dirtyintegral.tex, doc/introExample17.tex, doc/printfloat.tex, doc/printhexa.tex, doc/shlp2html.sh, doc/sollya.pdf, doc/sollya.tex, doc/timing.tex, double.c, double.h, execute.c, execute.h, expansion.c, expansion.h, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.cpp, fpminimax.h, general.c, general.h, help.h, implement.c, implement.h, infnorm.c, infnorm.h, integral.c, integral.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, libsollyaexample.c, main.c, main.h, minilexer.l, miniparser.y, parser.y, plot.c, plot.h, proof.c, proof.h, remez.c, remez.h, sollya.h, taylor.c, taylor.h, worstcase.c, worstcase.h, xml.c, xml.h: Backport from trunk, 817:840 This commit was extracted from SVN r841. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@841 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-18 clauter * expression.c: Patched performance bug #8093 "Dirtyinfnorm is slow on some instance" This commit was extracted from SVN r840. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@840 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-18 schevill * doc/shlp2html.sh: shlp2html not yet finished but in a good way. This commit was extracted from SVN r839. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@839 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-17 jmio17 * taylorModel.c, taylorform.c: Resolved conflict between Mioara's and Sylvain's work in taylorform This commit was extracted from SVN r838. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@838 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-17 schevill * execute.c, taylorform.c: Corrected small errors in Christoph's code for glueing taylorform. The interface seems to work correctly now. This commit was extracted from SVN r837. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@837 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-16 clauter * execute.c: Patched parse: a segfault could be seen only under Cygwin This commit was extracted from SVN r836. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@836 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-16 clauter * configure.ac: Made Sollya build as a statically linked program under Cygwin This commit was extracted from SVN r835. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@835 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-16 jmio17 * taylorform.c: added dirtysharpbound This commit was extracted from SVN r834. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@834 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-16 jmio17 * taylorform.c: division - "false poles" case works This commit was extracted from SVN r833. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@833 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-12 jmio17 * taylorform.c: finished power,base_division; missing general division This commit was extracted from SVN r832. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@832 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-08 jmio17 * taylorform.c: relative error works for basic functions This commit was extracted from SVN r831. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@831 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-08 jmio17 * taylorform.c: tm's for sin(x), x*x, exp(x) (easy ones) seem to be working This commit was extracted from SVN r830. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@830 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-08 clauter * configure.ac: Added -Xlinker --allow-multiple-definition to configure/ makefile where supported This commit was extracted from SVN r829. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@829 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-07 clauter * double.c, double.h, execute.c, execute.h, expression.c, expression.h, infnorm.c, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y, sollya.h, xml.c: Added single precision support. Extended syntax of roundcoefficients command. Extended syntax of round command. This commit was extracted from SVN r828. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@828 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-07 clauter * execute.c, general.c, general.h: Made Sollya accept an input file as a command line argument This commit was extracted from SVN r827. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@827 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-07 clauter * doc/introExample17.tex, doc/printfloat.tex, doc/printhexa.tex, doc/sollya.pdf, doc/timing.tex, help.h: Recompiled docc This commit was extracted from SVN r826. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@826 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-07 schevill * AUTHORS, assignment.c, assignment.h, chain.c, chain.h, configure.ac, doc/dirtyintegral.shlp, doc/dirtyintegral.tex, doc/sollya.tex, double.c, double.h, execute.c, execute.h, expansion.c, expansion.h, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.cpp, fpminimax.h, general.c, general.h, help.h, implement.c, implement.h, infnorm.c, infnorm.h, integral.c, integral.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, libsollyaexample.c, main.c, main.h, minilexer.l, miniparser.y, parser.y, plot.c, plot.h, proof.c, proof.h, remez.c, remez.h, sollya.h, taylor.c, taylor.h, worstcase.c, worstcase.h, xml.c, xml.h: changed addresses @ens-lyon.fr to @ens-lyon.org This commit was extracted from SVN r825. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@825 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-07 clauter * Makefile.am, configure.ac: Added newly needed AC indications This commit was extracted from SVN r824. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@824 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-06 clauter * execute.c, execute.h, expression.c, expression.h, minilexer.l, miniparser.y: Eventually updated miniparser (for parse()) to the Sollya-age This commit was extracted from SVN r823. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@823 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-06 jmio17 * taylorform.c: taylor forms - intermediary version This commit was extracted from SVN r822. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@822 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-06 clauter * execute.c: Changed a verbosity back because of Sylvain. This commit was extracted from SVN r821. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@821 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-03 clauter * execute.c, execute.h, infnorm.h, internlexer.l, internparser.y, lexer.l, parser.y, taylorform.c: Parsing support for taylorform This commit was extracted from SVN r820. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@820 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-03 schevill * Makefile.am, taylorform.c, taylorform.h: adding files for taylorform This commit was extracted from SVN r819. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@819 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-06-03 schevill * : Creating a branch for working on taylorform This commit was extracted from SVN r817. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/branches/taylorform@817 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-04-25 clauter * doc/sollya.pdf: Recompiled pdf This commit was extracted from SVN r815. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@815 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-04-25 clauter * doc/introExample6.tex, doc/sollya.pdf, doc/timing.tex, help.h: Recompiled documentation and help This commit was extracted from SVN r814. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@814 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-04-23 clauter * Makefile.am, configure.ac, doc/Makefile.am, doc/sollya.pdf, doc/sollya.tex, tests/Makefile.am: Tried to correct bug #7696 "Makefile does not launch recompilation on make check if sources changed" The bug has gone on Cygwin. ATTENTION: The help files should be recompiled. This commit was extracted from SVN r813. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@813 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-04-22 clauter * execute.c, expression.c, infnorm.c, infnorm.h, tests/check.sollya.output: Added smart sign test that can be used for proving that some constant term is constant zero. This commit was extracted from SVN r812. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@812 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-04-17 clauter * ChangeLog, doc/CommandsAndFunctions.tex, doc/accurateinfnorm.tex, doc/approx.tex, doc/bashexecute.tex, doc/divide.tex, doc/doubledouble.tex, doc/fpminimax.tex, doc/introExample17.tex, doc/introExample6.tex, doc/introExample8.tex, doc/points.tex, doc/printexpansion.tex, doc/round.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/sollya.pdf, doc/timing.tex, doc/tripledouble.tex, help.h: Updated help texts and texts for introduction in the documentation. The update is obtained through recompilation. New Changelog text also available. This commit was extracted from SVN r811. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@811 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-04-16 clauter * execute.c: Adapted evaluation to a constant (when a constant is needed for a subsequent command) to the new behaviour w.r.t. not-faithful values that might be zero. ATTENTION: MUST STILL UPDATE HELP TEXTS AND DOCUMENTATION. This commit was extracted from SVN r810. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@810 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-04-16 clauter * double.c, execute.c, expression.c, general.c, tests/check.sollya, tests/check.sollya.output: (1) Corrected a bug in reproducibility of the displaying of values: For precisions prec set between 32 and 64, integer values between 2^31 and 2^63-1 were displayed differently on machines for which sizeof(int) = 8 than for those for which sizeof(int) = 16. (2) Degraded 4 warnings on D, DD, TD, DE "Warning: rounding a value computed on less than 53 bits to double precision." to an information. (3) Changed the behaviour of the tool on automatic printing (on the prompt) if no faithful rounding can be determined for a constant expression. For constant expressions f(c) for which it can be proved that it exists two reals (not including infinity) a and b such that a <= f(c) <= b and a * b < 0, 0 is displayed instead of some FP-determined value if no faithful rounding for f(c) can be determined. The warning texts have significantly been changed, hence an update of the check files. The change might involve issue with backward compatibility. ATTENTION: The help text and documentation files have not been updated yet. THIS MUST BE DONE AS SOON AS POSSIBLE. (4) Corrected a bug concerning rationalmode. The value of that global constant did not get reset to its default value on restart. This commit was extracted from SVN r809. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@809 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-04-13 clauter * execute.c, execute.h, expression.c, expression.h, general.c, general.h, internlexer.l, internparser.y, lexer.l, parser.y: Added a rational computations mode. Still needs documentation. No expected changes in behaviour unless rationalmode = on; is issued. This commit was extracted from SVN r808. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@808 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-04-06 clauter * expression.c: Corrected a bug This commit was extracted from SVN r807. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@807 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-04-06 clauter * expression.c: Made exact simplifier *finally* simplify things like D(sin(3)), DD(exp(3)), TD(const), DE(const), floor(const), ceil(const) - where possible with a little more than the working precision This commit was extracted from SVN r806. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@806 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-03-30 clauter * expression.c, infnorm.c: Synchonization after debugging This commit was extracted from SVN r805. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@805 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-03-28 clauter * execute.c: Corrected a bug This commit was extracted from SVN r804. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@804 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-27 clauter * doc/CommandsAndFunctions.tex, doc/printfloat.tex, doc/printhexa.tex, doc/sollya.pdf, doc/sollya.tex, execute.c, help.h: Moved verbosity of annoying message "the given expression is not a constant but an expression to evaluate" from warning to information - at least if the evaluation is a faithful rounding. Recompiled documentation in order to reflect the change. This commit was extracted from SVN r803. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@803 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-26 clauter * configure.ac, doc/concat.shlp, doc/concat.tex, doc/sollya.pdf, doc/sollya.tex, execute.c, help.h: Started working on support of procedures with varying arity. This commit was extracted from SVN r802. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@802 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-24 jmio17 * taylorModel.c: Corrected polynomial bounding for initial polynomial found. Improved remainder for log. This commit was extracted from SVN r801. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@801 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-23 clauter * double.c, tests/check.sollya, tests/check.sollya.output: Second and hopefully final version of the patch for bug #7085 Rounding to simplie value with infinity overflow is wrong. The bug (and several bugs hidden by the bug [un bogue peut en cacher un autre]) was due to double rounding issues. The double roundings either occurred because of: - a first rounding to double precision or - a rounding to 24 bits with unbounded exponent range or - a rounding to 24 bits with unbounded exponent range followed by a rounding to double precision followed by a rounding to single precision. Everthing's should be fine now. This commit was extracted from SVN r800. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@800 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-23 clauter * double.c: First version of patch for bug #7085 Rounding to simple value with infinity overflow is wrong. The bug submitted is patched. Code shows now a double rounding issue the single precision subnormal range. This commit was extracted from SVN r799. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@799 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-23 clauter * infnorm.c, tests/check.sollya, tests/check.sollya.output: Small changes for #6844 "0/0 not evaluated to NaN in all cases" Checks for #6844 "0/0 not evaluated to NaN in all cases" This commit was extracted from SVN r798. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@798 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-23 clauter * execute.c, infnorm.c, tests/check.sollya.output: Tried to correct bug #6844 "0/0 not evaluated to NaN in all cases". Need check file needed because patch induces a change in over-all behaviour. Remark: the new check file does not include checks for that bug. This commit was extracted from SVN r797. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@797 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-18 schevill * expression.c: Fixed the typo "a integer" (see bug #7312) This commit was extracted from SVN r796. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@796 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-18 clauter * expression.c: Patched bug 7216, No parentheses when displaying numbers in binary format leads to an incorrect value when parsed again This commit was extracted from SVN r795. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@795 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-18 clauter * expression.c: Patched bug #7312, Colouring and English grammar are wrong in warning message This commit was extracted from SVN r794. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@794 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-18 clauter * expression.c: Correct bug with tracker #7215, Binary display prints numbers in a way that cannot be read again This commit was extracted from SVN r793. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@793 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-12 schevill * doc/length.shlp, doc/length.tex, doc/sollya.pdf, help.h: Corrected a typo in an example of the documentation of length This commit was extracted from SVN r792. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@792 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-11 jmio17 * tadiff.c: added f^ctPower case. This commit was extracted from SVN r791. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@791 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-10 jmio17 * tadiff.c, tadiff.h: TADIFF formulas implemented for: sin, cos, exp, log, ct, var, mul,add,div - (not completely tested). This commit was extracted from SVN r790. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@790 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-09 jmio17 * taylorModel.h: Demo version of Taylor Models. This commit was extracted from SVN r789. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@789 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-02-09 jmio17 * taylorModel.c: Demo version of Taylor Models. This commit was extracted from SVN r788. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@788 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-01-21 schevill * fpminimax.cpp: Bug of infinite loop (see bug report #7217) temporarily patched. If fpminimax has too many loops it fails. This commit was extracted from SVN r787. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@787 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2009-01-21 schevill * README, fpminimax.cpp: Fpminimax exhibitted an infinite loop in a particular case. When the coefficients are floating-point numbers, the algorithm has to guess the exponents of the coefficients first. Then, fpminimax is launched and we check afterwards that the coefficients have the same exponent as we guessed. If it is not the case, we correct the exponents and loop. I knew that it could lead theoretically to an infinite loop. Yet, it was never oberved in practice. Mioara found the following instance that effectively leads to an infinite loop: f=sqrt(x); d=[1+12/512, 1+13/512]; fpminimax(f, 2, [|18, 10, 14|], d); It turns out that the algorithm loops over the two polynomials p=-1.00100001000101_2 * 2^(-3) * x^2 + 1.10010001_2 * 2^(-1) * x + 1.0110111010000111_2 * 2^(-2) q=-1.100110000101_2 * 2^(-4) * x^2 + 1.011001011_2 * 2^(-1) * x + 1.10011011000101111_2 * 2^(-2) Surprinsingly, the coefficients of x^2 is not the same at all in both polynomials. I patched the algorithm with the following trick: when more than MAXLOOP trials have been performed, we stop as soon as a polynomial fits in the formats. This still ensures that the result of the algorithm has the good form. This avoids the previous infinite loop but the theoretical possibility of an infinite loop stays. This commit was extracted from SVN r786. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@786 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-11-17 clauter * execute.c, infnorm.c, infnorm.h, tests/check.sollya, tests/check.sollya.output: Changed 0 * infty behaviour -- behaviour was due to MPFI - discussion needed - bug 0/0 remains This commit was extracted from SVN r785. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@785 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-10-15 schevill * autodiff.c, sturm.c: Removed a useless line in autodiff.c and sturm.c This commit was extracted from SVN r784. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@784 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-10-07 schevill * remez.c, tests/check.sollya.output: Rewrote Newton's algorithm making it more readable. This commit was extracted from SVN r783. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@783 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-10-06 schevill * INSTALL, remez.c, tests/check.sollya, tests/check.sollya.output: Corrected a bug in dirtyfindzeros: in the case of a second order zero, the convergence is only linear. It lead to an overestimation of the precision by a factor ~= 2 This commit was extracted from SVN r782. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@782 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-10-05 clauter * execute.c: Patched bug when external procedure was renamed This commit was extracted from SVN r781. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@781 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-10-03 clauter * INSTALL, configure.ac: Changed required version of automake for overcoming a problem on Guillaume's machine This commit was extracted from SVN r780. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@780 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-10-02 clauter * expression.c: Changed simplification size in differentiation This commit was extracted from SVN r779. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@779 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-10-01 clauter * tests/check.sollya.output: New test cases This commit was extracted from SVN r778. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@778 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-10-01 clauter * execute.c, execute.h, expression.c, internparser.y, parser.y, tests/check.sollya, tests/check.sollya.output: Patched midpoint mode and range -- added mixed mode mpfi like interval arithmetic This commit was extracted from SVN r777. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@777 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-10-01 schevill * autodiff.c, library.c: Added expm1 base case in autodiff. Set a warning mode for the error messages of library.c This commit was extracted from SVN r776. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@776 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-10-01 schevill * remez.c: In guessdegree: even (or odd) functions on symetrical intervals used to disturb the algorithm. As a result, it was quite slow and returned poor intervals such as [0;14] or [27;43]. I corrected it by adding a small random pertubation in the points used for the interpolation (the same trick was already used for a while in Remez algorithm with good results). This commit was extracted from SVN r775. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@775 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-30 schevill * fpminimax.cpp, remez.c, tests/check.sollya, tests/check.sollya.output: Corrected two bugs (comparison between a signed and an unsigned int). Added a test case for the bug. This commit was extracted from SVN r774. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@774 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-29 clauter * tests/check.sollya.output: New test cases This commit was extracted from SVN r773. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@773 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-29 clauter * execute.c, infnorm.h: Added simple MPFI-like interval arithmetic to Sollya language This commit was extracted from SVN r772. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@772 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-25 schevill * remez.c: Corrected a typo. This commit was extracted from SVN r771. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@771 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-25 schevill * INSTALL, README, assignment.c, assignment.h, chain.c, chain.h, doc/accurateinfnorm.shlp, doc/accurateinfnorm.tex, doc/checkinfnorm.shlp, doc/checkinfnorm.tex, doc/dirtyinfnorm.shlp, doc/dirtyinfnorm.tex, doc/guessdegree.shlp, doc/guessdegree.tex, doc/infnorm.shlp, doc/infnorm.tex, doc/introExample8.sollya, doc/introExample8.tex, doc/remez.shlp, doc/remez.tex, doc/sollya.pdf, doc/sollya.tex, double.c, double.h, execute.c, execute.h, expansion.c, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.cpp, fpminimax.h, general.c, general.h, help.h, implement.c, implement.h, infnorm.c, infnorm.h, integral.c, integral.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, libsollyaexample.c, main.c, main.h, minilexer.l, miniparser.y, parser.y, plot.c, plot.h, proof.c, proof.h, remez.c, remez.h, sollya.h, taylor.c, taylor.h, worstcase.c, worstcase.h, xml.c, xml.h: Changed "infinite norm" to "infinity norm" everywhere. This commit was extracted from SVN r770. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@770 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-25 clauter * tests/check.sollya, tests/check.sollya.output: New test cases This commit was extracted from SVN r769. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@769 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-24 clauter * execute.c: Patched new evaluate behaviour This commit was extracted from SVN r768. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@768 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-24 clauter * INSTALL, configure.ac, doc/sollya.pdf, doc/sollya.tex: Patched affiliation, changed revision version number This commit was extracted from SVN r767. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@767 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-24 schevill * doc/evaluate.shlp, doc/evaluate.tex, doc/sollya.pdf, help.h: Updated the documentation of evaluate with the new feature evaluate(f,[a;a]). This commit was extracted from SVN r766. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@766 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-24 clauter * tests/check.sollya, tests/check.sollya.output: New test cases This commit was extracted from SVN r765. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@765 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-24 clauter * execute.c: Patched midpoint mode parsing if bounds are inverted This commit was extracted from SVN r764. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@764 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-24 clauter * execute.c, internlexer.l, lexer.l: Patched midpoint mode, changed slightly the behaviour of evaluate This commit was extracted from SVN r763. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@763 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-23 clauter * execute.c: Made inequality test finally safe - warnings are displayed iff floating-point evaluation changes a result This commit was extracted from SVN r762. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@762 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-23 clauter * tests/check.sollya, tests/check.sollya.output: New check files This commit was extracted from SVN r761. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@761 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-23 schevill * tests/check.sollya.output: Nothing This commit was extracted from SVN r760. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@760 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-23 clauter * execute.c, expression.c, internlexer.l, lexer.l: Patched displaying of decimal constants having a decimal exponent different from 0 and only one decimal to be displayed. Added %precision%constant parsing capability for numerical point constants. This commit was extracted from SVN r759. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@759 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-23 schevill * remez.c, tests/check.sollya: Patched a case of infinite looping in Newton's algorithm. This commit was extracted from SVN r758. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@758 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-23 schevill * doc/sollya.pdf, help.h: Nothing This commit was extracted from SVN r757. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@757 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-23 schevill * INSTALL, doc/sollya.pdf, doc/tail.shlp, doc/tail.tex, help.h, tests/check.sollya.output: corrected a type error in tail documentation. Updated check file. This commit was extracted from SVN r756. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@756 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-23 clauter * lexer.l, tests/Makefile.am: Made shebangs possible This commit was extracted from SVN r755. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@755 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-22 schevill * remez.c: Patched a bug about the estimation of the precision given by a numerical root in Newton's algorithm This commit was extracted from SVN r754. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@754 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-21 clauter * execute.c: Some changes for testing (2) This commit was extracted from SVN r753. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@753 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-21 clauter * execute.c: Some changes for testing This commit was extracted from SVN r752. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@752 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-21 clauter * expression.c, tests/check.sollya, tests/check.sollya.output: Patched bugs in midpointmode This commit was extracted from SVN r751. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@751 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 clauter * ChangeLog: New Changelog This commit was extracted from SVN r750. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@750 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 schevill * sollya.h: Added defined constant FLOATING, FIXED, ABSOLUTESYM, and RELATIVESYM for fpminimax This commit was extracted from SVN r749. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@749 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 clauter * doc/equal.shlp, doc/equal.tex, doc/ge.shlp, doc/ge.tex, doc/gt.shlp, doc/gt.tex, doc/le.shlp, doc/le.tex, doc/lt.shlp, doc/lt.tex, doc/neq.shlp, doc/neq.tex, doc/prec.shlp, doc/prec.tex, doc/sollya.pdf, doc/sollya.tex, execute.c, help.h: Changes in documentation This commit was extracted from SVN r748. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@748 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 clauter * ChangeLog, NEWS, README, doc/log.shlp, doc/log.tex, doc/minus.shlp, doc/minus.tex, doc/searchgal.shlp, doc/searchgal.tex, doc/sollya.pdf, doc/sollya.tex, help.h: New NEWS and Changlog files This commit was extracted from SVN r747. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@747 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 clauter * doc/sollya.pdf: Recompiled whole help This commit was extracted from SVN r746. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@746 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 clauter * doc/autosimplify.tex, doc/bashexecute.tex, doc/canonical.tex, doc/checkinfnorm.tex, doc/degree.tex, doc/diam.tex, doc/display.tex, doc/doubleextended.tex, doc/error.tex, doc/externalproc.tex, doc/fpminimax.tex, doc/fullparentheses.tex, doc/hopitalrecursions.tex, doc/horner.tex, doc/library.tex, doc/nop.tex, doc/off.tex, doc/on.tex, doc/pi.tex, doc/plot.tex, doc/points.tex, doc/print.tex, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/quit.tex, doc/rationalapprox.tex, doc/readxml.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/round.tex, doc/roundingwarnings.tex, doc/simplifysafe.tex, doc/sollya.pdf, doc/taylorrecursions.tex, doc/timing.tex, doc/write.tex, help.h: Updated recompiled documentation This commit was extracted from SVN r745. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@745 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 schevill * doc/asciiplot.tex, doc/fpminimax.shlp, doc/fpminimax.tex, doc/shlp2tex.sh, doc/sollya.pdf, help.h: several things This commit was extracted from SVN r744. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@744 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 clauter * doc/sollya.pdf, doc/sollya.tex: Forgot one thing This commit was extracted from SVN r743. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@743 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 clauter * doc/implementpoly.tex, doc/infnorm.tex, doc/sollya.pdf, help.h: Forgot to compile the changed help texts This commit was extracted from SVN r742. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@742 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 clauter * doc/implementpoly.shlp, doc/infnorm.shlp, doc/sollya.pdf, doc/sollya.tex: Some updates in the documentation This commit was extracted from SVN r741. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@741 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 clauter * doc/sollya.pdf, doc/sollya.tex: Slight change in sollya.tex main document This commit was extracted from SVN r740. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@740 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 clauter * doc/approx.tex, doc/sollya.pdf, help.h, internparser.y, parser.y: Patched a parsing bug for ~ operator This commit was extracted from SVN r739. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@739 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 schevill * doc/shlp2tex.sh, doc/sollya.pdf, help.h: Unified \sollya and Sollya in the generated documentation This commit was extracted from SVN r738. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@738 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-18 schevill * doc/approx.shlp, doc/approx.tex: Added two examples in the documentation of approx This commit was extracted from SVN r737. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@737 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-17 clauter * ChangeLog, tests/check.sollya.output: New check output file because errors corrected This commit was extracted from SVN r736. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@736 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-17 clauter * doc/approx.shlp, doc/approx.tex, doc/autosimplify.shlp, doc/autosimplify.tex, doc/default.shlp, doc/default.tex, doc/display.shlp, doc/display.tex, doc/evaluate.shlp, doc/evaluate.tex, doc/externalplot.shlp, doc/externalplot.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/findzeros.shlp, doc/findzeros.tex, doc/fpminimax.shlp, doc/fpminimax.tex, doc/fullparentheses.shlp, doc/fullparentheses.tex, doc/honorcoeffprec.shlp, doc/honorcoeffprec.tex, doc/implementpoly.shlp, doc/implementpoly.tex, doc/infnorm.shlp, doc/infnorm.tex, doc/integral.shlp, doc/integral.tex, doc/isbound.shlp, doc/isbound.tex, doc/log.shlp, doc/log.tex, doc/minus.shlp, doc/minus.tex, doc/printxml.tex, doc/proc.shlp, doc/proc.tex, doc/readxml.shlp, doc/readxml.tex, doc/remez.shlp, doc/remez.tex, doc/restart.tex, doc/return.shlp, doc/return.tex, doc/searchgal.shlp, doc/searchgal.tex, doc/sollya.pdf, doc/sollya.tex, doc/subpoly.shlp, doc/subpoly.tex, doc/substitute.shlp, doc/substitute.tex, doc/timing.tex, doc/verbosity.shlp, doc/verbosity.tex, doc/void.shlp, doc/void.tex, doc/write.shlp, doc/write.tex, execute.c, help.h, xml.c: Some changes This commit was extracted from SVN r735. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@735 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-17 jmio17 * autodiff.c: added POW case (f^g, f^ct, ct^f, ct^ct) This commit was extracted from SVN r734. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@734 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-17 jmio17 * sollya.h: added extern node* simplifyTreeErrorfree(node *tree); This commit was extracted from SVN r733. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@733 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-17 schevill * doc/fpminimax.shlp, doc/fpminimax.tex, help.h: Some explanations in the documentation of fpminimax This commit was extracted from SVN r732. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@732 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-17 clauter * doc/approx.shlp, doc/approx.tex, doc/introExample1.tex, doc/keywords.def, doc/sollya.pdf, execute.c: Corrected a warning text This commit was extracted from SVN r731. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@731 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-17 clauter * doc/CommandsAndFunctions.tex, doc/shlp2tex.sh: Added help for ~ This commit was extracted from SVN r730. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@730 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-17 clauter * doc/approx.shlp, doc/approx.tex: Updated documentation -- 2 This commit was extracted from SVN r729. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@729 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-17 clauter * doc/keywords.def, doc/sollya.pdf, help.h: Updated documentation This commit was extracted from SVN r728. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@728 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-17 clauter * ChangeLog: Updated Changelog file This commit was extracted from SVN r727. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@727 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-17 clauter * execute.c, library.c: Patched some memory leaks This commit was extracted from SVN r726. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@726 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-17 clauter * sturm.c: Speeded up getNrRoots on typical examples by a factor of 500 This commit was extracted from SVN r725. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@725 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-15 clauter * sollya.h, sturm.c: Improved handling of rational coefficients in Sturm This commit was extracted from SVN r724. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@724 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-15 clauter * INSTALL: Patching the 'a changé de statut spécial de façon inattendue' error - step 2 This commit was extracted from SVN r723. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@723 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-15 clauter * INSTALL: Patching the 'a changé de statut spécial de façon inattendue' error - step 1 This commit was extracted from SVN r722. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@722 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-15 clauter * sturm.c: Slightly changed FP coefficient handling in sturm external procedure This commit was extracted from SVN r721. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@721 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-15 clauter * doc/sollya.pdf, doc/sollya.tex: Reedited documentation This commit was extracted from SVN r720. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@720 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-15 clauter * doc/asciiplot.shlp, doc/asciiplot.tex, doc/sollya.pdf, doc/sollya.tex, general.c, help.h: Updated documentation, changed slightly the --help option behaviour This commit was extracted from SVN r719. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@719 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-15 clauter * general.c: Changed option syntax and added --help option This commit was extracted from SVN r718. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@718 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-12 jmio17 * sollya.h: changed signature of evaluateFaithful This commit was extracted from SVN r717. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@717 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-12 jmio17 * sturm.c: modified to find all distinct roots in the closed interval [a,b], a<=b. This commit was extracted from SVN r716. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@716 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-12 schevill * fpminimax.cpp: Added a dummy wrapper for printing FPLLL matrices This commit was extracted from SVN r715. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@715 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-12 jmio17 * sturm.c: Added sturm algo for obtaining the number of distinct roots of a polynomial. This commit was extracted from SVN r714. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@714 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-08 clauter * Makefile.am, configure.ac, tests/Makefile.am, tests/check.proto, tests/check.sollya, tests/check.sollya.output: Added first check environment This commit was extracted from SVN r713. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@713 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-08 clauter * AUTHORS, configure.ac, doc/fixed.tex, doc/floating.tex, doc/fpminimax.tex, doc/implementpoly.tex, doc/introExample1.tex, doc/introExample8.tex, doc/minus.tex, doc/remez.tex, doc/sollya.pdf, doc/sollya.tex, doc/subpoly.tex, doc/timing.tex, help.h, lexer.l: Patched failures in read when file did not exist This commit was extracted from SVN r712. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@712 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-08 clauter * lexer.l: Patched memory leak in lexer This commit was extracted from SVN r711. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@711 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-05 clauter * general.c: Patched color handling behaviour -- if colors do not work with your rlwrap, update our rlwrap or use the -oldrlwrapcompatible option This commit was extracted from SVN r710. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@710 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-03 clauter * internparser.y: Patched once again parser for unary plus and minus -- 2nd step This commit was extracted from SVN r709. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@709 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-03 clauter * general.c, general.h, parser.y: Patched once again parser for unary plus and minus -- 1st step This commit was extracted from SVN r708. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@708 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-03 clauter * internparser.y: Patched display and parsing of negation -- 2nd step This commit was extracted from SVN r707. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@707 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-03 clauter * expression.c, parser.y: Patched display and parsing of negation -- 1st step This commit was extracted from SVN r706. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@706 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-09-01 schevill * configure.ac, fpminimax.cpp: Minor changes for compatibility with fplll 3 This commit was extracted from SVN r705. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@705 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-30 clauter * ChangeLog: New changelog This commit was extracted from SVN r704. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@704 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-30 clauter * general.c, library.c, plot.c: Made Sollya compile under Cygwin, a warning persists under compilatio, Sollya library untested, externalproc, externalplot and library function untested, asciiplot plots always for a 77x24 character terminal because ioctrl impossible. This commit was extracted from SVN r703. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@703 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 clauter * doc/sollya.pdf, parser.y: New version This commit was extracted from SVN r702. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@702 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 schevill * sollya.h: updated sollya.h with the signature of FPminimax This commit was extracted from SVN r701. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@701 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 schevill * doc/introExample11.sollya, doc/introExample2.sollya, doc/introExample3.sollya, doc/introExample3.tex, doc/introExample4.sollya, doc/introExample5.sollya, doc/introExample6.sollya, doc/introExample6.tex, doc/sollya.pdf, doc/sollya.tex: updated the examples in introduction of the manual. This commit was extracted from SVN r700. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@700 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 clauter * doc/Makefile.am, doc/introExample1.tex: Some updates This commit was extracted from SVN r699. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@699 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 schevill * doc/compileExamples.sh, doc/example1.tex, doc/example1.txt, doc/example10.tex, doc/example10.txt, doc/example11.tex, doc/example11.txt, doc/example12.tex, doc/example12.txt, doc/example13.tex, doc/example13.txt, doc/example14.tex, doc/example14.txt, doc/example15.tex, doc/example15.txt, doc/example16.tex, doc/example16.txt, doc/example17.tex, doc/example17.txt, doc/example18.tex, doc/example18.txt, doc/example19.tex, doc/example19.txt, doc/example2.tex, doc/example2.txt, doc/example20.tex, doc/example20.txt, doc/example21.tex, doc/example21.txt, doc/example22.tex, doc/example22.txt, doc/example23.tex, doc/example23.txt, doc/example24.tex, doc/example24.txt, doc/example25.tex, doc/example25.txt, doc/example26.tex, doc/example26.txt, doc/example27.tex, doc/example27.txt, doc/example28.tex, doc/example28.txt, doc/example29.tex, doc/example29.txt, doc/example3.tex, doc/example3.txt, doc/example30.tex, doc/example30.txt, doc/example31.tex, doc/example31.txt, doc/example4.tex, doc/example4.txt, doc/example5.tex, doc/example5.txt, doc/example6.tex, doc/example6.txt, doc/example7.tex, doc/example7.txt, doc/example8.tex, doc/example8.txt, doc/example9.tex, doc/example9.txt, doc/introExample1.sollya, doc/introExample1.tex, doc/introExample10.sollya, doc/introExample10.tex, doc/introExample11.sollya, doc/introExample11.tex, doc/introExample12.sollya, doc/introExample12.tex, doc/introExample13.sollya, doc/introExample13.tex, doc/introExample14.sollya, doc/introExample14.tex, doc/introExample15.sollya, doc/introExample15.tex, doc/introExample16.sollya, doc/introExample16.tex, doc/introExample17.sollya, doc/introExample17.tex, doc/introExample18.sollya, doc/introExample18.tex, doc/introExample19.sollya, doc/introExample19.tex, doc/introExample2.sollya, doc/introExample2.tex, doc/introExample20.sollya, doc/introExample20.tex, doc/introExample21.sollya, doc/introExample21.tex, doc/introExample22.sollya, doc/introExample22.tex, doc/introExample23.sollya, doc/introExample23.tex, doc/introExample24.sollya, doc/introExample24.tex, doc/introExample25.sollya, doc/introExample25.tex, doc/introExample26.sollya, doc/introExample26.tex, doc/introExample27.sollya, doc/introExample27.tex, doc/introExample28.sollya, doc/introExample28.tex, doc/introExample29.sollya, doc/introExample29.tex, doc/introExample3.sollya, doc/introExample3.tex, doc/introExample30.sollya, doc/introExample30.tex, doc/introExample31.sollya, doc/introExample31.tex, doc/introExample4.sollya, doc/introExample4.tex, doc/introExample5.sollya, doc/introExample5.tex, doc/introExample6.sollya, doc/introExample6.tex, doc/introExample7.sollya, doc/introExample7.tex, doc/introExample8.sollya, doc/introExample8.tex, doc/introExample9.sollya, doc/introExample9.tex: Changed names of example files for the introduction. Updated compileExamples.sh This commit was extracted from SVN r698. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@698 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 clauter * doc/grammar.tex, doc/sollya.pdf, doc/sollya.tex: Removed grammar from help This commit was extracted from SVN r697. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@697 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 clauter * lexer.l: Made prompt come back after a comment started by // This commit was extracted from SVN r696. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@696 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 clauter * doc/accurateinfnorm.tex, doc/asciiplot.tex, doc/bashexecute.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/divide.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/evaluate.tex, doc/findzeros.tex, doc/fpminimax.tex, doc/hopitalrecursions.tex, doc/implementpoly.tex, doc/isevaluable.tex, doc/length.tex, doc/midpointmode.tex, doc/pi.tex, doc/points.tex, doc/print.tex, doc/printexpansion.tex, doc/remez.tex, doc/roundingwarnings.tex, doc/searchgal.tex, doc/simplify.tex, doc/sollya.pdf, doc/subpoly.tex, doc/timing.tex, doc/tripledouble.tex, doc/verbosity.tex, doc/worstcase.tex, help.h: New help text example compilation This commit was extracted from SVN r695. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@695 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 clauter * Makefile.am, configure.ac: Added fpminimax to libsollya This commit was extracted from SVN r694. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@694 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 schevill * execute.c, fpminimax.cpp, sollya.h: FPminimax does not construct an node of type error anymore. Now, it returns NULL and the error is generated in execute.c FPminimax does not handle singular matrices but does not crash on such matrices: it just returns an error Memory leak corrected in FPminimax. This commit was extracted from SVN r693. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@693 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 clauter * configure.ac, general.c: Colored SIGNAL handler messages This commit was extracted from SVN r692. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@692 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 schevill * general.c, plot.c, remez.c: removed some warnings This commit was extracted from SVN r691. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@691 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 schevill * README: Added information about how to configure sollya for compiling with g++-4.2 This commit was extracted from SVN r690. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@690 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 schevill * README: Updated README to include a warning about the version of g++ used to compile Sollya. This commit was extracted from SVN r689. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@689 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 clauter * configure.ac: New version of configure.ac for fplll (final) This commit was extracted from SVN r688. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@688 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 clauter * configure.ac: New version of configure.ac for fplll (communication version) This commit was extracted from SVN r687. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@687 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 clauter * configure.ac: New version of configure.ac for fplll (2) This commit was extracted from SVN r686. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@686 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 clauter * configure.ac: New version of configure.ac for fplll This commit was extracted from SVN r685. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@685 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-29 clauter * configure.ac, fpminimax.cpp: Added test for fplll in configure This commit was extracted from SVN r684. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@684 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-28 clauter * expression.c: Patched a very dangerous bug in binomial expression expansion affecting the sign of the monomials in the expansion. THIS CODE IS CALLED FROM EVERYWHERE EACH TIME A POLYNOMIAL IS HANDLED! Please re-check all results previously obtained using Sollya. This commit was extracted from SVN r683. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@683 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-28 schevill * doc/sollya.pdf: corrected a typo. This commit was extracted from SVN r682. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@682 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-28 schevill * doc/fpminimax.shlp, doc/fpminimax.tex, help.h: corrected a typo. This commit was extracted from SVN r681. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@681 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-28 clauter * execute.c: Really speeded up conversion of decimal constants This commit was extracted from SVN r680. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@680 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-28 clauter * doc/sollya.pdf, general.c: Patched coloring on timing information - I do not why it was blue This commit was extracted from SVN r679. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@679 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-28 schevill * fpminimax.cpp: Updated the message relative to the installation of fplll This commit was extracted from SVN r678. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@678 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-19 schevill * remez.c: New version of guessdegree much *much* more efficient. This commit was extracted from SVN r677. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@677 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-12 schevill * fpminimax.cpp: The dummy wrapper is more easy to comment now. This commit was extracted from SVN r676. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@676 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-12 schevill * fpminimax.cpp: Now sollya compiles with recent versions of g++. This commit was extracted from SVN r675. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@675 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-12 schevill * fpminimax.cpp, fpminimax.h: New files for fpminimax This commit was extracted from SVN r674. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@674 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-12 schevill * Makefile.am, README, assignment.c, assignment.h, chain.c, chain.h, double.c, double.h, execute.c, execute.h, expression.c, expression.h, external.c, fpminimax.c, fpminimax.h, general.h, help.h, infnorm.c, infnorm.h, internlexer.l, internparser.y, lexer.l, parser.y, plot.c, remez.c, remez.h, sollya.h: * Added: fixed, floating, and fpminimax. * Corrected a memory leak in function sprintValue of file expression.c * Corrected a bug in the informations displayed by plot and externalplot (buffer was badly flushed) * Updated help * Moved rationapprox code in file double.c * Moved a lot of useful functions that were in several files all together in chain.c (freeMpfiPtr, freeIntPtr, etc.) * Added useful declarations in sollya.h * Enhanced Newton's algorithm used by remez and dirtyfindzeros: an exact zero is detected more quickly now. This commit was extracted from SVN r673. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@673 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-12 schevill * doc/checkinfnorm.shlp, doc/checkinfnorm.tex, doc/equal.shlp, doc/equal.tex, doc/infnorm.shlp, doc/infnorm.tex, doc/parse.shlp, doc/parse.tex, doc/power.shlp, doc/power.tex, doc/printexpansion.tex, doc/remez.tex, doc/sollya.pdf, doc/subpoly.tex: Corrected a few things and updated the examples with current version of sollya. This commit was extracted from SVN r672. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@672 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-12 schevill * doc/fixed.tex, doc/floating.tex, doc/fpminimax.shlp, doc/fpminimax.tex: I forgot to add tex files This commit was extracted from SVN r671. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@671 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-12 schevill * doc/CommandsAndFunctions.tex, doc/compileExamples.sh, doc/example.sollya, doc/example1.tex, doc/example1.txt, doc/example10.tex, doc/example10.txt, doc/example11.tex, doc/example11.txt, doc/example12.tex, doc/example12.txt, doc/example13.tex, doc/example13.txt, doc/example14.tex, doc/example14.txt, doc/example15.tex, doc/example15.txt, doc/example16.tex, doc/example16.txt, doc/example17.tex, doc/example17.txt, doc/example18.tex, doc/example18.txt, doc/example19.tex, doc/example19.txt, doc/example2.tex, doc/example2.txt, doc/example20.tex, doc/example20.txt, doc/example21.tex, doc/example21.txt, doc/example22.tex, doc/example22.txt, doc/example23.tex, doc/example23.txt, doc/example24.tex, doc/example24.txt, doc/example25.tex, doc/example25.txt, doc/example26.tex, doc/example26.txt, doc/example27.tex, doc/example27.txt, doc/example28.tex, doc/example28.txt, doc/example29.tex, doc/example29.txt, doc/example3.tex, doc/example3.txt, doc/example30.tex, doc/example30.txt, doc/example31.tex, doc/example31.txt, doc/example4.tex, doc/example4.txt, doc/example5.tex, doc/example5.txt, doc/example6.tex, doc/example6.txt, doc/example7.tex, doc/example7.txt, doc/example8.tex, doc/example8.txt, doc/example9.tex, doc/example9.txt, doc/fixed.shlp, doc/floating.shlp, doc/infnorm.shlp, doc/infnorm.tex, doc/keywords.def, doc/plot.shlp, doc/plot.tex, doc/sollya.pdf, doc/sollya.tex, doc/types.def: * Added a script compileExamples.sh that lets one write easily an example for the documentation of sollya, out of a .shlp file. The examples in the first sections of the documentation are now written in separate files and may be recompiled at any time with compileExamples. * Added documentation for fixed, floating and fpminimax. * Corrected a few things in other documentation files. This commit was extracted from SVN r670. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@670 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-08-01 clauter * sollya.h: Added printInterval to sollya.h This commit was extracted from SVN r669. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@669 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-29 jmio17 * autodiff.c: added auto diff base functions: tan,asin, acos ... modified pow This commit was extracted from SVN r668. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@668 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-25 schevill * internparser.y, parser.y: I forgot to suppress references to pari.h in these internparser.y and parser.y This commit was extracted from SVN r667. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@667 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-25 schevill * autodiff.c: Implementation of base_diffs for sin, cos, sinh, cosh, log, log2, log10, exp and sqrt. This commit was extracted from SVN r666. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@666 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-25 schevill * autodiff.c: Implementation of exp. Note that I rewrote the base case for x^p : p may be any value (not only integer) and the results should be more accurate when the input interval is large. This commit was extracted from SVN r665. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@665 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-25 schevill * autodiff.c: First implementation of the multiplication. This commit was extracted from SVN r664. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@664 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-25 schevill * autodiff.c: Incomplete version of autodiff. For working purpose This commit was extracted from SVN r663. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@663 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-25 schevill * Makefile.am, README, configure.ac, doc/sollya.pdf, doc/sollya.tex, fpminimax.c, general.c, pari_utils.c, pari_utils.h: Removed dependance to PARI/GP. This commit was extracted from SVN r662. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@662 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-24 clauter * parser.y: Added Mioara This commit was extracted from SVN r661. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@661 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-24 clauter * ChangeLog, configure.ac: Applied patch provided by Christophe Mouilleron This commit was extracted from SVN r660. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@660 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-24 schevill * sollya.h: update of sollya.h in order to allow more possibilities This commit was extracted from SVN r659. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@659 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-16 clauter * internlexer.l, internparser.y: Added floating-point approximation mode (forgot something) This commit was extracted from SVN r658. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@658 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-16 clauter * execute.c, execute.h, lexer.l, parser.y: Added floating-point approximation mode This commit was extracted from SVN r657. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@657 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-08 clauter * infnorm.c: Patched color handling on a warning message in infnorm This commit was extracted from SVN r656. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@656 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-07-03 schevill * remez.c: Christoph introduced a bug in the printing of the line "A slower algorithm is used for this step (pseudo-alternating condition changed)" when he introduced the coloring. It is corrected. This commit was extracted from SVN r655. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@655 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-27 schevill * remez.c: Avoid infinite looping when reaching the maximum allowed iterations of the algorithm This commit was extracted from SVN r654. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@654 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-24 schevill * remez.c: I forgot the initialization of variable HaarCompliant This commit was extracted from SVN r653. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@653 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-24 clauter * expression.c, expression.h: Improved precision management on constants This commit was extracted from SVN r652. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@652 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-24 schevill * remez.c: When there is too many oscillations, the algorithm should use the exchange algorithm. In the particular case when the algorithm did not use the slower algorithm, this error was caught at the end by a call to dirtyinfnorm but nothing was done to solve the problem. Now, the main loop is relaunched forcing an exchange step. Hopefully, this will introduce the maximum and converge. The convergence should not be taken for sure. This commit was extracted from SVN r651. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@651 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-18 schevill * remez.c: A quality less than ~ 2^(-53) used to lead to an error. However, the polynomial was correctly computed: it was a bug affecting the final test. It is now corrected This commit was extracted from SVN r650. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@650 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-17 schevill * double.c, execute.c, expression.c, expression.h, external.c, fpminimax.c, infnorm.c, plot.c, remez.c, worstcase.c: suppressed useless argument prec of printValue This commit was extracted from SVN r649. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@649 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-10 schevill * execute.c, expression.c, remez.c, worstcase.c: suppressed some warnings This commit was extracted from SVN r648. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@648 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-09 schevill * double.c, execute.c: suppressed some warnings This commit was extracted from SVN r647. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@647 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-09 schevill * xml.c: suppressed some warnings This commit was extracted from SVN r646. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@646 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-09 schevill * assignment.c, expression.c, expression.h, general.c, general.h, proof.c: suppressed some warnings This commit was extracted from SVN r645. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@645 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-09 schevill * double.c, execute.c, xml.c: suppressed some warnings This commit was extracted from SVN r644. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@644 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-09 schevill * fpminimax.c, general.h, infnorm.c, remez.c: suppressed some warnings This commit was extracted from SVN r643. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@643 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-09 clauter * integral.c: Added faithful rounded evaluation to dirtyintegral This commit was extracted from SVN r642. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@642 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-06 clauter * internlexer.l, lexer.l: reduced once again list of special characters in identifiers This commit was extracted from SVN r641. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@641 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-06 schevill * doc/autosimplify.tex, doc/midpointmode.tex, doc/print.tex, doc/sollya.pdf, help.h: changed doc This commit was extracted from SVN r640. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@640 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-06 schevill * doc/accurateinfnorm.tex, doc/autosimplify.shlp, doc/autosimplify.tex, doc/canonical.shlp, doc/canonical.tex, doc/default.shlp, doc/default.tex, doc/display.shlp, doc/display.tex, doc/fullparentheses.shlp, doc/fullparentheses.tex, doc/midpointmode.tex, doc/print.tex, doc/sollya.pdf, doc/sollya.tex: updated some doc files This commit was extracted from SVN r639. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@639 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-06 clauter * internlexer.l, lexer.l: Patched special character set in identifiers This commit was extracted from SVN r638. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@638 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-05 clauter * execute.c, execute.h, expression.c, general.c, general.h, internlexer.l, internparser.y, lexer.l, parser.y: Correct midpoint mode on display and parsing This commit was extracted from SVN r637. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@637 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-04 clauter * execute.c, general.c, internlexer.l, internparser.y, lexer.l, parser.y: Some additional features This commit was extracted from SVN r636. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@636 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 clauter * doc/accurateinfnorm.tex, doc/asciiplot.tex, doc/bashexecute.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/display.tex, doc/doubleextended.tex, doc/evaluate.tex, doc/hopitalrecursions.tex, doc/implementpoly.tex, doc/infnorm.tex, doc/integral.tex, doc/isevaluable.tex, doc/pi.tex, doc/points.tex, doc/print.tex, doc/remez.tex, doc/roundingwarnings.tex, doc/searchgal.tex, doc/simplify.tex, doc/sollya.pdf, doc/subpoly.tex, doc/taylorrecursions.tex, doc/timing.tex, doc/tripledouble.tex, doc/verbosity.tex, doc/worstcase.tex, help.h: Recompiled doc after patching bugs This commit was extracted from SVN r635. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@635 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 clauter * expression.c, infnorm.c: Patched a lot of bugs This commit was extracted from SVN r634. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@634 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 clauter * doc/canonical.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/honorcoeffprec.tex, doc/implementpoly.tex, doc/pi.tex, doc/printexpansion.tex, doc/printfloat.tex, doc/printhexa.tex, doc/roundcoefficients.tex, doc/sollya.pdf, doc/timing.tex, doc/tripledouble.tex, doc/verbosity.tex, help.h: Recompiled once again the documentation This commit was extracted from SVN r633. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@633 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 schevill * doc/canonical.shlp, doc/shlp2tex.sh, doc/shlp2txt.sh: activated roundingwarnings by default in the examples of the documentation. Minor patch in canonical.shlp This commit was extracted from SVN r632. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@632 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 clauter * doc/roundingwarnings.tex, doc/sollya.pdf: Transfer commit This commit was extracted from SVN r631. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@631 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 clauter * doc/sollya.pdf, help.h: recompiled parts of docu This commit was extracted from SVN r630. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@630 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 schevill * doc/roundingwarnings.tex, doc/suppresswarnings.tex: moved suppresswarnings.tex into roundindwarnings.tex This commit was extracted from SVN r629. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@629 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 clauter * configure.ac, doc/canonical.tex, doc/sollya.pdf, doc/sollya.tex, doc/timing.tex, help.h: Recompiled once again help texts, adapted manual documentation to new behaviour This commit was extracted from SVN r628. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@628 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 clauter * expression.c: Patched a real big bug in coefficient extraction on multiplicative horner terms This commit was extracted from SVN r627. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@627 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 clauter * doc/accurateinfnorm.tex, doc/asciiplot.tex, doc/canonical.tex, doc/checkinfnorm.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/display.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/equal.tex, doc/evaluate.tex, doc/ge.tex, doc/honorcoeffprec.tex, doc/hopitalrecursions.tex, doc/implementpoly.tex, doc/infnorm.tex, doc/integral.tex, doc/isevaluable.tex, doc/le.tex, doc/library.tex, doc/lt.tex, doc/neq.tex, doc/parse.tex, doc/pi.tex, doc/plot.tex, doc/points.tex, doc/power.tex, doc/print.tex, doc/printexpansion.tex, doc/printfloat.tex, doc/printhexa.tex, doc/remez.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/searchgal.tex, doc/simplify.tex, doc/sollya.pdf, doc/subpoly.tex, doc/substitute.tex, doc/taylorrecursions.tex, doc/timing.tex, doc/tripledouble.tex, doc/worstcase.tex, help.h: Recompiled help texts This commit was extracted from SVN r626. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@626 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 schevill * execute.c, help.h, internlexer.l, lexer.l, parser.y: Changed suppressroundingwarnings into roundingwarnings This commit was extracted from SVN r625. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@625 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 schevill * doc/roundingwarnings.shlp, doc/suppresswarnings.shlp: Changed suppresswarnings.shlp into roundingwarnings.shlp This commit was extracted from SVN r624. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@624 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-02 schevill * doc/CommandsAndFunctions.tex, doc/keywords.def, doc/midpointmode.shlp, doc/midpointmode.tex, doc/sollya.pdf, doc/suppresswarnings.shlp, doc/verbosity.shlp, doc/verbosity.tex: Changed suppressroundingwarnings into roundingwarnings This commit was extracted from SVN r623. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@623 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-06-01 clauter * general.c: Still better rlwrap compatibility This commit was extracted from SVN r622. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@622 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-30 clauter * execute.c, plot.c: Still better rlwrap and color compatibility This commit was extracted from SVN r621. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@621 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-30 clauter * execute.c: Better rlwrap compatiblity for color mode This commit was extracted from SVN r620. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@620 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-29 clauter * general.c: Restore color mode upon recovering from error This commit was extracted from SVN r619. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@619 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-29 clauter * general.c: Speeded up color mode switching This commit was extracted from SVN r618. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@618 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-29 clauter * general.c: Improved color mode handling in scripts and added compatibility flags '-nocolor' and '-noprompt' This commit was extracted from SVN r617. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@617 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-28 clauter * doc/CommandsAndFunctions.tex, doc/keywords.def, doc/midpointmode.shlp, doc/midpointmode.tex, doc/sollya.pdf, doc/suppresswarnings.shlp, doc/suppresswarnings.tex, doc/verbosity.shlp, doc/verbosity.tex, help.h, parser.y: Added suppressroundingwarnings to docu This commit was extracted from SVN r616. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@616 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-28 clauter * general.c, general.h, plot.c: Added still more colors This commit was extracted from SVN r615. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@615 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-28 clauter * execute.c, expression.c, external.c, general.c, general.h, implement.c, infnorm.c, parser.y, plot.c, remez.c, worstcase.c: Added coloring This commit was extracted from SVN r614. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@614 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-28 clauter * internparser.y, miniparser.y, parser.y: Changed implicit parenthesation order for power operator ^ This commit was extracted from SVN r613. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@613 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-23 schevill * infnorm.c: Patched evaluate in order to handle correctly intervals containing NaN This commit was extracted from SVN r612. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@612 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-22 clauter * execute.c, expression.c: Patched small bug concerning precision handling on autoprint display of negative, unevaluated values This commit was extracted from SVN r611. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@611 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-21 clauter * expression.c: Patched new expression handling behaviour This commit was extracted from SVN r610. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@610 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-20 clauter * expression.c: Some optimizations to expression tree handling This commit was extracted from SVN r609. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@609 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-20 clauter * expression.c, infnorm.c: Changed slightly the heuristics for differentiating polynomials This commit was extracted from SVN r608. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@608 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-20 clauter * expression.c: Changed verbosity levels in expression handling This commit was extracted from SVN r607. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@607 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-19 clauter * execute.c, expression.c: Changed behaviour in converting literal constants to internal binary floating-point format - less rounding occurs This commit was extracted from SVN r606. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@606 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-19 clauter * infnorm.c: Changed behaviour of 1/x in 0 to [-infty;infty] This commit was extracted from SVN r605. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@605 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-18 clauter * internlexer.l, lexer.l, minilexer.l: Added infty, @Inf@, nan, NaN, NAN, @NaN@ lexing/ parsing capability This commit was extracted from SVN r604. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@604 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-18 clauter * infnorm.c: Patched behaviour on divison by only value 0 This commit was extracted from SVN r603. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@603 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-17 clauter * execute.c: Improved code size in execute, patched a bug in autoprint This commit was extracted from SVN r602. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@602 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-15 schevill * expression.c: Corrected frenglish "Remplacing" expression. This commit was extracted from SVN r601. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@601 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-05-12 schevill * remez.c: Corrected a bug leading to segfault when remez was called with only one monomial. This commit was extracted from SVN r600. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@600 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-04-29 schevill * remez.c: patched a big bug with the random perturbation This commit was extracted from SVN r599. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@599 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-04-29 schevill * remez.c: The initial set of points is now randomly perturbed in order to avoid singular matrices. It seems to enhance considerably the behavior of the algorithm in the bad cases. This commit was extracted from SVN r598. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@598 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-04-29 clauter * expression.c: Patched bug in printing NaNs and Infs This commit was extracted from SVN r597. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@597 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-04-29 clauter * infnorm.c: Patched evaluate(1/x,[-1;1]) behaviour This commit was extracted from SVN r596. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@596 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-04-28 clauter * expression.c: Changed information level This commit was extracted from SVN r595. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@595 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-04-28 schevill * remez.c: Corrected some bugs, in particular one in guessdegee that lead to a segfault. This commit was extracted from SVN r594. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@594 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-04-27 clauter * expression.c: Corrected precision handling in displaying of decimal values This commit was extracted from SVN r593. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@593 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-04-25 schevill * remez.c: Added heuristics to make the algorithm more robust. Corrected few bugs as well. The code is still not perfect. It seems to perform too much exchange steps. However this does not compromise the algorithm. This commit was extracted from SVN r592. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@592 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-04-25 schevill * remez.c: Changed temporarily the maximal number of loops in remez algorithm This commit was extracted from SVN r591. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@591 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-04-25 schevill * infnorm.c: patched a bug leading to an infinite loop in dirtyinfnorm This commit was extracted from SVN r590. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@590 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-04-25 schevill * remez.c: MAJOR MODIFICATION: this is a first try to integrate the exchange algorithm into the current implementation of remez command. Since it merges two different algorithms (second algorithm and exchange algorithm) into a single program, I am completely unsure of the stability of this new implementation. However, the new implementation should always give a correct minimax when it finishes normally. In the case when the Haar condition is fulfilled, the algorithm should be at most twice slower than the old implementation. This is provided as a temporary and experimental implementation before a safer and faster one in the next few weeks. This commit was extracted from SVN r589. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@589 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-03-30 clauter * double.c, execute.c, execute.h, expression.c, general.c, general.h, implement.c, internlexer.l, internparser.y, lexer.l, miniparser.y, parser.y, taylor.c, xml.c: Added warning suppression for rounding warnings. This commit was extracted from SVN r588. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@588 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-03-17 clauter * expansion.c: Added timing support for external polynomial evaluation codes. This commit was extracted from SVN r587. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@587 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-02-29 schevill * remez.c: Corrected a bug in Remez' algorithm. More precisely, when there is only n+1 oscillations in the interval, we have to choose one of the bounds. The way it was done did not check if the alternation property was fulfilled. It is now the case. This commit was extracted from SVN r586. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@586 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-02-19 schevill * remez.c: added a message that prints the norm of the current polynomial whenever Remez' algorithm crashes because there are not enough oscillations. This commit was extracted from SVN r585. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@585 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-16 schevill * execute.c: Same bug as in plot corrected for externalplot This commit was extracted from SVN r584. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@584 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-16 schevill * ChangeLog, execute.c: bug in default case of plot command corrected This commit was extracted from SVN r583. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@583 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-16 clauter * doc/Makefile.am, doc/sollya.pdf: Patched Makefile error in distribution This commit was extracted from SVN r582. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@582 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-16 clauter * general.c: Added mpfr_free_cache call at the end of the tool This commit was extracted from SVN r581. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@581 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-16 clauter * doc/Makefile.am, pari_utils.c: Corrected svn This commit was extracted from SVN r580. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@580 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-16 clauter * Makefile.am, configure.ac, doc/sollya.pdf, doc/sollya.tex: Added sollya.pdf build to make dist This commit was extracted from SVN r579. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@579 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-16 clauter * README, autogen.sh, configure.ac: Patched build files for overcoming the bug encountered on John Harrison's computer. Work in progress. This commit was extracted from SVN r578. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@578 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-09 schevill * remez.c: More explicits message when the curve fails to oscillate sufficiently. This commit was extracted from SVN r577. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@577 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-09 clauter * execute.c: Patched error message on guessdegree failure This commit was extracted from SVN r576. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@576 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-09 schevill * remez.c: corrected a bug concerning the verbosity and defaultpoints in guessdegree This commit was extracted from SVN r575. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@575 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-09 clauter * execute.c: Patched guessdegree behaviour in interpreter This commit was extracted from SVN r574. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@574 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-08 schevill * doc/externalproc.shlp, doc/externalproc.tex, doc/sollya.pdf, help.h: Corrected a bug in the doc This commit was extracted from SVN r573. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@573 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-08 clauter * README, configure.ac: Added MPFR version checking to configure script -- following mail exchange with N. Brisebarre This commit was extracted from SVN r572. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@572 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-07 schevill * README: Added a mention about the necessity of GMP This commit was extracted from SVN r571. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@571 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-07 schevill * doc/sollya.tex: Added a mention about the necessity of GMP This commit was extracted from SVN r570. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@570 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-05 clauter * ChangeLog, doc/proc.tex, doc/sollya.pdf, doc/taylor.tex, help.h: Compiled versions of new help texts This commit was extracted from SVN r569. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@569 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-05 clauter * doc/proc.shlp, doc/sollya.tex, doc/taylor.shlp: Patched some documentation files This commit was extracted from SVN r568. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@568 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-04 clauter * parser.y: Improved help help command This commit was extracted from SVN r567. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@567 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-04 clauter * assignment.c, assignment.h, chain.c, chain.h, doc/sollya.pdf, doc/sollya.tex, doc/timing.tex, double.c, double.h, execute.c, execute.h, expansion.c, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.c, fpminimax.h, general.c, general.h, help.h, implement.c, implement.h, infnorm.c, infnorm.h, integral.c, integral.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, libsollyaexample.c, main.c, main.h, minilexer.l, miniparser.y, pari_utils.c, pari_utils.h, parser.y, plot.c, plot.h, proof.c, proof.h, remez.c, remez.h, sollya.h, taylor.c, taylor.h, worstcase.c, worstcase.h, xml.c, xml.h: Small changes in documentation This commit was extracted from SVN r566. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@566 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-04 clauter * doc/absolute.shlp, doc/absolute.tex, doc/accurateinfnorm.shlp, doc/accurateinfnorm.tex, doc/autosimplify.shlp, doc/autosimplify.tex, doc/bashexecute.tex, doc/binary.shlp, doc/binary.tex, doc/boolean.shlp, doc/boolean.tex, doc/canonical.shlp, doc/canonical.tex, doc/checkinfnorm.shlp, doc/checkinfnorm.tex, doc/constant.shlp, doc/constant.tex, doc/decimal.shlp, doc/decimal.tex, doc/denominator.shlp, doc/denominator.tex, doc/diff.shlp, doc/diff.tex, doc/display.shlp, doc/display.tex, doc/dyadic.shlp, doc/dyadic.tex, doc/error.shlp, doc/error.tex, doc/externalplot.shlp, doc/externalplot.tex, doc/externalproc.shlp, doc/externalproc.tex, doc/fullparentheses.shlp, doc/fullparentheses.tex, doc/function.shlp, doc/function.tex, doc/hexadecimal.shlp, doc/hexadecimal.tex, doc/implementpoly.shlp, doc/implementpoly.tex, doc/integer.shlp, doc/integer.tex, doc/neq.shlp, doc/neq.tex, doc/numerator.shlp, doc/numerator.tex, doc/parse.shlp, doc/parse.tex, doc/perturb.shlp, doc/perturb.tex, doc/powers.shlp, doc/powers.tex, doc/print.shlp, doc/print.tex, doc/printexpansion.shlp, doc/printexpansion.tex, doc/printfloat.shlp, doc/printfloat.tex, doc/printhexa.shlp, doc/printhexa.tex, doc/printxml.shlp, doc/printxml.tex, doc/proc.shlp, doc/proc.tex, doc/quit.shlp, doc/quit.tex, doc/range.shlp, doc/range.tex, doc/readfile.shlp, doc/readfile.tex, doc/readxml.shlp, doc/readxml.tex, doc/relative.shlp, doc/relative.tex, doc/restart.shlp, doc/restart.tex, doc/return.shlp, doc/return.tex, doc/roundcorrectly.shlp, doc/roundcorrectly.tex, doc/searchgal.shlp, doc/searchgal.tex, doc/simplifysafe.shlp, doc/simplifysafe.tex, doc/sollya.pdf, doc/string.shlp, doc/string.tex, doc/subpoly.shlp, doc/subpoly.tex, doc/taylor.shlp, doc/taylor.tex, doc/timing.tex, doc/var.shlp, doc/var.tex, doc/void.shlp, doc/void.tex, doc/write.shlp, doc/write.tex, execute.c, help.h: Corrected a bug in autoprint displaying of strings contained in lists This commit was extracted from SVN r565. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@565 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2008-01-04 clauter * infnorm.c: Patched a memory leak in infnorm This commit was extracted from SVN r564. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@564 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-21 clauter * infnorm.c: Patched a memory leak This commit was extracted from SVN r563. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@563 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-20 clauter * README, doc/sollya.pdf, doc/sollya.tex: Finished working on documentation This commit was extracted from SVN r562. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@562 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-20 schevill * execute.c, fpminimax.c, infnorm.c: * patched leaks. This commit was extracted from SVN r561. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@561 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-19 clauter * configure.ac: Changed Sollya version number This commit was extracted from SVN r560. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@560 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-19 clauter * doc/implementpoly.shlp, doc/implementpoly.tex, doc/sollya.pdf, help.h: Patched a small error in the documentation This commit was extracted from SVN r559. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@559 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-19 clauter * doc/CommandsAndFunctions.tex, doc/RD.shlp, doc/RD.tex, doc/RN.shlp, doc/RN.tex, doc/RU.shlp, doc/RU.tex, doc/RZ.shlp, doc/RZ.tex, doc/bashexecute.tex, doc/evaluate.shlp, doc/evaluate.tex, doc/implementpoly.shlp, doc/implementpoly.tex, doc/parse.shlp, doc/parse.tex, doc/pi.shlp, doc/pi.tex, doc/rd.shlp, doc/rd.tex, doc/readxml.shlp, doc/readxml.tex, doc/restart.shlp, doc/restart.tex, doc/rn.shlp, doc/rn.tex, doc/ru.shlp, doc/ru.tex, doc/rz.shlp, doc/rz.tex, doc/searchgal.shlp, doc/searchgal.tex, doc/sollya.pdf, doc/timing.tex, doc/void.shlp, doc/void.tex, help.h: Continued work on help texts. This commit was extracted from SVN r558. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@558 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-19 clauter * infnorm.c: Patched memory leak in infnorm with proof generation. This commit was extracted from SVN r557. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@557 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-19 clauter * doc/RD.tex, doc/RN.tex, doc/RU.tex, doc/RZ.tex, doc/abs.tex, doc/absolute.tex, doc/accurateinfnorm.tex, doc/acos.tex, doc/acosh.tex, doc/and.tex, doc/append.tex, doc/asciiplot.tex, doc/asin.tex, doc/asinh.tex, doc/atan.tex, doc/atanh.tex, doc/autosimplify.tex, doc/bashexecute.tex, doc/binary.tex, doc/boolean.tex, doc/canonical.tex, doc/ceil.tex, doc/checkinfnorm.tex, doc/coeff.tex, doc/concat.tex, doc/constant.tex, doc/cos.tex, doc/cosh.tex, doc/decimal.tex, doc/default.tex, doc/degree.tex, doc/denominator.tex, doc/diam.tex, doc/diff.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/display.tex, doc/divide.tex, doc/double.shlp, doc/double.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/dyadic.tex, doc/equal.tex, doc/erf.tex, doc/erfc.tex, doc/error.tex, doc/evaluate.tex, doc/execute.tex, doc/exp.tex, doc/expand.shlp, doc/expand.tex, doc/expm1.tex, doc/exponent.tex, doc/externalplot.tex, doc/externalproc.tex, doc/false.tex, doc/file.tex, doc/findzeros.tex, doc/floor.tex, doc/fullparentheses.tex, doc/function.tex, doc/ge.tex, doc/gt.tex, doc/guessdegree.tex, doc/head.tex, doc/hexadecimal.tex, doc/honorcoeffprec.tex, doc/hopitalrecursions.tex, doc/horner.tex, doc/implementpoly.shlp, doc/implementpoly.tex, doc/inf.tex, doc/infnorm.tex, doc/integer.tex, doc/integral.tex, doc/isbound.tex, doc/isevaluable.tex, doc/le.tex, doc/length.shlp, doc/length.tex, doc/library.tex, doc/listof.tex, doc/log.tex, doc/log10.tex, doc/log1p.tex, doc/log2.tex, doc/lt.tex, doc/mantissa.tex, doc/mid.shlp, doc/mid.tex, doc/midpointmode.tex, doc/minus.tex, doc/mult.tex, doc/neq.tex, doc/nop.tex, doc/not.tex, doc/numerator.tex, doc/off.tex, doc/on.tex, doc/or.tex, doc/parse.tex, doc/perturb.tex, doc/pi.shlp, doc/pi.tex, doc/plot.tex, doc/points.tex, doc/postscript.tex, doc/postscriptfile.tex, doc/power.shlp, doc/power.tex, doc/powers.tex, doc/prec.tex, doc/precision.shlp, doc/precision.tex, doc/prepend.tex, doc/print.tex, doc/printexpansion.tex, doc/printfloat.tex, doc/printhexa.tex, doc/printxml.shlp, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/quit.tex, doc/range.tex, doc/rationalapprox.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.tex, doc/remez.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/round.shlp, doc/round.tex, doc/roundcoefficients.shlp, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/searchgal.shlp, doc/searchgal.tex, doc/simplify.tex, doc/simplifysafe.tex, doc/sin.tex, doc/sinh.tex, doc/sollya.pdf, doc/sort.tex, doc/sqrt.shlp, doc/sqrt.tex, doc/string.tex, doc/subpoly.tex, doc/substitute.tex, doc/sup.tex, doc/tail.tex, doc/tan.shlp, doc/tan.tex, doc/tanh.shlp, doc/tanh.tex, doc/taylor.tex, doc/taylorrecursions.tex, doc/timing.tex, doc/tripledouble.tex, doc/true.tex, doc/var.shlp, doc/var.tex, doc/verbosity.tex, doc/void.shlp, doc/void.tex, doc/write.tex: Continued working on documentation This commit was extracted from SVN r556. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@556 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-19 clauter * doc/abs.shlp, doc/absolute.shlp, doc/externalproc.shlp, doc/grammar.tex, doc/sollya.pdf, doc/sollya.tex, doc/types.def: Continued working on documentation This commit was extracted from SVN r555. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@555 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-19 schevill * double.c, execute.c, expression.c, remez.c: * Corrected memory leaks * Added a test in Remez algorithm that prevents the command to return a false result when there is too many oscillations. This commit was extracted from SVN r554. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@554 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-19 schevill * doc/externalplot.tex, doc/shlp2tex.sh: patched version for handling pipes. This commit was extracted from SVN r553. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@553 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-18 schevill * doc/shlp2tex.sh, doc/worstcase.tex: patched shlp2tex in order to handle correctly tabulations in examples. This commit was extracted from SVN r552. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@552 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-18 schevill * doc/log.tex, doc/log2.tex, doc/plus.tex, doc/remez.tex, doc/shlp2tex.sh: patched shlp2tex in order to handle correctly labels of special function such as + etc. This commit was extracted from SVN r551. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@551 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-18 schevill * doc/remez.tex, doc/shlp2tex.sh: small bug fix This commit was extracted from SVN r550. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@550 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-18 schevill * doc/shlp2tex.sh: small bug fix. This commit was extracted from SVN r549. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@549 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-18 schevill * doc/remez.tex, doc/shlp2tex.sh: added hyperlink in seealso This commit was extracted from SVN r548. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@548 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-18 schevill * doc/remez.tex, doc/shlp2tex.sh: Now, labels work This commit was extracted from SVN r547. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@547 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-18 schevill * doc/remez.tex, doc/shlp2tex.sh: Added labels for each subsection in LaTeX mode. This commit was extracted from SVN r546. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@546 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-17 schevill * assignment.c, execute.c, expression.c, infnorm.c, plot.c, remez.c: Corrected memory leaks. This commit was extracted from SVN r545. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@545 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-17 clauter * general.c: Patched memory leak for timing This commit was extracted from SVN r544. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@544 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-17 clauter * execute.c, infnorm.c: Patched a memory leak. This commit was extracted from SVN r543. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@543 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-14 schevill * README: Added a comment explaining briefly what is Sollya. This commit was extracted from SVN r542. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@542 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-14 schevill * doc/sollya.tex: sollya.tex compatible with new shlp2tex This commit was extracted from SVN r541. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@541 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-14 schevill * doc/CommandsAndFunctions.tex, doc/RD.tex, doc/RN.tex, doc/RU.tex, doc/RZ.tex, doc/absolute.tex, doc/accurateinfnorm.tex, doc/and.tex, doc/append.tex, doc/asciiplot.tex, doc/autosimplify.tex, doc/bashexecute.tex, doc/canonical.tex, doc/checkinfnorm.tex, doc/coeff.tex, doc/concat.tex, doc/default.tex, doc/degree.tex, doc/denominator.tex, doc/diff.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/display.tex, doc/divide.tex, doc/double.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/equal.tex, doc/error.tex, doc/evaluate.tex, doc/execute.tex, doc/expand.tex, doc/exponent.tex, doc/externalplot.tex, doc/externalproc.tex, doc/false.tex, doc/file.tex, doc/findzeros.tex, doc/fullparentheses.tex, doc/ge.tex, doc/gt.tex, doc/guessdegree.tex, doc/head.tex, doc/honorcoeffprec.tex, doc/hopitalrecursions.tex, doc/horner.tex, doc/implementpoly.tex, doc/inf.tex, doc/infnorm.tex, doc/integral.tex, doc/isbound.tex, doc/isevaluable.tex, doc/keywords.def, doc/le.tex, doc/length.tex, doc/library.tex, doc/lt.tex, doc/mantissa.tex, doc/mid.tex, doc/midpointmode.tex, doc/minus.tex, doc/mult.tex, doc/neq.tex, doc/nop.tex, doc/not.tex, doc/numerator.tex, doc/off.tex, doc/on.tex, doc/or.tex, doc/parse.tex, doc/perturb.tex, doc/pi.tex, doc/plot.tex, doc/plus.tex, doc/points.tex, doc/postscript.tex, doc/postscriptfile.tex, doc/power.tex, doc/prec.tex, doc/precision.tex, doc/prepend.tex, doc/print.tex, doc/printexpansion.tex, doc/printfloat.tex, doc/printhexa.tex, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/quit.tex, doc/rationalapprox.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.tex, doc/remez.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/round.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/searchgal.tex, doc/shlp2tex.sh, doc/shlp2txt.sh, doc/simplify.tex, doc/simplifysafe.tex, doc/sort.tex, doc/subpoly.tex, doc/substitute.tex, doc/sup.tex, doc/tail.tex, doc/taylor.tex, doc/taylorrecursions.tex, doc/timing.tex, doc/tripledouble.tex, doc/true.tex, doc/var.tex, doc/verbosity.tex, doc/void.tex, doc/worstcase.tex, doc/write.tex: Upgrade of shlp2txt and shlp2tex. Examples are now correctly handled by shlp2tex. This commit was extracted from SVN r540. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@540 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-14 clauter * assignment.c, execute.c, expression.c, general.c, implement.c, proof.c: Patched *some* memory leaks. This commit was extracted from SVN r539. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@539 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-13 clauter * help.h, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y: Added licensing information to lexer and parser files This commit was extracted from SVN r538. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@538 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-13 clauter * COPYING, parser.y: Adapted version command. This commit was extracted from SVN r537. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@537 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-13 clauter * COPYING, assignment.c, assignment.h, chain.c, chain.h, double.c, double.h, execute.c, execute.h, expansion.c, expansion.h, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.c, fpminimax.h, general.c, general.h, implement.c, implement.h, infnorm.c, infnorm.h, integral.c, integral.h, library.c, library.h, libsollyaexample.c, main.c, main.h, pari_utils.c, pari_utils.h, plot.c, plot.h, proof.c, proof.h, remez.c, remez.h, sollya.h, taylor.c, taylor.h, worstcase.c, worstcase.h, xml.c, xml.h: Passed everything to CeCILL-C This commit was extracted from SVN r536. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@536 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-13 clauter * COPYING, assignment.c, assignment.h, chain.c, chain.h, doc/sollya.tex, double.c, double.h, execute.c, execute.h, expansion.c, expansion.h, expression.c, expression.h, external.c, external.h, externalfun.c, externalproc.c, fpminimax.c, fpminimax.h, general.c, general.h, implement.c, implement.h, infnorm.c, infnorm.h, integral.c, integral.h, library.c, library.h, libsollyaexample.c, main.c, main.h, pari_utils.c, pari_utils.h, plot.c, plot.h, proof.c, proof.h, remez.c, remez.h, sollya.h, taylor.c, taylor.h, worstcase.c, worstcase.h, xml.c, xml.h: Added CeCILL headers where appropriate. To be verified for legal reasons. This commit was extracted from SVN r535. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@535 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-12 clauter * doc/sollya.pdf: Compiled version of sollya.pdf This commit was extracted from SVN r534. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@534 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-12 schevill * doc/shlp2tex.sh: This commit was extracted from SVN r533. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@533 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-12 schevill * doc/RD.tex, doc/RN.tex, doc/RU.tex, doc/RZ.tex, doc/abs.tex, doc/absolute.tex, doc/accurateinfnorm.tex, doc/acos.tex, doc/acosh.tex, doc/and.tex, doc/append.tex, doc/asciiplot.tex, doc/asin.tex, doc/asinh.tex, doc/atan.tex, doc/atanh.tex, doc/autosimplify.tex, doc/bashexecute.tex, doc/binary.tex, doc/boolean.tex, doc/canonical.tex, doc/ceil.tex, doc/checkinfnorm.tex, doc/coeff.tex, doc/concat.tex, doc/constant.tex, doc/cos.tex, doc/cosh.tex, doc/decimal.tex, doc/default.tex, doc/degree.tex, doc/denominator.tex, doc/diam.tex, doc/diff.tex, doc/dirtyfindzeros.tex, doc/dirtyinfnorm.tex, doc/dirtyintegral.tex, doc/display.tex, doc/divide.tex, doc/double.tex, doc/doubledouble.tex, doc/doubleextended.tex, doc/dyadic.tex, doc/equal.tex, doc/erf.tex, doc/erfc.tex, doc/error.tex, doc/evaluate.tex, doc/execute.tex, doc/exp.tex, doc/expand.tex, doc/expm1.tex, doc/exponent.tex, doc/externalplot.tex, doc/externalproc.tex, doc/false.tex, doc/file.tex, doc/findzeros.tex, doc/floor.tex, doc/fullparentheses.tex, doc/function.tex, doc/ge.tex, doc/gt.tex, doc/guessdegree.tex, doc/head.tex, doc/hexadecimal.tex, doc/honorcoeffprec.tex, doc/hopitalrecursions.tex, doc/horner.tex, doc/implementpoly.tex, doc/inf.tex, doc/infnorm.tex, doc/integer.tex, doc/integral.tex, doc/isbound.tex, doc/isevaluable.tex, doc/le.tex, doc/length.tex, doc/library.tex, doc/listof.tex, doc/log.tex, doc/log10.tex, doc/log1p.tex, doc/log2.tex, doc/lt.tex, doc/mantissa.tex, doc/mid.tex, doc/midpointmode.tex, doc/minus.tex, doc/mult.tex, doc/neq.tex, doc/nop.tex, doc/not.tex, doc/numerator.tex, doc/off.tex, doc/on.tex, doc/or.tex, doc/parse.tex, doc/perturb.tex, doc/pi.tex, doc/plot.tex, doc/plus.tex, doc/points.tex, doc/postscript.tex, doc/postscriptfile.tex, doc/power.tex, doc/powers.tex, doc/prec.tex, doc/precision.tex, doc/prepend.tex, doc/print.shlp, doc/print.tex, doc/printexpansion.tex, doc/printfloat.tex, doc/printhexa.tex, doc/printxml.tex, doc/proc.tex, doc/procedure.tex, doc/quit.tex, doc/range.tex, doc/rationalapprox.tex, doc/readfile.tex, doc/readxml.tex, doc/relative.tex, doc/remez.tex, doc/rename.tex, doc/restart.tex, doc/return.tex, doc/revert.tex, doc/round.tex, doc/roundcoefficients.tex, doc/roundcorrectly.tex, doc/searchgal.tex, doc/simplify.tex, doc/simplifysafe.tex, doc/sin.tex, doc/sinh.tex, doc/sollya.tex, doc/sort.tex, doc/sqrt.tex, doc/string.tex, doc/subpoly.tex, doc/substitute.tex, doc/sup.tex, doc/tail.tex, doc/tan.tex, doc/tanh.tex, doc/taylor.tex, doc/taylorrecursions.tex, doc/timing.tex, doc/tripledouble.tex, doc/true.tex, doc/var.tex, doc/verbosity.tex, doc/void.tex, doc/worstcase.tex, doc/write.shlp, doc/write.tex, help.h: Added tex help files This commit was extracted from SVN r532. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@532 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-12 clauter * help.h: Corrected help for void keyword. This commit was extracted from SVN r531. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@531 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-12 clauter * doc/keywords.def, doc/nop.shlp, doc/proc.shlp, doc/procedure.shlp, doc/return.shlp, doc/types.def, doc/void.shlp, execute.c, help.h, parser.y: Corrected a small bug in procedure evaluation (consistancy check for restart statements in procedures read out of files included by #include). Corrected small bugs in help invokation. Added new help texts. This commit was extracted from SVN r530. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@530 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-12 schevill * doc/exp.shlp, doc/externalproc.shlp, doc/keywords.def, doc/quit.shlp, doc/relative.shlp, doc/remez.shlp, doc/restart.shlp, doc/shlp2txt.sh, doc/sqrt.shlp, help.h: * Help files patched in order to compile in TeX mode * Definitions of keywords modified to take in account that +, -, *, ^, & and | are special characters for LaTeX * shlp2txt patched for handling new keywords definitions. Moreover, shlp2txt supports now "-v" option which prints its output in stdout. Usage: ./shlp2txt -v list_of_shlp_files Note: it keeps updating help.h even when -v option is activated. This commit was extracted from SVN r529. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@529 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-12-10 schevill * doc/degree.shlp, doc/diam.shlp, doc/dirtyfindzeros.shlp, doc/doubledouble.shlp, doc/doubleextended.shlp, doc/findzeros.shlp, doc/isbound.shlp, doc/library.shlp, doc/libraryexample.c, doc/pi.shlp, doc/plot.shlp, doc/rationalapprox.shlp, doc/substitute.shlp, doc/taylorrecursions.shlp, doc/tripledouble.shlp, help.h: Added the two last example files. This commit was extracted from SVN r528. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@528 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-27 clauter * infnorm.c: Corrected a bug in findzeros: findzeros looped to infinity if the precision needed to represent intervals of size smaller than diam was not available. This commit was extracted from SVN r527. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@527 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-25 clauter * execute.c, execute.h, internlexer.l, internparser.y, lexer.l, parser.y: Added floating-point evaluated assignment operator :=. Corrected a small bug in procedure evaluation concerning void as an argument. This commit was extracted from SVN r526. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@526 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-25 clauter * execute.c, execute.h, internlexer.l, internparser.y, lexer.l, parser.y: Added support for procedures. This commit was extracted from SVN r525. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@525 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-21 clauter * proof.c: Corrected UTF-8 issue This commit was extracted from SVN r524. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@524 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-21 clauter * ChangeLog: New ChangeLog This commit was extracted from SVN r523. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@523 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-21 clauter * execute.c: Corrected 3 small bugs This commit was extracted from SVN r522. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@522 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-20 clauter * execute.c, internparser.y, parser.y: Corrected a bug in the parser. Made @ work on any type as long as the other argument is a string. Corrected a strange bug if verbosity = 2; an external library function is bound and a type error occurs with a subexpression of an expression having an usage of the library function as a head function. This commit was extracted from SVN r521. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@521 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-20 clauter * ChangeLog, execute.c, parser.y: Changed @ behaviour. Corrected a bug. This commit was extracted from SVN r520. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@520 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-20 schevill * doc/shlp2txt.sh, help.h, parser.y: shlp2txt modified in order to take in account commands that have a prefix that is also a command (like taylor and taylorrecursions). help.h modified accordingly This commit was extracted from SVN r519. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@519 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-20 clauter * parser.y: Corrected an error in help invokation for ^. This commit was extracted from SVN r518. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@518 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-20 schevill * configure.ac, help.h: First version of help.h This commit was extracted from SVN r517. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@517 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-20 clauter * doc/absolute.shlp, doc/externalplot.shlp, doc/perturb.shlp, doc/relative.shlp: Corrected some bugs in help texts. This commit was extracted from SVN r516. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@516 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-20 schevill * doc/shlp2txt.sh: shlp2txt modified in order to patch automatically help.h This commit was extracted from SVN r515. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@515 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-19 clauter * doc/readxmlexample.xml: Made help for readxml work. This commit was extracted from SVN r514. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@514 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-19 clauter * doc/absolute.shlp, doc/externalplot.shlp, doc/numerator.shlp, doc/searchgal.shlp, doc/void.shlp: Corrected some errors in help texts. This commit was extracted from SVN r513. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@513 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-19 clauter * ChangeLog: New ChangeLog This commit was extracted from SVN r512. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@512 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-19 schevill * doc/RD.shlp, doc/RN.shlp, doc/RU.shlp, doc/RZ.shlp, doc/abs.shlp, doc/acos.shlp, doc/acosh.shlp, doc/append.shlp, doc/asin.shlp, doc/asinh.shlp, doc/atan.shlp, doc/atanh.shlp, doc/bashexecute.shlp, doc/ceil.shlp, doc/coeff.shlp, doc/concat.shlp, doc/cos.shlp, doc/cosh.shlp, doc/default.shlp, doc/degree.shlp, doc/diam.shlp, doc/dirtyfindzeros.shlp, doc/dirtyinfnorm.shlp, doc/dirtyintegral.shlp, doc/double.shlp, doc/doubledouble.shlp, doc/doubleextended.shlp, doc/erf.shlp, doc/erfc.shlp, doc/execute.shlp, doc/exp.shlp, doc/expm1.shlp, doc/exponent.shlp, doc/false.shlp, doc/file.shlp, doc/findzeros.shlp, doc/floor.shlp, doc/guessdegree.shlp, doc/head.shlp, doc/hopitalrecursions.shlp, doc/inf.shlp, doc/infnorm.shlp, doc/integral.shlp, doc/length.shlp, doc/log.shlp, doc/log10.shlp, doc/log1p.shlp, doc/log2.shlp, doc/mantissa.shlp, doc/mid.shlp, doc/midpointmode.shlp, doc/off.shlp, doc/pi.shlp, doc/plot.shlp, doc/points.shlp, doc/postscript.shlp, doc/postscriptfile.shlp, doc/prec.shlp, doc/precision.shlp, doc/prepend.shlp, doc/rationalapprox.shlp, doc/remez.shlp, doc/rename.shlp, doc/revert.shlp, doc/round.shlp, doc/roundcoefficients.shlp, doc/sin.shlp, doc/sinh.shlp, doc/sort.shlp, doc/sqrt.shlp, doc/substitute.shlp, doc/sup.shlp, doc/tail.shlp, doc/tan.shlp, doc/tanh.shlp, doc/taylorrecursions.shlp, doc/timing.shlp, doc/tripledouble.shlp, doc/true.shlp, doc/verbosity.shlp: New help texts. This commit was extracted from SVN r511. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@511 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-19 clauter * Makefile.am, help.h, parser.y: Added support for help system in the parser. This commit was extracted from SVN r510. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@510 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-19 clauter * execute.c, parser.y: Corrected a huge bug in loud assignments to the global variable taylorrecursions. This commit was extracted from SVN r509. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@509 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-19 clauter * doc/keywords.def, doc/var.shlp: New help text for var. This commit was extracted from SVN r507. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@507 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-19 clauter * ChangeLog: Nouveau ChangeLog. This commit was extracted from SVN r506. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@506 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-18 clauter * assignment.c, assignment.h, execute.c, execute.h, general.c, general.h, internlexer.l, internparser.y, lexer.l, parser.y: Added support for declared variables living in definition frames, shadowing each other. This is work towards internal procedure support. Syntax: begin ... end ({...]) - blocks may start with commands like var a, b, c; var d; Once other commands are given, no variable declarations are possible. This commit was extracted from SVN r505. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@505 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-16 clauter * doc/fullparentheses.shlp: New help text. This commit was extracted from SVN r504. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@504 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-16 clauter * doc/absolute.shlp, doc/relative.shlp: New help texts. This commit was extracted from SVN r503. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@503 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-16 clauter * execute.c: Corrected a bug in printing with midpointmode and display != decimal. This commit was extracted from SVN r502. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@502 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-16 clauter * doc/binary.shlp, doc/decimal.shlp, doc/display.shlp, doc/dyadic.shlp, doc/hexadecimal.shlp, doc/powers.shlp: New help texts. This commit was extracted from SVN r501. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@501 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-16 schevill * doc/keywords.def, doc/on.shlp: Added hexadecimal in keywords.def This commit was extracted from SVN r500. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@500 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-16 clauter * doc/print.shlp, doc/write.shlp: New help texts. This commit was extracted from SVN r499. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@499 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-16 clauter * internparser.y: Changed behaviour of quit in execute. This commit was extracted from SVN r498. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@498 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-16 clauter * doc/autosimplify.shlp, doc/canonical.shlp, doc/horner.shlp, doc/simplify.shlp, doc/simplifysafe.shlp: New help texts/ corrected help texts. This commit was extracted from SVN r497. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@497 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-16 schevill * integral.c, remez.c: Added a warning in remez when the input interval is reduced to a single point. This commit was extracted from SVN r496. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@496 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-16 clauter * doc/printexpansion.shlp, doc/taylor.shlp: Added new help files. This commit was extracted from SVN r495. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@495 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-16 clauter * expression.c: Added some simplifications to simplifyTreeErrorfree. This commit was extracted from SVN r494. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@494 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-16 clauter * doc/equal.shlp, doc/ge.shlp, doc/gt.shlp, doc/le.shlp, doc/lt.shlp, doc/neq.shlp: Some new help texts. This commit was extracted from SVN r493. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@493 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-15 schevill * remez.c: Bug fix in dirtyfindzeros when a=b Another bug fix: when f(a)=0 there used to be some value of points that make the algorithm ignore a. This is now fixed This commit was extracted from SVN r492. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@492 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-15 clauter * infnorm.c: Correcting a bug in dirtyinfnorm had introduced a new one. Corrected that one. This commit was extracted from SVN r491. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@491 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-15 clauter * infnorm.c: Corrected a slight bug in dirtyinfnorm (NaN handling for evaluateFaithful). This commit was extracted from SVN r490. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@490 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-14 clauter * double.c, expression.c: Corrected a bug in isSyntacticallyEqual. Corrected a bug in printexpansion. Adapted roundPolynomialCoefficients to a more sensible behaviour on lists of incorrect length. This commit was extracted from SVN r489. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@489 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-13 clauter * general.c, general.h, parser.y: Improved help system for neophytes. This commit was extracted from SVN r488. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@488 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-12 clauter * doc/honorcoeffprec.shlp, doc/implementpoly.shlp, doc/searchgal.shlp, implement.c: Added new documentation. Corrected a subtile bug in implementpoly. This commit was extracted from SVN r487. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@487 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-12 schevill * configure.ac: patch from Guillaume Melquiond This commit was extracted from SVN r486. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@486 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-12 clauter * infnorm.c: Corrected some bug with infinities and NaNs in input to evaluateI and infnorm. This commit was extracted from SVN r485. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@485 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-12 schevill * infnorm.c: Fixed a bug in dirtyinfnorm when the interval contains an Inf. Now returns NaN and prints a warning. This commit was extracted from SVN r484. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@484 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-12 clauter * doc/accurateinfnorm.shlp, doc/autosimplify.shlp, doc/boolean.shlp, doc/checkinfnorm.shlp, doc/constant.shlp, doc/denominator.shlp, doc/diff.shlp, doc/error.shlp, doc/externalplot.shlp, doc/externalplotexample.c, doc/externalproc.shlp, doc/function.shlp, doc/integer.shlp, doc/numerator.shlp, doc/parse.shlp, doc/perturb.shlp, doc/printfloat.shlp, doc/printhexa.shlp, doc/printxml.shlp, doc/quit.shlp, doc/range.shlp, doc/readfile.shlp, doc/readxml.shlp, doc/restart.shlp, doc/roundcorrectly.shlp, doc/searchgal.shlp, doc/string.shlp, doc/subpoly.shlp, doc/types.def, doc/void.shlp, doc/worstcase.shlp, external.c: Added/ changed documentation. Corrected a bug in externalplot. This commit was extracted from SVN r483. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@483 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-12 schevill * fpminimax.c: Fixed a bug in rationalapprox(x,n) when x is exactly representable with n bits This commit was extracted from SVN r482. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@482 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-08 clauter * doc/boolean.shlp, doc/constant.shlp, doc/function.shlp, doc/integer.shlp, doc/listof.shlp, doc/range.shlp, doc/readfile.shlp, doc/roundcorrectly.shlp, doc/string.shlp: New help files. This commit was extracted from SVN r481. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@481 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-08 schevill * doc/shlp2txt.sh: Changed "Function name" into "Name" This commit was extracted from SVN r480. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@480 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-07 clauter * ChangeLog, doc/parse.shlp, internlexer.l, internparser.y, lexer.l, minilexer.l, miniparser.y, parser.y: Slight changes. This commit was extracted from SVN r479. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@479 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-07 clauter * doc/externalprocvoidexample.c: Forgotten file for doc. This commit was extracted from SVN r478. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@478 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-07 clauter * doc/and.shlp, doc/denominator.shlp, doc/diff.shlp, doc/divide.shlp, doc/error.shlp, doc/evaluate.shlp, doc/expand.shlp, doc/externalproc.shlp, doc/externalprocexample.c, doc/isevaluable.shlp, doc/keywords.def, doc/minus.shlp, doc/mult.shlp, doc/not.shlp, doc/numerator.shlp, doc/or.shlp, doc/parse.shlp, doc/plus.shlp, doc/power.shlp, doc/printfloat.shlp, doc/printhexa.shlp, doc/printxml.shlp, doc/quit.shlp, doc/readxml.shlp, doc/restart.shlp, doc/void.shlp, parser.y: Added help texts and corrected a bug in the parser. This commit was extracted from SVN r477. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@477 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-07 clauter * ChangeLog, doc/asciiplot.shlp, doc/externalproc.shlp, doc/types.def, execute.c: Corrected som inconsistencies in tail and indexing concerning finally elliptic lists. Added some documentation. This commit was extracted from SVN r476. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@476 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-07 schevill * doc/keywords.def: Fixed a big with && This commit was extracted from SVN r475. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@475 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-07 schevill * doc/shlp2txt.sh: Fixed a bug with the use of the symbol "*" Now the output txt file write "Function name" or "Function names" depending of the number of names for the function This commit was extracted from SVN r474. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@474 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-07 clauter * doc/asciiplot.shlp, doc/externalproc.shlp, doc/externalprocexample.c, doc/types.def: Made externalproc work in the doc. This commit was extracted from SVN r473. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@473 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-06 schevill * doc/shlp2txt.sh, doc/types.def: types.def: type "ANY_TYPE" added shlp2txt.sh: bug fixes. Notation for LaTeX/text added This commit was extracted from SVN r472. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@472 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-06 clauter * execute.c: Provided inclusion property for range evaluation if result cannot be faithfully evalauted. This commit was extracted from SVN r471. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@471 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-06 schevill * doc/keywords.def, doc/shlp2txt.sh: shlp2txt should now be plainly functional This commit was extracted from SVN r470. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@470 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-06 clauter * execute.c: Patched a bug in range bound evaluation on not constant range bounds. This commit was extracted from SVN r469. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@469 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-11-05 clauter * ChangeLog, configure.ac, external.c, general.h, parser.y, plot.c, xml.c: Applied patch proposed by Guillaume Melquiond for resolving a bug with CPPFLAGS. This commit was extracted from SVN r468. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@468 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-31 clauter * external.c: Corrected a bug in externalplot. This commit was extracted from SVN r467. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@467 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-31 clauter * doc/asciiplot.shlp, doc/externalproc.shlp, doc/keywords.def, doc/subpoly.shlp: New help files. This commit was extracted from SVN r466. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@466 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-31 schevill * doc/keywords.def, doc/types.def, execute.c, parser.y: small changes in parser (corrected a bug). Added definitions for help system This commit was extracted from SVN r465. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@465 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-30 clauter * ChangeLog: New ChangeLog This commit was extracted from SVN r464. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@464 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-30 clauter * Makefile.am: Added installation of the sollya.h header file for usage of libsollya. This commit was extracted from SVN r463. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@463 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-30 schevill * configure.ac: autoconf was complaining about AM_PROG_CC_C_O. It is now fixed This commit was extracted from SVN r462. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@462 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-30 clauter * README, doc/sollya.pdf, doc/tools_manual.pdf, sollya.h: Some name changes. This commit was extracted from SVN r461. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@461 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-30 clauter * arenairetoolsexample.c, libsollyaexample.c: Changed name of arenairetoolsexample.c. This commit was extracted from SVN r460. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@460 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-30 clauter * Makefile.am, arenaireplot.h, arenairetoolsexample.c, external.c, externalfun.c, externalproc.c, plot.c, sollya.h, xml.c: Renamed occurrences of arenaireplot/tools to sollya. This commit was extracted from SVN r459. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@459 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-29 clauter * execute.c, externalproc.c, parser.y: Finished work on external procedures. Principally working. Not all combinations of types in argument and result have been tested, yet. Added example file for implementing an external C procedure. This commit was extracted from SVN r458. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@458 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-28 clauter * ChangeLog, arenaireplot.h, execute.c, execute.h, expression.h, general.c, general.h, internlexer.l, internparser.y, lexer.l, library.c, library.h, parser.y: Started adding support for binding identifiers to external procedures. Work in progress. Compiles, old functionalities work, usage of external procedure may segfault. This commit was extracted from SVN r457. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@457 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-25 clauter * Makefile.am: Switched back to tools for philosophical reasons. This commit was extracted from SVN r456. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@456 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-25 clauter * ChangeLog, Makefile.am, configure.ac, execute.c, execute.h, expression.c, expression.h, internlexer.l, internparser.y, lexer.l, parser.y: Added hexadecimal IEEE754R printing and parsing mode. Corrected a memory leak for dyadic constants. Changed name to sollya. This commit was extracted from SVN r455. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@455 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-25 njourdan * configure.ac: FIX: gmp test This commit was extracted from SVN r454. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@454 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-25 clauter * configure.ac: Brought configure.ac back to first version This commit was extracted from SVN r453. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@453 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-25 njourdan * configure.ac: FIX: gmp test This commit was extracted from SVN r452. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@452 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-23 clauter * ChangeLog, double.c, double.h, execute.c, execute.h, internlexer.l, internparser.y, lexer.l, parser.y: Added simple precision hexadecimal parsing capability. Added printfloat(constant) for print out in simple precision. This commit was extracted from SVN r451. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@451 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-23 clauter * ChangeLog, double.c: Added a wraning for sNaN This commit was extracted from SVN r450. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@450 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-22 clauter * ChangeLog, execute.c, execute.h, internlexer.l, internparser.y, lexer.l, parser.y: Added .: and :. in addition to :: Added #include as a replacement to read without removing read in the moment. This commit was extracted from SVN r449. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@449 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-17 clauter * ChangeLog, parser.y: Added help for isbound. This commit was extracted from SVN r448. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@448 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-17 clauter * ChangeLog, execute.c, execute.h, internlexer.l, internparser.y, lexer.l, parser.y: Added isbound. This commit was extracted from SVN r447. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@447 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-15 schevill * arenairetoolsexample.c, double.c, execute.c, expression.c, external.c, general.c, implement.c, infnorm.c, miniparser.y, pari_utils.c, plot.c, taylor.c, worstcase.c: changed *occured* into *occurred* everywhere This commit was extracted from SVN r446. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@446 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-08 clauter * expression.c: Corrected a bug in string length computation that could generate a segmentation fault. This commit was extracted from SVN r445. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@445 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-08 clauter * ChangeLog, execute.c, expression.c: Slight changes. This commit was extracted from SVN r444. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@444 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-08 clauter * ChangeLog: New Changelog. This commit was extracted from SVN r443. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@443 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-08 clauter * general.c: Changed slightly malloc. This commit was extracted from SVN r442. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@442 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-08 clauter * general.c, general.h, xml.c: Changed slightly malloc use. This commit was extracted from SVN r441. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@441 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-08 clauter * ChangeLog, configure.ac: Temporarily remove test for malloc and realloc in configure.ac for compatibility issues. This commit was extracted from SVN r440. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@440 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-06 clauter * execute.c: Constants (or constant expressions once evaluate to a constant) retain their precisions even on range constructions. Nevertheless, complex types as lists and ranges may be rounded down at their last evaluation. This commit was extracted from SVN r439. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@439 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-04 clauter * ChangeLog: New Changelog. This commit was extracted from SVN r438. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@438 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-04 clauter * expression.c: Patched a bug introduced when patching a bug (2). This commit was extracted from SVN r437. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@437 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-04 clauter * ChangeLog: New Changelog This commit was extracted from SVN r436. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@436 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-04 clauter * execute.c: Expressions are constant only if they can be proven constant by safe means. This commit was extracted from SVN r435. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@435 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-04 clauter * execute.c: Improved syntax error handling on constant expressions. This commit was extracted from SVN r434. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@434 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-04 clauter * execute.c, general.c: In range bounds and comparisons, expressions that are not detected to be constant are considered as a type error. This commit was extracted from SVN r433. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@433 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-03 schevill * remez.c: Newton's algorithm used to fail when a point x where f'(x)=0 is met during the algorithm. This bug is fixed. I also patched the code to be more confident when a step of bisection is performed. The final result is that the algorithm should be now more robust. Eventually, we cannot avoid cases where the algorithm loops infinitely and this implementation claims nothing but being a heuristic This commit was extracted from SVN r432. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@432 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-03 clauter * expression.c: Corrected a bug in expand. This commit was extracted from SVN r431. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@431 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-03 clauter * ChangeLog, configure.ac: Changed configure for disabling building a shared library by default. This commit was extracted from SVN r430. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@430 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-02 njourdan * xml.c: Add: variable name check, unknown markup check, error recovery This commit was extracted from SVN r429. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@429 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-01 njourdan * configure.ac: [no log message] 2007-10-01 njourdan * configure.ac: Upd: version autoconf This commit was extracted from SVN r427. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@427 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-01 njourdan * configure.ac: Upd: version autoconf This commit was extracted from SVN r426. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@426 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-01 clauter * parser.y: Adapted help. This commit was extracted from SVN r425. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@425 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-01 schevill * configure.ac: configure.ac checks correctly export-dynamic This commit was extracted from SVN r424. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@424 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-01 clauter * configure.ac, general.c: Added check for backtrace. This commit was extracted from SVN r423. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@423 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-01 schevill * configure.ac: configure.ac compatible with a Mac OS X architecture This commit was extracted from SVN r422. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@422 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-01 clauter * ChangeLog, Makefile.am, arenairetoolsexample.c: Corrected compilation indication in libary example. This commit was extracted from SVN r421. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@421 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-01 clauter * Makefile.am, lexer.l, parser.y: Removed convenience library support because it did not work. Added version. This commit was extracted from SVN r420. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@420 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-01 clauter * ChangeLog, Makefile.am: Added support for a convenience library libtools2. This commit was extracted from SVN r419. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@419 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-01 clauter * internlexer.l, lexer.l, minilexer.l: Forgotten files. This commit was extracted from SVN r418. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@418 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-01 clauter * Manuel_fr.tex: Removing french Manual. This commit was extracted from SVN r417. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@417 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-10-01 clauter * AUTHORS, COPYING, ChangeLog, INSTALL, Makefile.am, NEWS, autogen.sh, configure.ac, doc/tools_manual.pdf, expression.c, externalfun.c, general.c, internlexer.lex, internparser.y, lexer.lex, makefile, minilexer.lex, miniparser.y, parser.y: Catapulted arenaireplot to the configure - age. This commit was extracted from SVN r416. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@416 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-27 clauter * makefile: Modified makefile and XML parser. This commit was extracted from SVN r415. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@415 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-27 clauter * general.c, makefile: Removed the annoying old version of PARI Improved makefile. This commit was extracted from SVN r414. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@414 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-27 clauter * execute.c, execute.h, general.c, general.h, internlexer.lex, internparser.y, lexer.lex, makefile, minilexer.lex, miniparser.y, parser.y: Added execute. Allowed for empty blocks. Allowed for error recovery to the last command not leaving the outest block. Improved makefile. This commit was extracted from SVN r413. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@413 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-26 schevill * remez.c: correct verbosity level in guessdegree This commit was extracted from SVN r412. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@412 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-26 schevill * remez.c: intervals should now be correct as output of guessdegree This commit was extracted from SVN r411. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@411 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-25 clauter * compile.sh, execute.c: Changed a verbosity. This commit was extracted from SVN r410. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@410 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-24 schevill * remez.c: A major bug affecting the construction of the matrix when w(x)=0 for some x has been corrected This commit was extracted from SVN r409. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@409 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-24 schevill * remez.c: an important warning is displayed even if verbosity=0, but it is now displayed as a commentar This commit was extracted from SVN r408. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@408 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-20 schevill * remez.c: minor fixes in remez This commit was extracted from SVN r407. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@407 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-20 schevill * remez.c: A bug corrected in Remez This commit was extracted from SVN r406. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@406 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-20 clauter * execute.c, general.c: Added backtrace display upon SIGSEGV. This commit was extracted from SVN r405. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@405 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-19 clauter * compile.sh, execute.c: Changed slightly compiling script. Corrected a bug in externalplot execution. This commit was extracted from SVN r404. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@404 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-19 clauter * general.c, parser.y: Changed a bug in the demasking of strings. This commit was extracted from SVN r403. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@403 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-19 clauter * lexer.lex, parser.y: Modifier user output upon syntax error. This commit was extracted from SVN r402. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@402 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-18 clauter * double.c, execute.c, parser.y: Corrected two bugs. This commit was extracted from SVN r401. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@401 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-18 clauter * double.c, double.h, execute.c, execute.h, lexer.lex, parser.y: Added roundcorrectly. This commit was extracted from SVN r400. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@400 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-18 clauter * execute.c: Changed behaviour of comparisons on expressions that are not constants. This commit was extracted from SVN r399. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@399 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-17 clauter * expression.c: Added printing of small integers as integers. This commit was extracted from SVN r398. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@398 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-17 clauter * execute.c, execute.h, lexer.lex, parser.y: Added readfile. This commit was extracted from SVN r397. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@397 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-17 clauter * execute.c: corrected two bugs. This commit was extracted from SVN r396. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@396 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-14 njourdan * xml.c: Upd: add file://./mathmlc2p-web.xsl This commit was extracted from SVN r395. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@395 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-14 clauter * arenaireplot.h, arenairetoolsexample.c, assignment.c, chain.c, double.c, execute.c, execute.h, expression.c, external.c, fpminimax.c, general.c, general.h, implement.c, implement.h, infnorm.c, integral.c, lexer.lex, library.c, main.c, main.h, makefile, minilexer.lex, miniparser.y, pari_utils.c, pari_utils.h, parser.y, plot.c, proof.c, remez.c, taylor.c, worstcase.c, xml.c, xml.h: Allowed for and added compilation of a library version of arenaireplot. Added an example usage file to the repository. This commit was extracted from SVN r394. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@394 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-14 njourdan * xml.c: Upd: XML header files This commit was extracted from SVN r393. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@393 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-14 njourdan * xml.c: Upd: XML header files This commit was extracted from SVN r392. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@392 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-13 njourdan * xml.c: Simplify parsing code (FSM) This commit was extracted from SVN r391. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@391 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-13 njourdan * xml.c: Simplify parsing code (FSM) This commit was extracted from SVN r390. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@390 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-13 njourdan * xml.c: Simplify parsing code (FSM) This commit was extracted from SVN r389. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@389 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-12 clauter * double.c, double.h, execute.c, execute.h, lexer.lex, parser.y: Added functionalities mantissa, exponent and precision to user interface. This commit was extracted from SVN r388. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@388 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-11 clauter * xml.c: Removed a printf to have a printMessage. This commit was extracted from SVN r387. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@387 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-11 clauter * xml.c: Removed a displayed line in readxml. This commit was extracted from SVN r386. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@386 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-11 clauter * xml.c: Removed some warnings in xml.c This commit was extracted from SVN r385. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@385 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-11 njourdan * xml.c: Less warning? This commit was extracted from SVN r384. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@384 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-11 clauter * lexer.lex, main.c, parser.y: Removed trailing newlines in non-interactive mode. This commit was extracted from SVN r383. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@383 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-11 clauter * expression.c, main.c: Added fullparentheses mode support to printing/ writing to files. This commit was extracted from SVN r382. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@382 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-11 njourdan * xml.c: Add support for This commit was extracted from SVN r381. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@381 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-10 njourdan * makefile: no dependance with xml2-dev This commit was extracted from SVN r380. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@380 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-10 schevill * README, remez.c: update README with libxml2 This commit was extracted from SVN r379. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@379 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-10 njourdan * makefile: ca doit compiler avec ca... (xml lib) This commit was extracted from SVN r378. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@378 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-10 clauter * expression.c, expression.h: Added int readDecimalConstant(mpfr_t result, char *str) for internal usage. This commit was extracted from SVN r377. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@377 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-10 clauter * execute.c: Added faithful simplifications of constant expressions to user interface. This commit was extracted from SVN r376. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@376 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-10 clauter * execute.c, lexer.lex: Changed rounding modes to RN, RU, RD, RZ. Changed output of things inf, sup, mid from *< >*, ... to inf, sup, mid. This commit was extracted from SVN r375. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@375 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-10 njourdan * xml.c: simplify reader xml This commit was extracted from SVN r374. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@374 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-10 njourdan * xml.c: Merge with reader1.c example This commit was extracted from SVN r373. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@373 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-10 clauter * execute.c: Added automatic binding to free variable on XML parsing. This commit was extracted from SVN r372. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@372 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-10 clauter * execute.c, expression.c, expression.h: Changed functionality in printing/ writing to files (on user interface). Values are displayed in the current display mode. This commit was extracted from SVN r371. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@371 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-06 clauter * execute.c, execute.h, lexer.lex, parser.y, xml.c, xml.h: Added framework for readxml. Added support for list of functions in first argument of plot. This commit was extracted from SVN r370. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@370 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-06 clauter * expression.c: Slight change in output for differentiate. This commit was extracted from SVN r369. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@369 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-05 clauter * execute.c, lexer.lex, parser.y: Added sup, inf, mid and their handling on constants. This commit was extracted from SVN r368. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@368 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-05 clauter * execute.c, parser.y: Added help. Corrected a bug. This commit was extracted from SVN r367. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@367 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-04 clauter * arenaireplot.h, parser.y: Added some help texts. This commit was extracted from SVN r366. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@366 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-04 clauter * xml.c: Corrected a bug in xml generation. This commit was extracted from SVN r365. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@365 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-04 clauter * expression.c, xml.c: Updated xml output. This commit was extracted from SVN r364. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@364 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-04 clauter * execute.c, execute.h, expression.c, expression.h, lexer.lex, makefile, parser.y, xml.c, xml.h: Added xml output functionality. This commit was extracted from SVN r363. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@363 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-04 clauter * lexer.lex: Added { and } as a replacement for begin and end. This commit was extracted from SVN r362. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@362 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-09-02 clauter * arenaireplot.h, chain.c, chain.h, execute.c, execute.h, expression.c, expression.h, infnorm.c, infnorm.h, lexer.lex, main.c, main.h, makefile, minilexer.lex, miniparser.y, parser.y: First version of the Turing-complete brand-new arenaireplot 0.2 This commit was extracted from SVN r361. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@361 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-07-11 clauter * arenaireplot.h, infnorm.c: Slight changes for having a Newton with start value. This commit was extracted from SVN r360. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@360 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-07-05 clauter * arenaireplot.h, externalfun.c: Added some functionalities to arenaireplot.h Added an example for an external function to the CVS. This commit was extracted from SVN r359. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@359 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-07-05 clauter * arenaireplot.h: Added header file for using arenaireplot functionalities in dynamic libraries that can dynamically be linked to arenaireplot function symbols. This commit was extracted from SVN r358. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@358 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-07-05 clauter * makefile: Allowed using symbols in arenaireplot in external libraries. This commit was extracted from SVN r357. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@357 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-06-14 schevill * remez.c: The list returned by dirtyfindzeros is now sorted by increasing values This commit was extracted from SVN r356. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@356 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-06-14 schevill * remez.c: The list returned by dirtyfindzeros is now sorted by increasing values This commit was extracted from SVN r355. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@355 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-06-14 clauter * infnorm.c, lexer.lex, parser.y: Added dirtyfindzeros to user interface. Added additionally fpfindzeros f in d, evaluate g at; and dirtyfindzeros f in d, evaluate g at; This commit was extracted from SVN r354. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@354 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-06-14 schevill * remez.c, remez.h: a first version of uncertifiedFindZeros This commit was extracted from SVN r353. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@353 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-06-14 schevill * parser.y: added help support for guessdegree This commit was extracted from SVN r352. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@352 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-06-07 clauter * expression.c, infnorm.c: Patched Horner Patched evaluateI. This commit was extracted from SVN r351. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@351 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-06-07 clauter * parser.y: Changed midpoint mode display. This commit was extracted from SVN r350. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@350 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-06-06 clauter * expression.c, infnorm.c, lexer.lex, main.h, parser.y: Corrected use of Hopital's rule for recursion. Recursion is a allowed if the zero point is the same for each derivative. Added simple help functionality. This commit was extracted from SVN r349. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@349 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-05-30 clauter * infnorm.c, lexer.lex, main.c, main.h, parser.y: Changed Hopital's rule recursion behaviour to be consistant with the current state of mathematics behind it. This commit was extracted from SVN r348. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@348 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-05-22 clauter * plot.c: Patched an overflow bug in plot. This commit was extracted from SVN r347. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@347 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-05-16 clauter * parser.y: Allowed concatenation of strings using the + operator. This commit was extracted from SVN r346. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@346 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-05-15 clauter * parser.y: Corrected a bug on restart. This commit was extracted from SVN r345. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@345 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-05-14 clauter * makefile: Corrected again a bug in makefile This commit was extracted from SVN r344. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@344 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-05-14 clauter * makefile: Corrected bug in makefile This commit was extracted from SVN r343. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@343 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-05-14 clauter * Manuel_fr.tex: Corrected error in doc. This commit was extracted from SVN r342. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@342 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-05-14 clauter * Manuel_fr.tex: Corrected a orthography bug. This commit was extracted from SVN r341. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@341 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-05-14 clauter * Manuel_fr.tex, README: Changed doc. This commit was extracted from SVN r340. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@340 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-18 clauter * library.c: Patched a little the library system. This commit was extracted from SVN r339. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@339 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-16 schevill * chain.c, chain.h, remez.c: transition between PARI and my own gauss is finished. I have made the basic set of tests on this version but it can still contain some bugs This commit was extracted from SVN r338. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@338 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-16 schevill * chain.c, remez.c: functional testing version of remez with my own gauss elimination This commit was extracted from SVN r337. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@337 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-15 clauter * expression.c, expression.h, infnorm.c, lexer.lex, library.c, library.h, main.c, main.h, makefile, parser.y: Added handling of functions bound to external code. This commit was extracted from SVN r336. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@336 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-13 schevill * chain.c, chain.h, remez.c: Testing version before replacing PARI by my own Gauss elimination This commit was extracted from SVN r335. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@335 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-13 clauter * infnorm.c: Patched differentiate on evaluate rule in evaluateFaithfulWithCutOff. This commit was extracted from SVN r334. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@334 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-13 clauter * infnorm.c: Patched version of evaluateITaylor. This commit was extracted from SVN r333. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@333 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-13 clauter * expression.c, main.h, parser.y: Corrected some bugs in Horner form handling. This commit was extracted from SVN r332. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@332 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-13 clauter * expression.c, expression.h, lexer.lex, main.c, main.h, parser.y: Intermediate version with new features. This commit was extracted from SVN r331. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@331 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-12 clauter * expression.c, main.c, main.h: Intermediate version. This commit was extracted from SVN r330. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@330 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-11 schevill * main.c, remez.c: timer is now displayed even if verbosity=0 This commit was extracted from SVN r329. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@329 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-06 clauter * infnorm.c: Added a test for preventing decorrelation trials on addition and substraction evaluation on point intervals. This commit was extracted from SVN r328. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@328 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-05 clauter * expression.c: Some new high verbosity display code. This commit was extracted from SVN r327. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@327 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-05 clauter * lexer.lex: Added warning for cases when read macros do not form complete expressions. This commit was extracted from SVN r326. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@326 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-05 schevill * main.c: corrected version of the timer This commit was extracted from SVN r325. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@325 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-05 clauter * lexer.lex, main.c, parser.y: Added timing functionality. This commit was extracted from SVN r324. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@324 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-05 schevill * main.c: time counter with a new message This commit was extracted from SVN r323. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@323 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-05 schevill * infnorm.c, main.c, main.h: time counter added This commit was extracted from SVN r322. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@322 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-02 clauter * infnorm.c: Added interval handling count in dirtyinform for verbosity >= 2; This commit was extracted from SVN r321. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@321 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-02 clauter * parser.y: Added quality parameter in remez function to user-interface. This commit was extracted from SVN r320. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@320 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-04-02 schevill * parser.y, remez.c, remez.h: added user support for quality in Remez This commit was extracted from SVN r319. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@319 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-30 schevill * remez.c: guessdegree uses now the new optimizations of Remez. Better handling of the differentiation of the polynomial in Remez This commit was extracted from SVN r318. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@318 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-30 clauter * expression.h: Made isHorner and isCanonical available for other parts of the tool. This commit was extracted from SVN r317. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@317 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-30 schevill * remez.c: Optimized construction of the Remez' matrix This commit was extracted from SVN r316. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@316 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-29 schevill * remez.c: new message when resovig the system in Remez This commit was extracted from SVN r315. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@315 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-28 schevill * remez.c: normal version This commit was extracted from SVN r314. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@314 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-28 schevill * remez.c: debugging version This commit was extracted from SVN r313. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@313 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-28 schevill * remez.c: synchronization This commit was extracted from SVN r312. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@312 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-28 clauter * expression.c, lexer.lex, main.c, main.h, parser.y: Speeded up differentiation of horner polynomials. Added speed-up code to autoprint. Added autosimplify switch in the user interface. This commit was extracted from SVN r311. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@311 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-27 schevill * remez.c: More adapted messages in level 3 This commit was extracted from SVN r310. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@310 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-27 clauter * expression.c: Speeded up autoprint by speeding up horner, makeCanonical and getCoefficients for horner and canonical polynomials. This commit was extracted from SVN r309. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@309 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-27 schevill * main.c, remez.c: More messages in Remez with verbosity levet set to 3 This commit was extracted from SVN r308. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@308 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-26 clauter * infnorm.c: Speeded up plot by speeding up evaluateFaithful family. This commit was extracted from SVN r307. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@307 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-26 clauter * infnorm.c, main.c: Speeded up evaluateFaithulWithCutOff. This commit was extracted from SVN r306. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@306 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-26 schevill * remez.c: Corrected a bug in Newton's algorithm when binary search must be used This commit was extracted from SVN r305. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@305 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-13 clauter * infnorm.c: Slightly changed evaluateFaithful This commit was extracted from SVN r304. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@304 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-13 clauter * expression.c, expression.h, lexer.lex, main.c, main.h, makefile, minilexer.lex, miniparser.y, parser.y: Added a miniparser for parsing strings of simple expressions. Added tree manipulation functions. Added miniparser parse functionality in the main parser. This commit was extracted from SVN r303. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@303 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-02 clauter * README: README This commit was extracted from SVN r302. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@302 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-02 schevill * remez.c: corrected a memory leak in guessdegree This commit was extracted from SVN r301. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@301 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-02 schevill * remez.c: Final version of Remez This commit was extracted from SVN r300. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@300 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-03-01 clauter * lexer.lex, main.c, main.h, parser.y: Corrected Ctrl-C behaviour for avoiding contact loss with Houston. This commit was extracted from SVN r299. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@299 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-28 clauter * lexer.lex: Corrected a SIGSEV on syntax error. This commit was extracted from SVN r298. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@298 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-28 clauter * lexer.lex, main.c, main.h, parser.y: Corrected memory leaks in lexer/ parser structure. This commit was extracted from SVN r297. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@297 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-28 schevill * pari_utils.c, remez.c: faster Remez This commit was extracted from SVN r296. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@296 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-28 clauter * expression.c: Patched a memory leak in simplifyTreeErrorfree. This commit was extracted from SVN r295. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@295 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-28 clauter * parser.y: autoprint accepts comma separated lists of elements. This commit was extracted from SVN r294. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@294 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-28 clauter * lexer.lex: Corrected omission of newlines in comments. This commit was extracted from SVN r293. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@293 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-28 schevill * infnorm.h, remez.c: an unfinished version of Remez but already fully functional in normal cases This commit was extracted from SVN r292. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@292 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-27 clauter * infnorm.c: evaluateFaithfulWithCutOffFast accepts NULL as an argument for the derivative, avoiding in this case Taylor evaluation. This commit was extracted from SVN r291. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@291 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-25 clauter * expression.c, parser.y: Improved quality of results obtained with simplifyTreeErrorfree. This commit was extracted from SVN r290. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@290 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-23 clauter * expression.c: Corrected a bug introduced by the modification of simplifyTreeErrorfree. This commit was extracted from SVN r289. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@289 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-23 schevill * remez.c: minor changes : a counter limits the number of iterations, NaN and Inf should now be avoided as often as possible. This commit was extracted from SVN r288. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@288 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-23 clauter * expression.c: Added simplification of expressions f(x) * (1/g(x)) = f(x)/g(x) in simplifysafe. This commit was extracted from SVN r287. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@287 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-22 clauter * parser.y: Corrected a memory leak in degree definition. This commit was extracted from SVN r286. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@286 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-22 schevill * remez.c: remez is now fully functional but still not so quick as it could be This commit was extracted from SVN r285. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@285 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-22 clauter * parser.y: Added weight function functionality to remez. This commit was extracted from SVN r284. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@284 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-22 schevill * pari_utils.c, remez.c, remez.h: beta of new remez This commit was extracted from SVN r283. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@283 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-16 schevill * Manuel_fr.tex: updated the doc with guessdegree, printbinary and round This commit was extracted from SVN r282. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@282 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-16 clauter * double.c, implement.c, parser.y: Corrected a bug in printbinary and printexpansion. This commit was extracted from SVN r281. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@281 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-09 clauter * implement.c: Corrected a slight bug in implementpoly. This commit was extracted from SVN r280. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@280 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-09 schevill * infnorm.c, remez.c: memory leaks corrected This commit was extracted from SVN r279. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@279 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-09 clauter * remez.c: Corrected some bugs in guessdegree. This commit was extracted from SVN r278. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@278 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-08 schevill * remez.c: alternative function ton find zeros This commit was extracted from SVN r277. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@277 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-08 schevill * remez.c: guessDegree finished but not alleyooped This commit was extracted from SVN r276. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@276 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-08 schevill * remez.c: dummy guessDegree for checking This commit was extracted from SVN r275. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@275 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-08 clauter * lexer.lex, parser.y, remez.h: Added guessDegree to user interface. This commit was extracted from SVN r274. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@274 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-08 clauter * expansion.h, parser.y: Slight change in the parser. This commit was extracted from SVN r273. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@273 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-07 clauter * Manuel_fr.tex: Rajout de certaines fonctionalites dans la doc. This commit was extracted from SVN r272. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@272 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-07 clauter * fpminimax.h, parser.y, worstcase.c, worstcase.h: Added multiple function Gal value search. This commit was extracted from SVN r271. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@271 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-02-06 clauter * external.c, infnorm.c: Corrected the evaluate abs(x) at 0 infinite recursion bug. Optimized interval evaluation on point intervals. This commit was extracted from SVN r270. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@270 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-18 clauter * infnorm.c: Improved dirtyinfnorm performance. This commit was extracted from SVN r269. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@269 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-18 clauter * infnorm.c, infnorm.h: Improved dirtyinfnorm performance. This commit was extracted from SVN r268. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@268 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-18 clauter * infnorm.c, lexer.lex, main.c: Improved Houston loss. This commit was extracted from SVN r267. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@267 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-18 clauter * main.c: Patch again Houston. This commit was extracted from SVN r266. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@266 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-18 clauter * lexer.lex, main.c, parser.y: Debugged Houston. This commit was extracted from SVN r265. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@265 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-18 clauter * expression.c, infnorm.c, plot.c: Changed dirtyinfnorm for using evaluateFaithfulWithCutOff. Corrected precision handling in plot. This commit was extracted from SVN r264. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@264 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-18 schevill * lexer.lex: corrected a bug in the function read: the allocated size for the temporary string was not sufficient This commit was extracted from SVN r263. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@263 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-18 clauter * lexer.lex, parser.y: Added round(constantfunction,integer,[N,M,P,Z]) to user interface. This commit was extracted from SVN r262. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@262 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-18 schevill * double.c, double.h, fpminimax.c: added the function round_to_format This commit was extracted from SVN r261. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@261 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-17 clauter * infnorm.c, infnorm.h, plot.c: Implemented evaluateFaithfulWithCutoff and plot using it This commit was extracted from SVN r260. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@260 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-17 clauter * expression.c, lexer.lex, parser.y: Added dyadic = binary to user interface. This commit was extracted from SVN r259. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@259 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-17 clauter * expression.c: Corrected a bug in simplifysafe. This commit was extracted from SVN r258. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@258 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-12 clauter * double.c: Corrected a bug in double precision hexadecimal parser for 32 bit machines. This commit was extracted from SVN r257. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@257 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-12 clauter * double.c, parser.y: Patch This commit was extracted from SVN r256. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@256 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-12 clauter * parser.y: DEBUG VERSION This commit was extracted from SVN r255. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@255 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-12 clauter * parser.y: Don't know. This commit was extracted from SVN r254. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@254 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-12 clauter * expression.c: Corrected a bug in doubledouble simplification. This commit was extracted from SVN r253. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@253 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-11 clauter * expression.c, lexer.lex, parser.y: Added parsing capability for binary constants: 1.1_2 = 1.5 Adapted printbinary output. This commit was extracted from SVN r252. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@252 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2007-01-11 clauter * expression.c, expression.h, lexer.lex, parser.y: Added printbinary constant; This commit was extracted from SVN r251. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@251 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-12-19 clauter * infnorm.c: Corrected a bug in Warning display in certified infnorm. This commit was extracted from SVN r250. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@250 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-12-19 clauter * expression.c, parser.y: Corrected a display error in print functions for repeated substraction and division trees. This commit was extracted from SVN r249. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@249 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-12-18 schevill * fpminimax.c, makefile, remez.c, remez.h: A rare bug in Remez corrected : when the optimal error doesn't reach its extrema at any of the two bounds This commit was extracted from SVN r248. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@248 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-12-06 clauter * infnorm.c: Corrected a memory leak. This commit was extracted from SVN r247. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@247 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-12-06 clauter * infnorm.c: Improved infnorm on functions that are fractions on the first level. This commit was extracted from SVN r246. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@246 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-12-04 clauter * parser.y: Corrected unary -. This commit was extracted from SVN r245. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@245 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-12-04 clauter * chain.c, parser.y: Changed parsing order for fpminimax. This commit was extracted from SVN r244. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@244 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-12-03 clauter * assignment.c, assignment.h, lexer.lex, main.c, main.h, parser.y: Added assignments of strings to variables. If syntax does not allow unique typing, $a must be used for accessing to variable a containing a string. This commit was extracted from SVN r243. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@243 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-12-03 clauter * lexer.lex, parser.y, plot.c, plot.h: Added asciiplot This commit was extracted from SVN r242. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@242 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-12-03 clauter * expression.c, expression.h, lexer.lex, main.c, main.h, parser.y: Added lexing and parsing capability for GP/PARI scientific notation: 1.24 (spaces)E+2 Attention: no spaces are permitted for cases where no exponent (e/E) is given. If the exponent sign (e/E) is given, the exponent value becomes obligatory. The feature is *not* available for dyadic notation: 1232b-5 is correct 1234 b-5 is not. Added write command to user interface: the same as print but no spaces or newlines are added. Special syntax for writing/ appending to a file is available: write 1, 2; -> prints 12 on stdout write > "toto" 1, 2 -> prints 12 in file "toto", erasing an old file "toto" write >> "toto" 1, 2 -> prints 12 in file "toto", appending to its content. Attention: on writing to files, strings to print a first created in memory and then printed. High memory usage may follow. Added trailing zero removal in scientific notation output. This commit was extracted from SVN r241. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@241 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-12-02 schevill * Manuel_fr.tex, pari_utils.c: updated the doc about reassignment ; mpfr->pari produces now an exact zero when called on 0. ; pari->mpfr checks now first if its argument is an int and deal with This commit was extracted from SVN r240. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@240 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-29 clauter * implement.c: Corrected a bug in implementpoly. This commit was extracted from SVN r239. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@239 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-29 schevill * pari_utils.c, remez.c: Again the cray feature about floating 0 in PARI This commit was extracted from SVN r238. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@238 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-29 schevill * remez.c: Oops This commit was extracted from SVN r237. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@237 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-29 schevill * remez.c: Again the bug with PARI handling the floating point 0 This commit was extracted from SVN r236. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@236 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-29 schevill * remez.c: Again the bug with PARI handling the floating point 0 This commit was extracted from SVN r235. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@235 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-29 schevill * pari_utils.c, remez.c: A bug due to PARI handling 0 in a subtraction corrected This commit was extracted from SVN r234. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@234 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-29 clauter * lexer.lex, parser.y: Changed reassignment behaviour. Added // \n and /* */ comments. This commit was extracted from SVN r233. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@233 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-29 schevill * pari_utils.c, remez.c: A bug in the conversion function PARI->mpfr affecting the exponents corrected This commit was extracted from SVN r232. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@232 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-29 clauter * lexer.lex: Added errno.h to lexer.lex in order to overcome a compile error on Mac OS X This commit was extracted from SVN r231. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@231 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-28 schevill * remez.c: The bug affecting remez algorithm near the bounds is corrected This commit was extracted from SVN r230. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@230 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-28 clauter * lexer.lex, main.c, main.h, parser.y: Added read "file" functionality. This commit was extracted from SVN r229. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@229 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-28 clauter * expression.c, infnorm.c: Corrected a bug. This commit was extracted from SVN r228. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@228 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-27 clauter * expression.c: Corrected a bug in expandPowerInPolynomialUnsafe. This commit was extracted from SVN r227. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@227 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-24 schevill * remez.c: bug affecting precision in Remez really corrected This commit was extracted from SVN r226. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@226 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-24 clauter * parser.y: Corrected an error with a pointer. This commit was extracted from SVN r225. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@225 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-24 schevill * remez.c: corrected the rounding of the bounds in remez This commit was extracted from SVN r224. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@224 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-24 schevill * remez.c: corrected a bug affecting the precision in Remez This commit was extracted from SVN r223. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@223 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-24 schevill * Manuel_fr.tex: Added the doc part for rationalapprox This commit was extracted from SVN r222. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@222 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-22 schevill * fpminimax.c, fpminimax.h: rationalApprox is implemented This commit was extracted from SVN r221. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@221 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-22 clauter * main.c: Plot files are not removed when in a scripted. This commit was extracted from SVN r220. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@220 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-22 clauter * lexer.lex, parser.y: Added rationalapprox This commit was extracted from SVN r219. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@219 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-22 schevill * fpminimax.c: [no log message] 2006-11-22 schevill * fpminimax.c, fpminimax.h: Dummy version of rationalApprox This commit was extracted from SVN r217. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@217 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-22 schevill * external.c, plot.c, plot.h: Now handles filenames in /tmp This commit was extracted from SVN r216. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@216 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-22 clauter * double.c, double.h, lexer.lex, parser.y, worstcase.c, worstcase.h: Added Gal searches. This commit was extracted from SVN r215. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@215 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-22 schevill * external.c: external plot handles file, postscript and postscriptfiles options This commit was extracted from SVN r214. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@214 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-22 schevill * Manuel_fr.tex: Doc up to date This commit was extracted from SVN r213. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@213 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-22 clauter * parser.y: Corrected elliptic lists. This commit was extracted from SVN r212. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@212 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-21 clauter * double.c, expression.c, lexer.lex, main.c, main.h, parser.y, plot.c: - Checked correct implementation of elliptic monomial definition in Remez: remez(exp(x),[4...6],[-1;1]) works. - Implemented elliptic monomial definition in subpoly: subpoly(poly,[4...6]) works - Implemented final elliptic monomial definition in subpoly: subpoly(poly,[4,5,...]) works - Adapted final elliptic format definition in roundcoefficients: roundcoefficients(poly,[DD,D,...]) works - Implemented DE support in roundcoefficients (no correct exponent range check, no subnormal support) - Implemented forced assignment of a new name to the bound free variable: > x + 1; 1 + x > a = x + 5; > a; 5 + x; > x = b!; > a; 5 + b; This commit was extracted from SVN r211. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@211 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-21 clauter * expression.c, expression.h: Intermediate version This commit was extracted from SVN r210. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@210 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-20 clauter * external.c, external.h, main.c, parser.y, plot.c, plot.h: Started implementing file numbering for (external)plot and file saving for externalplot. This commit was extracted from SVN r209. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@209 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-20 clauter * implement.c, proof.c: Finished implementpoly with proof generation. This commit was extracted from SVN r208. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@208 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-20 clauter * implement.c, proof.c: Finished automatic generation of code and proof in implementpoly. This commit was extracted from SVN r207. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@207 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-17 clauter * proof.c: Improved Gappa generation. This commit was extracted from SVN r206. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@206 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-17 clauter * implement.c, proof.c: Finished first version of Gappa generation. Untested. Will test now. This commit was extracted from SVN r205. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@205 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-17 clauter * implement.c, main.c, parser.y, proof.c, proof.h: Continued working on Gappa proof generation. Implemented Ctrl-C as exit(0) in scripts. Implemented <[ commandfunction ]> for recovering interval results. This commit was extracted from SVN r204. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@204 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-16 clauter * double.c, expansion.h, implement.c, makefile, proof.c: Improved printexpansion Continued working on Gappa proof generation for implementpoly. This commit was extracted from SVN r203. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@203 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-14 clauter * implement.c, proof.c, proof.h: Continued working on Gappa proof generation for implementpoly. This commit was extracted from SVN r202. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@202 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-14 clauter * chain.c, infnorm.c, parser.y: Improved fpfindzeros. This commit was extracted from SVN r201. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@201 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-13 clauter * chain.c, chain.h, implement.c, implement.h, infnorm.c, parser.y, proof.c, proof.h: Continued working on Gappa proof generation for implementpoly. Improved fpfindzeros. This commit was extracted from SVN r200. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@200 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-13 clauter * assignment.c, assignment.h, expression.c, expression.h, lexer.lex, parser.y: Added additional functionalities to the user interface: - querying environnement variables: prec = ?, verbosity = ?... - forcing reassignment of already assigned variables: a = 4; a = 5!; - printing (and autoprinting) of domains: print [-1;1]; print [a]; This commit was extracted from SVN r199. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@199 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-10 clauter * expression.c, expression.h, lexer.lex, parser.y: Added subpoly support. This commit was extracted from SVN r198. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@198 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-10 clauter * implement.c: Finished generation of SSA code for implementpoly. This commit was extracted from SVN r197. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@197 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-10 clauter * implement.c, infnorm.c: Improved fpfindzeros. Continued on working on SSA generation for implementpoly This commit was extracted from SVN r196. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@196 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-10 clauter * implement.c, infnorm.c: Improved fpfindzeros Started implementing SSA in implement.c This commit was extracted from SVN r195. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@195 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-09 clauter * lexer.lex, parser.y: Corrected a mistake in the parser. This commit was extracted from SVN r194. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@194 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-09 clauter * expression.c, expression.h, lexer.lex, parser.y: Added coeff(poly,i); This commit was extracted from SVN r193. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@193 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-09 clauter * infnorm.c: Improved fpfindzeros. This commit was extracted from SVN r192. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@192 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-08 clauter * parser.y: Corrected a bug in This commit was extracted from SVN r191. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@191 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-08 clauter * compile.sh, expansion.c, expansion.h, external.c: Completed helper functions for implementpoly and externalplot. This commit was extracted from SVN r190. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@190 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 schevill * external.c: bug of the man page corrected This commit was extracted from SVN r189. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@189 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 schevill * external.c: corrected a bug where x looped around 0 This commit was extracted from SVN r188. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@188 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 clauter * expansion.c, expansion.h: Added expansion handling default files. This commit was extracted from SVN r187. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@187 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 schevill * external.c, makefile, plot.c, plot.h: external plot This commit was extracted from SVN r186. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@186 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 clauter * lexer.lex, parser.y: Added externalplot to parser. This commit was extracted from SVN r185. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@185 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 schevill * external.c, makefile: updated makefile This commit was extracted from SVN r184. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@184 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 schevill * external.c, external.h: signatures for external.c This commit was extracted from SVN r183. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@183 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 clauter * lexer.lex, parser.y: Added bashexecute. This commit was extracted from SVN r182. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@182 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 schevill * external.c: bashExecute implemented This commit was extracted from SVN r181. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@181 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 clauter * external.c, external.h: Added externals. This commit was extracted from SVN r180. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@180 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 clauter * makefile: Changed makefile This commit was extracted from SVN r179. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@179 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 clauter * double.c: Corrected a bug on printing expansions of non real numbers. This commit was extracted from SVN r178. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@178 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 clauter * parser.y: Corrected a bug. This commit was extracted from SVN r177. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@177 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-07 clauter * double.c, double.h, lexer.lex, parser.y, plot.c: Added printexpansion. Corrected precision in plot to 64 bits. This commit was extracted from SVN r176. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@176 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-06 clauter * infnorm.c, main.h: Changed a constant for fpfindzeros. This commit was extracted from SVN r175. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@175 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-11-06 clauter * infnorm.c: Speeded up plot through more clever evaluateFaithful. This commit was extracted from SVN r174. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@174 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-26 clauter * implement.c: Adapted implement to new operators in crlibm. This commit was extracted from SVN r173. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@173 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-25 clauter * lexer.lex, main.c: Added Ctrl-C handling. Ctrl-D works only on a fresh prompt. This commit was extracted from SVN r172. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@172 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-25 clauter * infnorm.c: Slightly changed newton. This commit was extracted from SVN r171. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@171 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-25 clauter * infnorm.c, main.h, parser.y, plot.c: Slightly changed newton, fpfindzeros and plot. This commit was extracted from SVN r170. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@170 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-25 schevill * plot.c: A bug corrected in plot when using file option This commit was extracted from SVN r169. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@169 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-24 schevill * makefile, remez.c: enhanced makefile This commit was extracted from SVN r168. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@168 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-24 clauter * expression.c: Corrected a bug in getDegree This commit was extracted from SVN r167. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@167 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-23 schevill * Manuel_fr.tex: Doc updated to take in account the new syntax of plot This commit was extracted from SVN r166. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@166 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-23 schevill * lexer.lex, parser.y, plot.c, plot.h: plot can now manage output files This commit was extracted from SVN r165. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@165 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-23 clauter * lexer.lex, parser.y: User interface handling for plotting into files. This commit was extracted from SVN r164. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@164 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-23 schevill * expression.h, plot.c, plot.h: header for postscipt output and so on This commit was extracted from SVN r163. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@163 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-23 clauter * parser.y: Lists of things can be framed by brackets. This commit was extracted from SVN r162. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@162 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-23 clauter * parser.y: Modified the parser for multiplot. This commit was extracted from SVN r161. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@161 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-23 clauter * expression.c, plot.c: Plot uses evaluateFaithful. This commit was extracted from SVN r160. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@160 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-23 clauter * expression.c: Added a bugfix. This commit was extracted from SVN r159. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@159 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-23 clauter * expression.c, lexer.lex, parser.y: Added dyadic power of 2 support. This commit was extracted from SVN r158. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@158 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-23 clauter * expression.c: Added bugfix. This commit was extracted from SVN r157. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@157 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-23 clauter * lexer.lex: Added Pi. This commit was extracted from SVN r156. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@156 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-20 clauter * implement.c: Added information output to implementpoly This commit was extracted from SVN r155. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@155 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-20 clauter * expression.c: Corrected a bug in expand sequences. This commit was extracted from SVN r154. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@154 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-20 clauter * infnorm.c, parser.y: Made some modifications This commit was extracted from SVN r153. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@153 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-20 schevill * infnorm.c: corrected a bug in mpfi_erfc This commit was extracted from SVN r152. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@152 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-20 clauter * expression.c, infnorm.c: Slightly changed things. This commit was extracted from SVN r151. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@151 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-19 clauter * double.c, double.h, expression.c, expression.h, infnorm.c, lexer.lex, parser.y: Added erf, erfc, log1p, expm1, doubleextended. Currently untested. This commit was extracted from SVN r150. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@150 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-19 clauter * infnorm.c: Changed slightly accurateinfnorm constants. This commit was extracted from SVN r149. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@149 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-19 schevill * infnorm.c, pari_utils.c, pari_utils.h, remez.c, remez.h: Faithful evaluation in Remez This commit was extracted from SVN r148. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@148 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-19 clauter * infnorm.c: Modified constants for automatic accurateinfnorm This commit was extracted from SVN r147. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@147 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-19 clauter * expression.c, expression.h, infnorm.c: Completed accurateinfnorm Syntax: accurateinfnorm function in range [without rangelist] with number bits; This commit was extracted from SVN r146. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@146 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-19 clauter * expression.c, main.c: Added #define for Pari version. This commit was extracted from SVN r145. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@145 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-19 clauter * infnorm.c, infnorm.h, lexer.lex, main.c, parser.y: Added accurateinfnorm support. This commit was extracted from SVN r144. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@144 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-18 clauter * infnorm.c: Added an information in evaluateFaithful. This commit was extracted from SVN r143. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@143 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-18 clauter * infnorm.c, infnorm.h: evaluateFaithful This commit was extracted from SVN r142. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@142 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-17 clauter * expression.c, infnorm.c, proof.c, proof.h: Added monotonicity clou. This commit was extracted from SVN r141. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@141 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-17 clauter * infnorm.c, infnorm.h, parser.y: Added evaluateFaithfulOrFail This commit was extracted from SVN r140. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@140 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-17 clauter * infnorm.c: Slightly modified accurate evaluate. This commit was extracted from SVN r139. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@139 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-17 clauter * infnorm.c, infnorm.h, lexer.lex, main.c, main.h, parser.y: Changed slightly evaluateAccurate This commit was extracted from SVN r138. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@138 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-16 clauter * infnorm.c, infnorm.h, lexer.lex, parser.y: First trial for evaluateaccurate. This commit was extracted from SVN r137. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@137 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-16 clauter * infnorm.c, infnorm.h, lexer.lex, parser.y: Added isevaluable This commit was extracted from SVN r136. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@136 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-16 clauter * infnorm.c: Improved dirtyinfnorm. This commit was extracted from SVN r135. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@135 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-16 clauter * infnorm.c: improved dirtyInfnorm in NaNs occur. This commit was extracted from SVN r134. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@134 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-16 clauter * expression.c, expression.h, infnorm.c, infnorm.h, lexer.lex, parser.y: Some modifications. This commit was extracted from SVN r133. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@133 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-11 clauter * expression.c: Changed slightly printMpfr. This commit was extracted from SVN r132. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@132 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-11 clauter * expression.c, expression.h: Added a printMpfr function for debugging and develloping purposes. This commit was extracted from SVN r131. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@131 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-06 clauter * main.c, main.h: Made parser scripting capable. This commit was extracted from SVN r130. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@130 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-05 clauter * parser.y: Slightly modified the autoprint functionality. This commit was extracted from SVN r129. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@129 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-04 schevill * plot.c: small modification for the names of file stored in /tmp when plotting This commit was extracted from SVN r128. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@128 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-10-02 clauter * expression.h, infnorm.c, infnorm.h, main.c, main.h, parser.y: Modified automatic displaying of values on the prompt user interface. This commit was extracted from SVN r127. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@127 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-22 clauter * expression.c: Corrected a bug in expand and diff. This commit was extracted from SVN r126. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@126 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-22 clauter * main.c, parser.y, plot.c: Added automatic printing of simplified expressions. This commit was extracted from SVN r125. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@125 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-20 schevill * infnorm.c, plot.c: modified version of plot to deal with overflow in conversions into double values This commit was extracted from SVN r124. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@124 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-15 clauter * main.c: Correctly frees memory on SIGINT This commit was extracted from SVN r123. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@123 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-13 clauter * implement.c: Corrected a bug in implementpoly when the polynomial to implement ends on a multiplication. This commit was extracted from SVN r122. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@122 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-13 schevill * pari_utils.c: declaration of variable j moved This commit was extracted from SVN r121. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@121 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-13 schevill * pari_utils.c: Test procedure finished This commit was extracted from SVN r120. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@120 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-13 schevill * pari_utils.c: tests enhanced This commit was extracted from SVN r119. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@119 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-12 schevill * pari_utils.c: Fixed a cast with sizeof This commit was extracted from SVN r118. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@118 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-12 clauter * pari_utils.c: Changed minimal exponent value for AMD64 machines. This commit was extracted from SVN r117. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@117 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-12 schevill * pari_utils.c: Fixed a cast with sizeof This commit was extracted from SVN r116. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@116 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-12 clauter * pari_utils.c: Added a letter (l) This commit was extracted from SVN r115. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@115 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-12 clauter * main.c: Added safeRealloc and made PARI compatible to GMP in Debian. This commit was extracted from SVN r114. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@114 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-12 schevill * pari_utils.c: tests function implemented This commit was extracted from SVN r113. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@113 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-12 schevill * pari_utils.c: modified conversion functions This commit was extracted from SVN r112. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@112 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-12 schevill * pari_utils.c: modified conversion functions This commit was extracted from SVN r111. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@111 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-12 clauter * lexer.lex, pari_utils.c, pari_utils.h, parser.y: Added testpari functionality to the user interface. This commit was extracted from SVN r110. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@110 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-12 clauter * main.c, worstcase.c: Don't know what we are comitting ;-( This commit was extracted from SVN r109. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@109 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-07 schevill * Manuel_fr.tex, main.c: Adapted version for PARI 2.3.0 This commit was extracted from SVN r108. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@108 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-07 clauter * pari_utils.c, remez.c: Brought pari_utils.c and remez.c over to safeMalloc and printMessage. This commit was extracted from SVN r107. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@107 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-07 clauter * expression.c, expression.h, infnorm.c: Added an additional end case for recursive Taylor recursion: the expression becomes too big. This commit was extracted from SVN r106. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@106 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-06 clauter * implement.c: Finished implementing the first version of implementpoly. This commit was extracted from SVN r105. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@105 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-05 clauter * Manuel_fr.tex, parser.y: Documented restart feature. Corrected it for dyadic display and verbosity. This commit was extracted from SVN r104. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@104 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-05 clauter * assignment.c, implement.c, lexer.lex, main.c, parser.y: Corrected a memory lack in assignment. Added renormalize3 functionality to implementpoly (unfinished) Added restart functionality to the user interface. "Corrected" a memory lack of PARI This commit was extracted from SVN r103. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@103 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-09-01 clauter * Manuel_fr.tex, makefile: Added documentation for the new fonctionalities. This commit was extracted from SVN r102. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@102 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-08-14 clauter * implement.c, implement.h, infnorm.c, lexer.lex, parser.y: Improved implementpoly. Coefficient precisions are now rounded automatically by default. An option (honorcoeffprec) allows to get no rounding on the coefficients. It is now possible to get the implemented polynomial back using p = There is an additional check that the additions in the Horner steps do not cancellate. This commit was extracted from SVN r101. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@101 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-08-14 clauter * double.c, double.h, expression.c, expression.h, implement.c, lexer.lex, parser.y: Added a functionality to round the coefficients of a polynomial to TD, DD or D: print roundcoefficients(simplify(t),[TD,TD,TD,DD,DD,D...]); This commit was extracted from SVN r100. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@100 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-08-14 clauter * double.c, double.h, lexer.lex, parser.y: Added hexadecimal double precision printing and parsing capabilities. printhexa 2; 0x4000000000000000 print 1 + 0x3ff0000000000000; 2 This commit was extracted from SVN r99. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@99 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-08-11 clauter * implement.c, implement.h: Added the forgotten files to the CVS. This commit was extracted from SVN r98. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@98 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-08-11 clauter * assignment.c, assignment.h, expression.c, expression.h, main.c, main.h, parser.y: Added assignment functionality for ranges: for example a = [-1;2]; print ; 2 print _; -1 infnorm x in a; ... Dereferencing ranges while assigning them is not possible. This stays possible for (normal) expression assignments. This commit was extracted from SVN r97. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@97 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-08-11 clauter * infnorm.c, infnorm.h, lexer.lex, main.c, main.h, makefile, parser.y: Added a functionality to check an infinite norm on a function by interval arithmetic. The corresponding command is: checkinfnorm in bounded by [, diam = ]; Highly improved the quality of Taylor interval evaluations and thus improved the quality of the certified infinite norm by allowing the Taylor evaluation to recurse on the linear term up to a certain level. The default level is 0, so by default, nothing changes. The command for setting the recursion level is taylorrecursions = ; This commit was extracted from SVN r96. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@96 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-08-10 clauter * infnorm.c, main.h: Improved infnorm performance. This commit was extracted from SVN r95. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@95 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-08-10 clauter * expression.c, infnorm.c: Added information printouts at high verbosity levels. Slightly increased performance of isPolynomial() function. This commit was extracted from SVN r94. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@94 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-08-10 clauter * main.h: Slight change in main. This commit was extracted from SVN r93. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@93 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-08-10 clauter * expression.c, infnorm.c: Corrected a bug in isPolynomial(node *tree) introduced when correcting another bug ;-) This commit was extracted from SVN r92. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@92 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-08-10 clauter * double.c, expression.c, expression.h, infnorm.c, lexer.lex, main.h, makefile, parser.y: Added the first version of a functionality for the automatic implementation of a polynomial (function). This commit was extracted from SVN r91. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@91 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-07-23 schevill * makefile, pari_utils.c, pari_utils.h, remez.c: Restructured a bit the file remez.c, moving some code into a new file pari_utils.c. Changed makefile to compile on OS X with Fink. May not compile any more on Linux. We should quickly begin to use automake/autoconf This commit was extracted from SVN r90. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@90 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-30 schevill * Manuel_fr.tex, makefile: Documentation (in french at the moment) This commit was extracted from SVN r89. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@89 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-28 schevill * main.c, parser.y: memory leaks filled This commit was extracted from SVN r88. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@88 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-28 clauter * parser.y: Added relative integers to user interface. This commit was extracted from SVN r87. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@87 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-28 schevill * fpminimax.c, parser.y: debugged fpminimax and parser This commit was extracted from SVN r86. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@86 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-28 clauter * chain.c, chain.h, expression.c, expression.h, fpminimax.c, fpminimax.h, lexer.lex, main.c, main.h, parser.y, taylor.c: Added user interface for fpminimax. Corrected syntax of commandfunctions as expressions using angles. Added < >. Corrected Taylor: added a check that the development point is a constant expression. Patched differentiate on double, doubledouble and tripledouble rounding functions. The fpminimax interface must still be checked. This commit was extracted from SVN r85. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@85 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-27 clauter * lexer.lex, main.h, parser.y: Started implementing angles instead of parentheses for command functions. This commit was extracted from SVN r84. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@84 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-27 clauter * fpminimax.c, fpminimax.h, makefile, parser.y, remez.c: Started working on fpminimax Corrected silly syntax of plot This commit was extracted from SVN r83. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@83 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-15 clauter * infnorm.c, main.c, parser.y: Corrected a segfault in infnorm. Added support in user-interface for being able to consider infnorm, dirtyinfnorm, integral and dirtyintegral as a constant in another expression. The syntax is e.g. like follows: print 1+(infnorm x in [-1;1]); This commit was extracted from SVN r82. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@82 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-15 clauter * lexer.lex, parser.y, proof.h, worstcase.c, worstcase.h: Added file output support to worst case search. This commit was extracted from SVN r81. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@81 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-14 clauter * lexer.lex, makefile, parser.y, worstcase.c, worstcase.h: Added worstcase search. This commit was extracted from SVN r80. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@80 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-13 schevill * integral.c, remez.c: Remez is supposed to function with polynomials with holes This commit was extracted from SVN r79. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@79 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-13 clauter * double.c, expression.c, infnorm.c, integral.c, main.c, parser.y, plot.c, taylor.c: Changed all warnings and errors for proper support of verbosity and stderr output. It remain some occurences in Remez. This commit was extracted from SVN r78. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@78 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-13 clauter * infnorm.c, lexer.lex, main.c, main.h, parser.y: Added verbosity support. This commit was extracted from SVN r77. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@77 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-13 clauter * chain.c, chain.h, main.c, main.h, parser.y, remez.c, remez.h: Added user interface support for remez with holes. This commit was extracted from SVN r76. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@76 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-09 clauter * assignment.c, chain.c, expression.c, expression.h, infnorm.c, lexer.lex, main.c, main.h, parser.y, proof.c, proof.h, taylor.c: Added safeMalloc and safeCalloc. Completed the generation of a proof for infnorm. This commit was extracted from SVN r75. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@75 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-07 clauter * expression.c, expression.h, infnorm.c, infnorm.h, proof.c, proof.h: Continued working on the generation of a proof for the certified infnorm. This commit was extracted from SVN r74. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@74 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-07 clauter * infnorm.c, infnorm.h, lexer.lex, main.c, main.h, parser.y, proof.c, proof.h: Implemented first version of proof generation for certified infnorm. This commit was extracted from SVN r73. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@73 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-06-05 clauter * expression.c, expression.h, infnorm.c, infnorm.h, makefile, proof.c, proof.h: Started implementing the generation of a proof for an infinite norm. This commit was extracted from SVN r72. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@72 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-29 clauter * infnorm.c, parser.y: Corrected a bug in user interface displaying of certified integral result. This commit was extracted from SVN r71. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@71 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-29 clauter * integral.c, lexer.lex, parser.y: Added dirtyinfnorm to user interface. This commit was extracted from SVN r70. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@70 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-29 schevill * integral.c, integral.h: added an uncertified (but hopefully faster) integral This commit was extracted from SVN r69. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@69 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-29 clauter * infnorm.c, infnorm.h: Implemented void evaluateRangeFunctionFast(rangetype yrange, node *func, node *deriv, rangetype xrange, mp_prec_t prec) This commit was extracted from SVN r68. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@68 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-29 clauter * integral.c, integral.h, lexer.lex, makefile, parser.y: Added integral support to user-interface. This commit was extracted from SVN r67. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@67 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-29 schevill * integral.c, integral.h: Added files to compute integrals This commit was extracted from SVN r66. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@66 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-27 clauter * chain.h, expression.c, expression.h, infnorm.c, infnorm.h, lexer.lex, main.c, main.h, parser.y: Added support for excluding intervals in certified infnorm: infnorm exp(x) in [-1;1] without [-2^(-12);2^(12)], diam=2^(-10); Added support for dyadic numbers: - Input: always supported; b<+/->e = m * 2^(+/-e) - Output: supported only when dyadic=on; and number is not an integer representable on machine int. The displaying is <+/->b<+/->e = +/- * m * 2^(+/-e) where m is odd. This commit was extracted from SVN r65. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@65 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-26 clauter * parser.y: Corrected a bug in parser file that made segfault bison This commit was extracted from SVN r64. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@64 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-26 clauter * plot.c: Improved plot printout. This commit was extracted from SVN r63. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@63 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-26 clauter * plot.c: Improved precision in plot files. This commit was extracted from SVN r62. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@62 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-26 clauter * expression.c, lexer.lex, parser.y: Added numerator(func) support to user-interface Improved safety of printing values. This commit was extracted from SVN r61. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@61 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-26 clauter * parser.y: Improved evaluate on user-interface when the function evaluates to a point interval. This commit was extracted from SVN r60. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@60 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-26 clauter * infnorm.c, infnorm.h, lexer.lex, main.c, main.h, parser.y: Added interval evaluation of a function to the user-interface: evaluate exp(x) in [-1;1]; or evaluate exp(x) at 5; This commit was extracted from SVN r59. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@59 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-22 clauter * main.c: Added error recovering for PARI. This commit was extracted from SVN r58. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@58 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-19 clauter * main.c, remez.c: Remez fully debugged relatively to the *flows This commit was extracted from SVN r57. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@57 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-19 clauter * remez.c: Denormalized and Inf are OK on Itanium This commit was extracted from SVN r56. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@56 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-19 clauter * makefile: [no log message] 2006-05-19 clauter * remez.c: Test version of mpfr_2_PARI This commit was extracted from SVN r54. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@54 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-19 schevill * remez.c: Bug fixed with underflow This commit was extracted from SVN r53. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@53 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-19 clauter * parser.y: Corrected a bug in the parser. This commit was extracted from SVN r52. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@52 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-16 clauter * expression.c, expression.h, infnorm.c: Added pole detection to infnorm to correct the 1/x flaw. This commit was extracted from SVN r51. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@51 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-15 clauter * infnorm.c: Improved dirty infnorm. This commit was extracted from SVN r50. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@50 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-15 schevill * remez.c: I began to implement a more careful version of mpfr_to_PARI which takes care of denormalized numbers This commit was extracted from SVN r49. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@49 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-15 schevill * remez.c: Fixed bug in Remez algorithm when the function fails to oscillate enough This commit was extracted from SVN r48. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@48 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-12 clauter * expression.c, expression.h, infnorm.c, infnorm.h, lexer.lex, main.c, main.h, parser.y, taylor.c: Added dirty infnorm. Added substitutions in assigned variables: t(x+1) This commit was extracted from SVN r47. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@47 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-12 clauter * infnorm.c: Improved infnorm. This commit was extracted from SVN r46. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@46 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-11 clauter * chain.c, infnorm.c: Corrected a bug in infnorm (segfault). This commit was extracted from SVN r45. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@45 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-11 clauter * expression.c, infnorm.c, parser.y: Improved infnorm to produced results different from +infty on ill-conditionned problems. This commit was extracted from SVN r44. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@44 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-11 clauter * infnorm.c: Started working on infnorm with excluded domains. This commit was extracted from SVN r43. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@43 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-11 clauter * infnorm.c: Improved infnorm by improving Newton. No more division by zero possible. This commit was extracted from SVN r42. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@42 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-11 clauter * infnorm.c: Improved application of Horner's rule in infnorm. This commit was extracted from SVN r41. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@41 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-10 clauter * expression.c: Improved still horner code. This commit was extracted from SVN r40. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@40 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-10 schevill * remez.c: Bug in Newton's algorithm fixed This commit was extracted from SVN r39. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@39 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-10 clauter * infnorm.c: Added additional safety warnings in infnorm (contourning NaN). This commit was extracted from SVN r38. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@38 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-10 clauter * infnorm.c: Corrected bug in Newton zero search. This commit was extracted from SVN r37. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@37 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-10 clauter * expression.c, infnorm.c: Improved infnorm on function with false poles which are representable in FP. This commit was extracted from SVN r36. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@36 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-10 clauter * expression.c, expression.h, infnorm.c, infnorm.h, lexer.lex, main.c, main.h, parser.y, taylor.c: Corrected bugs in expand. Improved infnorm, work in progress Improved Taylor This commit was extracted from SVN r35. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@35 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-09 clauter * expression.c: Corrected a bug still remaining in Horner scheme horner() function. This commit was extracted from SVN r34. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@34 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-09 clauter * parser.y: A small combat with the bison versions... This commit was extracted from SVN r33. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@33 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-08 clauter * expression.c: Corrected a slight bug in Horner scheme function horner() This commit was extracted from SVN r32. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@32 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-08 clauter * expression.c, lexer.lex, makefile, parser.y, taylor.c, taylor.h: Added Taylor support. This commit was extracted from SVN r31. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@31 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-08 clauter * assignment.c, assignment.h, chain.c, chain.h, infnorm.c, lexer.lex, main.c, main.h, makefile, parser.y: Added assignment support. This commit was extracted from SVN r30. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@30 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-08 clauter * expression.c, infnorm.c, lexer.lex, main.c, main.h, makefile, parser.y: Committing merged versions. This commit was extracted from SVN r29. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@29 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-05 schevill * remez.c: Remez without all the windows at each step of the algorithm This commit was extracted from SVN r28. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@28 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-05 schevill * main.c, remez.c: Clean catch of Remez when not oscillating. This commit was extracted from SVN r27. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@27 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-05 clauter * infnorm.c: Debug version of infnorm. This commit was extracted from SVN r26. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@26 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-05 clauter * expression.c: Corrected differentiate. This commit was extracted from SVN r25. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@25 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-05 clauter * expression.c: Corrected derivative of a polynomial. This commit was extracted from SVN r24. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@24 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-04 schevill * remez.c: Better management of the memory and less use of the differnetiate function which increases the speed of computation. There is now a warning if the precision is not sufficient and the remez function returns then its argument as a result This commit was extracted from SVN r23. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@23 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-04 schevill * remez.c: Without plotting all intermediate results of Remez This commit was extracted from SVN r22. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@22 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-04 schevill * remez.c: Nothing ? This commit was extracted from SVN r21. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@21 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-04 clauter * expression.c, parser.y: Corrected expand. Added special code for differentiating polynomials. Avoided useless warnings. This commit was extracted from SVN r20. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@20 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-04 schevill * parser.y: Memory leaks corrected This commit was extracted from SVN r19. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@19 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-04 schevill * remez.c: Debug messages removed and commentaries translated in english This commit was extracted from SVN r18. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@18 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-04 schevill * remez.c: Remez fully functional. There is still the dirty handling of the memory but it seems to not affect the efficiency of the algorithm. And yes, there is still the debug logs This commit was extracted from SVN r17. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@17 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-04 clauter * double.c, double.h, expression.c, expression.h, lexer.lex, parser.y: Added simplifysafe support. This commit was extracted from SVN r16. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@16 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-04 clauter * expression.c, infnorm.c, main.c, main.h, parser.y: Completed horner support. This commit was extracted from SVN r15. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@15 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-03 schevill * remez.c: Fixed bug on exponent overflow. It's still failing for high degrees. It's more a prototype to play around than a definitive function. This commit was extracted from SVN r14. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@14 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-03 schevill * remez.c: Remez functionning. I did not implement Newton but it's awesome how this works without. A great number of memory optimisations on the trees are still possible. If the degree is increasing too much, an exponent overflow happens in PARI; this is a MINOR bug. This commit was extracted from SVN r13. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@13 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-03 schevill * remez.c: Compilation without warnings. Remez still not working but one step of the principal loop is needed, which should already be okay with respect to memory leaks. This commit was extracted from SVN r12. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@12 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-03 schevill * expression.c, main.c, main.h, parser.y, remez.c: Changing the precision variable to tools_precision because of fucking PARI. I hope I did not to many mistakes in the lexer and parser. Remez still reduced to identity. This commit was extracted from SVN r11. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@11 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-03 schevill * expression.c, expression.h, infnorm.c, makefile, parser.y, remez.c: Modification of the names LOG2, LOG10 and simplify. Adding the PARI lib to the Makefile. Some functionalities in remez.c: don't use it for now. This commit was extracted from SVN r10. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@10 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-03 clauter * expression.c, expression.h, lexer.lex, parser.y: Added expand support and continued working on horner scheme rewriting. This commit was extracted from SVN r9. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@9 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-02 clauter * expression.c, expression.h, lexer.lex, parser.y: Started working on horner-rewrite support. This commit was extracted from SVN r8. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@8 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-02 clauter * double.c, double.h, expression.c, expression.h, infnorm.c, lexer.lex, makefile, parser.y: Added double, double-double and triple-double support. This commit was extracted from SVN r7. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@7 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-02 clauter * results.txt, scratch.txt: Removed files that had been added by error. This commit was extracted from SVN r6. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@6 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-02 clauter * chain.c, chain.h, expression.c, expression.h, infnorm.c, infnorm.h, lexer.lex, main.c, main.h, makefile, parser.y, plot.c, plot.h, remez.c, remez.h, results.txt, scratch.txt: Initial revision This commit was extracted from SVN r2. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@2 af37bc7e-59aa-4313-bbaf-7d19c0032f32 2006-05-02 (no author) <(no author)@af37bc7e-59aa-4313-bbaf-7d19c0032f32> * New repository initialized by cvs2svn. This commit was extracted from SVN r1. git-svn-id: svn://scm.gforge.inria.fr/svn/sollya/trunk@1 af37bc7e-59aa-4313-bbaf-7d19c0032f32 sollya-6.0+ds/Makefile.am000066400000000000000000000063511300174114700153230ustar00rootroot00000000000000SUBDIRS = doc tests-tool tests-lib EXTRA_DIST = externalfun.c externalproc.c sollya.h2m sollya.1 sollya.map AM_YFLAGS = -d AM_LFLAGS = -o$(LEX_OUTPUT_ROOT).c # The following line is added to follow a suggestion from libtoolize. ACLOCAL_AMFLAGS = -I m4 BUILT_SOURCES = \ miniparser.h \ parser.h \ internparser.h \ lexer.c \ minilexer.c \ internlexer.c include_HEADERS = sollya.h sollya-messages.h lib_LTLIBRARIES = libsollya.la libsollya_la_LT_INFO = -version-info 6:0:0 libsollya_la_LD_VERSION_SCRIPT = if HAVE_LD_VERSION_SCRIPT libsollya_la_LD_VERSION_SCRIPT += -Wl,--version-script=$(top_srcdir)/sollya.map endif libsollya_la_SOURCES = \ sollya.h \ mpfi-compat.h \ mpfi-compat.c \ hash.c \ hash.h \ hooks.c \ hooks.h \ polynomials.c \ polynomials.h \ sollya-library-wrappers.c \ sollya-library-wrappers.h \ sollya-messaging.h \ sollya-messages.h \ sollya-messaging.c \ bitfields.h \ bitfields.c \ printf.c \ printf.h \ internparser.y \ miniparser.y \ parser.y \ internlexer.l \ lexer.l \ minilexer.l \ help.h \ version.h \ assignment.c \ assignment.h \ autodiff.c \ autodiff.h \ chain.c \ chain.h \ double.c \ double.h \ execute.c \ execute.h \ expression.c \ expression.h \ external.c \ external.h \ general.c \ general.h \ signalhandling.c \ signalhandling.h \ implement.c \ implement.h \ implementconst.c \ implementconst.h \ infnorm.c \ infnorm.h \ integral.c \ integral.h \ library.c \ library.h \ plot.c \ plot.h \ proof.c \ proof.h \ fplll_wrapper.cpp \ fplll_wrapper.h \ fpminimax.c \ fpminimax.h \ remez.c \ remez.h \ match.c \ match.h \ taylorform.c \ taylorform.h \ chebyshevform.c \ chebyshevform.h \ chebyshevformaux.c \ chebyshevformaux.h \ supnorm.c \ supnorm.h \ sturm.c \ sturm.h \ taylor.c \ taylor.h \ worstcase.c \ worstcase.h \ xml.c \ xml.h bin_PROGRAMS = sollya sollya_SOURCES = main.c sollya_LDADD = $(lib_LTLIBRARIES) libsollya_la_LDFLAGS = \ $(libsollya_la_LT_INFO) \ $(libsollya_la_LD_VERSION_SCRIPT) \ $(AM_LDFLAGS) check-lib: $(BUILT_SOURCES) @fail= failcom='exit 1'; \ for f in x $$MAKEFLAGS; do \ case $$f in \ *=* | --[!k]*);; \ *k*) failcom='fail=yes';; \ esac; \ done; \ echo "Making check in tests-lib"; \ ($(am__cd) tests-lib && $(MAKE) $(AM_MAKEFLAGS) check) \ || eval $$failcom; \ $(MAKE) $(AM_MAKEFLAGS) check-am || exit 1; \ test -z "$$fail" check-tool: $(BUILT_SOURCES) @fail= failcom='exit 1'; \ for f in x $$MAKEFLAGS; do \ case $$f in \ *=* | --[!k]*);; \ *k*) failcom='fail=yes';; \ esac; \ done; \ echo "Making check in tests-tool"; \ ($(am__cd) tests-tool && $(MAKE) $(AM_MAKEFLAGS) check) \ || eval $$failcom; \ $(MAKE) $(AM_MAKEFLAGS) check-am || exit 1; \ test -z "$$fail" man_MANS = sollya.1 if HAVE_HELP2MAN AM_H2MFLAGS = \ --locale=C.UTF-8 \ --libtool \ --no-info # Short descriptions for manpages sollya_DESCRIPTION = "tool environment for safe floating-point code development -- command-line interface" sollyaman_verbose = $(sollyaman_verbose_@AM_V@) sollyaman_verbose_ = $(sollyaman_verbose_@AM_DEFAULT_V@) sollyaman_verbose_0 = @echo " H2M "$@; sollya.1: sollya sollya.h2m $(sollyaman_verbose) SOLLYA_BANNER_OFF=YES $(HELP2MAN) \ -s 1 \ $(AM_H2MFLAGS) \ -I $(top_srcdir)/sollya.h2m \ -n $(sollya_DESCRIPTION) \ -o $@ \ $(top_builddir)/$< endif sollya-6.0+ds/NEWS000066400000000000000000000546561300174114700140010ustar00rootroot00000000000000Changes from version 5.0 to 6.0: ================================ Critical bug fixes: * Fixed a bug leading min and max commands to return wrong results when infinities were involved. Major bug fixes: * Many cases that used to make remez command enter into an infinite loop are now correctly handled. This fixes bugs [#8867] and [#12892], and also partly [#17200]. Changes of syntax and output: * Changed the way negative constants are displayed, so as to grant the property that an expression displayed by the tool and then parsed by the tool leads to the reconstruction of the exact same expression tree when autosimplify is set to off and fullparentheses is set to on (see bug [#20818]). * Patched a minor issue with displaying of code elements in match-with constructs. Improvements in internal handling: * Slight improvement in numberroots command. * Slight changes in what remez and fpminimax commands display at verbosity levels higher or equal than 2. * The interactive tool is now built upon the the library. * The tool now accepts without an error files containing DOS-style new line characters, i.e., "\r\n". Others: * Made Sollya compatible with the new API and requirements of recent versions of FPLLL. * configure now uses silent-mode, providing a more readable output. * LaTex sources of the documentation are now distributed with the released tarballs (notice that they always have been available under the same licence as the rest of Sollya sources in the public cvs/svn/git repositories. The only change is that they are now also distributed with the tarballs). * Tests that check execution timings are now skipped when they do not pass instead of being marked as 'FAIL', because running them on a busy machine could prevent them from passing (notice however that systematic failure of these tests on a non-busy machine should not be regarded as completely normal and is worth being reported). * A certain number of performance bugs fixed, in particular with respect to low precision evaluations and evaluations involving NaNs. * Fixed a problem with the environment variable 'showmessagenumbers' that was not recognized when used in a file read by the execute command. ---------------------------------------------------------------------- Changes from version 4.1 to 5.0: ================================ Critical bug fixes: * Fixed bug #20056: an integer division by zero occurred when using the degree() operator on certain polynomial expressions of high degree. Major bug fixes: * Fixed bug #17197: when compiled in a VPATH build, Sollya did not allow the Sollya test infrastructure to be executed. * Fixed bug #20369: a double-rounding issue could occur under some circumstances for the round() operator. This issue has been fixed. Changes of syntax and output: * Fixed bug #19925: Sollya followed no clear convention for hexadecimal output. The hexadecimal output of Sollya is now standardized for non-zero real numbers: they are always printed with a leading one before the hexadecimal point. * The @ operator now also works on externalprocedures, not only procedures. See documentation for details. Major new functionnalities: * New --args option to pass command line (bash) arguments to a Sollya script. * New feature __unique_id. See documentation for details. * New feature annotatefunction for allowing the user to add annotations to functional expressions. * New features getbacktrace and objectname allowing the Sollya procedure stack to be investigated and objects to be retranslated into object identifiers. * The Sollya execute command is now available in the Sollya library. Sollya scripts can hence be executed out of code using the Sollya library. Minor new functionnalities: * New function sollya_lib_printlibrarymessage. See documentation for details. * New functions sollya_lib_execute_procedure and sollya_lib_v_execute_procedure. See documentation for details. * New function sollya_lib_obj_is_procedure. * New --oldexternalprocprint command line option. See documentation for details. * New function sollya_lib_hash. * New library functions for external procedures, library constants and library functions: - sollya_lib_externalprocedure - sollya_lib_externalprocedure_with_data - sollya_lib_decompose_externalprocedure_with_data - sollya_lib_obj_is_externalprocedure - sollya_lib_libraryconstant_with_data - sollya_lib_libraryconstant_with_data - sollya_lib_libraryfunction_with_data - sollya_lib_build_function_libraryfunction_with_data - sollya_lib_decompose_libraryconstant_with_data - sollya_lib_decompose_libraryfunction_with_data. See documentation for details. * New library functions allowing functions to be constructed and deconstructed: - sollya_lib_construct_function - sollya_lib_v_construct_function - sollya_lib_get_nth_subfunction. See documentation for details. Improvements in internal handling: * Sollya is now always compiled with memory reference counting. The compile time option --enable-legacy-memory-management is no longer supported. * Improved execution speed of code used for faithful evaluation of a Sollya function. * Heavily improved handling of polynomial expressions. * The practical complexity of decimal display was improved by a certain amount. This is related to bug #12665. * Improved handling of temporary files generated by Sollya when calling gnuplot. And some bugs fixed. ---------------------------------------------------------------------- Changes from version 4.0 to 4.1: ================================ Critical bug fixes: * Patched a bug on printing library functions: printing second or higher derivatives of functions bound to Sollya using library might have led to a segmentation fault. * Fixed a bug in fpminimax that might have led to a possible segmentation fault (bug #16164). Major bug fixes: * Fixed some problems with Sollya's configure, leading to an error related to FPLLL during the compilation of Sollya. This error was especially observed when compiling Sollya under certain versions of Ubuntu. * Fixed bug #8306: older versions of Sollya used directed roundings on positive constants used in point-intervals and rounding to nearest for both bounds on negative constants. This led to point intervals not containing the decimal constant when the constant was not representable and negative. * Fixed bug #16155: older versions of Sollya were affected by a double rounding problem for ceil, floor and nearestint computation, yielding to incorrect results such as ceil(X) < X, floor(X) > X or abs(nearestint(X) - X) > 0.5. * Fixed bug #10322: older versions of Sollya disregarded the rounding mode when the single precision rounding to nearest led to overflow. * Fixed bug #15256: older versions of Sollya rounded NaN to Infinity under certain circumstances. Changes of syntax and output: * Making Gappa proof generation work better with recent versions of Gappa. The Gappa proof generated by this version of Sollya generally leads to tighter error enclosures. * Changed simplify to dirtysimplify and aliased simplifysafe with simplify. See documentation. * In order to allow users to include C code produced by Sollya using implementpoly or implementconstant in their own projects without making their own project available as works derived from Sollya, Sollya now includes a copyright exception text in such code sequences. See the actual text produced for details. The exception text was derived from the bison exception text and has informally been checked by Red Hat Inc. legal personnel. * New safe simplification procedures, solving bug #13046 and partially #16434. Older versions of Sollya performed illegal simplifications of expressions f - f to 0 and f/f to 1 even if f could become infinity resp. 0 over a whole interval. * Corrected a bug affecting the way rational numbers were displayed with sollya_lib_printf using %r conversion modifier: the displayed numerator and denominator were rounded values in some cases. * New conversion specifier %k in sollya_lib_printf to display mpz_t values. Minor new functionnalities: * Added support for an optional destructor function in an external library. See the documentation for library, libraryconstant or externalproc for details. * New functions sollya_lib_constant_from_mpz(), sollya_lib_constant_from_mpq(), sollya_lib_get_constant_as_mpz() and sollya_lib_get_constant_as_mpq() in the library. See documentation for details. And some bugs fixed. ---------------------------------------------------------------------- Changes from version 3.0 to 4.0: ================================ Critical bug fixes: * Fixed a bug in rationalapprox leading to possible segmentation fault (bug #13943). * Fixed a bug in horner with expressions containing NaNs leading the tool to exit (bug #15249). * Patched segfaulting behavior of comparisons of accesses to structures (bug #15162). * Avoided GMP overflow on simplification of powers on 64-bit machines (bug #14259). * Fixed a bug in simplification of some polynomials that resulted in a crash of the tool (bug #13930). * Fixed a bug when comparing unevaluated apply statements with themselves, possibly yielding to a segmentation fault. Major bug fixes: * Fixed hornerization algorithm to run in linear time in most cases (bug #15363). * Patched: the first tail operation on a list passed in argument of a procedure reverts the list (bug #15147). * Faithful rounding on evaluation of point intervals done too lower precisions as it should (bug #13902). * Patched a bug in supnorm that could yield to completely wrong results. * Patched: error-free simplification of divisions might yield incorrect answers if the denominator is 0 but cannot be proven to be so. * Patched: substitution of one polynomial into another could yield a completely wrong result, as constant coefficients could be omitted at some places. Changes of syntax and output: * Implicit parenthezation of .: operator has changed. a.:b.:c now reads a.:(b.:c). * () is now always allowed when (void) is. * parse and parse_string do no longer accept non-blank characters in excess (but one single occurrence of ';'). * The derivative of acos, asin, tan and tanh now all use squares. * When a comparison is hard to decide or undecidable, the result now produced is the one that would be produced if both members of the comparison were equal. * Introduced a default name for the free mathematical variable. _x_ is a permanent placeholder for the free variable. * Remez function now accepts a sixth parameter that allows the user to stop the computation as soon as a given accuracy is reached, or on the contrary, as soon as it may be proven that a given accuracy is unreachable. * The warning message displayed when a faithful rounding is performed now displays the precision the result is rounded at. * In cases when an evaluation is unable to perform faithful rounding because the real value of an expression is too close to 0, the returned value is now 0. * The behavior of expansion of end-elliptic lists has changed (see Section "Data Types > Lists" of the documentation for details). * void is no longer displayed by autoprint when verbosity is at least 2. Major new functionnalities: * New Sollya library, with a real interface. This interface will be officially supported and maintained in the future. * The round command now provides correct rounding of any constant expression given as argument, avoiding double-rounding (the previous behavior consisted in rounding it first faithfully to the current precision of the tool, and then rounding correctly that value at the required precision). * New chebyshevform command for computing Chebyshev Models (see documentation for details). * The commands remez and fpminimax can now take any list of base functions, and not only monomials. * Partial application of procedures is now available through the bind command (see documentation for details). Minor new functionnalities: * Faithful evaluation has been optimized (in particular, it now favors correct rounding whenever possible at low cost). * New command composepolynomials (see documentation for details). * New optional argument to guessdegree indicating the maximum degree the algorithm should allow (see documentation for details). * Sollya now compiles with icc. * New commands suppressmessage, unsuppressmessage, getsuppressedmessages and showmessagenumbers allowing for particular messages to be suppressed. Improvements in internal handling: * Various algorithms have been optimized for performance. * Memory usage of the tool has been improved a lot. In particular: - Copies of sollya objects now use reference counting. - Useless repeated evaluations are now detected and avoided. - Constant expressions are not evaluated again if some previous evaluation at a higher precision has already been performed. - For debugging purposes, a new configure option --enable-legacy-management allows the user to compile Sollya without these new optimizations. This option is for the developers of Sollya and is useless for the users of the tool (in particular, it is *expected* that 'make check' fails if this option is enabled). * Performance of handling lists has been optimized a lot: - The following instructions have now O(1) complexity in most cases: head(L), L=tail(L), L=a.:L where 'L' is a list and 'a' is some sollya object (notice that the same variable 'L' is used at both sides of the assignments). - Random read access to an element of a list has now O(1) complexity (except maybe the first access). * The definition of nop(n) has been changed so as to improve the stability of timings using it accross different architectures. * The temporary files used for the plot and externalplot commands now use unique names so as to avoid conflicts with other instances of the tool running at the same time. And many bugs fixed. ---------------------------------------------------------------------- Changes from version 2.9 to 3.0: ================================ Major new functionnalities: * Added expression matching support to the Sollya language. It is now possible to perform pattern matching on the objects of the Sollya language (expressions, lists, intervals, etc.). This is documented in a new section called "Pattern matching" in the User's Manual. * Added bashevaluate command. * Added operators halfprecision (or equivalently HP) and quad (or equivalently QD). Minor new functionnalities: * The Sollya executable now returns a meaningful error code: 0 - the tool has been quit with a "quit;" 1 - the tool has died because of an internal error that should never happen 2 - the tool has died because it was in "dieonerrormode = on" and an error has occurred 3 - the tool has been quit without a "quit;" but the last command was syntactically correct and got correctly executed 4 - the tool has been quit on an incomplete input * Added a fitfth optional argument to guessdegree that is used as a maximal allowed degree. * Changed behavior of doubleextended (resp. DE) with respect to subnormal rounding. Now, doubleextended correctly performs subnormal rounding for an exponent width of 15 bits. (see documentation on doubleextended for details). Improvements in internal handling: * A new technique gives sharper remainder bounds when taylorform is used in relative mode. Others: * Sollya was not compatible with FPLLL 3.0 or later. This is now fixed. * Two important bugs fixed in taylorform. Results obtained with an older version of taylorform often were incorrect. And some bugs fixed. ---------------------------------------------------------------------- Changes from version 2.0 to 2.9: ================================ Changes of syntax and output: * The addition of the min and max commands (see below) reserves the identifiers min and max as Sollya keywords, impacting legacy scripts which might have used these identifiers as variable names Major new functionnalities: * Added supnorm command * Added libraryconstant command * Added implementconstant command * Added function command for turning procedures into functions * Added support for user-defined structures into the Sollya language * Added min and max commands Minor new functionnalities: * Added --warnonstderr, --warninfile and --warninfileappend options to Sollya * Added MPFR, GMP and MPFI version printing to version and --help Improvements in internal handling: * Equality and inequality tests optimized when simple interval evaluation allows the result to be immediately decided upon. * Added a wrapper around MPFI for interval arithmetic computations within Sollya. As a consequence, the behaviors of Sollya and MPFI on some operations may now be different. See the new Appendix in the user's manual. * For the users of libsollya: new sollya_mpfi_t type must now be used instead of mpfi_t. Currently, they are exactly the same type, but they might differ in future versions. * The performance of Sollya's internal algorithms used for shifting a polynomial have been greatly improved. There is still headroom, though. Others: * Multiplications, divisions or powers involving infinities, zeros, or NaNs now produce different results, compared to older versions of Sollya. This is documented in the new Appendix of the user's manual. And some bugs fixed. ---------------------------------------------------------------------- Changes from version 1.1 to version 2.0: ======================================== Changes of syntax and output: * When the evaluation of an expression seems to be zero but cannot be proven to be exactly zero, the value zero is now returned (instead of a very small value as before) * Added %precision%constant parsing capability for numerical point constants * printhexa, printfloat are now deprecated. They should be replaced by printdouble and printsingle * Syntax like prec = ? is still supported but deprecated. It should be replaced by prec (or any other global variable). * The syntax *< interval >*, *< interval >_, *. is deprecated. It should be replaced by sup(), inf() and mid() * The read keyword is deprecated. It should be replaced by #include or even execute() * The begin and end keywords are deprecated. They should be replaced by { and } * Polymorphic prepend :: is now deprecated. It should be replaced by .: and :. Major new functionnalities: * Added nearestint function * Added single precision rounding function * Added taylorform command * Added autodiff command * Added numberroots command * Added support for procedures with an arbitrary number of arguments * Added time command * Made Sollya accept an input file as a command line argument (in particular, it makes shebangs possible) * Updated parse command with all new functionnalities * Added rationalmode mode * Added support for interval arithmetic * Added "in" operator for testing if a value belongs to an interval * Equality and inequality tests now automatically adapt the precision for guaranteeing safe results whenever possible (or display a warning) Minor new functionnalities: * Added dieonerror mode * Added --flush option to Sollya * Added support for integer arguments in nop * Extended syntax of roundcoefficients command * Extended syntax of round command Improvements in internal handling: * Added smart sign test used for proving that some constant expressions are constant zero * Made exact simplifier simplify things like D(sin(3)), ceil(log(pi)), etc. where possible with a little more than the working precision * Improvement of fpminimax (some infinite loops are now avoided) * Infinities and NaN behavior is now IEEE 754-like * Rewrote dirtyinfnorm command and remez command for better performance * Randomized sampling in plot in order to avoid regular patterns Others: * Enable linkage of sollya.h with C++ * Added -Xlinker --allow-multiple-definition for CygWin users * Added --help option * Slight changes in the behavior of autoprint. Introduced new option --oldautoprint for recovering the old behavior * The option --oldrlwrapcompatible is now deprecated. Users should use a recent version of rlwrap supporting "-A" option. And many bugs fixed. ---------------------------------------------------------------------- Changes from version 1.0 to version 1.1: ======================================== Critical bug fixes: * Patched expansion of polynomial terms. Signs and coefficient values could be completely wrong All results previously obtained using Sollya should be re-checked Changes of syntax and output: * Unary + and - are now correctly parsed * Changes in midpointmode. In particular, midpoint values are now parsed back as ranges. * Changed implicit parenthesation order for power operator ^: 2^3^4 is now understood as 2^(3^4) * Integers and binary representations are now read without rounding (see documentation for details) * Added infty, @Inf@, nan, NaN, NAN, @NaN@ lexing/parsing capability Major new functionnalities: * Remez' algorithm is now able to correctly handle cases where the Haar condition is not fulfilled * Added fpminimax command (see documentation for details) * Added ~ operator for evaluating constant expressions * Added roundingwarnings mode (see documentation for details) Improvements in internal handling: * Speeded up dirtyfindzeros when 0 is a zero of the function * Improvement in execution speed of guessdegree Others: * Fixes of many slight bugs and memory leaks * Made Sollya compile under Cygwin (Sollya library untested) * Removed dependance to PARI/GP * New dependency to Damien Stehle's fplll library * Added --help, --oldrlwrapcompatible, --nocolor and --noprompt command-line options * Added check environment * Added color printing sollya-6.0+ds/README000066400000000000000000000033161300174114700141450ustar00rootroot00000000000000Sollya is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. In order to compile the software you will need the following packages installed: - gcc - g++ - gnuplot - gmp - mpfr - mpfi - libxml2-dev - fplll (available at url https://github.com/dstehle/fplll) - libtool In order to compile, use the makefile by invoking it using the following command: ./configure make The configure script coming with this distribution of Sollya supports several --with-*** switches. These switches, as usual, enable the libraries Sollya depends on to be installed in non-standard directories. Please use ./configure --help to get an overview over the different switches. You can finally use the software typing ./sollya or install it with: make install The use of the readline-wrapper rlwrap is highly recommended for interactive work with sollya. If you wish to compile and install Sollya from a fresh git clone, you further need: - bison version 2.4 or later - flex version 2.5.33 or later Bison and flex are really needed if you compile a fresh git clone or if you modify the grammar files contained in the distribution. Otherwise, precompiled versions are found in the distribution and can be used. When compiling a fresh git clone, launch first the autogen.sh shell script before executing the two steps indicated above. Users compiling fresh git clones are recommended to use the --enable-strict-lexer-parser-check option of the configure script. sollya-6.0+ds/assignment.c000066400000000000000000000407321300174114700156040ustar00rootroot00000000000000/* Copyright 2006-2015 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include #include "chain.h" #include "assignment.h" #include "expression.h" #include "execute.h" #include "general.h" chain *addEntry(chain *symTbl, char *name, void *value, void * (*copyValue) (void *)) { entry *newEntry; if (containsEntry(symTbl,name)) return symTbl; newEntry = (entry *) safeMalloc(sizeof(entry)); newEntry->name = (char *) safeCalloc(strlen(name)+1,sizeof(char)); strcpy(newEntry->name,name); newEntry->value = copyValue(value); symTbl = addElement(symTbl,newEntry); return symTbl; } int containsEntry(chain *symTbl, char *name) { chain *curr; curr = symTbl; while (curr != NULL) { if (strcmp(((entry *) (curr->value))->name,name) == 0) return 1; curr = curr->next; } return 0; } void *getEntry(chain *symTbl, char *name, void * (*copyValue) (void *)) { chain *curr; void *result; result = NULL; curr = symTbl; while (curr != NULL) { if (strcmp(((entry *) (curr->value))->name,name) == 0) { result = copyValue(((entry *) curr->value)->value); break; } curr = curr->next; } return result; } void freeEntry(void *e, void (*f) (void *)) { f(((entry *) e)->value); safeFree(((entry *) e)->name); safeFree(e); } chain *removeEntry(chain *symTbl, char *name, void (*f) (void *)) { chain *curr, *prev, *newSymTbl; curr = symTbl; prev = NULL; while (curr != NULL) { if (strcmp(((entry *) (curr->value))->name,name) == 0) { if ((prev == NULL) && (curr->next == NULL)) { newSymTbl = NULL; } else { if (prev == NULL) { newSymTbl = curr->next; } else { prev->next = curr->next; newSymTbl = symTbl; } } freeEntry(((entry *) curr->value),f); safeFree(curr); return newSymTbl; } prev = curr; curr = curr->next; } return symTbl; } void freeSymbolTable(chain *symTbl, void (*f) (void *)) { if (symTbl != NULL) { if (symTbl->next != NULL) freeSymbolTable(symTbl->next,f); freeEntry(symTbl->value,f); safeFree(symTbl); } } void freeNothing(void *thing) { UNUSED_PARAM(thing); return; } void freeDeclaredSymbolTable(chain *declSymTbl, void (*f) (void *)) { chain *curr; curr = declSymTbl; while (curr != NULL) { freeSymbolTable((chain *) (curr->value), f); curr->value = NULL; curr = curr->next; } freeChain(declSymTbl, freeNothing); } char *getEntryName(chain *symTbl, chain *declSymTbl, void *value, int (*f)(void *, void *)) { chain *curr, *currFrame, *currDecl, *currFrameAbove, *currDeclAbove; int shadowed; char *res; /* Go over global symbol table first, for each hit check if the identifier isn't shadowed by the declared symbol table. */ for (curr=symTbl;curr!=NULL;curr=curr->next) { if (f(value, ((entry *) (curr->value))->value)) { /* We have a hit. Check if its name isn't shadowed */ shadowed = 0; for (currFrame=declSymTbl;((currFrame!=NULL)&&(!shadowed));currFrame=currFrame->next) { for (currDecl=((chain *) (currFrame->value));((currDecl!=NULL)&&(!shadowed));currDecl=currDecl->next) { if (strcmp(((entry *) (curr->value))->name, ((entry *) (currDecl->value))->name) == 0) { shadowed = 1; } } } if (!shadowed) { res = (char *) safeCalloc(strlen(((entry *) (curr->value))->name) + 1, sizeof(char)); strcpy(res, ((entry *) (curr->value))->name); return res; } } } /* Now go over the declared symbol table, frame by frame. For each hit check if the identifier isn't shadowed by an identifier in an above frame of the declared symbol table. */ for (currFrame=declSymTbl;currFrame!=NULL;currFrame=currFrame->next) { for (currDecl=((chain *)(currFrame->value));currDecl!=NULL;currDecl=currDecl->next) { if (f(value, ((entry *) (currDecl->value))->value)) { /* We have a hit. Check if its name isn't shadowed in a frame above. */ shadowed = 0; for (currFrameAbove=declSymTbl; ((currFrameAbove!=NULL) && (currFrameAbove!=currFrame) && (!shadowed)); currFrameAbove=currFrameAbove->next) { for (currDeclAbove=((chain *) (currFrameAbove->value));((currDeclAbove!=NULL)&&(!shadowed));currDeclAbove=currDeclAbove->next) { if (strcmp(((entry *) (currDecl->value))->name, ((entry *) (currDeclAbove->value))->name) == 0) { shadowed = 1; } } } if (!shadowed) { res = (char *) safeCalloc(strlen(((entry *) (currDecl->value))->name) + 1, sizeof(char)); strcpy(res, ((entry *) (currDecl->value))->name); return res; } } } } /* We didn't find anything or everything we found was shadowed. */ return NULL; } chain *pushFrame(chain *declSymTbl) { return addElement(declSymTbl, NULL); } chain *popFrame(chain *declSymTbl, void (*f) (void *)) { chain *newDeclSymTbl; if (declSymTbl == NULL) return NULL; newDeclSymTbl = declSymTbl->next; freeSymbolTable((chain *) (declSymTbl->value), f); safeFree(declSymTbl); return newDeclSymTbl; } chain *declareNewEntry(chain *declSymTbl, char *name, void *value, void * (*copyValue) (void *)) { chain *newValue; if (declSymTbl == NULL) return NULL; if (containsEntry((chain *) (declSymTbl->value), name)) return declSymTbl; newValue = addEntry((chain *) (declSymTbl->value), name, value, copyValue); declSymTbl->value = newValue; return declSymTbl; } chain *replaceDeclaredEntry(chain *declSymTbl, char *name, void *value, void * (*copyValue) (void *), void (*freeValue) (void *)) { chain *curr; chain *newValue; if (declSymTbl == NULL) return NULL; curr = declSymTbl; while (curr != NULL) { if (containsEntry((chain *) (curr->value), name)) { newValue = removeEntry((chain *) (curr->value), name, freeValue); curr->value = newValue; newValue = addEntry((chain *) (curr->value), name, value, copyValue); curr->value = newValue; break; } curr = curr->next; } return declSymTbl; } int containsDeclaredEntry(chain *declSymTbl, char *name) { chain *curr; curr = declSymTbl; while (curr != NULL) { if (containsEntry((chain *) (curr->value), name)) return 1; curr = curr->next; } return 0; } void *getDeclaredEntry(chain *declSymTbl, char *name, void * (*copyValue) (void *)) { chain *curr; curr = declSymTbl; while (curr != NULL) { if (containsEntry((chain *) (curr->value), name)) return getEntry((chain *) (curr->value), name, copyValue); curr = curr->next; } return NULL; } chain *assignDeclaredEntry(chain *declSymTbl, char *name, void *value, void * (*copyValue) (void *), void (*freeValue) (void *)) { chain *newDeclSymTbl; if (containsDeclaredEntry(declSymTbl, name)) newDeclSymTbl = replaceDeclaredEntry(declSymTbl, name, value, copyValue, freeValue); else newDeclSymTbl = declareNewEntry(declSymTbl, name, value, copyValue); return newDeclSymTbl; } int performListPrependOnEntry(chain *symTbl, char *ident, node *tree) { chain *curr, *newArgs; node *oldNode, *newNode; int okay; int oldChecked, addedChecked, newChecked; size_t neededSize; oldChecked = 0; newChecked = 0; addedChecked = 0; if ((tree->nodeType == MEMREF) && (tree->isCorrectlyTyped)) addedChecked = 1; okay = 0; curr = symTbl; while (curr != NULL) { if (strcmp(((entry *) (curr->value))->name,ident) == 0) { oldNode = (node *) (((entry *) curr->value)->value); if (oldNode->nodeType == MEMREF) { oldNode->hashComputed = 0; } if ((oldNode->nodeType == MEMREF) && (oldNode->isCorrectlyTyped)) oldChecked = 1; newChecked = oldChecked && addedChecked; while (1) { if (oldNode->nodeType != MEMREF) break; else { if (!newChecked) oldNode->isCorrectlyTyped = 0; } if (oldNode->libFunDeriv > 1) break; oldNode = getMemRefChild(oldNode); } switch (oldNode->nodeType) { case MEMREF: if (!newChecked) oldNode->isCorrectlyTyped = 0; if (oldNode->libFunDeriv > 1) { if ((getMemRefChild(oldNode)->nodeType == LIST) || (getMemRefChild(oldNode)->nodeType == FINALELLIPTICLIST)) { newArgs = addElement(copyChainWithoutReversal(getMemRefChild(oldNode)->arguments, copyThingOnVoid), tree); newNode = (node *) safeMalloc(sizeof(node)); newNode->nodeType = getMemRefChild(oldNode)->nodeType; newNode->argArray = NULL; newNode->argArraySize = 0; newNode->argArrayAllocSize = 0; newNode->arguments = newArgs; newNode = addMemRef(newNode); if (newChecked && (newNode->nodeType == MEMREF)) { newNode->isCorrectlyTyped = 1; } ((entry *) curr->value)->value = newNode; freeThing(oldNode); okay = 1; } else { newNode = deepCopyThing(oldNode); if ((newNode->nodeType == LIST) || (newNode->nodeType == FINALELLIPTICLIST)) { freeThing(oldNode); newNode->arguments = addElement(newNode->arguments, tree); newNode->argArray = NULL; newNode->argArraySize = 0; newNode->argArrayAllocSize = 0; newNode = addMemRef(newNode); /* We might want to re-use the re-usable memref'ed parts of the original expression here */ ((entry *) curr->value)->value = newNode; if (newChecked && (newNode->nodeType == MEMREF)) { newNode->isCorrectlyTyped = 1; } okay = 1; } else { freeThing(newNode); } } } break; case LIST: case FINALELLIPTICLIST: oldNode->arguments = addElement(oldNode->arguments, tree); if (oldNode->argArray != NULL) { neededSize = ((size_t) (oldNode->argArraySize + 1)) * sizeof(node *); if (neededSize <= (oldNode->argArrayAllocSize)) { oldNode->argArraySize++; (oldNode->argArray)[(oldNode->argArraySize - 1) - 0] = tree; } else { if ((neededSize <= ((size_t) (2 * oldNode->argArrayAllocSize))) && (((size_t) (2 * oldNode->argArrayAllocSize)) <= ((size_t) SOLLYA_MAX_ARG_ARRAY_ALLOC_SIZE)) && (((size_t) (2 * oldNode->argArrayAllocSize)) > ((size_t) 0))) { oldNode->argArrayAllocSize = (size_t) (2 * oldNode->argArrayAllocSize); oldNode->argArray = safeRealloc(oldNode->argArray, oldNode->argArrayAllocSize); oldNode->argArraySize++; (oldNode->argArray)[(oldNode->argArraySize - 1) - 0] = tree; } else { safeFree(oldNode->argArray); oldNode->argArray = NULL; oldNode->argArraySize = 0; oldNode->argArrayAllocSize = 0; } } } okay = 1; break; default: okay = 0; break; } break; } curr = curr->next; } return okay; } int performListPrependOnDeclaredEntry(chain *declSymTbl, char *name, node *tree) { chain *curr; curr = declSymTbl; while (curr != NULL) { if (containsEntry((chain *) (curr->value), name)) return performListPrependOnEntry((chain *) (curr->value), name, tree); curr = curr->next; } return 0; } int performListTailOnEntry(chain *symTbl, char *ident) { chain *curr, *newArgs; node *oldNode, *newNode; int okay; int oldChecked; oldChecked = 0; okay = 0; curr = symTbl; while (curr != NULL) { if (strcmp(((entry *) (curr->value))->name,ident) == 0) { oldNode = (node *) (((entry *) curr->value)->value); if (oldNode->nodeType == MEMREF) { oldNode->hashComputed = 0; } if ((oldNode->nodeType == MEMREF) && (oldNode->isCorrectlyTyped)) oldChecked = 1; while (1) { if (oldNode->nodeType != MEMREF) break; if (oldNode->libFunDeriv > 1) break; oldNode = getMemRefChild(oldNode); } switch (oldNode->nodeType) { case MEMREF: if (oldNode->libFunDeriv > 1) { if (((getMemRefChild(oldNode)->nodeType == LIST) || (getMemRefChild(oldNode)->nodeType == FINALELLIPTICLIST)) && ((getMemRefChild(oldNode)->arguments != NULL) && (getMemRefChild(oldNode)->arguments->next != NULL) && (getMemRefChild(oldNode)->arguments->next != NULL))) { newArgs = copyChainWithoutReversal(getMemRefChild(oldNode)->arguments->next, copyThingOnVoid); newNode = (node *) safeMalloc(sizeof(node)); newNode->nodeType = getMemRefChild(oldNode)->nodeType; newNode->arguments = newArgs; newNode->argArray = NULL; newNode->argArraySize = 0; newNode->argArrayAllocSize = 0; newNode = addMemRef(newNode); if (oldChecked && (newNode->nodeType == MEMREF)) { newNode->isCorrectlyTyped = 1; } ((entry *) curr->value)->value = newNode; freeThing(oldNode); okay = 1; } else { newNode = deepCopyThing(oldNode); if (((newNode->nodeType == LIST) || (newNode->nodeType == FINALELLIPTICLIST)) && ((getMemRefChild(oldNode)->arguments != NULL) && (getMemRefChild(oldNode)->arguments->next != NULL) && (getMemRefChild(oldNode)->arguments->next->next != NULL))) { freeThing(oldNode); freeThing((node *) (newNode->arguments->value)); newArgs = newNode->arguments->next; safeFree(newNode->arguments); newNode->arguments = newArgs; newNode->argArray = NULL; newNode->argArraySize = 0; newNode->argArrayAllocSize = 0; newNode = addMemRef(newNode); /* We might want to re-use the re-usable memref'ed parts of the original expression here */ if (oldChecked && (newNode->nodeType == MEMREF)) { newNode->isCorrectlyTyped = 1; } ((entry *) curr->value)->value = newNode; okay = 1; } else { freeThing(newNode); } } } break; case LIST: case FINALELLIPTICLIST: if ((oldNode->arguments != NULL) && (oldNode->arguments->next != NULL) && (oldNode->arguments->next->next != NULL)) { freeThing((node *) (oldNode->arguments->value)); newArgs = oldNode->arguments->next; safeFree(oldNode->arguments); oldNode->arguments = newArgs; if (oldNode->argArray != NULL) { if (oldNode->argArraySize >= 2) { oldNode->argArraySize--; } else { safeFree(oldNode->argArray); oldNode->argArray = NULL; oldNode->argArraySize = 0; oldNode->argArrayAllocSize = 0; } } okay = 1; } else { okay = 0; } break; default: okay = 0; break; } break; } curr = curr->next; } return okay; } int performListTailOnDeclaredEntry(chain *declSymTbl, char *name) { chain *curr; curr = declSymTbl; while (curr != NULL) { if (containsEntry((chain *) (curr->value), name)) return performListTailOnEntry((chain *) (curr->value), name); curr = curr->next; } return 0; } sollya-6.0+ds/assignment.h000066400000000000000000000070751300174114700156140ustar00rootroot00000000000000/* Copyright 2006-2014 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef ASSIGNMENT_H #define ASSIGNMENT_H #include "expression.h" #include "chain.h" typedef struct entryStruct entry; struct entryStruct { char *name; void *value; }; chain *addEntry(chain *symTbl, char *name, void *value, void * (*copyValue) (void *)); int containsEntry(chain *symTbl, char *name); void *getEntry(chain *symTbl, char *name, void * (*copyValue) (void *)); chain *removeEntry(chain *symTbl, char *name, void (*f) (void *)); void freeSymbolTable(chain *symTbl, void (*f) (void *)); void freeDeclaredSymbolTable(chain *declSymTbl, void (*f) (void *)); chain *pushFrame(chain *declSymTbl); chain *popFrame(chain *declSymTbl, void (*f) (void *)); int containsDeclaredEntry(chain *declSymTbl, char *name); void *getDeclaredEntry(chain *declSymTbl, char *name, void * (*copyValue) (void *)); chain *assignDeclaredEntry(chain *declSymTbl, char *name, void *value, void * (*copyValue) (void *), void (*freeValue) (void *)); chain *declareNewEntry(chain *declSymTbl, char *name, void *value, void * (*copyValue) (void *)); char *getEntryName(chain *symTbl, chain *declSymTbl, void *value, int (*f)(void *, void *)); int performListPrependOnDeclaredEntry(chain *symTbl, char *ident, node *tree); int performListPrependOnEntry(chain *symTbl, char *ident, node *tree); int performListTailOnDeclaredEntry(chain *symTbl, char *ident); int performListTailOnEntry(chain *symTbl, char *ident); #endif /* ifdef ASSIGNMENT_H*/ sollya-6.0+ds/autodiff.c000066400000000000000000001415361300174114700152410ustar00rootroot00000000000000/* Copyright 2008-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors S. Chevillard, M. Joldes, Ch. Lauter sylvain.chevillard@ens-lyon.org joldes@laas.fr christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "autodiff.h" #include "general.h" #include "infnorm.h" #include "execute.h" #include /* The functions in AD manipulate arrays of size (n+1): [u0...un] */ /* Each array is supposed to represent a function u at a given */ /* point x0. The value ui is a small sollya_mpfi_t such that */ /* u^(i)(x0)/i! belongs to ui */ /* Apply Leibniz' formula: (uv)_p = sum(i=0..p, u_i * v_(p-i)) */ void multiplication_AD(sollya_mpfi_t *res, sollya_mpfi_t *f, sollya_mpfi_t *g, int n) { int i,j,p; sollya_mpfi_t temp; mp_prec_t prec; sollya_mpfi_t *temp_array; prec = getToolPrecision(); sollya_mpfi_init2(temp, prec); temp_array = (sollya_mpfi_t *)safeCalloc((n+1),sizeof(sollya_mpfi_t)); for(p=0;p<=n;p++) sollya_mpfi_init2(temp_array[p], prec); for(p=0; p<=n; p++) { sollya_mpfi_set_ui(temp_array[p], 0); i=0; j=p; while(i<=p) { sollya_mpfi_mul(temp, f[i], g[j]); sollya_mpfi_add(temp_array[p], temp_array[p], temp); i++; j--; } } for(p=0; p<=n; p++) { sollya_mpfi_set(res[p], temp_array[p]); sollya_mpfi_clear(temp_array[p]); } safeFree(temp_array); sollya_mpfi_clear(temp); return; } /* Generic recursive algorithm for the successive derivation of (g o f) */ /* The array [f0...fn] represents a function f at point x0 */ /* The array [g0...gn] represents a function g at point f(x0) */ /* Algo: */ /* If n==0, return [g0] */ /* Else, (g o f)^(i+1) = ((g o f)')^(i) = (f' * (g' o f))^(i) = h^(i) */ /* So (g o f)^(i+1) / (i+1)! = (1/(i+1)) * h^(i)/i! */ /* So we compute the array [w0 ... w(n-1)] corresponding to */ /* (g' o f), up to order (n-1) (by a recursive call) */ /* We apply multiplication_AD to w and [(1*f1) ... (n*fn)] */ /* (we remark that [(1*f1) ... (n*fn)] corresponds to f') */ /* This leads to an array [h0...h(n-1)] corresponding to h */ /* Finally, we return [g0 (h0/1) ... (h(n-1)/n)] */ void composition_AD(sollya_mpfi_t *res, sollya_mpfi_t *g, sollya_mpfi_t *f, int n) { sollya_mpfi_t *fprime, *gprime; sollya_mpfi_t *temp_array; int i; mp_prec_t prec; prec = getToolPrecision(); if(n==0) sollya_mpfi_set(res[0], g[0]); else { temp_array = (sollya_mpfi_t *)safeCalloc(n,sizeof(sollya_mpfi_t)); fprime = (sollya_mpfi_t *)safeCalloc(n,sizeof(sollya_mpfi_t)); gprime = (sollya_mpfi_t *)safeCalloc(n,sizeof(sollya_mpfi_t)); for(i=0;i<=n-1;i++) { sollya_mpfi_init2(temp_array[i], prec); sollya_mpfi_init2(fprime[i], prec); sollya_mpfi_init2(gprime[i], prec); sollya_mpfi_mul_ui(fprime[i], f[i+1], i+1); sollya_mpfi_mul_ui(gprime[i], g[i+1], i+1); } composition_AD(temp_array, gprime, f, n-1); multiplication_AD(res+1, temp_array, fprime, n-1); sollya_mpfi_set(res[0], g[0]); for(i=1; i<=n; i++) sollya_mpfi_div_ui(res[i], res[i], i); for(i=0; i<=n-1; i++) { sollya_mpfi_clear(temp_array[i]); sollya_mpfi_clear(fprime[i]); sollya_mpfi_clear(gprime[i]); } safeFree(temp_array); safeFree(fprime); safeFree(gprime); } return ; } void binary_function_diff(sollya_mpfi_t *res, int nodeType, sollya_mpfi_t x0, node *f, node *g, int n, int *silent) { int i; sollya_mpfi_t *res1, *res2, *temp_array; mpfr_t minusOne; mp_prec_t prec; prec = getToolPrecision(); res1 = (sollya_mpfi_t *)safeCalloc((n+1),sizeof(sollya_mpfi_t)); res2 = (sollya_mpfi_t *)safeCalloc((n+1),sizeof(sollya_mpfi_t)); for(i=0;i<=n;i++) { sollya_mpfi_init2(res1[i], prec); sollya_mpfi_init2(res2[i], prec); } auto_diff_scaled(res1, f, x0, n); auto_diff_scaled(res2, g, x0, n); switch(nodeType) { case ADD: for(i=0; i<=n; i++) sollya_mpfi_add(res[i], res1[i], res2[i]); break; case SUB: for(i=0; i<=n; i++) sollya_mpfi_sub(res[i], res1[i], res2[i]); break; case MUL: multiplication_AD(res, res1, res2, n); break; case DIV: /* We compute it by g/h = g * h^{-1} */ temp_array = (sollya_mpfi_t *)safeCalloc((n+1),sizeof(sollya_mpfi_t)); for(i=0;i<=n;i++) sollya_mpfi_init2(temp_array[i], prec); /* temp_array corresponds to x->1/x at point h(x0) */ mpfr_init2(minusOne, prec); mpfr_set_si(minusOne, -1, GMP_RNDN); constantPower_diff(temp_array, res2[0], minusOne, n, silent); mpfr_clear(minusOne); /* temp_array corresponds to (x->1/x)(h) = 1/h */ composition_AD(temp_array, temp_array, res2, n); /* res corresponds to g * 1/h */ multiplication_AD(res, res1, temp_array, n); for(i=0;i<=n;i++) sollya_mpfi_clear(temp_array[i]); safeFree(temp_array); break; default: sollyaFprintf(stderr, "Error in autodiff: unknown binary operator (%d)\n", nodeType); return; } for(i=0;i<=n;i++) { sollya_mpfi_clear(res1[i]); sollya_mpfi_clear(res2[i]); } safeFree(res1); safeFree(res2); } /* Computes the successive derivatives of y -> y^p at point x */ /* [x^p/0! p*x^(p-1)/1! ... p*(p-1)*...*(p-n+1)*x^(p-n)/n! ] */ void constantPower_diff(sollya_mpfi_t *res, sollya_mpfi_t x, mpfr_t p, int n, int *silent) { sollya_mpfi_t expo, acc; mp_prec_t prec_expo, prec; int i; UNUSED_PARAM(silent); prec = getToolPrecision(); prec_expo = (prec > mpfr_get_prec(p))?prec:mpfr_get_prec(p); sollya_mpfi_init2(expo, prec_expo); sollya_mpfi_init2(acc, prec); sollya_mpfi_set_fr(expo, p); sollya_mpfi_set_ui(acc, 1); for(i=0; i<=n; i++) { if (sollya_mpfi_is_zero(acc)) sollya_mpfi_set_ui(res[i],0); else { sollya_mpfi_pow(res[i], x, expo); sollya_mpfi_mul(res[i], res[i], acc); sollya_mpfi_mul(acc, acc, expo); sollya_mpfi_div_ui(acc, acc, i+1); sollya_mpfi_sub_ui(expo, expo, 1); } } sollya_mpfi_clear(expo); sollya_mpfi_clear(acc); return; } /* the power function is: p^x, where p is a positive constant */ /* [p^x/0!, log(p)p^x/1!, ... , log(p)^n p^x / n! ] */ void powerFunction_diff(sollya_mpfi_t *res, mpfr_t p, sollya_mpfi_t x, int n, int *silent) { int i; sollya_mpfi_t temp1,temp2; mp_prec_t prec; UNUSED_PARAM(silent); prec = getToolPrecision(); sollya_mpfi_init2(temp1, prec); sollya_mpfi_init2(temp2, prec); sollya_mpfi_set_fr(temp1,p); sollya_mpfi_pow(temp2, temp1, x); /* temp2 = p^x */ sollya_mpfi_log(temp1,temp1); /* temp1 = log(p) */ for(i=0;i<=n;i++) { sollya_mpfi_set(res[i], temp2); sollya_mpfi_mul(temp2,temp2,temp1); sollya_mpfi_div_ui(temp2, temp2, i+1); } sollya_mpfi_clear(temp1); sollya_mpfi_clear(temp2); return; } void exp_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i; sollya_mpfi_t temp; mp_prec_t prec; UNUSED_PARAM(silent); prec = getToolPrecision(); sollya_mpfi_init2(temp, prec); sollya_mpfi_exp(temp, x); for(i=0;i<=n;i++) { sollya_mpfi_set(res[i], temp); sollya_mpfi_div_ui(temp, temp, i+1); } sollya_mpfi_clear(temp); return; } void expm1_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { exp_diff(res, x, n, silent); sollya_mpfi_sub_ui(res[0], res[0], 1); return; } void log_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { mpfr_t minusOne; mp_prec_t prec; int i; prec = getToolPrecision(); sollya_mpfi_log(res[0], x); if(n>=1) { mpfr_init2(minusOne, prec); mpfr_set_si(minusOne, -1, GMP_RNDN); constantPower_diff(res+1, x, minusOne, n-1, silent); mpfr_clear(minusOne); } for(i=1;i<=n;i++) sollya_mpfi_div_ui(res[i], res[i], i); return; } void log1p_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { mpfr_t minusOne; sollya_mpfi_t u; int i; mp_prec_t prec; prec = getToolPrecision(); sollya_mpfi_log1p(res[0], x); if(n>=1) { sollya_mpfi_init2(u, prec); sollya_mpfi_add_ui(u, x, 1); mpfr_init2(minusOne, prec); mpfr_set_si(minusOne, -1, GMP_RNDN); constantPower_diff(res+1, u, minusOne, n-1, silent); mpfr_clear(minusOne); sollya_mpfi_clear(u); } for(i=1;i<=n;i++) sollya_mpfi_div_ui(res[i], res[i], i); return; } /* log2(x) = log(x) * (1/log(2)) */ void log2_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i; sollya_mpfi_t log2; mp_prec_t prec; prec = getToolPrecision(); sollya_mpfi_init2(log2, prec); sollya_mpfi_set_ui(log2, 2); sollya_mpfi_log(log2, log2); log_diff(res,x,n,silent); for(i=0;i<=n;i++) sollya_mpfi_div(res[i], res[i], log2); sollya_mpfi_clear(log2); return; } /* idem */ void log10_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i; sollya_mpfi_t log10; mp_prec_t prec; prec = getToolPrecision(); sollya_mpfi_init2(log10, prec); sollya_mpfi_set_ui(log10, 10); sollya_mpfi_log(log10, log10); log_diff(res,x,n,silent); for(i=0;i<=n;i++) sollya_mpfi_div(res[i], res[i], log10); sollya_mpfi_clear(log10); return; } void sin_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i; UNUSED_PARAM(silent); sollya_mpfi_sin(res[0], x); for(i=2; i<=n; i+=2) sollya_mpfi_div_ui(res[i], res[i-2], (i-1)*i); for(i=2; i<=n; i +=4) sollya_mpfi_neg(res[i], res[i]); if(n>=1) { sollya_mpfi_cos(res[1], x); for(i=3; i<=n; i+=2) sollya_mpfi_div_ui(res[i], res[i-2], (i-1)*i); for(i=3; i<=n; i +=4) sollya_mpfi_neg(res[i], res[i]); } return; } void cos_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i; UNUSED_PARAM(silent); sollya_mpfi_cos(res[0], x); for(i=2; i<=n; i+=2) sollya_mpfi_div_ui(res[i], res[i-2], (i-1)*i); for(i=2; i<=n; i +=4) sollya_mpfi_neg(res[i], res[i]); if(n>=1) { sollya_mpfi_sin(res[1], x); for(i=3; i<=n; i+=2) sollya_mpfi_div_ui(res[i], res[i-2], (i-1)*i); for(i=1; i<=n; i +=4) sollya_mpfi_neg(res[i], res[i]); } return; } void sinh_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i; UNUSED_PARAM(silent); sollya_mpfi_sinh(res[0], x); for(i=2; i<=n; i+=2) sollya_mpfi_div_ui(res[i], res[i-2], (i-1)*i); if(n>=1) { sollya_mpfi_cosh(res[1], x); for(i=3; i<=n; i+=2) sollya_mpfi_div_ui(res[i], res[i-2], (i-1)*i); } return; } void cosh_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i; UNUSED_PARAM(silent); sollya_mpfi_cosh(res[0], x); for(i=2; i<=n; i+=2) sollya_mpfi_div_ui(res[i], res[i-2], (i-1)*i); if(n>=1) { sollya_mpfi_sinh(res[1], x); for(i=3; i<=n; i+=2) sollya_mpfi_div_ui(res[i], res[i-2], (i-1)*i); } return; } /* Takes a polynomial given by the array of its coefficients [p0...pn] and differentiates it (returns the array of the derivative) */ /* It IS safe to use the same pointer for res and coeff_array */ /* (in-place computation) */ void symbolic_poly_diff(sollya_mpfi_t *res, sollya_mpfi_t *coeff_array, int degree) { int i; for(i=0;i<=degree-1;i++) sollya_mpfi_mul_ui(res[i], coeff_array[i+1], i+1); } /* Evaluates a symbolic polynomial at point x by Horner scheme */ void symbolic_poly_evaluation_horner(sollya_mpfi_t res, sollya_mpfi_t *coeffs_array, sollya_mpfi_t x, int degree) { int i; sollya_mpfi_t temp; mp_prec_t prec; prec = getToolPrecision(); sollya_mpfi_init2(temp, prec); sollya_mpfi_set(temp, coeffs_array[degree]); for(i=degree-1;i>=0;i--) { sollya_mpfi_mul(temp, temp, x); sollya_mpfi_add(temp, temp, coeffs_array[i]); } sollya_mpfi_set(res, temp); sollya_mpfi_clear(temp); } /* Evaluates a symbolic polynomial at point x by computing successive powers */ void symbolic_poly_evaluation_powers(sollya_mpfi_t res, sollya_mpfi_t *coeffs_array, sollya_mpfi_t *powers_array, sollya_mpfi_t x, int degree) { int i; sollya_mpfi_t temp, acc; mp_prec_t prec; UNUSED_PARAM(x); prec = getToolPrecision(); sollya_mpfi_init2(temp, prec); sollya_mpfi_init2(acc, prec); sollya_mpfi_set_ui(acc, 0); for(i=0;i<=degree;i++) { sollya_mpfi_mul(temp, coeffs_array[i], powers_array[i]); sollya_mpfi_add(acc, acc, temp); } sollya_mpfi_set(res, acc); sollya_mpfi_clear(temp); sollya_mpfi_clear(acc); } /* u=tan(x), tan^(n) / n! = p_(n)(u) with p_0 = u; recurrence formula: p_(n+1)(u) = (p_n(u))' / (n+1) = p'_n(u) * (1+u^2) / (n+1) -> p_n of degree n+1 */ void tan_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i,index; sollya_mpfi_t *coeffs_array; sollya_mpfi_t u; mp_prec_t prec; UNUSED_PARAM(silent); prec = getToolPrecision(); coeffs_array = (sollya_mpfi_t *)safeCalloc( (n+2),sizeof(sollya_mpfi_t)); for (index=0; index<=n+1; index++) { sollya_mpfi_init2(coeffs_array[index], prec); sollya_mpfi_set_ui(coeffs_array[index], 0); } sollya_mpfi_init2(u, prec); sollya_mpfi_tan(u, x); sollya_mpfi_set_ui(coeffs_array[0], 0); sollya_mpfi_set_ui(coeffs_array[1], 1); sollya_mpfi_set(res[0], u); for(index=1; index<=n; index++) { /* coeffs_array represents p_(index-1) */ symbolic_poly_diff(coeffs_array, coeffs_array, index); sollya_mpfi_set_ui(coeffs_array[index], 0); /* now it represents p_(index-1)' */ for(i=index+1; i>=2; i--) { sollya_mpfi_add(coeffs_array[i], coeffs_array[i], coeffs_array[i-2]); sollya_mpfi_div_ui(coeffs_array[i], coeffs_array[i], index); } sollya_mpfi_div_ui(coeffs_array[1], coeffs_array[1], index); sollya_mpfi_div_ui(coeffs_array[0], coeffs_array[0], index); /* now it represents p_(index) */ symbolic_poly_evaluation_horner(res[index], coeffs_array, u, index+1); } for (index=0; index<=n+1; index++){ sollya_mpfi_clear(coeffs_array[index]); } sollya_mpfi_clear(u); safeFree(coeffs_array); return; } /* u=tanh(x), tanh^(n) / n! = p_(n)(u) with p_0 = u; recurrence formula: p_(n+1)(u) = (p_n(u))' / (n+1) = p'_n(u) * (1-u^2) / (n+1) -> p_n of degree n+1 */ void tanh_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i,index; sollya_mpfi_t *coeffs_array; sollya_mpfi_t u; mp_prec_t prec; UNUSED_PARAM(silent); prec = getToolPrecision(); coeffs_array = (sollya_mpfi_t *)safeCalloc( (n+2),sizeof(sollya_mpfi_t)); for (index=0; index<=n+1; index++) { sollya_mpfi_init2(coeffs_array[index], prec); sollya_mpfi_set_ui(coeffs_array[index], 0); } sollya_mpfi_init2(u, prec); sollya_mpfi_tanh(u, x); sollya_mpfi_set_ui(coeffs_array[0], 0); sollya_mpfi_set_ui(coeffs_array[1], 1); sollya_mpfi_set(res[0], u); for(index=1; index<=n; index++) { /* coeffs_array represents p_(index-1) */ symbolic_poly_diff(coeffs_array, coeffs_array, index); sollya_mpfi_set_ui(coeffs_array[index], 0); /* now it represents p_(index-1)' */ for(i=index+1; i>=2; i--) { sollya_mpfi_sub(coeffs_array[i], coeffs_array[i], coeffs_array[i-2]); sollya_mpfi_div_ui(coeffs_array[i], coeffs_array[i], index); } sollya_mpfi_div_ui(coeffs_array[1], coeffs_array[1], index); sollya_mpfi_div_ui(coeffs_array[0], coeffs_array[0], index); /* now it represents p_(index) */ symbolic_poly_evaluation_horner(res[index], coeffs_array, u, index+1); } for (index=0; index<=n+1; index++){ sollya_mpfi_clear(coeffs_array[index]); } sollya_mpfi_clear(u); safeFree(coeffs_array); return; } /* atan_diff : reccurence formula: p_(n+1) = (p'_n * (1+x^2) - 2nx * p_n) / (n+1) atan^(0) = atan(x) atan^(n) / n! = p_(n)(x)/((1+x^2)^n) p_1=1; --> degree of p_n is (n-1) */ void atan_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i,index; sollya_mpfi_t *coeffs_array, *coeffs_array_diff; sollya_mpfi_t u, temp; mp_prec_t prec; UNUSED_PARAM(silent); prec = getToolPrecision(); coeffs_array = (sollya_mpfi_t *)safeCalloc( n,sizeof(sollya_mpfi_t)); coeffs_array_diff = (sollya_mpfi_t *)safeCalloc( n,sizeof(sollya_mpfi_t)); for (index=0; index<=n-1; index++) { sollya_mpfi_init2(coeffs_array[index], prec); sollya_mpfi_init2(coeffs_array_diff[index], prec); sollya_mpfi_set_ui(coeffs_array[index], 0); sollya_mpfi_set_ui(coeffs_array_diff[index], 0); } sollya_mpfi_init2(u, prec); sollya_mpfi_init2(temp, prec); sollya_mpfi_atan(res[0], x); if(n>=1) { sollya_mpfi_sqr(u, x); sollya_mpfi_add_ui(u, u, 1); sollya_mpfi_inv(res[1], u); sollya_mpfi_set_ui(coeffs_array[0], 1); } for(index=2; index<=n; index++) { /* coeffs_array represents p_(index-1) */ symbolic_poly_diff(coeffs_array_diff, coeffs_array, index-2); sollya_mpfi_set_ui(coeffs_array_diff[index-2], 0); /* now it represents p_(index-1)' */ for(i=index-1; i>=2; i--) { sollya_mpfi_add(coeffs_array[i], coeffs_array_diff[i], coeffs_array_diff[i-2]); sollya_mpfi_mul_ui(temp, coeffs_array[i-1], 2*(index-1)); sollya_mpfi_sub(coeffs_array[i], coeffs_array[i], temp); sollya_mpfi_div_ui(coeffs_array[i], coeffs_array[i], index); } sollya_mpfi_mul_ui(temp, coeffs_array[0], 2*(index-1)); sollya_mpfi_sub(coeffs_array[1], coeffs_array_diff[1], temp); sollya_mpfi_div_ui(coeffs_array[1], coeffs_array[1], index); sollya_mpfi_set(coeffs_array[0], coeffs_array_diff[0]); sollya_mpfi_div_ui(coeffs_array[0], coeffs_array[0], index); /* now it represents p_(index) */ symbolic_poly_evaluation_horner(res[index], coeffs_array, x, index-1); sollya_mpfi_set_ui(temp, index); sollya_mpfi_pow(temp, u, temp); sollya_mpfi_div(res[index], res[index], temp); } for (index=0; index<=n-1; index++){ sollya_mpfi_clear(coeffs_array[index]); sollya_mpfi_clear(coeffs_array_diff[index]); } sollya_mpfi_clear(u); sollya_mpfi_clear(temp); safeFree(coeffs_array); safeFree(coeffs_array_diff); return; } /* atanh_diff : reccurence formula: p_(n+1) = (p'_n * (1-x^2) + 2nx * p_n)/ (n+1) atanh^(0) = atanh(x) atanh^(n)/n! = p_(n)(x)/((1-x^2)^n) p_1=1; --> degree of p_n is (n-1) */ void atanh_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i,index; sollya_mpfi_t *coeffs_array, *coeffs_array_diff; sollya_mpfi_t u, temp; mp_prec_t prec; UNUSED_PARAM(silent); prec = getToolPrecision(); coeffs_array = (sollya_mpfi_t *)safeCalloc( n,sizeof(sollya_mpfi_t)); coeffs_array_diff = (sollya_mpfi_t *)safeCalloc( n,sizeof(sollya_mpfi_t)); for (index=0; index<=n-1; index++) { sollya_mpfi_init2(coeffs_array[index], prec); sollya_mpfi_init2(coeffs_array_diff[index], prec); sollya_mpfi_set_ui(coeffs_array[index], 0); sollya_mpfi_set_ui(coeffs_array_diff[index], 0); } sollya_mpfi_init2(u, prec); sollya_mpfi_init2(temp, prec); sollya_mpfi_atanh(res[0], x); if(n>=1) { sollya_mpfi_sqr(u, x); sollya_mpfi_sub_ui(u, u, 1); /* TODO: FIX IT when MPFI is patched */ sollya_mpfi_neg(u, u); sollya_mpfi_inv(res[1], u); sollya_mpfi_set_ui(coeffs_array[0], 1); } for(index=2; index<=n; index++) { /* coeffs_array represents p_(index-1) */ symbolic_poly_diff(coeffs_array_diff, coeffs_array, index-2); sollya_mpfi_set_ui(coeffs_array_diff[index-2], 0); /* now it represents p_(index-1)' */ for(i=index-1; i>=2; i--) { sollya_mpfi_sub(coeffs_array[i], coeffs_array_diff[i], coeffs_array_diff[i-2]); sollya_mpfi_mul_ui(temp, coeffs_array[i-1], 2*(index-1)); sollya_mpfi_add(coeffs_array[i], coeffs_array[i], temp); sollya_mpfi_div_ui(coeffs_array[i], coeffs_array[i], index); } sollya_mpfi_mul_ui(temp, coeffs_array[0], 2*(index-1)); sollya_mpfi_add(coeffs_array[1], coeffs_array_diff[1], temp); sollya_mpfi_div_ui(coeffs_array[1], coeffs_array[1], index); sollya_mpfi_set(coeffs_array[0], coeffs_array_diff[0]); sollya_mpfi_div_ui(coeffs_array[0], coeffs_array[0], index); /* now it represents p_(index) */ symbolic_poly_evaluation_horner(res[index], coeffs_array, x, index-1); sollya_mpfi_set_ui(temp, index); sollya_mpfi_pow(temp, u, temp); sollya_mpfi_div(res[index], res[index], temp); } for (index=0; index<=n-1; index++){ sollya_mpfi_clear(coeffs_array[index]); sollya_mpfi_clear(coeffs_array_diff[index]); } sollya_mpfi_clear(u); sollya_mpfi_clear(temp); safeFree(coeffs_array); safeFree(coeffs_array_diff); return; } /* asin_diff : recurrence formula: p_(n+1)= (p'_n * (1-x^2) + (2n-1)x * p_n)/(n+1) asin^(0) = asin(x) asin^(n) / n! = p_(n)(x) / (1-x^2)^((2n-1)/2) p_1=1; --> degree of p_n is (n-1) */ void asin_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i,index; sollya_mpfi_t *coeffs_array, *coeffs_array_diff; sollya_mpfi_t u, temp; mp_prec_t prec; UNUSED_PARAM(silent); prec = getToolPrecision(); coeffs_array = (sollya_mpfi_t *)safeCalloc( n,sizeof(sollya_mpfi_t)); coeffs_array_diff = (sollya_mpfi_t *)safeCalloc( n,sizeof(sollya_mpfi_t)); for (index=0; index<=n-1; index++) { sollya_mpfi_init2(coeffs_array[index], prec); sollya_mpfi_init2(coeffs_array_diff[index], prec); sollya_mpfi_set_ui(coeffs_array[index], 0); sollya_mpfi_set_ui(coeffs_array_diff[index], 0); } sollya_mpfi_init2(u, prec); sollya_mpfi_init2(temp, prec); sollya_mpfi_asin(res[0], x); if(n>=1) { sollya_mpfi_sqr(u, x); sollya_mpfi_sub_ui(u, u, 1); /* TODO: FIX IT when MPFI is patched */ sollya_mpfi_neg(u, u); sollya_mpfi_sqrt(u, u); sollya_mpfi_inv(res[1], u); sollya_mpfi_set_ui(coeffs_array[0], 1); } for(index=2; index<=n; index++) { /* coeffs_array represents p_(index-1) */ symbolic_poly_diff(coeffs_array_diff, coeffs_array, index-2); sollya_mpfi_set_ui(coeffs_array_diff[index-2], 0); /* now it represents p_(index-1)' */ for(i=index-1; i>=2; i--) { sollya_mpfi_sub(coeffs_array[i], coeffs_array_diff[i], coeffs_array_diff[i-2]); sollya_mpfi_mul_ui(temp, coeffs_array[i-1], 2*(index-1)-1); sollya_mpfi_add(coeffs_array[i], coeffs_array[i], temp); sollya_mpfi_div_ui(coeffs_array[i], coeffs_array[i], index); } sollya_mpfi_mul_ui(temp, coeffs_array[0], 2*(index-1)-1); sollya_mpfi_add(coeffs_array[1], coeffs_array_diff[1], temp); sollya_mpfi_div_ui(coeffs_array[1], coeffs_array[1], index); sollya_mpfi_set(coeffs_array[0], coeffs_array_diff[0]); sollya_mpfi_div_ui(coeffs_array[0], coeffs_array[0], index); /* now it represents p_(index) */ symbolic_poly_evaluation_horner(res[index], coeffs_array, x, index-1); sollya_mpfi_set_ui(temp, 2*index-1); sollya_mpfi_pow(temp, u, temp); sollya_mpfi_div(res[index], res[index], temp); } for (index=0; index<=n-1; index++){ sollya_mpfi_clear(coeffs_array[index]); sollya_mpfi_clear(coeffs_array_diff[index]); } sollya_mpfi_clear(u); sollya_mpfi_clear(temp); safeFree(coeffs_array); safeFree(coeffs_array_diff); return; } /* acos_diff : except for the res[0], all the terms are equal to -asin^(n)(x)/n! */ void acos_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i; asin_diff(res,x,n,silent); sollya_mpfi_acos(res[0], x); for (i=1; i<=n;i++) sollya_mpfi_neg(res[i], res[i]); return; } /* asinh_diff : recurrence formula: p_(n+1) = (p'_n * (1+x^2) - (2n-1)x * p_n) / (n+1) asinh^(0) = asinh(x) asinh^(n)/n! = p_(n)(x) / (1+x^2)^((2n-1)/2) p_1=1; --> degree of p_n is (n-1) */ void asinh_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i,index; sollya_mpfi_t *coeffs_array, *coeffs_array_diff; sollya_mpfi_t u, temp; mp_prec_t prec; UNUSED_PARAM(silent); prec = getToolPrecision(); coeffs_array = (sollya_mpfi_t *)safeCalloc( n,sizeof(sollya_mpfi_t)); coeffs_array_diff = (sollya_mpfi_t *)safeCalloc( n,sizeof(sollya_mpfi_t)); for (index=0; index<=n-1; index++) { sollya_mpfi_init2(coeffs_array[index], prec); sollya_mpfi_init2(coeffs_array_diff[index], prec); sollya_mpfi_set_ui(coeffs_array[index], 0); sollya_mpfi_set_ui(coeffs_array_diff[index], 0); } sollya_mpfi_init2(u, prec); sollya_mpfi_init2(temp, prec); sollya_mpfi_asinh(res[0], x); if(n>=1) { sollya_mpfi_sqr(u, x); sollya_mpfi_add_ui(u, u, 1); sollya_mpfi_sqrt(u, u); sollya_mpfi_inv(res[1], u); sollya_mpfi_set_ui(coeffs_array[0], 1); } for(index=2; index<=n; index++) { /* coeffs_array represents p_(index-1) */ symbolic_poly_diff(coeffs_array_diff, coeffs_array, index-2); sollya_mpfi_set_ui(coeffs_array_diff[index-2], 0); /* now it represents p_(index-1)' */ for(i=index-1; i>=2; i--) { sollya_mpfi_add(coeffs_array[i], coeffs_array_diff[i], coeffs_array_diff[i-2]); sollya_mpfi_mul_ui(temp, coeffs_array[i-1], 2*(index-1)-1); sollya_mpfi_sub(coeffs_array[i], coeffs_array[i], temp); sollya_mpfi_div_ui(coeffs_array[i], coeffs_array[i], index); } sollya_mpfi_mul_ui(temp, coeffs_array[0], 2*(index-1)-1); sollya_mpfi_sub(coeffs_array[1], coeffs_array_diff[1], temp); sollya_mpfi_div_ui(coeffs_array[1], coeffs_array[1], index); sollya_mpfi_set(coeffs_array[0], coeffs_array_diff[0]); sollya_mpfi_div_ui(coeffs_array[0], coeffs_array[0], index); /* now it represents p_(index) */ symbolic_poly_evaluation_horner(res[index], coeffs_array, x, index-1); sollya_mpfi_set_ui(temp, 2*index-1); sollya_mpfi_pow(temp, u, temp); sollya_mpfi_div(res[index], res[index], temp); } for (index=0; index<=n-1; index++){ sollya_mpfi_clear(coeffs_array[index]); sollya_mpfi_clear(coeffs_array_diff[index]); } sollya_mpfi_clear(u); sollya_mpfi_clear(temp); safeFree(coeffs_array); safeFree(coeffs_array_diff); return; } /* acosh_diff : recurrence formula: p_(n+1) = (p'_n * (x^2-1) - (2n-1)x * p_n) / (n+1) acosh^(0) = acosh(x) acosh^(n)/n! = p_(n)(x) / (x^2-1)^((2n-1)/2) p_1=1; --> degree of p_n is (n-1) */ void acosh_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i,index; sollya_mpfi_t *coeffs_array, *coeffs_array_diff; sollya_mpfi_t u, temp; mp_prec_t prec; UNUSED_PARAM(silent); prec = getToolPrecision(); coeffs_array = (sollya_mpfi_t *)safeCalloc( n,sizeof(sollya_mpfi_t)); coeffs_array_diff = (sollya_mpfi_t *)safeCalloc( n,sizeof(sollya_mpfi_t)); for (index=0; index<=n-1; index++) { sollya_mpfi_init2(coeffs_array[index], prec); sollya_mpfi_init2(coeffs_array_diff[index], prec); sollya_mpfi_set_ui(coeffs_array[index], 0); sollya_mpfi_set_ui(coeffs_array_diff[index], 0); } sollya_mpfi_init2(u, prec); sollya_mpfi_init2(temp, prec); sollya_mpfi_acosh(res[0], x); if(n>=1) { sollya_mpfi_sqr(u, x); sollya_mpfi_sub_ui(u, u, 1); sollya_mpfi_sqrt(u, u); sollya_mpfi_inv(res[1], u); sollya_mpfi_set_ui(coeffs_array[0], 1); } for(index=2; index<=n; index++) { /* coeffs_array represents p_(index-1) */ symbolic_poly_diff(coeffs_array_diff, coeffs_array, index-2); sollya_mpfi_set_ui(coeffs_array_diff[index-2], 0); /* now it represents p_(index-1)' */ for(i=index-1; i>=2; i--) { sollya_mpfi_sub(coeffs_array[i], coeffs_array_diff[i-2], coeffs_array_diff[i]); sollya_mpfi_mul_ui(temp, coeffs_array[i-1], 2*(index-1)-1); sollya_mpfi_sub(coeffs_array[i], coeffs_array[i], temp); sollya_mpfi_div_ui(coeffs_array[i], coeffs_array[i], index); } sollya_mpfi_mul_ui(temp, coeffs_array[0], 2*(index-1)-1); sollya_mpfi_add(coeffs_array[1], temp, coeffs_array_diff[1]); sollya_mpfi_neg(coeffs_array[1], coeffs_array[1]); sollya_mpfi_div_ui(coeffs_array[1], coeffs_array[1], index); sollya_mpfi_neg(coeffs_array[0], coeffs_array_diff[0]); sollya_mpfi_div_ui(coeffs_array[0], coeffs_array[0], index); /* now it represents p_(index) */ symbolic_poly_evaluation_horner(res[index], coeffs_array, x, index-1); sollya_mpfi_set_ui(temp, 2*index-1); sollya_mpfi_pow(temp, u, temp); sollya_mpfi_div(res[index], res[index], temp); } for (index=0; index<=n-1; index++){ sollya_mpfi_clear(coeffs_array[index]); sollya_mpfi_clear(coeffs_array_diff[index]); } sollya_mpfi_clear(u); sollya_mpfi_clear(temp); safeFree(coeffs_array); safeFree(coeffs_array_diff); return; } /* erf^(n)(x)/n! = p_n(x)*e^(-x^2) */ /* with p_1(x) = 2/sqrt(pi) */ /* and p_(n+1)(x) = (p_n'(x) - 2xp_n(x))/(n+1) */ /* -> degree of p_n is n-1 */ void erf_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i,index; sollya_mpfi_t *coeffs_array, *coeffs_array_diff; sollya_mpfi_t u, temp; mp_prec_t prec; UNUSED_PARAM(silent); prec = getToolPrecision(); coeffs_array = (sollya_mpfi_t *)safeCalloc( n,sizeof(sollya_mpfi_t)); coeffs_array_diff = (sollya_mpfi_t *)safeCalloc( n,sizeof(sollya_mpfi_t)); for (index=0; index<=n-1; index++) { sollya_mpfi_init2(coeffs_array[index], prec); sollya_mpfi_init2(coeffs_array_diff[index], prec); sollya_mpfi_set_ui(coeffs_array[index], 0); sollya_mpfi_set_ui(coeffs_array_diff[index], 0); } sollya_mpfi_init2(u, prec); sollya_mpfi_init2(temp, prec); sollya_mpfi_erf(res[0], x); if(n>=1) { sollya_mpfi_const_pi(temp); sollya_mpfi_sqrt(temp, temp); sollya_mpfi_ui_div(temp, 2, temp); sollya_mpfi_sqr(u, x); sollya_mpfi_neg(u, u); sollya_mpfi_exp(u, u); sollya_mpfi_mul(res[1], temp, u); sollya_mpfi_set(coeffs_array[0], temp); } for(index=2; index<=n; index++) { /* coeffs_array represents p_(index-1) */ symbolic_poly_diff(coeffs_array_diff, coeffs_array, index-2); sollya_mpfi_set_ui(coeffs_array_diff[index-2], 0); /* now it represents p_(index-1)' */ for(i=index-1; i>=1; i--) { sollya_mpfi_mul_ui(temp, coeffs_array[i-1], 2); sollya_mpfi_sub(coeffs_array[i], coeffs_array_diff[i], temp); sollya_mpfi_div_ui(coeffs_array[i], coeffs_array[i], index); } sollya_mpfi_set(coeffs_array[0], coeffs_array_diff[0]); sollya_mpfi_div_ui(coeffs_array[0], coeffs_array[0], index); /* now it represents p_(index) */ symbolic_poly_evaluation_horner(res[index], coeffs_array, x, index-1); sollya_mpfi_mul(res[index], res[index], u); } for (index=0; index<=n-1; index++){ sollya_mpfi_clear(coeffs_array[index]); sollya_mpfi_clear(coeffs_array_diff[index]); } sollya_mpfi_clear(u); sollya_mpfi_clear(temp); safeFree(coeffs_array); safeFree(coeffs_array_diff); return; } void erfc_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i; erf_diff(res, x, n, silent); sollya_mpfi_erfc(res[0], x); for (i=1; i<=n;i++) sollya_mpfi_neg(res[i],res[i]); return; } void abs_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent) { int i; mpfr_t temp2; mp_prec_t prec; prec = getToolPrecision(); sollya_mpfi_abs(res[0], x); if(n >= 1) { if (sollya_mpfi_has_zero(x)) sollya_mpfi_interv_si(res[1], -1, 1); else sollya_mpfi_set_si(res[1], sollya_mpfi_is_nonneg(x) ? 1 : (-1)); } if(n >= 2) { mpfr_init2(temp2, prec); mpfr_set_nan(temp2); if (!(*silent)) { *silent = 1; printMessage(1, SOLLYA_MSG_ABS_NOT_TWICE_DIFFERENTIABLE, "Warning: the absolute value is not twice differentiable.\n"); printMessage(1, SOLLYA_MSG_CONTINUATION, "Will return [@NaN@, @NaN@].\n"); } for(i=2;i<=n;i++) sollya_mpfi_set_fr(res[i], temp2); mpfr_clear(temp2); } return; } void single_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent){ int i; mpfr_t temp; mp_prec_t prec; UNUSED_PARAM(x); prec = getToolPrecision(); mpfr_init2(temp, prec); mpfr_set_nan(temp); if (!(*silent)) { *silent = 1; printMessage(1, SOLLYA_MSG_SINGLE_NOT_DIFFERENTIABLE, "Warning: the single rounding operator is not differentiable.\n"); printMessage(1, SOLLYA_MSG_CONTINUATION, "Will return [@NaN@, @NaN@].\n"); } for(i=0;i<=n;i++) sollya_mpfi_set_fr(res[i], temp); mpfr_clear(temp); } void quad_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent){ int i; mpfr_t temp; mp_prec_t prec; UNUSED_PARAM(x); prec = getToolPrecision(); mpfr_init2(temp, prec); mpfr_set_nan(temp); if (!(*silent)) { *silent = 1; printMessage(1, SOLLYA_MSG_QUAD_NOT_DIFFERENTIABLE, "Warning: the quad rounding operator is not differentiable.\n"); printMessage(1, SOLLYA_MSG_CONTINUATION, "Will return [@NaN@, @NaN@].\n"); } for(i=0;i<=n;i++) sollya_mpfi_set_fr(res[i], temp); mpfr_clear(temp); } void halfprecision_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent){ int i; mpfr_t temp; mp_prec_t prec; UNUSED_PARAM(x); prec = getToolPrecision(); mpfr_init2(temp, prec); mpfr_set_nan(temp); if (!(*silent)) { *silent = 1; printMessage(1, SOLLYA_MSG_HALF_NOT_DIFFERENTIABLE, "Warning: the half-precision rounding operator is not differentiable.\n"); printMessage(1, SOLLYA_MSG_CONTINUATION, "Will return [@NaN@, @NaN@].\n"); } for(i=0;i<=n;i++) sollya_mpfi_set_fr(res[i], temp); mpfr_clear(temp); } void double_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent){ int i; mpfr_t temp; mp_prec_t prec; UNUSED_PARAM(x); prec = getToolPrecision(); mpfr_init2(temp, prec); mpfr_set_nan(temp); if (!(*silent)) { *silent = 1; printMessage(1, SOLLYA_MSG_DOUBLE_NOT_DIFFERENTIABLE, "Warning: the double rounding operator is not differentiable.\n"); printMessage(1, SOLLYA_MSG_CONTINUATION, "Will return [@NaN@, @NaN@].\n"); } for(i=0;i<=n;i++) sollya_mpfi_set_fr(res[i], temp); mpfr_clear(temp); } void double_double_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent){ int i; mpfr_t temp; mp_prec_t prec; UNUSED_PARAM(x); prec = getToolPrecision(); mpfr_init2(temp, prec); mpfr_set_nan(temp); if (!(*silent)) { *silent = 1; printMessage(1, SOLLYA_MSG_DOUBLE_DOUBLE_NOT_DIFFERENTIABLE, "Warning: the doubledouble rounding operator is not differentiable.\n"); printMessage(1, SOLLYA_MSG_CONTINUATION, "Will return [@NaN@, @NaN@].\n"); } for(i=0;i<=n;i++) sollya_mpfi_set_fr(res[i], temp); mpfr_clear(temp); } void triple_double_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent){ int i; mpfr_t temp; mp_prec_t prec; UNUSED_PARAM(x); prec = getToolPrecision(); mpfr_init2(temp, prec); mpfr_set_nan(temp); if (!(*silent)) { *silent = 1; printMessage(1, SOLLYA_MSG_TRIPLE_DOUBLE_NOT_DIFFERENTIABLE, "Warning: the tripledouble rounding operator is not differentiable.\n"); printMessage(1, SOLLYA_MSG_CONTINUATION, "Will return [@NaN@, @NaN@].\n"); } for(i=0;i<=n;i++) sollya_mpfi_set_fr(res[i], temp); mpfr_clear(temp); } void double_extended_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent){ int i; mpfr_t temp; mp_prec_t prec; UNUSED_PARAM(x); prec = getToolPrecision(); mpfr_init2(temp, prec); mpfr_set_nan(temp); if (!(*silent)) { *silent = 1; printMessage(1, SOLLYA_MSG_DOUBLEEXTENDED_NOT_DIFFERENTIABLE, "Warning: the doubleextended rounding operator is not differentiable.\n"); printMessage(1, SOLLYA_MSG_CONTINUATION, "Will return [@NaN@, @NaN@].\n"); } for(i=0;i<=n;i++) sollya_mpfi_set_fr(res[i], temp); mpfr_clear(temp); } void ceil_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent){ int i; mpfr_t temp; mp_prec_t prec; UNUSED_PARAM(x); prec = getToolPrecision(); mpfr_init2(temp, prec); mpfr_set_nan(temp); if (!(*silent)) { *silent = 1; printMessage(1, SOLLYA_MSG_CEIL_NOT_DIFFERENTIABLE, "Warning: the ceil operator is not differentiable.\n"); printMessage(1, SOLLYA_MSG_CONTINUATION, "Will return [@NaN@, @NaN@].\n"); } for(i=0;i<=n;i++) sollya_mpfi_set_fr(res[i], temp); mpfr_clear(temp); } void floor_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent){ int i; mpfr_t temp; mp_prec_t prec; UNUSED_PARAM(x); prec = getToolPrecision(); mpfr_init2(temp, prec); mpfr_set_nan(temp); if (!(*silent)) { *silent = 1; printMessage(1, SOLLYA_MSG_FLOOR_NOT_DIFFERENTIABLE, "Warning: the floor operator is not differentiable.\n"); printMessage(1, SOLLYA_MSG_CONTINUATION, "Will return [@NaN@, @NaN@].\n"); } for(i=0;i<=n;i++) sollya_mpfi_set_fr(res[i], temp); mpfr_clear(temp); } void nearestint_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent){ int i; mpfr_t temp; mp_prec_t prec; UNUSED_PARAM(x); prec = getToolPrecision(); mpfr_init2(temp, prec); mpfr_set_nan(temp); if (!(*silent)) { *silent = 1; printMessage(1, SOLLYA_MSG_NEARESTINT_NOT_DIFFERENTIABLE, "Warning: the nearestint operator is not differentiable.\n"); printMessage(1, SOLLYA_MSG_CONTINUATION, "Will return [@NaN@, @NaN@].\n"); } for(i=0;i<=n;i++) sollya_mpfi_set_fr(res[i], temp); mpfr_clear(temp); } void libraryFunction_diff(sollya_mpfi_t *res, node *f, sollya_mpfi_t x, int n, int *silent) { sollya_mpfi_t fact, temp, temp2; mp_prec_t prec; int i; UNUSED_PARAM(silent); prec = getToolPrecision(); sollya_mpfi_init2(fact, prec); sollya_mpfi_set_ui(fact, 1); sollya_mpfi_init2(temp, prec); for(i=0;i<=n;i++) { if (accessThruMemRef(f)->libFun->hasData) { ((int (*)(mpfi_t, mpfi_t, int, void *)) (accessThruMemRef(f)->libFun->code))(temp, x, accessThruMemRef(f)->libFunDeriv + i, accessThruMemRef(f)->libFun->data); } else { ((int (*)(mpfi_t, mpfi_t, int)) (accessThruMemRef(f)->libFun->code))(temp, x, accessThruMemRef(f)->libFunDeriv + i); } sollya_init_and_convert_interval(temp2, temp); sollya_mpfi_div(res[i], temp2, fact); sollya_mpfi_clear(temp2); sollya_mpfi_mul_ui(fact, fact, i+1); } sollya_mpfi_clear(fact); sollya_mpfi_clear(temp); } void procedureFunction_diff(sollya_mpfi_t *res, node *f, sollya_mpfi_t x, int n, int *silent) { sollya_mpfi_t fact; mp_prec_t prec; int i; UNUSED_PARAM(silent); prec = getToolPrecision(); sollya_mpfi_init2(fact, prec); sollya_mpfi_set_ui(fact, 1); for(i=0;i<=n;i++) { computeFunctionWithProcedure(res[i], accessThruMemRef(f)->child2, x, (unsigned int) (accessThruMemRef(f)->libFunDeriv + i), f); sollya_mpfi_div(res[i], res[i], fact); sollya_mpfi_mul_ui(fact, fact, i+1); } sollya_mpfi_clear(fact); } void baseFunction_diff(sollya_mpfi_t *res, int nodeType, sollya_mpfi_t x, int n, int *silent) { mpfr_t oneHalf; mp_prec_t prec; prec = getToolPrecision(); int i; switch(nodeType) { case NEG: /* This case is useless since it is handled separately in auto_diff_scaled */ /* However, since x->(-x) could be seen as a base function, and since */ /* baseFunction_diff could be used in another context, we implement it. */ sollya_mpfi_neg(res[0], x); if(n>=1) { sollya_mpfi_set_si(res[1], -1); for(i=2;i<=n;i++) sollya_mpfi_set_ui(res[i], 0); } break; case SQRT: mpfr_init2(oneHalf, prec); mpfr_set_d(oneHalf, 0.5, GMP_RNDN); constantPower_diff(res, x, oneHalf, n, silent); mpfr_clear(oneHalf); break; case ERF: erf_diff(res, x, n, silent); break; case ERFC: erfc_diff(res, x, n, silent); break; case EXP: exp_diff(res, x, n, silent); break; case EXP_M1: expm1_diff(res, x, n, silent); break; case LOG_1P: log1p_diff(res, x, n, silent); break; case LOG: log_diff(res, x, n, silent); break; case LOG_2: log2_diff(res, x, n, silent); break; case LOG_10: log10_diff(res, x, n, silent); break; case SIN: sin_diff(res, x, n, silent); break; case COS: cos_diff(res, x, n, silent); break; case TAN: tan_diff(res, x, n, silent); break; case ASIN: asin_diff(res, x, n, silent); break; case ACOS: acos_diff(res, x, n, silent); break; case ATAN: atan_diff(res, x, n, silent); break; case SINH: sinh_diff(res, x, n, silent); break; case COSH: cosh_diff(res, x, n, silent); break; case TANH: tanh_diff(res, x, n, silent); break; case ASINH: asinh_diff(res, x, n, silent); break; case ACOSH: acosh_diff(res, x, n, silent); break; case ATANH: atanh_diff(res, x, n, silent); break; case ABS: abs_diff(res, x, n, silent); break; case SINGLE: single_diff(res, x, n, silent); break; case QUAD: quad_diff(res, x, n, silent); break; case HALFPRECISION: halfprecision_diff(res, x, n, silent); break; case DOUBLE: double_diff(res, x, n, silent); break; case DOUBLEDOUBLE: double_double_diff(res, x, n, silent); break; case TRIPLEDOUBLE: triple_double_diff(res, x, n, silent); break; case DOUBLEEXTENDED: double_extended_diff(res, x, n, silent); break; case CEIL: ceil_diff(res, x, n, silent); break; case FLOOR: floor_diff(res, x, n, silent); break; case NEARESTINT: nearestint_diff(res, x, n, silent); break; default: sollyaFprintf(stderr,"Error in autodiff: unknown unary function (%d) in the tree\n", nodeType); } return; } /* res is a reserved space for n+1 sollya_mpfi_t such that: */ /* res_i = f^(i)(x0)/i! */ /* We proceed recursively on the structure. */ void auto_diff_scaled(sollya_mpfi_t* res, node *f, sollya_mpfi_t x0, int n) { int i; sollya_mpfi_t *res1, *res2; node *simplifiedChild1, *simplifiedChild2, *tempTree; sollya_mpfi_t temp1, temp2; mp_prec_t prec; int silent = 0; prec = getToolPrecision(); switch (accessThruMemRef(f)->nodeType) { case VARIABLE: sollya_mpfi_set(res[0], x0); if(n>=1) { sollya_mpfi_set_ui(res[1], 1); for(i=2; i<=n; i++) sollya_mpfi_set_ui(res[i], 0); } break; case PI_CONST: sollya_mpfi_const_pi(res[0]); for(i=1; i<=n; i++) sollya_mpfi_set_ui(res[i], 0); break; case LIBRARYCONSTANT: libraryConstantToInterval(res[0], accessThruMemRef(f)); for(i=1; i<=n; i++) sollya_mpfi_set_ui(res[i], 0); break; case CONSTANT: sollya_mpfi_set_fr(res[0], *(accessThruMemRef(f)->value)); for(i=1; i<=n; i++) sollya_mpfi_set_ui(res[i], 0); break; case NEG: auto_diff_scaled(res, accessThruMemRef(f)->child1, x0, n); for(i=0;i<=n;i++) sollya_mpfi_neg(res[i], res[i]); break; case ADD: case SUB: case MUL: case DIV: binary_function_diff(res, accessThruMemRef(f)->nodeType, x0, accessThruMemRef(f)->child1, accessThruMemRef(f)->child2, n, &silent); break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case ABS: case SINGLE: case QUAD: case HALFPRECISION: case DOUBLE: case DOUBLEEXTENDED: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case CEIL: case FLOOR: case NEARESTINT: case LIBRARYFUNCTION: case PROCEDUREFUNCTION: res1 = (sollya_mpfi_t *)safeCalloc((n+1),sizeof(sollya_mpfi_t)); res2 = (sollya_mpfi_t *)safeCalloc((n+1),sizeof(sollya_mpfi_t)); for(i=0;i<=n;i++) { sollya_mpfi_init2(res1[i], prec); sollya_mpfi_init2(res2[i], prec); } auto_diff_scaled(res1, accessThruMemRef(f)->child1, x0, n); if(accessThruMemRef(f)->nodeType==LIBRARYFUNCTION) libraryFunction_diff(res2, accessThruMemRef(f), res1[0], n, &silent); else if(accessThruMemRef(f)->nodeType==PROCEDUREFUNCTION) procedureFunction_diff(res2, accessThruMemRef(f), res1[0], n, &silent); else baseFunction_diff(res2, accessThruMemRef(f)->nodeType, res1[0], n, &silent); composition_AD(res, res2, res1, n); for(i=0;i<=n;i++) { sollya_mpfi_clear(res1[i]); sollya_mpfi_clear(res2[i]); } safeFree(res1); safeFree(res2); break; case POW: simplifiedChild2 = simplifyTreeErrorfree(accessThruMemRef(f)->child2); simplifiedChild1 = simplifyTreeErrorfree(accessThruMemRef(f)->child1); /* x^p case */ if ( (accessThruMemRef(simplifiedChild1)->nodeType == VARIABLE) && (accessThruMemRef(simplifiedChild2)->nodeType == CONSTANT) ) { constantPower_diff(res, x0, *(accessThruMemRef(simplifiedChild2)->value), n, &silent); } /* p^x case */ else if ( (accessThruMemRef(simplifiedChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplifiedChild2)->nodeType == VARIABLE) ) { powerFunction_diff(res, *(accessThruMemRef(simplifiedChild1)->value), x0, n, &silent); } /* p^q case */ else if ( (accessThruMemRef(simplifiedChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplifiedChild2)->nodeType == CONSTANT) ) { sollya_mpfi_init2(temp1, prec); sollya_mpfi_set_fr(temp1, *(accessThruMemRef(simplifiedChild1)->value)); sollya_mpfi_init2(temp2, prec); sollya_mpfi_set_fr(temp2, *(accessThruMemRef(simplifiedChild2)->value)); sollya_mpfi_pow(res[0], temp1, temp2); for(i=1; i<=n; i++) sollya_mpfi_set_ui(res[i], 0); sollya_mpfi_clear(temp1); sollya_mpfi_clear(temp2); } /* p^f or f^p case */ else if ( (accessThruMemRef(simplifiedChild1)->nodeType==CONSTANT) || (accessThruMemRef(simplifiedChild2)->nodeType==CONSTANT) ) { res1 = (sollya_mpfi_t *)safeCalloc((n+1),sizeof(sollya_mpfi_t)); res2 = (sollya_mpfi_t *)safeCalloc((n+1),sizeof(sollya_mpfi_t)); for(i=0;i<=n;i++) { sollya_mpfi_init2(res1[i], prec); sollya_mpfi_init2(res2[i], prec); } if (accessThruMemRef(simplifiedChild1)->nodeType == CONSTANT) { /* p^f */ auto_diff_scaled(res1, simplifiedChild2, x0, n); powerFunction_diff(res2, *(accessThruMemRef(simplifiedChild1)->value), res1[0], n, &silent); } else { /* f^p */ auto_diff_scaled(res1, simplifiedChild1, x0, n); constantPower_diff(res2, res1[0], *(accessThruMemRef(simplifiedChild2)->value), n, &silent); } composition_AD(res, res2, res1, n); for(i=0; i<=n; i++) { sollya_mpfi_clear(res1[i]); sollya_mpfi_clear(res2[i]); } safeFree(res1); safeFree(res2); } /* f^g case */ /* f^g = exp(g*log(f)) */ else { tempTree = makeExp(makeMul(copyTree(simplifiedChild2), makeLog(copyTree(simplifiedChild1)))); auto_diff_scaled(res, tempTree, x0, n); free_memory(tempTree); } free_memory(simplifiedChild1); free_memory(simplifiedChild2); break; default: sollyaFprintf(stderr,"Error in autodiff: unknown identifier (%d) in the tree\n",accessThruMemRef(f)->nodeType); exit(1); } return; } /* res is a reserved space for n+1 sollya_mpfi_t such that: */ /* res_i = f^(i)(x0) */ void auto_diff(sollya_mpfi_t* res, node *f, sollya_mpfi_t x0, int n) { int i; sollya_mpfi_t fact; mp_prec_t prec; prec = getToolPrecision(); sollya_mpfi_init2(fact, prec); sollya_mpfi_set_ui(fact, 1); auto_diff_scaled(res, f, x0, n); for(i=1;i<=n;i++) { sollya_mpfi_mul_ui(fact, fact, i); sollya_mpfi_mul(res[i], res[i], fact); } sollya_mpfi_clear(fact); } sollya-6.0+ds/autodiff.h000066400000000000000000000131251300174114700152360ustar00rootroot00000000000000/* Copyright 2008-2010 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2) Contributors S. Chevillard, M. Joldes, Ch. Lauter sylvain.chevillard@ens-lyon.org joldes@laas.fr christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef AUTODIFF_H #define AUTODIFF_H #include "mpfi-compat.h" #include "expression.h" void symbolic_poly_diff(sollya_mpfi_t *res, sollya_mpfi_t *coeff_array, int degree); void symbolic_poly_evaluation_horner(sollya_mpfi_t res, sollya_mpfi_t *coeffs_array, sollya_mpfi_t x, int degree); void symbolic_poly_evaluation_powers(sollya_mpfi_t res, sollya_mpfi_t *coeffs_array, sollya_mpfi_t *powers_array, sollya_mpfi_t x, int degree); void exp_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void expm1_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void log1p_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void log_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void log2_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void log10_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void sin_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void cos_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void sinh_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void cosh_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void tan_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void tanh_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void atan_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void atanh_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void asin_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void acos_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void asinh_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void acosh_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void erf_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void erfc_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void abs_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, int n, int *silent); void ceil_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent); void double_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent); void double_double_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent); void double_extended_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent); void floor_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent); void nearestint_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent); void single_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent); void triple_double_diff(sollya_mpfi_t *res, sollya_mpfi_t x, int n, int *silent); void libraryFunction_diff(sollya_mpfi_t *res, node *f, sollya_mpfi_t x, int n, int *silent); void procedureFunction_diff(sollya_mpfi_t *res, node *f, sollya_mpfi_t x, int n, int *silent); void powerFunction_diff(sollya_mpfi_t *res, mpfr_t p, sollya_mpfi_t x0, int n, int *silent); void constantPower_diff(sollya_mpfi_t *res, sollya_mpfi_t x0, mpfr_t p, int n, int *silent); void baseFunction_diff(sollya_mpfi_t *res, int nodeType, sollya_mpfi_t x0, int n, int *silent); void multiplication_AD(sollya_mpfi_t *res, sollya_mpfi_t *f, sollya_mpfi_t *g, int n); void composition_AD(sollya_mpfi_t *res, sollya_mpfi_t *g, sollya_mpfi_t *f, int n); void auto_diff_scaled(sollya_mpfi_t* res, node *f, sollya_mpfi_t x0, int n); void auto_diff(sollya_mpfi_t* res, node *f, sollya_mpfi_t x0, int n); #endif /* AUTODIFF_H */ sollya-6.0+ds/bitfields.c000066400000000000000000000074161300174114700154030ustar00rootroot00000000000000/* Copyright 2012 by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include "general.h" #include "bitfields.h" bitfield initializeBitfield() { bitfield res; res = (bitfield) safeMalloc(sizeof(bitfieldBlock)); res->limbs = 1; res->fields = (uint64_t *) safeMalloc(sizeof(uint64_t)); res->fields[0] = 0ULL; return res; } void freeBitfield(bitfield bf) { safeFree(bf->fields); safeFree(bf); } void setBitInBitfield(bitfield bf, unsigned int bit) { uint64_t *newFields; unsigned int i; if ((bit >> 6) >= bf->limbs) { newFields = (uint64_t *) safeCalloc((bit >> 6) + 1,sizeof(uint64_t)); for (i=0;i<(bit >> 6) + 1;i++) { newFields[i] = 0ULL; } for (i=0;ilimbs;i++) { newFields[i] = bf->fields[i]; } bf->limbs = (bit >> 6) + 1; safeFree(bf->fields); bf->fields = newFields; } bf->fields[bit >> 6] |= 1ULL << (bit & 0x3f); } void clearBitInBitfield(bitfield bf, unsigned int bit) { if ((bit >> 6) < bf->limbs) { bf->fields[bit >> 6] &= ~(1ULL << (bit & 0x3f)); } } void fixBitInBitfield(bitfield bf, unsigned int bit, int val) { if (val) { setBitInBitfield(bf, bit); } else { clearBitInBitfield(bf, bit); } } int getBitInBitfield(bitfield bf, unsigned int bit) { if ((bit >> 6) >= bf->limbs) return 0; return !(!(bf->fields[bit >> 6] & (1ULL << (bit & 0x3f)))); } void clearBitfield(bitfield bf) { unsigned int i; for (i=0;ilimbs;i++) bf->fields[i] = 0ULL; } int getMaxIndexOfSetBit(bitfield bf) { int i, j; for (i=bf->limbs-1;i>=0;i--) { if (!(!(bf->fields[i]))) { for (j=63;j>=0;j--) { if (!(!(bf->fields[i] & (1ULL << j)))) { return j + (i << 6); } } } } return -1; } sollya-6.0+ds/bitfields.h000066400000000000000000000052671300174114700154120ustar00rootroot00000000000000/* Copyright 2012 by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributor Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef BITFIELDS_H #define BITFIELDS_H #include typedef struct bitfieldStruct bitfieldBlock; struct bitfieldStruct { unsigned int limbs; uint64_t *fields; }; typedef bitfieldBlock * bitfield; bitfield initializeBitfield(); void freeBitfield(bitfield); void setBitInBitfield(bitfield, unsigned int); void clearBitInBitfield(bitfield, unsigned int); void fixBitInBitfield(bitfield, unsigned int, int); int getBitInBitfield(bitfield, unsigned int); void clearBitfield(bitfield); int getMaxIndexOfSetBit(bitfield); #endif /* ifdef BITFIELDS_H*/ sollya-6.0+ds/chain.c000066400000000000000000000234701300174114700145160ustar00rootroot00000000000000/* Copyright 2006-2014 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include #include #include "chain.h" #include "general.h" void freeChain(chain *c, void (*f) (void *)) { chain *curr, *prev; if (c == NULL) return; curr = c; while (curr != NULL) { f(curr->value); prev = curr; curr = curr->next; safeFree(prev); } } chain *addElement(chain *c, void *elem) { chain *newChain; newChain = (chain *) safeMalloc(sizeof(chain)); newChain->next = c; newChain->value = elem; return newChain; } void *first(chain *c) { return c->value; } chain *tail(chain *c) { return c->next; } chain *copyChain(chain *c, void *(*f) (void *)) { chain *copy, *curr; copy = NULL; curr = c; while (curr != NULL) { copy = addElement(copy,f(curr->value)); curr = curr->next; } return copy; } chain *copyChainWithoutReversal(chain *c, void * (*f) (void *)) { chain *curr, *copy, *prev, *elem; prev = NULL; /* compiler happiness */ if (c == NULL) return NULL; copy = NULL; for (curr=c; curr!=NULL; curr=curr->next) { if (copy == NULL) { copy = (chain *) safeMalloc(sizeof(chain)); elem = copy; } else { prev->next = (chain *) safeMalloc(sizeof(chain)); elem = prev->next; } elem->value = f(curr->value); elem->next = NULL; prev = elem; } return copy; } chain *copyChainAndMap(chain *c, void *d, void * (*f) (void *, void *)) { chain *curr, *copy, *prev, *elem; prev = NULL; /* compiler happiness */ if (c == NULL) return NULL; copy = NULL; for (curr=c; curr!=NULL; curr=curr->next) { if (copy == NULL) { copy = (chain *) safeMalloc(sizeof(chain)); elem = copy; } else { prev->next = (chain *) safeMalloc(sizeof(chain)); elem = prev->next; } elem->value = f(curr->value, d); elem->next = NULL; prev = elem; } return copy; } void *copyString(void *oldString) { char *newString; newString = (char *) safeCalloc(strlen((char *) oldString) + 1,sizeof(char)); strcpy(newString,(char *) oldString); return (void *) newString; } void *copyTreeOnVoid(void *tree) { return copyTree((node *) tree); } void *copyRangetypePtr(void *ptr) { rangetype *newPtr; newPtr = (rangetype *) safeMalloc(sizeof(rangetype)); newPtr->a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); newPtr->b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(newPtr->a),mpfr_get_prec(*(((rangetype *) ptr)->a))); mpfr_init2(*(newPtr->b),mpfr_get_prec(*(((rangetype *) ptr)->b))); mpfr_set(*(newPtr->a),*(((rangetype *) ptr)->a),GMP_RNDN); mpfr_set(*(newPtr->b),*(((rangetype *) ptr)->b),GMP_RNDN); return newPtr; } void *copyMpfiPtr(void *ptr) { sollya_mpfi_t *newMpfi; newMpfi = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*newMpfi,sollya_mpfi_get_prec(*((sollya_mpfi_t *) ptr))); sollya_mpfi_set(*newMpfi,*((sollya_mpfi_t *) ptr)); return (void *) newMpfi; } void *copyIntPtrOnVoid(void *i) { int *copy; copy = (int *) safeMalloc(sizeof(int)); *copy = *((int *) i); return (void *) copy; } void *copyMpfrPtr(void *ptr) { mpfr_t *newMpfr; newMpfr = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*newMpfr,mpfr_get_prec(*((mpfr_t *) ptr))); mpfr_set(*newMpfr,*((mpfr_t *) ptr), GMP_RNDN); /* exect */ return (void *) newMpfr; } chain* concatChains(chain *c1, chain *c2) { chain *curr; if (c1 == NULL) return c2; curr = c1; while (curr->next != NULL) { curr = curr->next; } curr->next = c2; return c1; } /* Removes the first occurence of n in a chain containing int values The chain c is modified. If n is not the first element of the chain, the returned pointer points at the same place as c */ chain *removeInt(chain *c, int n) { chain *curr; int i; if(c==NULL) return c; curr = c; i = *(int *)(curr->value); if(i==n) { curr=c->next; safeFree(c->value); safeFree(c); return curr; } else { curr = removeInt(c->next, n); c->next=curr; return c; } } void freeMpfrPtr(void *ptr) { if (ptr == NULL) return; mpfr_clear(*((mpfr_t *) ptr)); safeFree((mpfr_t *) ptr); } void freeMpfiPtr(void *i) { if (i == NULL) return; sollya_mpfi_clear(*((sollya_mpfi_t *) i)); safeFree(i); } void freeIntPtr(void *ptr) { if (ptr == NULL) return; safeFree(ptr); } void freeRangetypePtr(void *ptr) { mpfr_clear(*(((rangetype *) ptr)->a)); mpfr_clear(*(((rangetype *) ptr)->b)); safeFree(((rangetype *) ptr)->a); safeFree(((rangetype *) ptr)->b); safeFree(ptr); } void freeStringPtr(void *aString) { safeFree((char *) aString); } void freeMemoryOnVoid(void *tree) { free_memory((node *) tree); } /* A function that does nothing but that has the right signature for freeChain */ void freeNoPointer(void *thing) { UNUSED_PARAM(thing); return; } chain *makeIntPtrChain(int n) { return makeIntPtrChainFromTo(0,n); } chain *makeIntPtrChainFromTo(int m, int n) { int i; int *elem; chain *c; c = NULL; for (i=n;i>=m;i--) { elem = (int *) safeMalloc(sizeof(int)); *elem = i; c = addElement(c,elem); } return c; } chain *makeConstantIntChain(int n) { return makeConstantIntChainFromTo(0,n); } chain *makeConstantIntChainFromTo(int m, int n) { int i; node *elem; chain *c; c = NULL; for (i=n;i>=m;i--) { elem = makeConstantInt(i); c = addElement(c,elem); } return c; } int lengthChain(chain *c) { int i; chain *curr; i = 0; curr = c; while (curr != NULL) { i++; curr = curr->next; } return i; } void sortChain(chain *c, int (*f) (void *, void *)) { chain *curr1, *curr2; void *t; if (c==NULL) return; if (c->next == NULL) return; /* else... */ curr1 = c; while (curr1 != NULL) { curr2 = curr1->next; while (curr2 != NULL) { if (f(curr1->value, curr2->value)>=0) { t = curr1->value; curr1->value = curr2->value; curr2->value = t; } curr2 = curr2->next; } curr1 = curr1->next; } return; } int cmpIntPtr(void *a, void *b) { return (*((int *) a) - *((int *) b)); } int cmpMpfrPtr(void *a, void *b) { int res; res = -mpfr_cmp(*((mpfr_t *) a), *((mpfr_t *) b)); return res; } void printIntChain(chain *c) { chain *curr=c; sollyaPrintf("["); while(curr!=NULL) { sollyaPrintf(" %d ", *(int *)(curr->value)); curr=curr->next; } sollyaPrintf("]\n"); return; } void *accessInList(chain *c, int index) { chain *curr; int i; if (index < 0) return NULL; curr = c; i = 0; while (curr != NULL) { if (i == index) return curr->value; i++; curr = curr->next; } return NULL; } chain *copyChainAndReplaceNth(chain *c, int k, void *obj, void * (*f) (void *)) { void **array; int len, i; chain *curr, *copy; if (c == NULL) return NULL; len = lengthChain(c); array = (void *) safeCalloc(len,sizeof(void *)); curr = c; i = 0; while (curr != NULL) { array[i++] = curr->value; curr = curr->next; } if ((k >= 0) && (k < len)) { array[k] = obj; } copy = NULL; for (i=len-1;i>=0;i--) { copy = addElement(copy,f(array[i])); } safeFree(array); return copy; } int isEqualStringOnVoid(void *s, void *s2) { if (strcmp((char *) s, (char *) s2) == 0) return 1; else return 0; } int isEqualIntPtrOnVoid(void *a, void *b) { return (*((int *) a) == *((int *) b)); } int isEqualChain(chain *c, chain *c2, int (*f) (void *, void *)) { chain *curr, *curr2; if (lengthChain(c) != lengthChain(c2)) return 0; curr = c; curr2 = c2; while (curr != NULL) { if (!f(curr->value,curr2->value)) return 0; curr = curr->next; curr2 = curr2->next; } return 1; } sollya-6.0+ds/chain.h000066400000000000000000000075141300174114700145240ustar00rootroot00000000000000/* Copyright 2006-2014 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef CHAIN_H #define CHAIN_H typedef struct chainStruct chain; struct chainStruct { void *value; chain *next; }; void freeChain(chain *c, void (*f) (void *)); chain *addElement(chain *c, void *elem); chain *removeInt(chain *c, int n); void *first(chain *c); chain *tail(chain *c); chain *copyChain(chain *c, void * (*f) (void *)); chain *copyChainWithoutReversal(chain *c, void * (*f) (void *)); chain *copyChainAndMap(chain *c, void *, void * (*f) (void *, void *)); void *copyString(void *oldString); void *copyTreeOnVoid(void *tree); void *copyRangetypePtr(void *ptr); void *copyMpfiPtr(void *ptr); void *copyIntPtrOnVoid(void *); void *copyMpfrPtr(void *ptr); chain *concatChains(chain *c1, chain *c2); void freeRangetypePtr(void *ptr); void freeMpfrPtr(void *ptr); void freeMpfiPtr(void *i); void freeIntPtr(void *ptr); void freeStringPtr(void *aString); void freeMemoryOnVoid(void *tree); void freeNoPointer(void *thing); /* Does nothing */ chain *makeIntPtrChain(int n); chain *makeIntPtrChainFromTo(int m, int n); chain *makeConstantIntChain(int n); chain *makeConstantIntChainFromTo(int m, int n); int lengthChain(chain *c); void sortChain(chain *c, int (*f) (void *, void *)); int cmpIntPtr(void *a, void *b); int cmpMpfrPtr(void *a, void *b); void printIntChain(chain *c); void *accessInList(chain *, int); chain *copyChainAndReplaceNth(chain *c, int k, void *obj, void * (*f) (void *)); int isEqualStringOnVoid(void *s, void *s2); int isEqualIntPtrOnVoid(void *a, void *b); int isEqualChain(chain *c, chain *c2, int (*f) (void *, void *)); #endif /* ifdef CHAIN_H*/ sollya-6.0+ds/chebyshevform.c000066400000000000000000001305101300174114700162720ustar00rootroot00000000000000/* Copyright 2011-2012 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 Contributor M. Joldes joldes@laas.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "infnorm.h" #include "autodiff.h" #include "general.h" #include #include #include #include "chebyshevformaux.h" #include "chebyshevform.h" #include "taylorform.h" /***************************************************************/ /***************************************************************/ /**********Functions related to Chebyshev Models****************/ /***************************************************************/ /***************************************************************/ /* This function creates an empty cheb model */ chebModel* createEmptycModel(int n,sollya_mpfi_t x, mp_prec_t p){ chebModel* t; int i; mp_prec_t prec; prec=p; t= (chebModel *)safeMalloc(sizeof(chebModel)); sollya_mpfi_init2(t->rem_bound, prec); sollya_mpfi_init2(t->poly_bound,prec); sollya_mpfi_init2(t->x,prec); sollya_mpfi_set(t->x,x); t->n=n; t->poly_array= (sollya_mpfi_t *)safeMalloc((n)*sizeof(sollya_mpfi_t)); for(i=0;ipoly_array[i], prec); } t->cheb_array= (sollya_mpfi_t **)safeMalloc(sizeof(sollya_mpfi_t *)); t->cheb_matrix= (sollya_mpfi_t **)safeMalloc(sizeof(sollya_mpfi_t *)); return t; } /*This function creates an empty chebyshev model and depending on two flags: flag_points, flag_matrix, with convention 1= compute, 0=do not compute computes the chebyshev points of order n over x, x_i^{[a,b]} and the chebMatrix (T_j(x_i)), i=0..n-1, j=0..n-1 */ chebModel* createEmptycModelCompute(int n,sollya_mpfi_t x, int flag_points, int flag_matrix, mp_prec_t p){ chebModel* t; int i; mp_prec_t prec; prec=p; t= (chebModel *)safeMalloc(sizeof(chebModel)); sollya_mpfi_init2(t->rem_bound, prec); sollya_mpfi_init2(t->poly_bound,prec); sollya_mpfi_init2(t->x,prec); sollya_mpfi_set(t->x,x); t->n=n; t->poly_array= (sollya_mpfi_t *)safeMalloc((n)*sizeof(sollya_mpfi_t)); for(i=0;ipoly_array[i], prec); } t->cheb_matrix= (sollya_mpfi_t **)safeMalloc(sizeof(sollya_mpfi_t *)); t->cheb_array= (sollya_mpfi_t **)safeMalloc(sizeof(sollya_mpfi_t *)); *(t->cheb_array)= (sollya_mpfi_t *)safeMalloc((n)*sizeof(sollya_mpfi_t)); for(i=0;icheb_array))[i], prec); } if (flag_points!=0) getChebyshevPoints(*(t->cheb_array),n,x); if (flag_matrix!=0) getChebMatrix(t->cheb_matrix,n,prec); return t; } /*This function creates an empty chebyshev model and makes the link from chebpoints and chebMatrix into the new cmodel (this function assumes that we have already computed chebpoints and chebMatrix (if the respective pointers are not NULL) */ chebModel* createEmptycModelPrecomp(int n,sollya_mpfi_t x, sollya_mpfi_t **chebPoints, sollya_mpfi_t **chebM, mp_prec_t p){ chebModel* t; int i; mp_prec_t prec; prec=p; t= (chebModel *)safeMalloc(sizeof(chebModel)); sollya_mpfi_init2(t->rem_bound, prec); sollya_mpfi_init2(t->poly_bound,prec); sollya_mpfi_init2(t->x,sollya_mpfi_get_prec(x)); sollya_mpfi_set(t->x,x); t->n=n; t->poly_array= (sollya_mpfi_t *)safeMalloc((n)*sizeof(sollya_mpfi_t)); for(i=0;ipoly_array[i], prec); } t->cheb_matrix= (sollya_mpfi_t **)safeMalloc(sizeof(sollya_mpfi_t *)); t->cheb_array= (sollya_mpfi_t **)safeMalloc(sizeof(sollya_mpfi_t *)); if (chebPoints!=NULL) if ((*chebPoints)!=NULL) *(t->cheb_array)=*chebPoints; if (chebM!=NULL) if ((*chebM)!=NULL) *(t->cheb_matrix)=*chebM; return t; } /*This function dealocates a cheb model, without touching the memory referenced by cheb_array and cheb_matrix parts */ void clearcModelLight(chebModel *t){ int i; if (t == NULL) return; for(i=0;in;i++) sollya_mpfi_clear(t->poly_array[i]); safeFree(t->poly_array); sollya_mpfi_clear(t->rem_bound); sollya_mpfi_clear(t->poly_bound); sollya_mpfi_clear(t->x); safeFree(t->cheb_matrix); safeFree(t->cheb_array); safeFree(t); } /*This function dealocates a cheb model, distroying the cheb_array and cheb_matrix parts */ void clearcModelComplete(chebModel *t){ int i; for(i=0;in;i++) sollya_mpfi_clear(t->poly_array[i]); safeFree(t->poly_array); sollya_mpfi_clear(t->rem_bound); sollya_mpfi_clear(t->poly_bound); sollya_mpfi_clear(t->x); for(i=0;in;i++) sollya_mpfi_clear((*(t->cheb_array))[i]); safeFree(*(t->cheb_array)); safeFree(t->cheb_array); for(i=0;i<(t->n)* (t->n);i++) sollya_mpfi_clear((*(t->cheb_matrix))[i]); safeFree(*(t->cheb_matrix)); safeFree(t->cheb_matrix); safeFree(t); } /***************************************************************/ /*******The convention for all the following functions is:******/ /***the cmodel given as parameter must be previously created ***/ /***************************************************************/ /***************************************************************/ /*This function sets the chebModel t with constant ct; It updates the bound. */ void constcModel(chebModel*t, sollya_mpfi_t ct){ int i,n; n=t->n; for(i=1;ipoly_array[i],0); } sollya_mpfi_set(t->poly_array[0],ct); sollya_mpfi_set(t->poly_bound,ct); sollya_mpfi_set_ui(t->rem_bound,0); } /* Check that models are compatible one with another: i.e. they can be added, mulitplied, copied, etc. */ int cModelsAreCompatible(chebModel *t1, chebModel *t2) { return ((t1 != NULL) && (t2 != NULL) && (sollya_mpfi_equal_p(t1->x, t2->x) || (sollya_mpfi_nan_p(t1->x) && sollya_mpfi_nan_p(t2->x))) && (t1->n == t2->n)); } /*This function sets a cm t with the values given by anoter cm tt they should have the same basis and interval, if an incompatibility is detected, no modification is made. */ void copycModel(chebModel *t, chebModel *tt){ int i; if (!cModelsAreCompatible(t, tt)) { printMessage(0, SOLLYA_MSG_ERROR_IN_CHEBYSHEVFORM_COPYING_INCOMPAT_MODELS, "Error in chebyshevform: trying to copy incompatible models.\n"); printMessage(0, SOLLYA_MSG_CONTINUATION, "No modification is made.\n"); return; } for(i=0;in;i++) { sollya_mpfi_set(t->poly_array[i],tt->poly_array[i]); } sollya_mpfi_set(t->rem_bound,tt->rem_bound); sollya_mpfi_set(t->poly_bound,tt->poly_bound); if (tt->cheb_matrix!=NULL) if ((*tt->cheb_matrix)!=NULL) *(t->cheb_matrix)=*tt->cheb_matrix; if (tt->cheb_array!=NULL) if ((*tt->cheb_array)!=NULL) *(t->cheb_array)=*tt->cheb_array; } /***************************************************************/ /*********************Operations on ChebModels******************/ /***************************************************************/ /*Compute the cm for addition of two given cms. Updates the resulting polynomial bound. */ void addition_CM(chebModel *t,chebModel *child1_tm, chebModel *child2_tm, mp_prec_t prec){ int i; int n; chebModel *tt; if ( (!cModelsAreCompatible(child1_tm, child2_tm)) || (!cModelsAreCompatible(t, child1_tm)) ) { printMessage(0, SOLLYA_MSG_ERROR_IN_CHEBYSHEVFORM_COPYING_INCOMPAT_MODELS, "Error in chebyshevform: trying to copy incompatible models.\n"); printMessage(0, SOLLYA_MSG_CONTINUATION, "No modification is made.\n"); return; } n=t->n; tt=createEmptycModelPrecomp(n,t->x, child1_tm->cheb_array,child1_tm->cheb_matrix, prec); for(i=0;ipoly_array[i], child1_tm->poly_array[i],child2_tm->poly_array[i]); sollya_mpfi_add(tt->rem_bound, child1_tm->rem_bound, child2_tm->rem_bound); copycModel(t,tt); clearcModelLight(tt); } /* Compute the multiplication of a cm by a constant */ void ctMultiplication_CM(chebModel*d, chebModel*s, sollya_mpfi_t c, mp_prec_t prec){ int i; int n; chebModel *tt; n=s->n; tt=createEmptycModelPrecomp(n,s->x, s->cheb_array,s->cheb_matrix, prec); for(i=0; ipoly_array[i], s->poly_array[i], c); sollya_mpfi_mul(tt->rem_bound, s->rem_bound, c); sollya_mpfi_mul(tt->poly_bound, s->poly_bound, c); copycModel(d,tt); clearcModelLight(tt); } /*This function multiplies two given cms; -- parameter *boundLevel* controls the algorithm used for bounding polynomials -- parameter *forComposition* specifies whether: forComposition=1 --> we are using the multiplication inside a composition, we suppose bounds for the polynomials are already updated inside models OTHERWISE --> we rebound them */ void multiplication_CM(chebModel *t,chebModel *c1, chebModel *c2, int boundLevel, int forComposition, mp_prec_t prec){ /*we will multiply two cm of order n; and obtain a new cm of order n;*/ int n,i,j; chebModel *tt; sollya_mpfi_t temp1, temp2; sollya_mpfi_t *r; if ( (!cModelsAreCompatible(c2, c1)) || (!cModelsAreCompatible(t, c1)) ) { printMessage(0, SOLLYA_MSG_ERROR_IN_CHEBYSHEVFORM_COPYING_INCOMPAT_MODELS, "Error in chebyshevform: trying to copy incompatible models.\n"); printMessage(0, SOLLYA_MSG_CONTINUATION, "No modification is made.\n"); return; } n=t->n; /*aux cm for doing the multiplications*/ tt=createEmptycModelPrecomp(n, t->x, t->cheb_array, t->cheb_matrix, prec); for(i=0;ipoly_array[i],0); } sollya_mpfi_init2(temp1, prec); sollya_mpfi_init2(temp2, prec); /*absolute error only*/ /*We are multiplying chebmodels, considering the absolute error We are given: (C1, r1) (C2, r2)*/ /*compute in temp1 r1*r2*/ sollya_mpfi_mul(temp1, c1->rem_bound, c2->rem_bound); if (forComposition==0){ /*update the bounds for polynomials*/ chebPolynomialBound(c1->poly_bound, n, c1->poly_array, boundLevel); chebPolynomialBound(c2->poly_bound, n, c2->poly_array, boundLevel); } /*if we use multiplication inside a composition, we suppose the the bounds are already computed*/ /*compute in temp2 delta1*B(C2)*/ sollya_mpfi_mul(temp2, c1->rem_bound, c2->poly_bound); sollya_mpfi_add(tt->rem_bound, temp2, temp1); /*compute in temp2 delta2*B(C1)*/ sollya_mpfi_mul(temp2, c2->rem_bound, c1->poly_bound); sollya_mpfi_add(tt->rem_bound, tt->rem_bound,temp2); /*compute the product of the two polynomials*/ /*the product has degree 2n-2=> we have to store 2n-1 coeffs*/ /*in r we store only the upper part of the polynomial*/ /*r = [0, 0 ...., 0, r0, ..., r(n-2)] */ /* it represents the polynomial T1*T2|[n....2n-2]*/ r = (sollya_mpfi_t *)safeMalloc((2*n-1)*sizeof(sollya_mpfi_t)); for(i=0; i < 2*n-1; i++){ sollya_mpfi_init2(r[i], prec); sollya_mpfi_set_ui(r[i],0); } for(i=0; ipoly_array[i], c2->poly_array[j]); if ( (i+j) < n ) sollya_mpfi_add(tt->poly_array[i+j], tt->poly_array[i+j], temp1); else sollya_mpfi_add(r[i+j], r[i+j], temp1); if ( abs(i-j) < n ) sollya_mpfi_add(tt->poly_array[abs(i-j)], tt->poly_array[abs(i-j)], temp1); else sollya_mpfi_add(r[abs(i-j)], r[abs(i-j)], temp1); } } for(i=0; ipoly_array[i], tt->poly_array[i], 2); } for(i=n; i<2*n-1; i++) { sollya_mpfi_div_ui(r[i], r[i], 2); } /*bound the upper part*/ chebPolynomialBound(temp1, 2*n-1, r, boundLevel); sollya_mpfi_add(tt->rem_bound, tt->rem_bound,temp1); for(i=0;i<2*n-1;i++) { sollya_mpfi_clear(r[i]);} safeFree(r); sollya_mpfi_clear(temp1); sollya_mpfi_clear(temp2); /*set the result*/ copycModel(t,tt); /*clear the aux tm*/ clearcModelLight(tt); } /* composition: g o f VERY IMPORTANT ASSUMPTIONS: We are given a cm for the function f over x, order n and a cm for basic function g over y, order n with: range(f->poly)+ f->rem_bound \subseteq y Note that these assumptions ARE NOT CHECKED inside the function. If these assumptions are true, it returns a valid tm for g(f(x)) over x. Note that it is indicated to bound f tightly before, such that the image over which g is computed is small. We suppose here that the image for f is already computed tightly, and will not be recomputed here. */ /*NOTE: targetRem is a parameter that will stop the composition of the computed remainder gets too large; currently, it is not used, but this should change in the future*/ void composition_CM(chebModel *t,chebModel *g, chebModel *f, int boundLevel, mpfr_t targetRem, mp_prec_t prec){ int i; int n,m; chebModel *tt,*tinterm,*tadd = NULL, *tcheb0 = NULL,*tcheb1 = NULL; sollya_mpfi_t z, zz, z1,doi,minusOne, one; mpfr_t a, b; UNUSED_PARAM(targetRem); n=g->n; m=f->n; /*create tinterm an intermediary cm for 2/(b-a) *f(x)-(b+a)/(b-a) that will be used just as a clone in multiplications: tinterm can be viewed as the variable in T_n(x). */ tinterm=createEmptycModelPrecomp(m,f->x, f->cheb_array, f->cheb_matrix, prec); copycModel(tinterm,f); sollya_mpfi_init2(z,prec); sollya_mpfi_init2(zz,prec); sollya_mpfi_init2(z1,prec); sollya_mpfi_init2(doi,prec); sollya_mpfi_init2(minusOne,prec); sollya_mpfi_init2(one,prec); mpfr_init2(a,sollya_mpfi_get_prec(f->x)); mpfr_init2(b,sollya_mpfi_get_prec(f->x)); sollya_mpfi_set_ui(doi,2); sollya_mpfi_set_ui(one,1); sollya_mpfi_set_si(minusOne,-1); sollya_mpfi_get_right(b,g->x); sollya_mpfi_get_left(a,g->x); sollya_mpfi_set_fr(z1,b); sollya_mpfi_sub_fr(z1,z1,a); sollya_mpfi_inv(z1,z1); sollya_mpfi_mul_ui(z,z1,2); ctMultiplication_CM(tinterm, tinterm, z, prec); sollya_mpfi_set_fr(zz,b); sollya_mpfi_add_fr(zz,zz,a); /*mpfi_add_fr(zz,zz,a);*/ sollya_mpfi_mul(zz,zz,z1); sollya_mpfi_sub(tinterm->poly_array[0],tinterm->poly_array[0],zz); sollya_mpfi_sub(tinterm->poly_bound,tinterm->poly_bound,zz); tt=createEmptycModelPrecomp(m,f->x,f->cheb_array, f->cheb_matrix, prec); constcModel(tt,g->poly_array[0]); if(n>0) { tadd=createEmptycModelPrecomp(m,f->x,f->cheb_array, f->cheb_matrix, prec); ctMultiplication_CM(tadd, tinterm, g->poly_array[1], prec); addition_CM(tt,tt,tadd, prec); /*T_0(x)=1*/ tcheb0=createEmptycModelPrecomp(m,f->x,f->cheb_array,f->cheb_matrix, prec); constcModel( tcheb0, one); /*T_1(x)=x*/ tcheb1=createEmptycModelPrecomp(m,f->x,f->cheb_array,f->cheb_matrix, prec); copycModel(tcheb1,tinterm); /*tinterm <-- 2*tinterm, to be used in recurrence: T_{i+1}(x)=2*x*T_i(x) - T_{i-1}(x)*/ ctMultiplication_CM(tinterm, tinterm, doi, prec); /*tinterm is already bounded*/ for (i=2;ipoly_bound, m, tcheb1->poly_array, boundLevel); multiplication_CM(tadd,tinterm,tcheb1,boundLevel,1, prec); /*t_{i+1}=2x*t_i(x)-t_{i-1}(x)*/ ctMultiplication_CM(tcheb0, tcheb0,minusOne, prec); addition_CM(tadd,tadd,tcheb0, prec); copycModel(tcheb0,tcheb1); /*t_{i-1}:=t_i*/ copycModel(tcheb1,tadd); /*t_i:= t_{i+1}*/ ctMultiplication_CM(tadd,tadd,g->poly_array[i], prec); addition_CM(tt,tt,tadd, prec); } } sollya_mpfi_add(tt->rem_bound,tt->rem_bound,g->rem_bound); /*the polybound is not updated in the end*/ /*cleaning stuff*/ copycModel(t,tt); clearcModelLight(tt); clearcModelLight(tinterm); if(n>0){ clearcModelLight(tadd); clearcModelLight(tcheb0); clearcModelLight(tcheb1); } sollya_mpfi_clear(z); sollya_mpfi_clear(zz); sollya_mpfi_clear(z1); sollya_mpfi_clear(doi); sollya_mpfi_clear(minusOne); sollya_mpfi_clear(one); mpfr_clear(a); mpfr_clear(b); } /*******************************************************************************/ /*****************Chebyshev models for a basic functions************************/ /*******************************************************************************/ #define MONOTONE_REMAINDER_BASE_FUNCTION 0 #define MONOTONE_REMAINDER_LIBRARY_FUNCTION 1 #define MONOTONE_REMAINDER_INV 2 #define MONOTONE_REMAINDER_CONSTPOWERVAR 3 #define MONOTONE_REMAINDER_VARCONSTPOWER 4 #define MONOTONE_REMAINDER_PROCEDURE_FUNCTION 5 /* This function computes a cheb remainder for a function on an interval, assuming the n-th derivative is monotone. typeOfFunction is used to separate the cases: * MONOTONE_REMAINDER_BASE_FUNCTION --> we consider a base function, represented by its nodeType (p and f are useless) * MONOTONE_REMAINDER_LIBRARY_FUNCTION --> we consider a base function, represented by its nodeType (p and nodeType are useless) * MONOTONE_REMAINDER_PROCEDURE_FUNCTION --> we consider a base function, represented by its nodeType (p and nodeType are useless) * MONOTONE_REMAINDER_INV --> we consider (x -> 1/x) (nodeType, f, and p are useless) * MONOTONE_REMAINDER_CONSTPOWERVAR --> we consider (x -> p^x) (nodeType and f are useless) * MONOTONE_REMAINDER_VARCONSTPOWER --> we consider (x -> x^p) (nodeType and f are useless) The coeffs of the interpolation polynomial are given as an array of mpfi's, developed over x. For more details, see the issac article. */ void computeMonotoneRemainderCheb(sollya_mpfi_t *bound, int typeOfFunction, int nodeType, node *f, mpfr_t p, int n, sollya_mpfi_t *poly_array, sollya_mpfi_t x){ sollya_mpfi_t xinf, xsup; mpfr_t xinfFr, xsupFr; sollya_mpfi_t bound1, bound2, boundf1, boundf2; sollya_mpfi_t p_interv; mp_prec_t prec; int silent; silent=1; prec= sollya_mpfi_get_prec(poly_array[0]); sollya_mpfi_init2(xinf, prec); sollya_mpfi_init2(xsup, prec); mpfr_init2(xinfFr, prec); mpfr_init2(xsupFr,prec); sollya_mpfi_init2(bound1, prec); sollya_mpfi_init2(bound2, prec); sollya_mpfi_init2(boundf1, prec); sollya_mpfi_init2(boundf2, prec); sollya_mpfi_init2(p_interv, prec); sollya_mpfi_get_left(xinfFr,x); sollya_mpfi_get_right(xsupFr,x); sollya_mpfi_set_fr(xinf, xinfFr); sollya_mpfi_set_fr(xsup, xsupFr); evaluateChebPolynomialClenshaw(bound1, n, poly_array, x,xinf); /* enclosure of p(xinf) */ evaluateChebPolynomialClenshaw(bound2, n, poly_array, x,xsup); /* enclosure of p(xsup) */ /* enclosure of f(xinf) and f(xsup) */ switch(typeOfFunction) { case MONOTONE_REMAINDER_BASE_FUNCTION: baseFunction_diff(&boundf1,nodeType,xinf,0, &silent); baseFunction_diff(&boundf2,nodeType,xsup,0, &silent); break; case MONOTONE_REMAINDER_LIBRARY_FUNCTION: libraryFunction_diff(&boundf1, accessThruMemRef(f), xinf, 0, &silent); libraryFunction_diff(&boundf2, accessThruMemRef(f), xsup, 0, &silent); break; case MONOTONE_REMAINDER_PROCEDURE_FUNCTION: procedureFunction_diff(&boundf1, accessThruMemRef(f), xinf, 0, &silent); procedureFunction_diff(&boundf2, accessThruMemRef(f), xsup, 0, &silent); break; case MONOTONE_REMAINDER_INV: sollya_mpfi_inv(boundf1, xinf); sollya_mpfi_inv(boundf2, xsup); break; case MONOTONE_REMAINDER_CONSTPOWERVAR: sollya_mpfi_set_fr(p_interv, p); sollya_mpfi_pow(boundf1, xinf, p_interv); sollya_mpfi_pow(boundf2, xsup, p_interv); break; case MONOTONE_REMAINDER_VARCONSTPOWER: sollya_mpfi_set_fr(p_interv,p); sollya_mpfi_pow(boundf1, p_interv, xinf); sollya_mpfi_pow(boundf2, p_interv, xsup); break; default: printMessage(0, SOLLYA_MSG_ERROR_IN_CHEBYSHEVFORM_UNKNOWN_FUNC_FOR_ZUMKELLER, "Error in chebyshev: unknown type of function used with Zumkeller's technique\n"); return; } sollya_mpfi_sub(bound1,boundf1,bound1); /* enclosure of f(xinf)-p(xinf-x0) */ sollya_mpfi_sub(bound2,boundf2,bound2); /* enclosure of f(xsup)-p(xsup-x0) */ sollya_mpfi_abs(bound1, bound1); sollya_mpfi_abs(bound2, bound2); sollya_mpfi_union(bound1, bound1, bound2); sollya_mpfi_neg(bound2, bound1); /* the remainder is bounded by the values it takes on the two extremas of the interval */ sollya_mpfi_union(*bound, bound1, bound2); mpfr_clear(xinfFr); mpfr_clear(xsupFr); sollya_mpfi_clear(xinf); sollya_mpfi_clear(xsup); sollya_mpfi_clear(bound1); sollya_mpfi_clear(bound2); sollya_mpfi_clear(boundf1); sollya_mpfi_clear(boundf2); sollya_mpfi_clear(p_interv); return; } /* This function computes a cheb model for a basic function, with the same convention as with computeMonotoneRemainderCheb */ void base_CMAux(chebModel *t, int typeOfFunction, int nodeType, node *f, mpfr_t p, int n, sollya_mpfi_t x,int verbosity, mp_prec_t prec){ int i; chebModel *tt; sollya_mpfi_t *nDeriv; sollya_mpfi_t temp, pow; mpfr_t minusOne, a,b; sollya_mpfi_t *fValues; int silent; silent=1; UNUSED_PARAM(verbosity); tt=createEmptycModelPrecomp(n,x, t->cheb_array,t->cheb_matrix, prec); fValues= (sollya_mpfi_t *)safeMalloc((n)*sizeof(sollya_mpfi_t)); for(i=0;icheb_array)[i],0,&silent); } break; case MONOTONE_REMAINDER_LIBRARY_FUNCTION: libraryFunction_diff(nDeriv, accessThruMemRef(f), x, n+1,&silent); for(i=0;icheb_array)[i],0,&silent); } break; case MONOTONE_REMAINDER_PROCEDURE_FUNCTION: procedureFunction_diff(nDeriv, accessThruMemRef(f), x, n+1,&silent); for(i=0;icheb_array)[i],0,&silent); } break; case MONOTONE_REMAINDER_INV: mpfr_init2(minusOne, prec); mpfr_set_si(minusOne, -1, GMP_RNDN); constantPower_diff(nDeriv, x, minusOne, n+1,&silent); for(i=0;icheb_array)[i],minusOne,0,&silent); } mpfr_clear(minusOne); break; case MONOTONE_REMAINDER_CONSTPOWERVAR: constantPower_diff(nDeriv, x, p, n+1,&silent); for(i=0;icheb_array)[i],p,0,&silent); } break; case MONOTONE_REMAINDER_VARCONSTPOWER: powerFunction_diff(nDeriv, p, x, n+1,&silent); for(i=0;icheb_array)[i],0,&silent); } break; default: printMessage(0, SOLLYA_MSG_ERROR_IN_CHEBYSHEVFORM_UNKNOWN_FUNC_FOR_ZUMKELLER, "Error in chebyshev: unknown type of function used with Zumkeller's technique\n"); return; } /*compute the values of the coefficients*/ getChebCoeffs(tt->poly_array, *(tt->cheb_matrix), fValues,n); /* Use Zumkeller technique to improve the bound in the absolute case, when the (n+1)th derivative has constant sign */ if((sollya_mpfi_is_nonpos(nDeriv[n+1]) > 0)||(sollya_mpfi_is_nonneg(nDeriv[n+1]) > 0)){ computeMonotoneRemainderCheb(&tt->rem_bound, typeOfFunction, nodeType, accessThruMemRef(f), p, n, tt->poly_array, x); } else{ /* just keep the bound obtained using AD, nDeriv[n] */ /* diffValue:=(2*nDeriv[n]*((op(2,X)-op(1,X))^(n)))/(4^n );*/ sollya_mpfi_set(tt->rem_bound, nDeriv[n]); mpfr_init2(a, sollya_mpfi_get_prec(x)); mpfr_init2(b, sollya_mpfi_get_prec(x)); sollya_mpfi_get_left(a,x); sollya_mpfi_get_right(b,x); sollya_mpfi_init2(temp, prec); sollya_mpfi_set_fr(temp, b); sollya_mpfi_sub_fr(temp, temp,a); sollya_mpfi_init2(pow, prec); sollya_mpfi_set_ui(pow, n); sollya_mpfi_pow(temp, temp, pow); sollya_mpfi_mul(tt->rem_bound,tt->rem_bound,temp); sollya_mpfi_mul_ui(tt->rem_bound,tt->rem_bound,2); sollya_mpfi_set_ui(temp, 4); sollya_mpfi_pow(temp, temp, pow); sollya_mpfi_div(tt->rem_bound,tt->rem_bound,temp); sollya_mpfi_neg(temp,tt->rem_bound); sollya_mpfi_union(tt->rem_bound,tt->rem_bound,temp); sollya_mpfi_clear(temp); sollya_mpfi_clear(pow); mpfr_clear(a); mpfr_clear(b); } /* We do not bound the polynomial obtained here*/ copycModel(t,tt); clearcModelLight(tt); for(i=0;i<=n+1;i++) sollya_mpfi_clear(nDeriv[i]); safeFree(nDeriv); for(i=0;ix, t->cheb_array, t->cheb_matrix, prec); getNChebCoeffsFromPolynomial(tt->poly_array, tt->rem_bound, f, x,n,boundLevel); copycModel(t,tt); /*clear old cheby models*/ clearcModelLight(tt); } else { switch (accessThruMemRef(f)->nodeType) { case NEG: /*create a new empty cheb model the child*/ child1_tm=createEmptycModelPrecomp(n,t->x, t->cheb_array,t->cheb_matrix,prec); /*call cheby_model on the child*/ cheb_model(child1_tm, accessThruMemRef(f)->child1,n,x, boundLevel, verbosity, prec); tt=createEmptycModelPrecomp(n,t->x, t->cheb_array,t->cheb_matrix, prec); /*do the necessary chages from child to parent*/ for(i=0;ipoly_array[i], child1_tm->poly_array[i]); sollya_mpfi_neg(tt->rem_bound,child1_tm->rem_bound); copycModel(t,tt); /*clear old cheby models*/ clearcModelLight(child1_tm); clearcModelLight(tt); break; case ADD: /*create a new empty chebmodel the children*/ child1_tm=createEmptycModelPrecomp(n,t->x,t->cheb_array,t->cheb_matrix, prec); child2_tm=createEmptycModelPrecomp(n,t->x,t->cheb_array,t->cheb_matrix, prec); /*call cheby_model on the children*/ cheb_model(child1_tm, accessThruMemRef(f)->child1,n,x,boundLevel, verbosity, prec); cheb_model(child2_tm, accessThruMemRef(f)->child2,n,x,boundLevel, verbosity, prec); tt=createEmptycModelPrecomp(n,child1_tm->x, child1_tm->cheb_array,child1_tm->cheb_matrix, prec); addition_CM(tt,child1_tm, child2_tm, prec); copycModel(t,tt); /*clear old cheby model*/ clearcModelLight(child1_tm); clearcModelLight(child2_tm); clearcModelLight(tt); break; case SUB: /*create a new empty cheby model the children*/ child1_tm=createEmptycModelPrecomp(n,t->x,t->cheb_array,t->cheb_matrix, prec); child2_tm=createEmptycModelPrecomp(n,t->x,t->cheb_array,t->cheb_matrix, prec); /*call cheby_model on the children*/ cheb_model(child1_tm, accessThruMemRef(f)->child1,n,x,boundLevel, verbosity, prec); cheb_model(child2_tm, accessThruMemRef(f)->child2,n,x,boundLevel, verbosity, prec); /*do the necessary chages from children to parent*/ sollya_mpfi_init2(minusOne,prec); sollya_mpfi_set_si(minusOne,-1); ctMultiplication_CM(child2_tm,child2_tm, minusOne, prec); tt=createEmptycModelPrecomp(n,child1_tm->x, child1_tm->cheb_array, child1_tm->cheb_matrix, prec); addition_CM(tt,child1_tm, child2_tm, prec); copycModel(t,tt); /*clear old cheby model*/ clearcModelLight(child1_tm); clearcModelLight(child2_tm); clearcModelLight(tt); sollya_mpfi_clear(minusOne); break; case MUL: /*create a new empty taylor model the children*/ child1_tm=createEmptycModelPrecomp(n,t->x,t->cheb_array, t->cheb_matrix, prec); child2_tm=createEmptycModelPrecomp(n,t->x,t->cheb_array, t->cheb_matrix, prec); /*call cheby_model on the children*/ cheb_model(child1_tm, accessThruMemRef(f)->child1,n,x,boundLevel, verbosity, prec); cheb_model(child2_tm, accessThruMemRef(f)->child2,n,x,boundLevel, verbosity, prec); /*do the necessary chages from children to parent*/ tt=createEmptycModelPrecomp(n,child1_tm->x, child1_tm->cheb_array, child1_tm->cheb_matrix, prec); multiplication_CM(tt,child1_tm, child2_tm,boundLevel,0,prec); copycModel(t,tt); /*clear old cheby model*/ clearcModelLight(child1_tm); clearcModelLight(child2_tm); clearcModelLight(tt); break; case DIV: /*create a new empty cheby model the child*/ child1_tm=createEmptycModelPrecomp(n,t->x, t->cheb_array, t->cheb_matrix, prec); /*call cheb_model on the child*/ cheb_model(child1_tm, accessThruMemRef(f)->child1,n,x,boundLevel, verbosity, prec); /*create a new empty cheby model the child*/ child2_tm=createEmptycModelPrecomp(n,t->x, t->cheb_array,t->cheb_matrix, prec); /*call cheb_model on the child*/ cheb_model(child2_tm, accessThruMemRef(f)->child2,n,x,boundLevel, verbosity, prec); /*compute cm for the basic case*/ sollya_mpfi_init2(rangeg, prec); chebPolynomialBound(child2_tm->poly_bound, n, child2_tm->poly_array, boundLevel); sollya_mpfi_add(rangeg,child2_tm->rem_bound, child2_tm->poly_bound); inv_tm=createEmptycModelCompute(n,rangeg,1,1,prec); base_CMAux(inv_tm, MONOTONE_REMAINDER_INV, 0, NULL, NULL, n, rangeg,verbosity,prec); /*Composition of models*/ ttt=createEmptycModelPrecomp(n,child2_tm->x, child2_tm->cheb_array,child2_tm->cheb_matrix, prec); composition_CM(ttt,inv_tm, child2_tm, boundLevel, NULL,prec); /*child1 * inverse(child2)*/ tt=createEmptycModelPrecomp(n,child1_tm->x, child1_tm->cheb_array, child1_tm->cheb_matrix, prec); multiplication_CM(tt, ttt, child1_tm, boundLevel,0,prec); /*clear old children*/ clearcModelLight(child1_tm); clearcModelLight(child2_tm); clearcModelComplete(inv_tm); clearcModelLight(ttt); copycModel(t,tt); clearcModelLight(tt); sollya_mpfi_clear(rangeg); break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case ABS: case SINGLE: case DOUBLE: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case CEIL: case FLOOR: case NEARESTINT: case LIBRARYFUNCTION: case PROCEDUREFUNCTION: if ((accessThruMemRef((accessThruMemRef(f)->child1))->nodeType)==VARIABLE) { child1_tm=createEmptycModelPrecomp(n,t->x, t->cheb_array,t->cheb_matrix, prec); /* CM for elementary function */ if (accessThruMemRef(f)->nodeType == LIBRARYFUNCTION) base_CMAux(child1_tm, MONOTONE_REMAINDER_LIBRARY_FUNCTION, 0, accessThruMemRef(f), NULL, n, x, verbosity,prec); else if (accessThruMemRef(f)->nodeType == PROCEDUREFUNCTION) base_CMAux(child1_tm, MONOTONE_REMAINDER_PROCEDURE_FUNCTION, 0, accessThruMemRef(f), NULL, n, x, verbosity,prec); else base_CMAux(child1_tm, MONOTONE_REMAINDER_BASE_FUNCTION, accessThruMemRef(f)->nodeType, NULL, NULL, n,x, verbosity,prec); copycModel(t,child1_tm); clearcModelLight(child1_tm); } else{ /*create a new empty CM for the child*/ child1_tm=createEmptycModelPrecomp(n,t->x, t->cheb_array,t->cheb_matrix, prec); /*call cheb_model on the child*/ cheb_model(child1_tm, accessThruMemRef(f)->child1,n,x,boundLevel, verbosity, prec); sollya_mpfi_init2(rangeg, prec); chebPolynomialBound(child1_tm->poly_bound, n, child1_tm->poly_array, boundLevel); sollya_mpfi_add(rangeg,child1_tm->rem_bound, child1_tm->poly_bound); child2_tm=createEmptycModelCompute(n,rangeg,1,1, prec); /*CM for elementary functions*/ if (accessThruMemRef(f)->nodeType == LIBRARYFUNCTION) base_CMAux(child2_tm, MONOTONE_REMAINDER_LIBRARY_FUNCTION, 0, accessThruMemRef(f), NULL, n, rangeg, verbosity,prec); else if (accessThruMemRef(f)->nodeType == PROCEDUREFUNCTION) base_CMAux(child2_tm, MONOTONE_REMAINDER_PROCEDURE_FUNCTION, 0, accessThruMemRef(f), NULL, n, rangeg, verbosity,prec); else base_CMAux(child2_tm, MONOTONE_REMAINDER_BASE_FUNCTION, accessThruMemRef(f)->nodeType, NULL, NULL, n,rangeg, verbosity,prec); tt=createEmptycModelPrecomp(n,child1_tm->x, child1_tm->cheb_array, child1_tm->cheb_matrix, prec); composition_CM(tt,child2_tm, child1_tm, boundLevel,NULL, prec); /*clear old child*/ clearcModelLight(child1_tm); /*we do not need values of chebpoints and chebMatrix in interval rangeg*/ clearcModelComplete(child2_tm); copycModel(t,tt); clearcModelLight(tt); sollya_mpfi_clear(rangeg); } break; case POW: simplifiedChild2=simplifyTreeErrorfree(accessThruMemRef(f)->child2); simplifiedChild1=simplifyTreeErrorfree(accessThruMemRef(f)->child1); if ((accessThruMemRef(simplifiedChild2)->nodeType==CONSTANT) &&(accessThruMemRef(simplifiedChild1)->nodeType==CONSTANT)) { /*We are in the ct1^ct2 case*/ sollya_mpfi_init2(temp1, prec); sollya_mpfi_set_fr(temp1, *(accessThruMemRef(simplifiedChild1)->value)); sollya_mpfi_init2(temp2, prec); sollya_mpfi_set_fr(temp2, *(accessThruMemRef(simplifiedChild2)->value)); sollya_mpfi_pow(temp1,temp1,temp2); tt=createEmptycModelPrecomp(n,t->x,t->cheb_array, t->cheb_matrix, prec); constcModel(tt,temp1); copycModel(t,tt); clearcModelLight(tt); sollya_mpfi_clear(temp1); sollya_mpfi_clear(temp2); } else if (accessThruMemRef(simplifiedChild2)->nodeType==CONSTANT) { /*We are in the f^p case*/ child1_tm=createEmptycModelPrecomp(n,t->x,t->cheb_array, t->cheb_matrix, prec); /*call cheb_model for the child*/ cheb_model(child1_tm, accessThruMemRef(f)->child1,n,x, boundLevel, verbosity, prec); /*bound the child*/ sollya_mpfi_init2(rangeg, prec); chebPolynomialBound(child1_tm->poly_bound, n, child1_tm->poly_array, boundLevel); sollya_mpfi_add(rangeg,child1_tm->rem_bound, child1_tm->poly_bound); /*create cm for x^p over rangeg*/ ctPowVar_tm=createEmptycModelCompute(n,rangeg,1,1, prec); base_CMAux(ctPowVar_tm, MONOTONE_REMAINDER_CONSTPOWERVAR, 0, NULL, *(accessThruMemRef(simplifiedChild2)->value), n,rangeg, verbosity,prec); /*compose*/ tt=createEmptycModelPrecomp(n,child1_tm->x, child1_tm->cheb_array, child1_tm->cheb_matrix, prec); composition_CM(tt,ctPowVar_tm,child1_tm, boundLevel, NULL, prec); /*clear old child*/ clearcModelLight(child1_tm); /*we do not need values of chebpoints and chebMatrix in interval rangeg*/ clearcModelComplete(ctPowVar_tm); copycModel(t,tt); clearcModelLight(tt); sollya_mpfi_clear(rangeg); } else if (accessThruMemRef(simplifiedChild1)->nodeType==CONSTANT) { /*we have the p^f case*/ /*create a new empty cheby model for the child*/ child2_tm=createEmptycModelPrecomp(n,t->x,t->cheb_array, t->cheb_matrix, prec); /*call cheb_model for the child*/ cheb_model(child2_tm, accessThruMemRef(f)->child2,n,x, boundLevel, verbosity, prec); /*bound the child*/ sollya_mpfi_init2(rangeg, prec); chebPolynomialBound(child2_tm->poly_bound, n, child2_tm->poly_array, boundLevel); sollya_mpfi_add(rangeg,child2_tm->rem_bound, child2_tm->poly_bound); /*create cm for p^x over rangeg*/ ctPowVar_tm=createEmptycModelCompute(n,rangeg,1,1, prec); base_CMAux(ctPowVar_tm, MONOTONE_REMAINDER_VARCONSTPOWER, 0, NULL, *(accessThruMemRef(simplifiedChild1)->value), n,rangeg, verbosity,prec); /*compose*/ tt=createEmptycModelPrecomp(n,t->x,t->cheb_array, t->cheb_matrix, prec); composition_CM(tt,ctPowVar_tm,child2_tm, boundLevel, NULL,prec); /*clear old child*/ clearcModelLight(child2_tm); /*we do not need values of chebpoints and chebMatrix in interval rangeg*/ clearcModelComplete(ctPowVar_tm); copycModel(t,tt); clearcModelLight(tt); sollya_mpfi_clear(rangeg); } else { /*We are in the f^g case*/ /*We use the formula exp(g log(f))*/ /*create a new empty cheb model the children*/ /*g*/ child2_tm=createEmptycModelPrecomp(n,t->x,t->cheb_array, t->cheb_matrix, prec); cheb_model(child2_tm, accessThruMemRef(f)->child2,n,x, boundLevel, verbosity, prec); /*f*/ child1_tm=createEmptycModelPrecomp(n,t->x,t->cheb_array, t->cheb_matrix, prec); cheb_model(child1_tm, accessThruMemRef(f)->child1,n,x, boundLevel, verbosity, prec); /*create cheb_model for log (child 1) = log(f)*/ /*log f*/ sollya_mpfi_init2(rangef, prec); chebPolynomialBound(child1_tm->poly_bound, n, child1_tm->poly_array, boundLevel); sollya_mpfi_add(rangef,child1_tm->rem_bound, child1_tm->poly_bound); logx_tm=createEmptycModelCompute(n,rangef,1,1, prec); base_CMAux(logx_tm, MONOTONE_REMAINDER_BASE_FUNCTION, LOG, NULL, NULL, n, rangef, verbosity,prec); logf_tm=createEmptycModelPrecomp(n,t->x,t->cheb_array, t->cheb_matrix, prec); composition_CM(logf_tm, logx_tm,child1_tm, boundLevel, NULL,prec); /*glog f*/ ttt=createEmptycModelPrecomp(n,t->x,t->cheb_array, t->cheb_matrix, prec); multiplication_CM(ttt,logf_tm,child2_tm, boundLevel,0,prec); /*exp(g log f)*/ chebPolynomialBound(ttt->poly_bound, n,ttt->poly_array,boundLevel); sollya_mpfi_add(rangef,ttt->rem_bound, ttt->poly_bound); expx_tm=createEmptycModelCompute(n,rangef,1,1, prec); base_CMAux(expx_tm, MONOTONE_REMAINDER_BASE_FUNCTION, EXP, NULL, NULL, n,rangef, verbosity,prec); tt=createEmptycModelPrecomp(n,t->x,t->cheb_array, t->cheb_matrix, prec); composition_CM(tt,expx_tm,ttt, boundLevel, NULL,prec); /*cleaning*/ clearcModelLight(child2_tm); clearcModelLight(child1_tm); clearcModelLight(ttt); clearcModelLight(logf_tm); /*we do not need values of chebpoints and chebMatrix in interval rangef*/ clearcModelComplete(expx_tm); clearcModelComplete(logx_tm); copycModel(t,tt); clearcModelLight(tt); sollya_mpfi_clear(rangef); } free_memory(simplifiedChild2); free_memory(simplifiedChild1); break; default: sollyaFprintf(stderr,"Error: CM: unknown identifier (%d) in the tree\n",accessThruMemRef(f)->nodeType); exit(1); } } return; } /* Compute a Chebyshev form of order n for f over dom Make a base change such that Ch + sum errors_i * x^i + delta is an absolute-error Taylor form for f over dom, developed at a point in the middle of dom. Return the original Chebyshev coefficients (in the Chebyshev basis) as chebyshevCoefficients. Upon entry, delta has already been initialized with sollya_mpfi_init2. The (sollya_mpfi_t *) intervals in errors and chebyshevCoefficients must be allocated (safeMalloc'ed) and initialized with sollya_mpfi_init2. The entries in errors and chebyshevCoefficients are in natural order, i.e. errors->value points to the 0-th (constant) radius interval around the 0-th (constant) coefficient in Ch. An error during computation can be signaled by setting Ch to NULL. In this case, no memory must be left allocated by the function upon return. All computations should be performed using prec as working precision (try to refrain from using getToolsPrecision()). */ void chebyshevform(node **Ch, chain **errors, sollya_mpfi_t delta, chain **chebyshevCoefficients, node *f, int n, sollya_mpfi_t dom, mp_prec_t prec) { chebModel *t; mpfr_t *coeffsMpfr, domL, domR; sollya_mpfi_t *coeffsErrors, **monomialCoeffs, *chebCoeffs; int i; chain *err; sollya_mpfi_t *rest, zero; /* Adjust n to the notion of degree in the chebyshev command */ n++; /* Check if degree is at least 1, once it has been adjusted */ if (n < 1) { printMessage(1,SOLLYA_MSG_CHEBYSHEVFORM_DEGREE_MUST_NOT_BE_NEGATIVE,"Warning: the degree of a Chebyshev must not be negative.\n"); *Ch = NULL; return; } /* Check that the interval dom is not a point interval*/ mpfr_init2(domR, sollya_mpfi_get_prec(dom)); sollya_mpfi_get_right(domR, dom); mpfr_init2(domL, sollya_mpfi_get_prec(dom)); sollya_mpfi_get_left(domL, dom); if (mpfr_cmp(domR,domL)==0) { printMessage(1,SOLLYA_MSG_CHEBYSHEVFORM_DOMAIN_MUST_NOT_BE_POINT_INTERVAL,"Warning: the domain of a Chebyshev Model can not be a point interval.\n"); mpfr_clear(domL); mpfr_clear(domR); *Ch = NULL; return; } mpfr_clear(domL); mpfr_clear(domR); t=createEmptycModelCompute(n,dom,1,1, prec); cheb_model(t, accessThruMemRef(f), n, dom, 0, 0, prec); monomialCoeffs= (sollya_mpfi_t **)safeMalloc(sizeof(sollya_mpfi_t *)); /*get interval coefficients in monomial basis*/ getCoeffsFromChebPolynomial(monomialCoeffs, t->poly_array, n, dom); /*Transform interval coeffs in monomial basis into (mpfr, error)*/ coeffsMpfr= (mpfr_t *)safeCalloc((n),sizeof(mpfr_t)); coeffsErrors = (sollya_mpfi_t *)safeCalloc((n),sizeof(sollya_mpfi_t)); rest= (sollya_mpfi_t*)safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*rest,prec); for(i=0;in -1,*monomialCoeffs, zero, t->x); /*create Ch;*/ *Ch=makePolynomial(coeffsMpfr, (t->n)-1); /* create errors;*/ err=constructChain(coeffsErrors,t->n-1); chebCoeffs = (sollya_mpfi_t *)safeCalloc((n),sizeof(sollya_mpfi_t)); for (i=0; ipoly_array[i]); } /* create chebycoeffsList;*/ *chebyshevCoefficients=constructChain(chebCoeffs,t->n-1); *errors = err; sollya_mpfi_set(delta,t->rem_bound); for(i=0;i we are using the multiplication inside a composition, we suppose bounds for the polynomials are already updated inside models OTHERWISE --> we rebound them */ void multiplication_CM(chebModel *t,chebModel *c1, chebModel *c2, int boundLevel, int forComposition, mp_prec_t prec); /* composition: g o f VERY IMPORTANT ASSUMPTIONS: We are given a cm for the function f over x, order n and a cm for basic function g over y, order n with: range(f->poly)+ f->rem_bound \subseteq y Note that these assumptions ARE NOT CHECKED inside the function. If these assumptions are true, it returns a valid tm for g(f(x)) over x. Note that it is indicated to bound f tightly before, such that the image over which g is computed is small. We suppose here that the image for f is already computed tightly, and will not be recomputed here. */ /*NOTE: targetRem is a parameter that will stop the composition of the computed remainder gets too large; currently, it is not used, but this should change in the future*/ void composition_CM(chebModel *t,chebModel *g, chebModel *f, int boundLevel, mpfr_t targetRem, mp_prec_t prec); void chebyshevform(node **Ch, chain **errors, sollya_mpfi_t delta, chain **chebyshevCoefficients, node *f, int n, sollya_mpfi_t dom, mp_prec_t prec); #endif /* CHEBYSHEVFORM_H */ sollya-6.0+ds/chebyshevformaux.c000066400000000000000000000641741300174114700170240ustar00rootroot00000000000000/* Copyright 2011-2012 by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, Contributors S. Chevillard, M. Joldes, Ch. Lauter joldes@laas.fr christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "chebyshevformaux.h" #include "general.h" #include "autodiff.h" #include "infnorm.h" /*This file contains auxiliary functions for constructing Chebyshev Models/forms */ /*This function sets an mpfi from evaluating a node* c: if c constant after simplification-> ok if not sets the value to 0 */ /* Remark by Christoph: what about using evaluateConstantExpressionToInterval ? */ int mpfi_set_node( sollya_mpfi_t r, node * c, mp_prec_t prec) { sollya_mpfi_t rr; sollya_mpfi_t *rrr; node *cc; sollya_mpfi_t dummy; /* mp_prec_t prec;*/ /* prec = getToolPrecision();*/ sollya_mpfi_init2(rr,prec); sollya_mpfi_init2(dummy,prec); rrr=safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*rrr,prec); if (c!=NULL){ cc=simplifyTreeErrorfree(c); switch (accessThruMemRef(cc)->nodeType){ case PI_CONST: sollya_mpfi_const_pi(rr); break; case CONSTANT:sollya_mpfi_set_fr(rr,*(accessThruMemRef(cc)->value)); break; default: auto_diff(rrr,c,dummy,0); sollya_mpfi_set(rr, *rrr); break; } free_memory(cc); } else sollya_mpfi_set_ui(rr,0); sollya_mpfi_set(r,rr); sollya_mpfi_clear(rr); sollya_mpfi_clear(dummy); sollya_mpfi_clear(*rrr); safeFree(rrr); return 0; } /**************************************************************************************/ /**************************************************************************************/ /***************************Functions related to Chebyshev points**********************/ /**************************************************************************************/ /**************************************************************************************/ /*returns n chebyshev points of first kind in interval x*/ void getChebyshevPoints(sollya_mpfi_t *chebPoints, int n, sollya_mpfi_t x){ int i; mpfr_t u, v; sollya_mpfi_t ui, vi, temp1, temp2, mpfiPi, mpfiPiArg; mp_prec_t prec; prec = sollya_mpfi_get_prec(chebPoints[0]); sollya_mpfi_init2(ui,prec); sollya_mpfi_init2(vi, prec); sollya_mpfi_init2(temp1, prec); sollya_mpfi_init2(temp2, prec); sollya_mpfi_init2(mpfiPi, prec); sollya_mpfi_init2(mpfiPiArg, prec); mpfr_init2(u, prec); mpfr_init2(v, prec); sollya_mpfi_get_left(u,x); sollya_mpfi_get_right(v,x); sollya_mpfi_set_fr(ui,u); sollya_mpfi_set_fr(vi,v); sollya_mpfi_sub(temp1, ui, vi); sollya_mpfi_div_ui(temp1, temp1,2); sollya_mpfi_add(temp2, ui, vi); sollya_mpfi_div_ui(temp2, temp2,2); sollya_mpfi_const_pi(mpfiPi); sollya_mpfi_div_ui(mpfiPi,mpfiPi,2*n); for (i=1;i<=n;i++){ sollya_mpfi_mul_ui(mpfiPiArg,mpfiPi,(2*i-1)); sollya_mpfi_cos(chebPoints[i-1],mpfiPiArg); sollya_mpfi_mul( chebPoints[i-1], chebPoints[i-1], temp1); sollya_mpfi_add( chebPoints[i-1], chebPoints[i-1], temp2); } sollya_mpfi_clear(ui); sollya_mpfi_clear(vi); sollya_mpfi_clear(temp1); sollya_mpfi_clear(temp2); sollya_mpfi_clear(mpfiPi); sollya_mpfi_clear(mpfiPiArg); mpfr_clear(u); mpfr_clear(v); } /*returns n-1 chebyshev points of second kind in interval x (extremas of T_n((2x-b-a)/(b-a)))*/ void getChebyshevExtrema(sollya_mpfi_t *chebPoints, int n, sollya_mpfi_t x){ int i; mpfr_t u, v; sollya_mpfi_t ui, vi, temp1, temp2, mpfiPi, mpfiPiArg; /*print("The chebyshev extremas are:"); }; for i from 1 to n-1 do{ chebExtremas[i-1]=(cos((i)*Pi/(n)))*(u-v)/2 + (u+v)/2; }; */ mp_prec_t prec; prec = sollya_mpfi_get_prec(chebPoints[0]); sollya_mpfi_init2(ui,prec); sollya_mpfi_init2(vi, prec); sollya_mpfi_init2(temp1, prec); sollya_mpfi_init2(temp2, prec); sollya_mpfi_init2(mpfiPi, prec); sollya_mpfi_init2(mpfiPiArg, prec); mpfr_init2(u, prec); mpfr_init2(v, prec); sollya_mpfi_get_left(u,x); sollya_mpfi_get_right(v,x); sollya_mpfi_set_fr(ui,u); sollya_mpfi_set_fr(vi,v); sollya_mpfi_sub(temp1, ui, vi); sollya_mpfi_div_ui(temp1, temp1,2); sollya_mpfi_add(temp2, ui, vi); sollya_mpfi_div_ui(temp2, temp2,2); sollya_mpfi_const_pi(mpfiPi); sollya_mpfi_div_ui(mpfiPi,mpfiPi,n); for (i=1;i<=n-1;i++){ sollya_mpfi_mul_ui(mpfiPiArg,mpfiPi,i); sollya_mpfi_cos(chebPoints[i-1],mpfiPiArg); sollya_mpfi_mul( chebPoints[i-1], chebPoints[i-1], temp1); sollya_mpfi_add( chebPoints[i-1], chebPoints[i-1], temp2); } sollya_mpfi_clear(ui); sollya_mpfi_clear(vi); sollya_mpfi_clear(temp1); sollya_mpfi_clear(temp2); sollya_mpfi_clear(mpfiPi); sollya_mpfi_clear(mpfiPiArg); mpfr_clear(u); mpfr_clear(v); } /* Returns a matrix chebMatrix of dimension nxn, s.t. chebMatrix[i,j]=T_i(x_j), for i=0..n-1, j=0..n-1, and x_j \in [-1,1] the chebyshev points of first kind in [-1,1]. */ void getChebMatrix(sollya_mpfi_t**chebMatrix, int n, mp_prec_t prec){ int i,j; sollya_mpfi_t *chebPoints; sollya_mpfi_t intrval; sollya_mpfi_t temp; /*mp_prec_t prec;*/ /*prec = getToolPrecision();*/ sollya_mpfi_init2(temp, prec); chebPoints=safeMalloc((n)*sizeof(sollya_mpfi_t)); for (i=0;i0) mpz_set_ui(chebCoeffsMatrix[0],1); if (n>1) mpz_set_ui(chebCoeffsMatrix[n+1],1); for (i=2;i=0;i--){ mpfi_div_z(chebCoeffs[i],pAux[i],chebMatrix[i*n+i]); for(j=i-1;j>=0;j--){ mpfi_mul_z(temp,chebCoeffs[i],chebMatrix[i*n+j]); mpfi_sub(pAux[j],pAux[j],temp); } } for (i=0;i Q(x)*/ /*P(x+alpha)= \sum P^{(i)}(alpha)/i! *x^i */ /*we have to compute the first n-1 derivatives in alpha: P(alpha), P'(alpha), ..., P^(n-1)(alpha)*/ /*evaluate P in alpha, P is of degree n-1*/ symbolic_poly_evaluation_horner(evalP, pAux,alpha,n-1); sollya_mpfi_set(c[0],evalP); mpfi_set_ui(temp, 1); for(i=1;i1) { sollya_mpfi_mul_ui(c[n-2],chebCoeffs[n-1],2*(n-1)); } if(n>2) { sollya_mpfi_mul_ui(c[n-3],chebCoeffs[n-2],2*(n-2)); } for (i=n-3;i>0;i--){ sollya_mpfi_mul_ui(c[i-1],chebCoeffs[i],2*i); sollya_mpfi_add(c[i-1],c[i-1],c[i+1]); } sollya_mpfi_div_ui(c[0],c[0],2); /*we have in c_i the values of the coefs of P'(y) = \sum c_i T_i(x)*/ /*we have to multiply by y'(x), which is z1=2/(b-a) */ /*we compute z1=2/(b-a)*/ sollya_mpfi_init2(ui, prec); sollya_mpfi_init2(vi, prec); mpfr_init2(u, prec); mpfr_init2(v, prec); sollya_mpfi_init2(z1, prec); sollya_mpfi_init2(z2, prec); sollya_mpfi_get_left(u,x); sollya_mpfi_get_right(v,x); sollya_mpfi_set_fr(ui,u); sollya_mpfi_set_fr(vi,v); sollya_mpfi_sub(z2,vi,ui); sollya_mpfi_ui_div(z1,2,z2); for (i=0;i0){ sollya_mpfi_div_ui(c[1],chebCoeffs[2],2); sollya_mpfi_sub(c[1],chebCoeffs[0], c[1]); } for (i=2;i1){ sollya_mpfi_set(c[n-1],chebCoeffs[n-2]); sollya_mpfi_div_ui(c[n-1],c[n-1],2*(n-1)); } if(n>0){ sollya_mpfi_set(c[n],chebCoeffs[n-1]); sollya_mpfi_div_ui(c[n],c[n],2*(n)); } /*we have in c_i the values of the coefs of \int P(y) = \sum c_i T_i(x) (the constant of integration in c_0 is not computed*/ /*we have to multiply by 1/y'(x), which is z1=(b-a)/2 */ /*we compute z1=(b-a)/2*/ sollya_mpfi_init2(ui, prec); sollya_mpfi_init2(vi, prec); mpfr_init2(u, prec); mpfr_init2(v, prec); sollya_mpfi_init2(z1, prec); sollya_mpfi_init2(z2, prec); sollya_mpfi_get_left(u,x); sollya_mpfi_get_right(v,x); sollya_mpfi_set_fr(ui,u); sollya_mpfi_set_fr(vi,v); sollya_mpfi_sub(z2,vi,ui); sollya_mpfi_div_ui(z1,z2,2); for (i=1;i0) sollya_mpfi_set(temp, coeffs[0]); for(i=1;i0; i--){ sollya_mpfi_mul(zz,z,b0); sollya_mpfi_mul_ui(zz,zz,2); sollya_mpfi_sub(zz,zz,b1); sollya_mpfi_add(zz,zz,coeffs[i]); sollya_mpfi_set(b1,b0); sollya_mpfi_set(b0,zz); } sollya_mpfi_mul(zz,z,b0); sollya_mpfi_sub(zz,zz,b1); sollya_mpfi_add(zz,zz,coeffs[0]); sollya_mpfi_set(bound, zz); sollya_mpfi_clear(zz); sollya_mpfi_clear(z); sollya_mpfi_clear(z1); sollya_mpfi_clear(b0); sollya_mpfi_clear(b1); mpfr_clear(b); mpfr_clear(a); } sollya-6.0+ds/chebyshevformaux.h000066400000000000000000000203551300174114700170220ustar00rootroot00000000000000/* Copyright 2011-2012 by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, Contributors S. Chevillard, M. Joldes, Ch. Lauter joldes@laas.fr christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef CHEBYSHEVFORMAUX_H #define CHEBYSHEVFORMAUX_H #include #include #include "mpfi-compat.h" #include "expression.h" /*This file contains headers of functions in chebModelsAux.c i.e. of auxiliary functions for constructing Chebyshev Models/forms*/ /*This function sets an mpfi from evaluating a node* c: if c constant after simplification-> ok if not sets the value to 0 */ int mpfi_set_node( sollya_mpfi_t r, node *c, mp_prec_t prec); /**************************************************************/ /*************Functions related to Chebyshev points************/ /**************************************************************/ /*returns n chebyshev points of first kind in interval x*/ void getChebyshevPoints(sollya_mpfi_t *chebPoints, int n, sollya_mpfi_t x); /*returns n-1 chebyshev points of second kind in interval x (extremas of T_n((2x-b-a)/(b-a)))*/ void getChebyshevExtrema(sollya_mpfi_t *chebPoints, int n, sollya_mpfi_t x); /* Returns a matrix chebMatrix of dimension nxn, s.t. chebMatrix[i,j]=T_i(x_j), for i=0..n-1, j=0..n-1, and x_j \in [-1,1] the chebyshev points of first kind in [-1,1]. */ void getChebMatrix(sollya_mpfi_t**chebMatrix, int n, mp_prec_t prec); /* Returns a matrix chebCoeffsMatrix of dimension nxn, s.t. chebCoeffsMatrix[i,j]=coeff(T_i(x), j), for i=0..n-1, j=0..n-1 */ void getChebPolyCoeffs(mpz_t* chebCoeffsMatrix, int n, mp_prec_t prec); /*Returns in chebCoeffs the coeffs of the finite Chebyshev basis expansion of the polynomial p of degree n-1, over [-1,1]; The coefficients in monomial basis of p are in *p */ void getPolyCoeffsChebBasis(sollya_mpfi_t *chebCoeffs, sollya_mpfi_t *p, int n); /*Returns in c the coeffs in the monomial basis for the polynomial p(a*x+b), where: -- a and b are mpfi_s -- polynomial p of degree n-1 given by the monomial coefficients stored as mpfi_s in *p*/ void getTranslatedPolyCoeffs(sollya_mpfi_t *c, sollya_mpfi_t *p, int n, sollya_mpfi_t a, sollya_mpfi_t b); /***************************************************************/ /**********Functions related to Obtaining Chebyshev Coeffs******/ /***************************************************************/ /*evaluate a function in n chebPoints*/ void getFunctionValues(sollya_mpfi_t* fValues, sollya_mpfi_t * chebPoints,node* f,int n); /*Compute the cheb coeffs for the interpolation polynomial of degree n-1 at chebpoints of first kind, we are given: n chebpoints x_i and a n*n chebMatrix T_i(x_j)) */ void getChebCoeffs(sollya_mpfi_t* coeffs, sollya_mpfi_t *chebMatrix, sollya_mpfi_t *fValues,int n); /*Wrapper that returns the coeffs of the interpolation polynomial of f at chebpoints */ void getChebCoeffsFromFunction(sollya_mpfi_t* coeffs, sollya_mpfi_t * chebPoints, sollya_mpfi_t * chebMatrix,node *f,int n); /*Wrapper to get directly the coeffs in the Chebyshev basis from a polynomial in the monomial basis given by a node* */ void getChebCoeffsFromPolynomial(sollya_mpfi_t**coeffs, int *n, node *f, sollya_mpfi_t x, mp_prec_t prec); /*Wrapper to get directly the coeffs in the monomial basis from a polynomial in the Chebyshev basis given by a list of coeffs*/ void getCoeffsFromChebPolynomial(sollya_mpfi_t**coeffs, sollya_mpfi_t *chebCoeffs, int n, sollya_mpfi_t x); /*Wrapper to get directly the coeffs in the monomial basis from a polynomial in the Chebyshev basis, over a given interval x*/ void getCoeffsFromChebPolynomial(sollya_mpfi_t**coeffs, sollya_mpfi_t *chebCoeffs, int n, sollya_mpfi_t x); /*wrapper to get directly the coeffs in the chebyshev basis up to degree n-1 (first n coeffs) and a bound for the remaining polynomial,from a polynomial in the monomial basis(given by a pointer to node), over a given interval x*/ void getNChebCoeffsFromPolynomial(sollya_mpfi_t *coeffs, sollya_mpfi_t bound, node *f, sollya_mpfi_t x, int n, int boundLevel); /******************************************************************************/ /*Functions related to derivation and integration of polynomials in cheb basis*/ /******************************************************************************/ /*Get the derivative of a polynomial in Chebyshev basis, using classical formula*/ void getChebCoeffsDerivativePolynomial(sollya_mpfi_t*coeffs, sollya_mpfi_t *chebCoeffs, int n, sollya_mpfi_t x); /*Computes the antiderivative of a polynomial in Chebyshev basis. NOTE: the constant coefficient is set to zero, but it should be viewed as a constant*/ void getChebCoeffsIntegrationPolynomial(sollya_mpfi_t*coeffs, sollya_mpfi_t *chebCoeffs, int n, sollya_mpfi_t x); void getChebCoeffsDerivativePolynomial(sollya_mpfi_t*coeffs, sollya_mpfi_t *chebCoeffs, int n, sollya_mpfi_t x); /*Computes the antiderivative of a polynomial in Chebyshev basis. NOTE: the constant coefficient is set to zero, but it should be viewed as a constant*/ void getChebCoeffsIntegrationPolynomial(sollya_mpfi_t*coeffs, sollya_mpfi_t *chebCoeffs, int n, sollya_mpfi_t x); /*****************************************************************************/ /*************Functions related to bounding polynomials in ChebBasis**********/ /*****************************************************************************/ /* Computes an interval bound for a polynomial in cheb basis, over [-1,1], by just adding the absolute values of the coeffs; The n coefficients are given in coeffs.*/ void chebPolynomialBoundSimple(sollya_mpfi_t bound, int n, sollya_mpfi_t *coeffs); /* Computes an interval bound for a polynomial in cheb basis. One day this function may become more complex*/ void chebPolynomialBound(sollya_mpfi_t bound, int n, sollya_mpfi_t *coeffs, int boundLevel); /* Computes an interval bound for a polynomial in cheb basis. by using Clenshaw's method. The n coefficients are given in coeffs.*/ void evaluateChebPolynomialClenshaw(sollya_mpfi_t bound, int n, sollya_mpfi_t *coeffs, mpfi_t x,mpfi_t x0); #endif /* CHEBYSHEVFORMAUX_H */ sollya-6.0+ds/configure.ac000066400000000000000000000750151300174114700155600ustar00rootroot00000000000000# -*- Autoconf -*- # Process this file with autoconf to produce a configure script. # Skeleton initially generated with autoscan AC_PREREQ(2.59) AC_INIT([sollya], [6.0], [sollya-devl@lists.gforge.inria.fr]) AC_CONFIG_MACRO_DIR([m4]) # To please autoconf. See c8fd07aa1d2bd54f8c1b519052849aed1ec39663 AC_CONFIG_AUX_DIR([build-aux]) # Put auxiliary files of autoconf into a specific directory AC_CONFIG_SRCDIR([sollya-library-wrappers.h]) # Checks that we are really trying to configure Sollya and not something else... AC_CONFIG_HEADER([config.h]) AM_INIT_AUTOMAKE([1.6 no-define dist-zip dist-bzip2]) AM_MAINTAINER_MODE([]) # Disables automatic call to ./configure after a modification has been made to configure.ac, Makefile.am, etc. # This simplifies the life of Debian maintainers when they apply patches. # The default behavior (automatic call to ./configure when necessary), that is probably desired for every-day developers is achieved by passing the option --enable-maintainer-mode to configure. m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) # On systems with a recent version of automake, produces a more synthetic output when compiling # Checks for programs. AC_PROG_YACC AC_PROG_CC AC_PROG_CPP AC_PROG_CXX AC_PROG_AWK # Used by ltmain.sh AC_PROG_SED # Used in some tests (although we do not currently use its replacement variable $SED) AM_PROG_CC_C_O # To please autoconf. See 68da652992422c073b8bd2fe0814cd1cf37ee1fc AC_LANG_PUSH([C++]) AC_MSG_CHECKING([whether C++ compiler works]) AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], [[exit(0);]])], [AC_MSG_RESULT(yes)], [AC_MSG_ERROR(no)]) AC_LANG_POP([C++]) AC_PROG_LEX if test "$missing_dir" = ""; then missing_dir="." fi if test "$LEX" != flex; then LEX="$SHELL $missing_dir/missing flex" AC_SUBST(LEX_OUTPUT_ROOT, lex.yy) AC_SUBST(LEXLIB, '') fi AC_PROG_INSTALL AC_PROG_LN_S AC_PROG_MAKE_SET AC_PROG_MKDIR_P AC_LIBTOOL_DLOPEN LT_INIT([dlopen shared]) # AC_PROG_RANLIB is superseeded by LT_INIT AC_SUBST(LIBTOOL_DEPS) AC_SUBST(AR_FLAGS, "cr") # To prevent a warning on some Ubuntu. See fbb8016beff7b45734e53ef8b80d2c306334c248 AC_PATH_PROG([HELP2MAN],[help2man],[no]) AM_CONDITIONAL([HAVE_HELP2MAN], [test "x$HELP2MAN" != "xno"]) #Checking for pdflatex with the required packages AC_PATH_PROG([PDFLATEX],[pdflatex],[no]) if test "x$PDFLATEX" != "xno" then AC_MSG_CHECKING([that pdflatex comes with the necessary packages]) rm -rf .tmp_sollya_ac_pdflatex mkdir .tmp_sollya_ac_pdflatex cd .tmp_sollya_ac_pdflatex echo "\documentclass@<:@a4paper@:>@{article}" > conftest.tex echo "\usepackage@<:@T1@:>@{fontenc}" >> conftest.tex echo "\usepackage@<:@utf8@:>@{inputenc}" >> conftest.tex echo "\usepackage@<:@english@:>@{babel}" >> conftest.tex echo "\usepackage@<:@naturalnames@:>@{hyperref}" >> conftest.tex echo "\usepackage{fullpage}" >> conftest.tex echo "\usepackage{xspace}" >> conftest.tex echo "\usepackage{amssymb}" >> conftest.tex echo "\usepackage{fancyvrb}" >> conftest.tex echo "\usepackage{cmap}" >> conftest.tex echo "\usepackage{lmodern}" >> conftest.tex echo "\usepackage{color}" >> conftest.tex echo "\usepackage{tocloft}" >> conftest.tex echo "\begin{document}" >> conftest.tex echo "Test" >> conftest.tex echo "\end{document}" >> conftest.tex PDFLATEX_WITH_PACKAGES="no" $PDFLATEX -interaction=batchmode conftest.tex 2>&1 1>/dev/null && PDFLATEX_WITH_PACKAGES="$PDFLATEX" PDFLATEX="$PDFLATEX_WITH_PACKAGES" cd .. rm -rf .tmp_sollya_ac_pdflatex fi if test "x$PDFLATEX" != "xno" then AC_MSG_RESULT(yes) else AC_MSG_RESULT(no) fi AM_CONDITIONAL([HAVE_PDFLATEX], [test "x$PDFLATEX" != "xno"]) #Check whether flex and bison support interactive and pure parsers AC_ARG_ENABLE(strict-lexer-parser-check, [[ --enable-strict-lexer-parser-check enables strict compatibility checking for building the lexer and parser files]], [STRICTFLEXBISONTESTING="1"], [STRICTFLEXBISONTESTING=""]) AC_MSG_CHECKING([flex supports interactive and pure lexers]) if test `echo -e "%{\n%}\n\n%option always-interactive\n%option reentrant\n%option prefix=\"coucou\"\n%option bison-bridge\n%option nounput\n\n%%\n"test" { }\n%%\n" > conftest.l ; $LEX conftest.l > /dev/null 2> /dev/null ; echo $?; rm -f lex.coucou.c` -eq 0 then AC_MSG_RESULT(yes) else if test "x$STRICTFLEXBISONTESTING" = "x" then AC_MSG_RESULT([flex version unable to compile the lexer from the grammar files]) else AC_MSG_ERROR(no) fi fi AC_MSG_CHECKING([bison supports interactive and pure parsers]) if test `echo -e "%{\n#define YYERROR_VERBOSE 1\n#define YYPARSE_PARAM scanner\n#define YYLEX_PARAM scanner\n%}\n\n%defines\n%name-prefix \"internyy\"\n%pure-parser\n\n%%\nstart: \".\"\n{ }\n;\n\n" > conftest.y ; $YACC conftest.y > /dev/null 2> /dev/null ; echo $?; rm -f y.tab.*` -eq 0 then AC_MSG_RESULT(yes) else if test "x$STRICTFLEXBISONTESTING" = "x"; then AC_MSG_RESULT([bison version unable to compile the parser from the grammar files]) else AC_MSG_ERROR(no) fi fi # withs... SO_LIB_PATH="" FPLLLVERSIONSTRING="" AC_ARG_WITH(gmp-include, [ --with-gmp-include=DIR GMP include directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval" fi]) AC_ARG_WITH(gmp-lib, [ --with-gmp-lib=DIR GMP lib directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_LDFLAGS="$AM_LDFLAGS -L$withval" SO_LIB_PATH="${SO_LIB_PATH:+$SO_LIB_PATH:}$withval" fi ]) AC_ARG_WITH(gmp, [ --with-gmp=DIR GMP install directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval/include" AM_LDFLAGS="$AM_LDFLAGS -L$withval/lib" SO_LIB_PATH="${SO_LIB_PATH:+$SO_LIB_PATH:}$withval/lib" fi ]) AC_ARG_WITH(mpfr-include, [ --with-mpfr-include=DIR MPFR include directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval" fi]) AC_ARG_WITH(mpfr-lib, [ --with-mpfr-lib=DIR MPFR lib directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_LDFLAGS="$AM_LDFLAGS -L$withval" SO_LIB_PATH="${SO_LIB_PATH:+$SO_LIB_PATH:}$withval" fi ]) AC_ARG_WITH(mpfr, [ --with-mpfr=DIR MPFR install directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval/include" AM_LDFLAGS="$AM_LDFLAGS -L$withval/lib" SO_LIB_PATH="${SO_LIB_PATH:+$SO_LIB_PATH:}$withval/lib" fi ]) AC_ARG_WITH(fplll-include, [ --with-fplll-include=DIR fplll include directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval" FPLLLVERSIONSTRING="$FPLLLVERSIONSTRING--with-fplll-include given as '$withval', " fi ]) AC_ARG_WITH(fplll-lib, [ --with-fplll-lib=DIR fplll lib directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_LDFLAGS="$AM_LDFLAGS -L$withval" SO_LIB_PATH="${SO_LIB_PATH:+$SO_LIB_PATH:}$withval" FPLLLVERSIONSTRING="$FPLLLVERSIONSTRING--with-fplll-lib given as '$withval', " fi ]) AC_ARG_WITH(fplll, [ --with-fplll=DIR fplll install directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval/include" AM_LDFLAGS="$AM_LDFLAGS -L$withval/lib" SO_LIB_PATH="${SO_LIB_PATH:+$SO_LIB_PATH:}$withval/lib" FPLLLVERSIONSTRING="$FPLLLVERSIONSTRING--with-fplll given as '$withval', " fi ]) AC_ARG_WITH(z-include, [ --with-z-include=DIR z include directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval" fi]) AC_ARG_WITH(z-lib, [ --with-z-lib=DIR z lib directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_LDFLAGS="$AM_LDFLAGS -L$withval" fi]) AC_ARG_WITH(z, [ --with-z=DIR z install directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval/include" AM_LDFLAGS="$AM_LDFLAGS -L$withval/lib" fi ]) AC_ARG_WITH(iconv-include, [ --with-iconv-include=DIR iconv include directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval" fi]) AC_ARG_WITH(iconv-lib, [ --with-iconv-lib=DIR iconv lib directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_LDFLAGS="$AM_LDFLAGS -L$withval" fi]) AC_ARG_WITH(iconv, [ --with-iconv=DIR iconv install directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval/include" AM_LDFLAGS="$AM_LDFLAGS -L$withval/lib" fi ]) AC_ARG_WITH(mpfi-include, [ --with-mpfi-include=DIR MPFI include directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval" fi]) AC_ARG_WITH(mpfi-lib, [ --with-mpfi-lib=DIR MPFI lib directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_LDFLAGS="$AM_LDFLAGS -L$withval" SO_LIB_PATH="${SO_LIB_PATH:+$SO_LIB_PATH:}$withval" fi ]) AC_ARG_WITH(mpfi, [ --with-mpfi=DIR MPFI install directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval/include" AM_LDFLAGS="$AM_LDFLAGS -L$withval/lib" SO_LIB_PATH="${SO_LIB_PATH:+$SO_LIB_PATH:}$withval/lib" fi ]) XML2INCLUDEGIVEN="" XML2LIBGIVEN="" AC_ARG_WITH(xml2-include, [ --with-xml2-include=DIR XML2 include directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval -I$withval/libxml2" XML2INCLUDEGIVEN=1 fi ]) AC_ARG_WITH(xml2-lib, [ --with-xml2-lib=DIR XML2 lib directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_LDFLAGS="$AM_LDFLAGS -L$withval" SO_LIB_PATH="${SO_LIB_PATH:+$SO_LIB_PATH:}$withval" XML2LIBGIVEN=1 fi ]) AC_ARG_WITH(xml2, [ --with-xml2=DIR XML2 install directory ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then AM_CPPFLAGS="$AM_CPPFLAGS -I$withval/include -I$withval/include/libxml2" AM_LDFLAGS="$AM_LDFLAGS -L$withval/lib" SO_LIB_PATH="${SO_LIB_PATH:+$SO_LIB_PATH:}$withval/lib" XML2INCLUDEGIVEN=1 XML2LIBGIVEN=1 fi ]) #Add xml2 include and lib XML2CONFIGGIVEN="" AC_ARG_WITH(xml2-config, [ --with-xml2-config=executable XML2 config tool ], [if test "x$withval" != "xyes" -a "x$withval" != "x" then XML2CONFIG="$withval" XML2CONFIGGIVEN=1 fi ]) if test "x$XML2CONFIGGIVEN" = "x" then AC_CHECK_PROG(XML2CONFIG, xml2-config, [xml2-config], [false]) fi if test "x$XML2INCLUDEGIVEN" = "x" then AM_CPPFLAGS="$AM_CPPFLAGS "`$XML2CONFIG --cflags` fi if test "x$XML2LIBGIVEN" = "x" then XML2LIBS=`$XML2CONFIG --libs --static` XML2LIBSPURE=`$XML2CONFIG --libs | $SED -e 's/^-l//g;s/[[:blank:]]-l//g;'` AC_SEARCH_LIBS([xmlTextReaderIsEmptyElement], [$XML2LIBSPURE], [], [], [$XML2LIBS]) fi # Save user flags and set flags given by configure for the rest of the tests USER_CFLAGS="$CFLAGS" USER_CXXFLAGS="$CXXFLAGS" USER_CPPFLAGS="$CPPFLAGS" USER_LDFLAGS="$LDFLAGS" CFLAGS="$AM_CFLAGS $USER_CFLAGS" CXXFLAGS="$AM_CXXFLAGS $USER_CXXFLAGS" CPPFLAGS="$AM_CPPFLAGS $USER_CPPFLAGS" LDFLAGS="$AM_LDFLAGS $USER_LDFLAGS" export LD_LIBRARY_PATH="${LD_LIBRARY_PATH:+$LD_LIBRARY_PATH:}$SO_LIB_PATH" # Checks for libraries. dlopen_ok="yes" AC_CHECK_LIB([c], [dlopen], [], [dlopen_ok="no"]) if test "x${dlopen_ok}y" = "xnoy" ; then AC_CHECK_LIB([dl], [dlopen], [], AC_MSG_ERROR([libdl unusable])) fi AC_CHECK_LIB([gmp], [__gmpz_init], [true], AC_MSG_ERROR([libgmp unusable])) AC_CHECK_LIB([gmp], [__gmpz_fac_ui], [true], AC_MSG_ERROR([libgmp version too old])) AC_CHECK_LIB([gmp], [__gmpz_bin_uiui], [true], AC_MSG_ERROR([libgmp version too old])) AC_CHECK_LIB([gmp], [__gmpz_export], [], AC_MSG_ERROR([libgmp version too old])) # This one adds -lgmp in case of success AC_CHECK_LIB([mpfr], [mpfr_init], [true], AC_MSG_ERROR([libmpfr unusable])) AC_CHECK_LIB([mpfr], [mpfr_set_z_2exp], [true], AC_MSG_ERROR([libmpfr version too old])) AC_CHECK_LIB([mpfr], [mpfr_erfc], [], AC_MSG_ERROR([libmpfr version too old])) # This one adds -lmpfr in case of success AC_CHECK_LIB([mpfi], [mpfi_init], [], AC_MSG_ERROR([libmpfi unusable])) AC_CHECK_LIB([z], [gzdopen], [], []) AC_CHECK_LIB([iconv], [libiconv_open], [], []) # This for providing a statically linked program under Cygwin. See e0d7171f9daf0027e075723d21fb40a864578cd5 AC_CHECK_LIB([m],[cos]) AC_CHECK_LIB([xml2], [xmlTextReaderIsEmptyElement], [], AC_MSG_ERROR([libxml2 unusable])) # Check that dynamic libraries are available at runtime AC_MSG_CHECKING([if libgmp is found at runtime]) AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include ]], [[mpz_t a; mpz_init(a); mpz_clear(a); return 0;]])], [AC_MSG_RESULT(yes)], [AC_MSG_WARN([libgmp is found at compile time but not at run time. Checking /etc/ld.so.conf and running ldconfig could fix the problem.])]) AC_MSG_CHECKING([if libmpfr is found at runtime]) AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include ]], [[mpfr_t a; mpfr_init2(a, 53); mpfr_clear(a); return 0;]])], [AC_MSG_RESULT(yes)], [AC_MSG_WARN([libmpfr is found at compile time but not at run time. Checking /etc/ld.so.conf and running ldconfig could fix the problem.])]) AC_MSG_CHECKING([if libmpfi is found at runtime]) AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include ]], [[mpfi_t a; mpfi_init(a); mpfi_clear(a); return 0;]])], [AC_MSG_RESULT(yes)], [AC_MSG_ERROR([libmpfi is found at compile time but not at run time. Checking /etc/ld.so.conf and running ldconfig could fix the problem.])]) AC_MSG_CHECKING([if libxml2 is found at runtime]) AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include ]], [[xmlCleanupParser(); return 0;]])], [AC_MSG_RESULT(yes)], [AC_MSG_WARN([libxml2 is found at compile time but not at run time. Checking /etc/ld.so.conf and running ldconfig could fix the problem.])]) #Special check for fplll AC_LANG_PUSH([C++]) #Check for -std=c++11 or -std=gnu++11 CXXFLAGS="$AM_CXXFLAGS -std=c++11 $USER_CXXFLAGS" AC_MSG_CHECKING([for -std=c++11 or -std=gnu++11 support]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], [ AC_MSG_RESULT(yes) STDCXX11="-std=c++11" ], [ CXXFLAGS="$AM_CXXFLAGS -std=gnu++11 $USER_CXXFLAGS" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], [ AC_MSG_RESULT(yes) STDCXX11="-std=gnu++11" ], [ AC_MSG_RESULT(no) STDCXX11="" ]) ]) # We currently have 4 parameters that can take two values and depending on the version of fplll and g++, a given combination of them might work or not: # - include or # - link with -lfplll flag or not # - use -std=c+11 or not # - use the old or new API of fplll # It seems reasonable to filter the 16 possible cases by noticing that the the necessity of including the -std option is quite recent, whereas the include actually corresponds to fairly old versions of fplll. Also, the compilation with -lfplll is required for quite a while now. # We first assume a relatively recent vers of fplll: trying include and linking with -lfplll, we explore the 4 remaining possibilities. # If none of these possibilities worked, we assume a fairly old version of fplll: trying the old API and without the -std option, we explore the 3 remaining possibilitie. # If nothing worked of these 7 possibilities, we give up. FPLLL_PROGV3=`printf "\ ZZ_mat *M; Z_NR zval; mpz_t mpzval; wrapper *LLLwrapper; int i,j;\n\ mpz_init(mpzval);\n\ M = new ZZ_mat(3, 3);\n\ for(i=0;i<=2;i++) {\n\ for(j=0;j<=2;j++) {\n\ mpz_set_ui(mpzval, (i+1)*(j+2));\n\ zval.set(mpzval);\n\ M->Set(i,j,zval);\n\ }\n\ }\n\ LLLwrapper = new wrapper(M);\n\ LLLwrapper->LLL();\ "` FPLLL_PROG=`printf "\ ZZ_mat *M; Z_NR zval; mpz_t mpzval; int i,j;\n\ mpz_init(mpzval);\n\ M = new ZZ_mat(3, 3);\n\ for(i=0;i<=2;i++) {\n\ for(j=0;j<=2;j++) {\n\ mpz_set_ui(mpzval, (i+1)*(j+2));\n\ zval = mpzval;\n\ (*M)@<:@i@:>@@<:@j@:>@ = zval;\n\ }\n\ }\n\ lll_reduction(*M);\ "` FPLLL_NORMAL_HEADER=`printf "\ #include \n\ #include \n\ #include \ "` FPLLL_SPECIAL_HEADER=`printf "\ #include \n\ #include \n\ #include \ "` FPLLLSPECIALINCLUDE="no" FPLLLISREALLIB="no" FPLLLCXX11="no" FPLLLMODERNAPI="no" AC_MSG_CHECKING([for a suitable installation of fplll]) OLD_LIBS="$LIBS"; LIBS="-lfplll $LIBS"; CXXFLAGS="$AM_CXXFLAGS $STDCXX11 $USER_CXXFLAGS" AC_LINK_IFELSE([AC_LANG_PROGRAM([[$FPLLL_NORMAL_HEADER]], [[$FPLLL_PROG]])], [ FPLLLSPECIALINCLUDE="no" FPLLLISREALLIB="yes" FPLLLCXX11="yes" FPLLLMODERNAPI="yes" AC_MSG_RESULT(yes) ], [AC_LINK_IFELSE([AC_LANG_PROGRAM([[$FPLLL_NORMAL_HEADER]], [[$FPLLL_PROGV3]])], [ FPLLLSPECIALINCLUDE="no" FPLLLISREALLIB="yes" FPLLLCXX11="yes" FPLLLMODERNAPI="no" AC_MSG_RESULT(yes) ], [CXXFLAGS="$AM_CXXFLAGS $USER_CXXFLAGS" AC_LINK_IFELSE([AC_LANG_PROGRAM([[$FPLLL_NORMAL_HEADER]], [[$FPLLL_PROGV3]])], [ FPLLLSPECIALINCLUDE="no" FPLLLISREALLIB="yes" FPLLLCXX11="no" FPLLLMODERNAPI="no" AC_MSG_RESULT(yes) ], [AC_LINK_IFELSE([AC_LANG_PROGRAM([[$FPLLL_NORMAL_HEADER]], [[$FPLLL_PROG]])], [ FPLLLSPECIALINCLUDE="no" FPLLLISREALLIB="yes" FPLLLCXX11="no" FPLLLMODERNAPI="yes" AC_MSG_RESULT(yes) ], [AC_LINK_IFELSE([AC_LANG_PROGRAM([[$FPLLL_SPECIAL_HEADER]], [[$FPLLL_PROGV3]])], [ FPLLLSPECIALINCLUDE="yes" FPLLLISREALLIB="yes" FPLLLCXX11="no" FPLLLMODERNAPI="no" AC_MSG_RESULT(yes) ], [LIBS="$OLD_LIBS" AC_LINK_IFELSE([AC_LANG_PROGRAM([[$FPLLL_SPECIAL_HEADER]], [[$FPLLL_PROGV3]])], [ FPLLLSPECIALINCLUDE="yes" FPLLLISREALLIB="no" FPLLLCXX11="no" FPLLLMODERNAPI="no" AC_MSG_RESULT(yes) ], [AC_LINK_IFELSE([AC_LANG_PROGRAM([[$FPLLL_NORMAL_HEADER]], [[$FPLLL_PROGV3]])], [ FPLLLSPECIALINCLUDE="no" FPLLLISREALLIB="no" FPLLLCXX11="no" FPLLLMODERNAPI="no" AC_MSG_RESULT(yes) ], [AC_MSG_RESULT(no)] )] )] )] )] )] )] ) if test "x${FPLLLSPECIALINCLUDE}y" = "xyesy" then FPLLL_GOOD_HEADER="$FPLLL_SPECIAL_HEADER" AC_DEFINE([HAVE_SPECIAL_FPLLL_INCLUDE],[1],[Define for determining a special version of FPLLL]) FPLLLVERSIONSTRING="$FPLLLVERSIONSTRING""fplll.h lies inside a subdirectory of the include directory (Debian-like), " else FPLLL_GOOD_HEADER="$FPLLL_NORMAL_HEADER" AC_DEFINE([HAVE_SPECIAL_FPLLL_INCLUDE],[0],[Define for determining a special version of FPLLL]) FPLLLVERSIONSTRING="$FPLLLVERSIONSTRING""fplll.h lies directly in the include directory, " fi if test "x${FPLLLISREALLIB}y" = "xyesy" then LIBS="-lfplll $OLD_LIBS" FPLLLVERSIONSTRING="$FPLLLVERSIONSTRING""linkage with -lfplll is compatible, " else LIBS="$OLD_LIBS" FPLLLVERSIONSTRING="$FPLLLVERSIONSTRING""linkage with -lfplll is not compatible, " fi if test "x${FPLLLCXX11}y" = "xyesy" then AM_CXXFLAGS="$AM_CXXFLAGS $STDCXX11" FPLLLVERSIONSTRING="$FPLLLVERSIONSTRING""-std option is passed (""$STDCXX11""), " else FPLLLVERSIONSTRING="$FPLLLVERSIONSTRING""no -std option is passed, " fi CXXFLAGS="$AM_CXXFLAGS $USER_CXXFLAGS" if test "x${FPLLLMODERNAPI}y" = "xyesy" then FPLLL_GOOD_PROG="$FPLLL_PROG" AC_DEFINE([HAVE_FPLLL_OLD_API],[0],[Define for determining what API to use with FPLLL]) FPLLLVERSIONSTRING="$FPLLLVERSIONSTRING""using standard API." else FPLLL_GOOD_PROG="$FPLLL_PROGV3" AC_DEFINE([HAVE_FPLLL_OLD_API],[1],[Define for determining what API to use with FPLLL]) FPLLLVERSIONSTRING="$FPLLLVERSIONSTRING""using the FPLLL_V3_COMPAT API." fi AC_DEFINE_UNQUOTED([HAVE_FPLLL_VERSION_STRING],["$FPLLLVERSIONSTRING"],[Define a kind of a version string for FPLLL]) AC_LANG_POP([C++]) # Testing if -lstdc++ works both with the C compiler and the C++ compiler. # We add it only if it works with both. ADD_LSTDC="yes" OLD_LIBS="$LIBS"; LIBS="$LIBS -lstdc++" AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], [], [ADD_LSTDC="no"]) AC_LANG_PUSH([C++]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], [], [ADD_LSTDC="no"]) AC_LANG_POP([C++]) if test "x${ADD_LSTDC}y" = "xnoy" then LIBS="$OLD_LIBS" fi AC_LANG_PUSH([C++]) # Checking that libfplll is found at runtime AC_MSG_CHECKING([if libfplll is found at runtime]) AC_RUN_IFELSE([AC_LANG_PROGRAM([[ #undef malloc #undef realloc $FPLLL_GOOD_HEADER]], [[$FPLLL_GOOD_PROG]]) ], [AC_MSG_RESULT(yes)], [AC_MSG_WARN([libfplll is found at compile time but not at run time. Checking /etc/ld.so.conf and running ldconfig could fix the problem.])]) AC_LANG_POP([C++]) #Check for -Wl,-export-dynamic etc. CFLAGS="$AM_CFLAGS -fPIC -Werror $USER_CFLAGS" AC_MSG_CHECKING([for -fPIC support]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], [ AC_MSG_RESULT(yes) AM_CFLAGS="$AM_CFLAGS -fPIC" CFLAGS="$AM_CFLAGS $USER_CFLAGS" ], [ AC_MSG_RESULT(no) CFLAGS="$AM_CFLAGS $USER_CFLAGS" ]) LDFLAGS="$AM_LDFLAGS -Wl,--export-dynamic $USER_LDFLAGS" AC_MSG_CHECKING([for --export-dynamic support]) AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include ]], [[exit(0);]] )], [ AC_MSG_RESULT(yes) AM_LDFLAGS="$AM_LDFLAGS -Wl,--export-dynamic" ], [ AC_MSG_RESULT(no) LDFLAGS="$AM_LDFLAGS $USER_LDFLAGS" ]) LDFLAGS="$AM_LDFLAGS -Xlinker --allow-multiple-definition $USER_LDFLAGS" AC_MSG_CHECKING([for -Xlinker --allow-multiple-definition support]) AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include ]], [[exit(0);]] )], [ AC_MSG_RESULT(yes) AM_LDFLAGS="$AM_LDFLAGS -Xlinker --allow-multiple-definition" ], [ AC_MSG_RESULT(no) LDFLAGS="$AM_LDFLAGS $USER_LDFLAGS" ]) AC_MSG_CHECKING([if compiler activates FTZ by default]) AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include ]], [[ union { uint64_t i; double d; } xct, yct; volatile double x, y; xct.i = 0x1f20000000000000ull; x = xct.d; y = x * x; yct.d = y; if (yct.i == 0x0000000000000000ull) return 1;]] )], [AC_MSG_RESULT(no)], [ AC_MSG_RESULT(yes) AC_MSG_CHECKING([if compiler supports -fp-model precise flag]) CFLAGS="$AM_CFLAGS -fp-model precise $USER_CFLAGS" AC_RUN_IFELSE([AC_LANG_PROGRAM([[#include ]], [[exit(0);]] )], [ AC_MSG_RESULT(yes) AM_CFLAGS="$AM_CFLAGS -fp-model precise" ], [ AC_MSG_RESULT(no) CFLAGS="$AM_CFLAGS $USER_CFLAGS" ]) ]) # Checks for linker script support: gl_LD_VERSION_SCRIPT # Checks for header files. AC_FUNC_ALLOCA AC_HEADER_STDC AC_HEADER_SYS_WAIT # If we do not have these ones, we consider that we cannot work properly. # As for termios.h we might do something even if it is missing (e.g., build the # library and provide the tool able to read files but not working # interactively). The current position is: we do not. AC_CHECK_HEADERS([inttypes.h stddef.h stdint.h stdlib.h string.h termios.h unistd.h limits.h wchar.h], [ ], AC_MSG_ERROR([Necessary header is missing])) # If we do not have these ones, we can survive, protecting corresponding calls by a #ifdef HAVE_.... AC_CHECK_HEADERS([sys/ioctl.h sys/time.h]) # Checks for typedefs, structures, and compiler characteristics. AC_C_CONST AC_HEADER_STDBOOL AC_TYPE_INT8_T AC_TYPE_INT16_T AC_TYPE_INT32_T AC_TYPE_INT64_T AC_TYPE_UINT8_T AC_TYPE_UINT16_T AC_TYPE_UINT32_T AC_TYPE_UINT64_T AC_HEADER_TIME AC_TYPE_PID_T AC_TYPE_SIZE_T AC_TYPE_SSIZE_T AC_C_VOLATILE AC_C_INLINE AC_CHECK_TYPES([ptrdiff_t]) # Checks for library functions. AC_FUNC_FORK AC_PROG_GCC_TRADITIONAL # To support very old versions of gcc AC_TYPE_SIGNAL AC_FUNC_VPRINTF AC_FUNC_MALLOC AC_FUNC_REALLOC # If we do not have these functions we should survive because they shall be reimplemented in Sollya if necessaray if they are not provided by the system. In any case a test #ifdef HAVE_ shall protect any call to a function listed here. AC_CHECK_FUNCS(gettimeofday memmove memset strchr strerror strrchr strtol dup2 strstr dladdr clock_gettime time sigaction sigaddset sigemptyset sigprocmask) AC_MSG_CHECKING([if the system allows %n in a writable segment]) AC_RUN_IFELSE([AC_LANG_PROGRAM([[#define _BSD_SOURCE #define _DEFAULT_SOURCE #include #include ]], [[ char *str; int count; str = malloc(20*sizeof(char)); sprintf(str, "%%n"); printf(str, &count); free(str); return 0;]] )], [ AC_MSG_RESULT(yes) ], [ AC_MSG_RESULT(no) AC_DEFINE([SYSTEM_DOES_NOT_ALLOW_COMPLETE_PRINTF],[1],[The system does not allow %n in malloced strings]) ]) AC_MSG_CHECKING([if the Dl_info type is usable]) AC_RUN_IFELSE([AC_LANG_PROGRAM([[#define _GNU_SOURCE 1 #define _DARWIN_C_SOURCE 1 #include #include ]], [[ Dl_info myInfo; if (dladdr(main, &myInfo) != 0) return 0; exit(1);]] )], [ AC_MSG_RESULT(yes) AC_DEFINE([HAVE_DL_INFO_TYPE],[1],[Enabling Dl_info type usage]) ], AC_MSG_RESULT(no)) AC_CHECK_TYPES([mp_bitcnt_t], [], [], [[#include ]]) CPPFLAGS="$USER_CPPFLAGS" CFLAGS="$USER_CFLAGS" LDFLAGS="$USER_LDFLAGS" # The following two lines are supposed to fix bug #17197. AM_CPPFLAGS="-I\${abs_top_srcdir} $AM_CPPFLAGS" AC_SUBST(AM_CPPFLAGS) AC_SUBST(AM_CFLAGS) AC_SUBST(AM_LDFLAGS) AC_CONFIG_FILES([Makefile doc/Makefile tests-tool/Makefile tests-lib/Makefile]) AC_OUTPUT sollya-6.0+ds/doc/000077500000000000000000000000001300174114700140275ustar00rootroot00000000000000sollya-6.0+ds/doc/CommandsAndFunctions.tex000066400000000000000000000061631300174114700206340ustar00rootroot00000000000000\input{abs} \input{absolute} \input{accurateinfnorm} \input{acos} \input{acosh} \input{and} \input{annotatefunction} \input{append} \input{approx} \input{asciiplot} \input{asin} \input{asinh} \input{atan} \input{atanh} \input{autodiff} \input{autosimplify} \input{bashevaluate} \input{bashexecute} \input{binary} \input{bind} \input{boolean} \input{canonical} \input{ceil} \input{chebyshevform} \input{checkinfnorm} \input{coeff} \input{composepolynomials} \input{concat} \input{constant} \input{cos} \input{cosh} \input{d} \input{dd} \input{de} \input{decimal} \input{default} \input{degree} \input{denominator} \input{diam} \input{dieonerrormode} \input{diff} \input{dirtyfindzeros} \input{dirtyinfnorm} \input{dirtyintegral} \input{dirtysimplify} \input{display} \input{divide} \input{double} \input{doubledouble} \input{doubleextended} \input{dyadic} \input{equal} \input{erf} \input{erfc} \input{error} \input{evaluate} \input{execute} \input{exp} \input{expand} \input{expm1} \input{exponent} \input{externalplot} \input{externalproc} \input{false} \input{file} \input{findzeros} \input{fixed} \input{floating} \input{floor} \input{fpminimax} \input{fullparentheses} \input{function} \input{ge} \input{getbacktrace} \input{getsuppressedmessages} \input{gt} \input{guessdegree} \input{halfprecision} \input{head} \input{hexadecimal} \input{honorcoeffprec} \input{hopitalrecursions} \input{horner} \input{hp} \input{implementconstant} \input{implementpoly} \input{in} \input{inf} \input{infnorm} \input{integer} \input{integral} \input{isbound} \input{isevaluable} \input{le} \input{length} \input{library} \input{libraryconstant} \input{listof} \input{log} \input{log10} \input{log1p} \input{log2} \input{lt} \input{mantissa} \input{max} \input{mid} \input{midpointmode} \input{min} \input{minus} \input{mult} \input{nearestint} \input{neq} \input{nop} \input{not} \input{numberroots} \input{numerator} \input{object} \input{objectname} \input{off} \input{on} \input{or} \input{parse} \input{perturb} \input{pi} \input{plot} \input{plus} \input{points} \input{postscript} \input{postscriptfile} \input{power} \input{powers} \input{prec} \input{precision} \input{prepend} \input{print} \input{printdouble} \input{printexpansion} \input{printsingle} \input{printxml} \input{proc} \input{procedure} \input{qd} \input{quad} \input{quit} \input{range} \input{rationalapprox} \input{rationalmode} \input{rd} \input{readfile} \input{readxml} \input{relative} \input{remez} \input{rename} \input{restart} \input{return} \input{revert} \input{rn} \input{round} \input{roundcoefficients} \input{roundcorrectly} \input{roundingwarnings} \input{ru} \input{rz} \input{searchgal} \input{sg} \input{showmessagenumbers} \input{simplify} \input{sin} \input{single} \input{sinh} \input{sort} \input{sqrt} \input{string} \input{subpoly} \input{substitute} \input{sup} \input{supnorm} \input{suppressmessage} \input{tail} \input{tan} \input{tanh} \input{taylor} \input{taylorform} \input{taylorrecursions} \input{td} \input{time} \input{timing} \input{tripledouble} \input{true} \input{unsuppressmessage} \input{var} \input{verbosity} \input{void} \input{worstcase} \input{write} \input{xfreevariable} sollya-6.0+ds/doc/Makefile.am000066400000000000000000000120661300174114700160700ustar00rootroot00000000000000# Make sollya.pdf be installed by make install dist_doc_DATA = sollya.pdf TEXSOURCES = sollya.tex \ absolute.tex \ abs.tex \ accurateinfnorm.tex \ acosh.tex \ acos.tex \ and.tex \ annotatefunction.tex \ append.tex \ approx.tex \ asciiplot.tex \ asinh.tex \ asin.tex \ atanh.tex \ atan.tex \ autodiff.tex \ autosimplify.tex \ bashevaluate.tex \ bashexecute.tex \ binary.tex \ bind.tex \ boolean.tex \ canonical.tex \ ceil.tex \ chebyshevform.tex \ checkinfnorm.tex \ coeff.tex \ CommandsAndFunctions.tex \ composepolynomials.tex \ concat.tex \ constant.tex \ cosh.tex \ cos.tex \ dd.tex \ decimal.tex \ default.tex \ degree.tex \ denominator.tex \ de.tex \ diam.tex \ dieonerrormode.tex \ diff.tex \ dirtyfindzeros.tex \ dirtyinfnorm.tex \ dirtyintegral.tex \ dirtysimplify.tex \ display.tex \ divide.tex \ doubledouble.tex \ doubleextended.tex \ double.tex \ d.tex \ dyadic.tex \ equal.tex \ erfc.tex \ erf.tex \ error.tex \ evaluate.tex \ execute.tex \ expand.tex \ expm1.tex \ exponent.tex \ exp.tex \ externalplot.tex \ externalproc.tex \ false.tex \ file.tex \ findzeros.tex \ fixed.tex \ floating.tex \ floor.tex \ fpminimax.tex \ fullparentheses.tex \ function.tex \ getbacktrace.tex \ ge.tex \ getsuppressedmessages.tex \ gt.tex \ guessdegree.tex \ halfprecision.tex \ head.tex \ hexadecimal.tex \ honorcoeffprec.tex \ hopitalrecursions.tex \ horner.tex \ hp.tex \ implementconstant.tex \ implementpoly.tex \ infnorm.tex \ inf.tex \ integer.tex \ integral.tex \ in.tex \ introExample10.tex \ introExample11.tex \ introExample12.tex \ introExample13.tex \ introExample14.tex \ introExample15.tex \ introExample16.tex \ introExample17.tex \ introExample18.tex \ introExample19.tex \ introExample1.tex \ introExample20.tex \ introExample21.tex \ introExample22.tex \ introExample23.tex \ introExample24.tex \ introExample25.tex \ introExample26.tex \ introExample27.tex \ introExample28.tex \ introExample29.tex \ introExample2.tex \ introExample30.tex \ introExample31.tex \ introExample32.tex \ introExample33.tex \ introExample34.tex \ introExample35.tex \ introExample36.tex \ introExample37bis.tex \ introExample37.tex \ introExample38.tex \ introExample39.tex \ introExample3bis.tex \ introExample3.tex \ introExample40.tex \ introExample41.tex \ introExample42.tex \ introExample43.tex \ introExample44.tex \ introExample45.tex \ introExample46.tex \ introExample47.tex \ introExample48.tex \ introExample49.tex \ introExample4.tex \ introExample50.tex \ introExample51.tex \ introExample52.tex \ introExample53.tex \ introExample54.tex \ introExample55.tex \ introExample56.tex \ introExample57.tex \ introExample58.tex \ introExample59.tex \ introExample5.tex \ introExample6.tex \ introExample7.tex \ introExample8.tex \ introExample9.tex \ isbound.tex \ isevaluable.tex \ length.tex \ le.tex \ libraryconstant.tex \ library.tex \ listof.tex \ log10.tex \ log1p.tex \ log2.tex \ log.tex \ lt.tex \ mantissa.tex \ max.tex \ midpointmode.tex \ mid.tex \ min.tex \ minus.tex \ mult.tex \ nearestint.tex \ neq.tex \ nop.tex \ not.tex \ numberroots.tex \ numerator.tex \ objectname.tex \ object.tex \ off.tex \ on.tex \ or.tex \ parse.tex \ perturb.tex \ pi.tex \ plot.tex \ plus.tex \ points.tex \ postscriptfile.tex \ postscript.tex \ powers.tex \ power.tex \ precision.tex \ prec.tex \ prepend.tex \ printdouble.tex \ printexpansion.tex \ printsingle.tex \ print.tex \ printxml.tex \ procedure.tex \ proc.tex \ qd.tex \ quad.tex \ quit.tex \ range.tex \ rationalapprox.tex \ rationalmode.tex \ rd.tex \ readfile.tex \ readxml.tex \ relative.tex \ remez.tex \ rename.tex \ restart.tex \ return.tex \ revert.tex \ rn.tex \ roundcoefficients.tex \ roundcorrectly.tex \ roundingwarnings.tex \ round.tex \ ru.tex \ rz.tex \ searchgal.tex \ sg.tex \ showmessagenumbers.tex \ simplify.tex \ single.tex \ sinh.tex \ sin.tex \ sort.tex \ sqrt.tex \ string.tex \ subpoly.tex \ substitute.tex \ supnorm.tex \ suppressmessage.tex \ sup.tex \ tail.tex \ tanh.tex \ tan.tex \ taylorform.tex \ taylorrecursions.tex \ taylor.tex \ td.tex \ time.tex \ timing.tex \ tripledouble.tex \ true.tex \ unsuppressmessage.tex \ var.tex \ verbosity.tex \ void.tex \ worstcase.tex \ write.tex \ xfreevariable.tex EXTRA_DIST = $(TEXSOURCES) if HAVE_PDFLATEX # Set interaction mode of latex so as not to ask questions to the user # in case of problems. LATEXFLAGS = -interaction=nonstopmode PDFLATEX_TEXINPUTS="$(abs_srcdir):" COMPOSE_PDFLATEX = TEXINPUTS=$(PDFLATEX_TEXINPUTS) $(PDFLATEX) $(LATEXFLAGS) sollyapdf_verbose = $(sollyapdf_verbose_@AM_V@) sollyapdf_verbose_ = $(sollyapdf_verbose_@AM_DEFAULT_V@) sollyapdf_verbose_0 = @echo " LATEX "$@; sollya.pdf: $(TEXSOURCES) @if $(AM_V_P); \ then $(COMPOSE_PDFLATEX) $< ; \ else echo " LATEX "$@ ; \ $(COMPOSE_PDFLATEX) $< > /dev/null; \ fi @if $(AM_V_P); then echo -n "pdflatex is now silently run so as to ensure proper labels and references."; fi @$(COMPOSE_PDFLATEX) $< > /dev/null @if $(AM_V_P); then echo -n "."; fi @$(COMPOSE_PDFLATEX) $< > /dev/null @if $(AM_V_P); then echo -n "."; fi @$(COMPOSE_PDFLATEX) $< > /dev/null @if $(AM_V_P); then echo " Done.";fi endif sollya-6.0+ds/doc/abs.tex000066400000000000000000000010251300174114700153140ustar00rootroot00000000000000\subsection{abs} \label{lababs} \noindent Name: \textbf{abs}\\ \phantom{aaa}the absolute value.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_abs(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_abs(sollya_obj_t)|\\ \verb| #define SOLLYA_ABS(x) sollya_lib_build_function_abs(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{abs} is the absolute value function. \textbf{abs}(x)=$\left \lbrace \begin{array}{rl} x & x > 0 \\ -x & x \leq 0 \end{array} \right.$. \end{itemize} sollya-6.0+ds/doc/absolute.tex000066400000000000000000000031511300174114700163670ustar00rootroot00000000000000\subsection{absolute} \label{lababsolute} \noindent Name: \textbf{absolute}\\ \phantom{aaa}indicates an absolute error for \textbf{externalplot}, \textbf{fpminimax} or \textbf{supnorm}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_absolute()|\\ \verb| int sollya_lib_is_absolute(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{absolute} : \textsf{absolute$|$relative}\\ \end{center} \noindent Description: \begin{itemize} \item The use of \textbf{absolute} in the command \textbf{externalplot} indicates that during plotting in \textbf{externalplot} an absolute error is to be considered. See \textbf{externalplot} for details. \item Used with \textbf{fpminimax}, \textbf{absolute} indicates that \textbf{fpminimax} must try to minimize the absolute error. See \textbf{fpminimax} for details. \item When given in argument to \textbf{supnorm}, \textbf{absolute} indicates that an absolute error is to be considered for supremum norm computation. See \textbf{supnorm} for details. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > bashexecute("gcc -fPIC -c externalplotexample.c"); > bashexecute("gcc -shared -o externalplotexample externalplotexample.o -lgmp -l mpfr"); > externalplot("./externalplotexample",absolute,exp(x),[-1/2;1/2],12,perturb); \end{Verbatim} \end{minipage}\end{center} See also: \textbf{externalplot} (\ref{labexternalplot}), \textbf{fpminimax} (\ref{labfpminimax}), \textbf{relative} (\ref{labrelative}), \textbf{bashexecute} (\ref{labbashexecute}), \textbf{supnorm} (\ref{labsupnorm}) sollya-6.0+ds/doc/accurateinfnorm.tex000066400000000000000000000065731300174114700177440ustar00rootroot00000000000000\subsection{accurateinfnorm} \label{labaccurateinfnorm} \noindent Name: \textbf{accurateinfnorm}\\ \phantom{aaa}computes a faithful rounding of the infinity norm of a function \\[0.2cm] \noindent Usage: \begin{center} \textbf{accurateinfnorm}(\emph{function},\emph{range},\emph{constant}) : (\textsf{function}, \textsf{range}, \textsf{constant}) $\rightarrow$ \textsf{constant}\\ \textbf{accurateinfnorm}(\emph{function},\emph{range},\emph{constant},\emph{exclusion range 1},...,\emph{exclusion range n}) : (\textsf{function}, \textsf{range}, \textsf{constant}, \textsf{range}, ..., \textsf{range}) $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents the function whose infinity norm is to be computed \item \emph{range} represents the infinity norm is to be considered on \item \emph{constant} represents the number of bits in the significant of the result \item \emph{exclusion range 1} through \emph{exclusion range n} represent ranges to be excluded \end{itemize} \noindent Description: \begin{itemize} \item The command \textbf{accurateinfnorm} computes an upper bound to the infinity norm of function \emph{function} in \emph{range}. This upper bound is the least floating-point number greater than the value of the infinity norm that lies in the set of dyadic floating point numbers having \emph{constant} significant mantissa bits. This means the value \textbf{accurateinfnorm} evaluates to is at the time an upper bound and a faithful rounding to \emph{constant} bits of the infinity norm of function \emph{function} on range \emph{range}. If given, the fourth and further arguments of the command \textbf{accurateinfnorm}, \emph{exclusion range 1} through \emph{exclusion range n} the infinity norm of the function \emph{function} is not to be considered on. \item The command \textbf{accurateinfnorm} is now considered DEPRECATED in \sollya. Users should be aware about the fact that the algorithm behind \textbf{accurateinfnorm} is highly inefficient and that other, better suited algorithms, such as \textbf{supnorm}, are available inside \sollya. As a matter of fact, while \textbf{accurateinfnorm} is maintained for compatibility reasons with legacy \sollya codes, users are advised to avoid using \textbf{accurateinfnorm} in new \sollya scripts and to replace it, where possible, by the \textbf{supnorm} command. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p = remez(exp(x), 5, [-1;1]); > accurateinfnorm(p - exp(x), [-1;1], 20); 4.52055246569216251373291015625e-5 > accurateinfnorm(p - exp(x), [-1;1], 30); 4.5205513970358879305422306060791015625e-5 > accurateinfnorm(p - exp(x), [-1;1], 40); 4.520551396713923253400935209356248378753662109375e-5 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p = remez(exp(x), 5, [-1;1]); > midpointmode = on!; > infnorm(p - exp(x), [-1;1]); 0.45205~5/7~e-4 > accurateinfnorm(p - exp(x), [-1;1], 40); 4.520551396713923253400935209356248378753662109375e-5 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{infnorm} (\ref{labinfnorm}), \textbf{dirtyinfnorm} (\ref{labdirtyinfnorm}), \textbf{supnorm} (\ref{labsupnorm}), \textbf{checkinfnorm} (\ref{labcheckinfnorm}), \textbf{remez} (\ref{labremez}), \textbf{diam} (\ref{labdiam}) sollya-6.0+ds/doc/acos.tex000066400000000000000000000011751300174114700155020ustar00rootroot00000000000000\subsection{acos} \label{labacos} \noindent Name: \textbf{acos}\\ \phantom{aaa}the arccosine function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_acos(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_acos(sollya_obj_t)|\\ \verb| #define SOLLYA_ACOS(x) sollya_lib_build_function_acos(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{acos} is the inverse of the function \textbf{cos}: \textbf{acos}($y$) is the unique number $x \in [0; \pi]$ such that \textbf{cos}($x$)=$y$. \item It is defined only for $y \in [-1;1]$. \end{itemize} See also: \textbf{cos} (\ref{labcos}) sollya-6.0+ds/doc/acosh.tex000066400000000000000000000012311300174114700156430ustar00rootroot00000000000000\subsection{acosh} \label{labacosh} \noindent Name: \textbf{acosh}\\ \phantom{aaa}the arg-hyperbolic cosine function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_acosh(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_acosh(sollya_obj_t)|\\ \verb| #define SOLLYA_ACOSH(x) sollya_lib_build_function_acosh(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{acosh} is the inverse of the function \textbf{cosh}: \textbf{acosh}(y) is the unique number $x \in [0; +\infty]$ such that \textbf{cosh}(x)=y. \item It is defined only for $y \in [0;+\infty]$. \end{itemize} See also: \textbf{cosh} (\ref{labcosh}) sollya-6.0+ds/doc/and.tex000066400000000000000000000021601300174114700153120ustar00rootroot00000000000000\subsection{$\&\&$} \label{laband} \noindent Name: \textbf{$\&\&$}\\ \phantom{aaa}boolean AND operator\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_and(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \emph{expr1} \textbf{$\&\&$} \emph{expr2} : (\textsf{boolean}, \textsf{boolean}) $\rightarrow$ \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr1} and \emph{expr2} represent boolean expressions \end{itemize} \noindent Description: \begin{itemize} \item \textbf{$\&\&$} evaluates to the boolean AND of the two boolean expressions \emph{expr1} and \emph{expr2}. \textbf{$\&\&$} evaluates to true iff both \emph{expr1} and \emph{expr2} evaluate to true. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > true && false; false \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > (1 == exp(0)) && (0 == log(1)); true \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$||$} (\ref{labor}), \textbf{!} (\ref{labnot}) sollya-6.0+ds/doc/annotatefunction.tex000066400000000000000000000160201300174114700201270ustar00rootroot00000000000000\subsection{annotatefunction} \label{labannotatefunction} \noindent Name: \textbf{annotatefunction}\\ \phantom{aaa}Annotates a \sollya function object with an approximation that is faster to evaluate\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_annotatefunction(sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t, ...);|\\ \verb| sollya_obj_t sollya_lib_v_annotatefunction(sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t,|\\ \verb| va_list);|\\[0.2cm] \noindent Usage: \begin{center} \textbf{annotatefunction}(\emph{f}, \emph{g}, \emph{I}, \emph{d}) : (\textsf{function}, \textsf{function}, \textsf{range}, \textsf{range}) $\rightarrow$ \textsf{function}\\ \textbf{annotatefunction}(\emph{f}, \emph{g}, \emph{I}, \emph{d}, \emph{$x_0$}) : (\textsf{function}, \textsf{function}, \textsf{range}, \textsf{range}, \textsf{constant}) $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is a function. \item \emph{g} is a function, in most cases a polynomial. \item \emph{I} is an interval. \item \emph{d} is an interval. \item \emph{$x_0$} is a constant (default value is $0$ when not provided). \end{itemize} \noindent Description: \begin{itemize} \item When a given function \emph{f} is to be evaluated at several points of a given interval \emph{I} to a given precision, it might be useful to precompute a good approximant \emph{g} of \emph{f} and further evaluate it instead of \emph{f} when the approximation is good enough to provide the desire precision. If \emph{f} is a complicated expression, whereas \emph{g} is, \emph{e.g.}, a polynomial of low degree, the cost of precomputing \emph{g} can be well compensated by the gain of time in each subsequent evaluation. The purpose of \textbf{annotatefunction} is to provide such a mechanism to the user. \item When using \textbf{annotatefunction}(\emph{f}, \emph{g}, \emph{I}, \emph{d}, \emph{$x_0$}), resp. \textbf{annotatefunction}(\emph{f}, \emph{g}, \emph{I}, \emph{d}) (where \emph{$x_0$} is assumed to be zero), it is assumed that $$\forall x \in I, f(x) - g(x - x_0) \in d.$$ It is the user responsibility to ensure this property. Otherwise, any subsequent use of \emph{f} on points of \emph{I} might lead to incorrect values. \item A call to \textbf{annotatefunction}(\emph{f}, \emph{g}, \emph{I}, \emph{d}, \emph{$x_0$}) annotates the given \sollya function object \emph{f} with the approximation \emph{g}. In further use, when asked to evaluate \emph{f} on a point $x$ of \emph{I}, \sollya will first evaluate \emph{g} on $x-x_0$ and check if the result is accurate enough in the given context (accounting for the fact that the error of approximation between the true value and $g(x-x_0)$ belongs to \emph{d}). If not (and only in this case), an evaluation of the expression of \emph{f} on $x$ is performed. \item The approximation \emph{g} can be any \sollya function but particular performance is expected when \emph{g} is a polynomial. Upon annotation with a polynomial, precomputations are performed to analyze certain properties of the given approximation polynomial. \item \textbf{annotatefunction} updates the internal representation of \emph{f} so as to persistently keep this information attached with the \sollya object representing \emph{f}. In particular, the annotation is persistent through copy or use of \emph{f} as a subexpression to build up bigger expressions. Notice however, that there is no way of deducing an annotation for the derivative of \emph{f} from an annotation of \emph{f}. So, in general, it should not be expected that \textbf{diff}(\emph{f}) will be automatically annotated (notice, however that \emph{f} might be a subexpression of its derivative, \emph{e.g.}, for \emph{f}=\textbf{exp} or \emph{f}=\textbf{tan}, in which case the corresponding subexpressions of the derivative could inherit the annotations from \emph{f}. It is currently not specified whether \sollya does this automatically or not). \item \textbf{annotatefunction} really is an imperative statement that modifies the internal representation of~\emph{f}. However, for convenience \textbf{annotatefunction} returns \emph{f} itself. \item \sollya function objects can be annotated more than once with different approximations on different domains, that do not need to be disjoint. Upon evaluation of the annotated function object, \sollya chooses an approximation annotation (if any) that provides for sufficient accuracy at the evaluation point. It is not specified in which order \sollya tries different possible annotations when several are available for a given point \emph{x}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > procedure EXP(X,n,p) { var res, oldPrec; oldPrec = prec; prec = p!; "Using procedure function exponential with X=" @ X @ ", n=" @ n @ ", and p=" @ p; res = exp(X); prec = oldPrec!; return res; }; > g = function(EXP); > p = 46768052394588893382516870161332864698044514954899b-165 + x * (23384026197 294446691258465802074096632225783601255b-164 + x * (58460065493236116729484266 13035653821819225877423b-163 + x * (389733769954907444862769649080681513731982 1946501b-164 + x * (7794675399098148717422744621371434831048848817417b-167 + x * (24942961277114075921122941174178849425809856036737b-171 + x * (83143204257 04876115613838900105097456456371179471b-172 + x * (190041609730397013715793569 91645932289422670402995b-176 + x * (190041609726693241489121222544499121560039 26801563b-179 + x * (33785175062542597526738679493857229456702396042255b-183 + x * (6757035113643674378393625988264926886191860669891b-184 + x * (9828414707 511252769908089206114262766633532289937b-188 + x * (26208861108003813314724515 233584738706961162212965b-193 + x * (32257064253325954315953742396999456577223 350602741b-197 + x * (578429089657689569703509185903214676926704485495b-195 + x * 2467888542176675658523627105540996778984959471957b-201)))))))))))))); > h = annotatefunction(g, p, [-1/2;1/2], [-475294848522543b-124;475294848522543b -124]); > h == g; true > prec = 24; The precision has been set to 24 bits. > h(0.25); Warning: rounding has happened. The value displayed is a faithful rounding to 24 bits of the true result. 1.2840254 > prec = 165; The precision has been set to 165 bits. > h(0.25); Using procedure function exponential with X=[0.25;0.25], n=0, and p=185 Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 1.28402541668774148407342056806243645833628086528147 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{chebyshevform} (\ref{labchebyshevform}), \textbf{taylorform} (\ref{labtaylorform}), \textbf{remez} (\ref{labremez}), \textbf{supnorm} (\ref{labsupnorm}), \textbf{infnorm} (\ref{labinfnorm}) sollya-6.0+ds/doc/append.tex000066400000000000000000000023671300174114700160300ustar00rootroot00000000000000\subsection{:.} \label{labappend} \noindent Name: \textbf{:.}\\ \phantom{aaa}add an element at the end of a list.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_append(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \emph{L}\textbf{:.}\emph{x} : (\textsf{list}, \textsf{any type}) $\rightarrow$ \textsf{list}\\ \end{center} Parameters: \begin{itemize} \item \emph{L} is a list (possibly empty). \item \emph{x} is an object of any type. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{:.} adds the element \emph{x} at the end of the list \emph{L}. \item Note that since \emph{x} may be of any type, it can in particular be a list. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [|2,3,4|]:.5; [|2, 3, 4, 5|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [|1,2,3|]:.[|4,5,6|]; [|1, 2, 3, [|4, 5, 6|]|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [||]:.1; [|1|] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{.:} (\ref{labprepend}), \textbf{@} (\ref{labconcat}) sollya-6.0+ds/doc/approx.tex000066400000000000000000000063601300174114700160670ustar00rootroot00000000000000\subsection{$\sim$} \label{labapprox} \noindent Name: \textbf{$\sim$}\\ \phantom{aaa}floating-point evaluation of a constant expression\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_approx(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{$\sim$} \emph{expression} : \textsf{function} $\rightarrow$ \textsf{constant}\\ \textbf{$\sim$} \emph{something} : \textsf{any type} $\rightarrow$ \textsf{any type}\\ \end{center} Parameters: \begin{itemize} \item \emph{expression} stands for an expression that is a constant \item \emph{something} stands for some language element that is not a constant expression \end{itemize} \noindent Description: \begin{itemize} \item \textbf{$\sim$} \emph{expression} evaluates the \emph{expression} that is a constant term to a floating-point constant. The evaluation may involve a rounding. If \emph{expression} is not a constant, the evaluated constant is a faithful rounding of \emph{expression} with \textbf{precision} bits, unless the \emph{expression} is exactly $0$ as a result of cancellation. In the latter case, a floating-point approximation of some (unknown) accuracy is returned. \item \textbf{$\sim$} does not do anything on all language elements that are not a constant expression. In other words, it behaves like the identity function on any type that is not a constant expression. It can hence be used in any place where one wants to be sure that expressions are simplified using floating-point computations to constants of a known precision, regardless of the type of actual language elements. \item \textbf{$\sim$} \textbf{error} evaluates to error and provokes a warning. \item \textbf{$\sim$} is a prefix operator not requiring parentheses. Its precedence is the same as for the unary $+$ and $-$ operators. It cannot be repeatedly used without brackets. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(exp(5)); exp(5) > print(~ exp(5)); 148.41315910257660342111558004055227962348766759388 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > autosimplify = off!; \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(~sin(5 * pi)); 0 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(~exp(x)); exp(x) > print(~ "Hello"); Hello \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(~exp(x*5*Pi)); exp((pi) * 5 * x) > print(exp(x* ~(5*Pi))); exp(x * 15.7079632679489661923132169163975144209858469968757) \end{Verbatim} \end{minipage}\end{center} \noindent Example 6: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(~exp(5)*x); 148.41315910257660342111558004055227962348766759388 * x > print( (~exp(5))*x); 148.41315910257660342111558004055227962348766759388 * x > print(~(exp(5)*x)); exp(5) * x \end{Verbatim} \end{minipage}\end{center} See also: \textbf{evaluate} (\ref{labevaluate}), \textbf{prec} (\ref{labprec}), \textbf{error} (\ref{laberror}) sollya-6.0+ds/doc/asciiplot.tex000066400000000000000000000136151300174114700165460ustar00rootroot00000000000000\subsection{asciiplot} \label{labasciiplot} \noindent Name: \textbf{asciiplot}\\ \phantom{aaa}plots a function in a range using ASCII characters\\[0.2cm] \noindent Library name:\\ \verb| void sollya_lib_asciiplot(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{asciiplot}(\emph{function}, \emph{range}) : (\textsf{function}, \textsf{range}) $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents a function to be plotted \item \emph{range} represents a range the function is to be plotted in \end{itemize} \noindent Description: \begin{itemize} \item \textbf{asciiplot} plots the function \emph{function} in range \emph{range} using ASCII characters. On systems that provide the necessary \texttt{TIOCGWINSZ ioctl}, \sollya determines the size of the terminal for the plot size if connected to a terminal. If it is not connected to a terminal or if the test is not possible, the plot is of fixed size $77\times25$ characters. The function is evaluated on a number of points equal to the number of columns available. Its value is rounded to the next integer in the range of lines available. A letter \texttt{x} is written at this place. If zero is in the hull of the image domain of the function, an x-axis is displayed. If zero is in range, a y-axis is displayed. If the function is constant or if the range is reduced to one point, the function is evaluated to a constant and the constant is displayed instead of a plot. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > asciiplot(exp(x),[1;2]); xx xx xx xx xx xxx xx xxx xx xxx xxx xxx xxx xxx xxxx xxx xxxx xxxx xxxx xxxx xxxxx xxxxx xxxxx xxx \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > asciiplot(expm1(x),[-1;2]); | x | x | x | x | xx | x | x | xx | x | xx | xx | xx | xx | xx | xx | xxx | xxx | xxxx | xxxx | xxxx | xxxxxx ---------------------xxxxxxxx----------------------------------------------- xxxxxxxxxxxx | xxxxxxxxx | \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > asciiplot(5,[-1;1]); 5 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > asciiplot(exp(x),[1;1]); 2.7182818284590452353602874713526624977572470937 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{plot} (\ref{labplot}), \textbf{externalplot} (\ref{labexternalplot}) sollya-6.0+ds/doc/asin.tex000066400000000000000000000012021300174114700154760ustar00rootroot00000000000000\subsection{asin} \label{labasin} \noindent Name: \textbf{asin}\\ \phantom{aaa}the arcsine function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_asin(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_asin(sollya_obj_t)|\\ \verb| #define SOLLYA_ASIN(x) sollya_lib_build_function_asin(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{asin} is the inverse of the function \textbf{sin}: \textbf{asin}($y$) is the unique number $x \in [-\pi/2; \pi/2]$ such that \textbf{sin}($x$)=$y$. \item It is defined only for $y \in [-1;1]$. \end{itemize} See also: \textbf{sin} (\ref{labsin}) sollya-6.0+ds/doc/asinh.tex000066400000000000000000000012361300174114700156550ustar00rootroot00000000000000\subsection{asinh} \label{labasinh} \noindent Name: \textbf{asinh}\\ \phantom{aaa}the arg-hyperbolic sine function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_asinh(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_asinh(sollya_obj_t)|\\ \verb| #define SOLLYA_ASINH(x) sollya_lib_build_function_asinh(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{asinh} is the inverse of the function \textbf{sinh}: \textbf{asinh}($y$) is the unique number $x \in [-\infty; +\infty]$ such that \textbf{sinh}($x$)=$y$. \item It is defined for every real number y. \end{itemize} See also: \textbf{sinh} (\ref{labsinh}) sollya-6.0+ds/doc/atan.tex000066400000000000000000000012061300174114700154730ustar00rootroot00000000000000\subsection{atan} \label{labatan} \noindent Name: \textbf{atan}\\ \phantom{aaa}the arctangent function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_atan(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_atan(sollya_obj_t)|\\ \verb| #define SOLLYA_ATAN(x) sollya_lib_build_function_atan(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{atan} is the inverse of the function \textbf{tan}: \textbf{atan}($y$) is the unique number $x \in [-\pi/2; +\pi/2]$ such that \textbf{tan}($x$)=$y$. \item It is defined for every real number y. \end{itemize} See also: \textbf{tan} (\ref{labtan}) sollya-6.0+ds/doc/atanh.tex000066400000000000000000000012411300174114700156420ustar00rootroot00000000000000\subsection{atanh} \label{labatanh} \noindent Name: \textbf{atanh}\\ \phantom{aaa}the hyperbolic arctangent function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_atanh(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_atanh(sollya_obj_t)|\\ \verb| #define SOLLYA_ATANH(x) sollya_lib_build_function_atanh(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{atanh} is the inverse of the function \textbf{tanh}: \textbf{atanh}($y$) is the unique number $x \in [-\infty; +\infty]$ such that \textbf{tanh}($x$)=$y$. \item It is defined only for $y \in [-1; 1]$. \end{itemize} See also: \textbf{tanh} (\ref{labtanh}) sollya-6.0+ds/doc/autodiff.tex000066400000000000000000000104121300174114700163500ustar00rootroot00000000000000\subsection{autodiff} \label{labautodiff} \noindent Name: \textbf{autodiff}\\ \phantom{aaa}Computes the first $n$ derivatives of a function at a point or over an interval.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_autodiff(sollya_obj_t, sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{autodiff}(\emph{f}, \emph{n}, \emph{$x_0$}) : (\textsf{function}, \textsf{integer}, \textsf{constant}) $\rightarrow$ \textsf{list}\\ \textbf{autodiff}(\emph{f}, \emph{n}, \emph{I}) : (\textsf{function}, \textsf{integer}, \textsf{range}) $\rightarrow$ \textsf{list}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is the function to be differentiated. \item \emph{n} is the order of differentiation. \item \emph{$x_0$} is the point at which the function is differentiated. \item \emph{I} is the interval over which the function is differentiated. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{autodiff} computes the first $n$ derivatives of $f$ at point $x_0$. The computation is performed numerically, without symbolically differentiating the expression of $f$. Yet, the computation is safe since small interval enclosures are produced. More precisely, \textbf{autodiff} returns a list $[f_0,\,\dots,\,f_n]$ such that, for each $i$, $f_i$ is a small interval enclosing the exact value of $f^{(i)}(x_0)$. \item Since it does not perform any symbolic differentiation, \textbf{autodiff} is much more efficient than \textbf{diff} and should be preferred when only numerical values are necessary. \item If an interval $I$ is provided instead of a point $x_0$, the list returned by \textbf{autodiff} satisfies: $\forall i,\, f^{(i)}(I) \subseteq f_i$. A particular use is when one wants to know the successive derivatives of a function at a non representable point such as $\pi$. In this case, it suffices to call \textbf{autodiff} with the (almost) point interval $I = [\textbf{pi}]$. \item When $I$ is almost a point interval, the returned enclosures $f_i$ are also almost point intervals. However, when the interval $I$ begins to be fairly large, the enclosures can be deeply overestimated due to the dependency phenomenon present with interval arithmetic. \item As a particular case, $f_0$ is an enclosure of the image of $f$ over $I$. However, since the algorithm is not specially designed for this purpose it is not very efficient for this particular task. In particular, it is not able to return a finite enclosure for functions with removable singularities (e.g. $\sin(x)/x$ at $0$). The command \textbf{evaluate} is much more efficient for computing an accurate enclosure of the image of a function over an interval. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > L = autodiff(exp(cos(x))+sin(exp(x)), 5, 0); > midpointmode = on!; > for f_i in L do f_i; 0.3559752813266941742012789792982961497379810154498~2/4~e1 0.5403023058681397174009366074429766037323104206179~0/3~ -0.3019450507398802024611853185539984893647499733880~6/2~e1 -0.252441295442368951995750696489089699886768918239~6/4~e1 0.31227898756481033145214529184139729746320579069~1/3~e1 -0.16634307959006696033484053579339956883955954978~3/1~e2 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = log(cos(x)+x); > L = autodiff(log(cos(x)+x), 5, [2,4]); > L[0]; [0;1.27643852425465597132446653114905059102580436018893] > evaluate(f, [2,4]); [0.45986058925497069206106494332976097408234056912429;1.207872105899641695959010 37621103012113048821362855] > fprime = diff(f); > L[1]; [2.53086745013099407167484456656211083053393118778677e-2;1.756802495307928251372 6390945118290941359128873365] > evaluate(fprime,[2,4]); [2.71048755415961996452136364304380881763456815673085e-2;1.109195306639432908373 9722578862353140555843127995] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > L = autodiff(sin(x)/x, 0, [-1,1]); > L[0]; [-infty;infty] > evaluate(sin(x)/x, [-1,1]); [0.5403023058681397174009366074429766037323104206179;1] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{diff} (\ref{labdiff}), \textbf{evaluate} (\ref{labevaluate}) sollya-6.0+ds/doc/autosimplify.tex000066400000000000000000000070451300174114700173040ustar00rootroot00000000000000\subsection{autosimplify} \label{labautosimplify} \noindent Name: \textbf{autosimplify}\\ \phantom{aaa}activates, deactivates or inspects the value of the automatic simplification state variable\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_autosimplify_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_autosimplify(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_autosimplify()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{autosimplify} = \emph{activation value} : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{autosimplify} = \emph{activation value} ! : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{autosimplify} : \textsf{on$|$off}\\ \end{center} Parameters: \begin{itemize} \item \emph{activation value} represents \textbf{on} or \textbf{off}, i.e. activation or deactivation \end{itemize} \noindent Description: \begin{itemize} \item An assignment \textbf{autosimplify} = \emph{activation value}, where \emph{activation value} is one of \textbf{on} or \textbf{off}, activates respectively deactivates the automatic safe simplification of expressions of functions generated by the evaluation of commands or in argument of other commands. \sollya commands like \textbf{remez}, \textbf{taylor} or \textbf{rationalapprox} sometimes produce expressions that can be simplified. Constant subexpressions can be evaluated to dyadic floating-point numbers, monomials with coefficients $0$ can be eliminated. Further, expressions indicated by the user perform better in many commands when simplified before being passed in argument to a command. When the automatic simplification of expressions is activated, \sollya automatically performs a safe (not value changing) simplification process on such expressions. The automatic generation of subexpressions can be annoying, in particular if it takes too much time for not enough benefit. Further the user might want to inspect the structure of the expression tree returned by a command. In this case, the automatic simplification should be deactivated. If the assignment \textbf{autosimplify} = \emph{activation value} is followed by an exclamation mark, no message indicating the new state is displayed. Otherwise the user is informed of the new state of the global mode by an indication. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > autosimplify = on !; > print(x - x); 0 > autosimplify = off ; Automatic pure tree simplification has been deactivated. > print(x - x); x - x \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > autosimplify = on !; > print(rationalapprox(sin(pi/5.9),7)); 33 / 65 > autosimplify = off !; > print(rationalapprox(sin(pi/5.9),7)); 33 / 65 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{print} (\ref{labprint}), \textbf{$==$} (\ref{labequal}), \textbf{!$=$} (\ref{labneq}), \textbf{prec} (\ref{labprec}), \textbf{points} (\ref{labpoints}), \textbf{diam} (\ref{labdiam}), \textbf{display} (\ref{labdisplay}), \textbf{verbosity} (\ref{labverbosity}), \textbf{canonical} (\ref{labcanonical}), \textbf{taylorrecursions} (\ref{labtaylorrecursions}), \textbf{timing} (\ref{labtiming}), \textbf{fullparentheses} (\ref{labfullparentheses}), \textbf{midpointmode} (\ref{labmidpointmode}), \textbf{hopitalrecursions} (\ref{labhopitalrecursions}), \textbf{remez} (\ref{labremez}), \textbf{rationalapprox} (\ref{labrationalapprox}), \textbf{taylor} (\ref{labtaylor}) sollya-6.0+ds/doc/bashevaluate.tex000066400000000000000000000045501300174114700172210ustar00rootroot00000000000000\subsection{bashevaluate} \label{labbashevaluate} \noindent Name: \textbf{bashevaluate}\\ \phantom{aaa}executes a shell command and returns its output as a string\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_bashevaluate(sollya_obj_t, ...)|\\ \verb| sollya_obj_t sollya_lib_v_bashevaluate(sollya_obj_t, va_list)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{bashevaluate}(\emph{command}) : \textsf{string} $\rightarrow$ \textsf{string}\\ \textbf{bashevaluate}(\emph{command},\emph{input}) : (\textsf{string}, \textsf{string}) $\rightarrow$ \textsf{string}\\ \end{center} Parameters: \begin{itemize} \item \emph{command} is a command to be interpreted by the shell. \item \emph{input} is an optional character sequence to be fed to the command. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{bashevaluate}(\emph{command}) will execute the shell command \emph{command} in a shell. All output on the command's standard output is collected and returned as a character sequence. \item If an additional argument \emph{input} is given in a call to \textbf{bashevaluate}(\emph{command},\emph{input}), this character sequence is written to the standard input of the command \emph{command} that gets executed. \item All characters output by \emph{command} are included in the character sequence to which \textbf{bashevaluate} evaluates but two exceptions. Every NULL character ($`\backslash 0$') in the output is replaced with `?' as \sollya is unable to handle character sequences containing that character. Additionally, if the output ends in a newline character ($`\backslash$n'), this character is stripped off. Other newline characters which are not at the end of the output are left as such. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > bashevaluate("LANG=C date"); Mon Oct 17 09:26:43 CEST 2016 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [| bashevaluate("echo Hello") |]; [|"Hello"|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a = bashevaluate("sed -e 's/a/e/g;'", "Hallo"); > a; Hello \end{Verbatim} \end{minipage}\end{center} See also: \textbf{bashexecute} (\ref{labbashexecute}) sollya-6.0+ds/doc/bashexecute.tex000066400000000000000000000024101300174114700170460ustar00rootroot00000000000000\subsection{bashexecute} \label{labbashexecute} \noindent Name: \textbf{bashexecute}\\ \phantom{aaa}executes a shell command.\\[0.2cm] \noindent Library name:\\ \verb| void sollya_lib_bashexecute(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{bashexecute}(\emph{command}) : \textsf{string} $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{command} is a command to be interpreted by the shell. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{bashexecute}(\emph{command}) lets the shell interpret \emph{command}. It is useful to execute some external code within \sollya. \item \textbf{bashexecute} does not return anything. It just executes its argument. However, if \emph{command} produces an output in a file, this result can be imported in \sollya with help of commands like \textbf{execute}, \textbf{readfile} and \textbf{parse}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > bashexecute("LANG=C date"); Mon Oct 17 09:26:45 CEST 2016 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{execute} (\ref{labexecute}), \textbf{readfile} (\ref{labreadfile}), \textbf{parse} (\ref{labparse}), \textbf{bashevaluate} (\ref{labbashevaluate}) sollya-6.0+ds/doc/binary.tex000066400000000000000000000014411300174114700160350ustar00rootroot00000000000000\subsection{binary} \label{labbinary} \noindent Name: \textbf{binary}\\ \phantom{aaa}special value for global state \textbf{display}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_binary()|\\ \verb| int sollya_lib_is_binary(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{binary} is a special value used for the global state \textbf{display}. If the global state \textbf{display} is equal to \textbf{binary}, all data will be output in binary notation. As any value it can be affected to a variable and stored in lists. \end{itemize} See also: \textbf{decimal} (\ref{labdecimal}), \textbf{dyadic} (\ref{labdyadic}), \textbf{powers} (\ref{labpowers}), \textbf{hexadecimal} (\ref{labhexadecimal}), \textbf{display} (\ref{labdisplay}) sollya-6.0+ds/doc/bind.tex000066400000000000000000000053731300174114700154750ustar00rootroot00000000000000\subsection{bind} \label{labbind} \noindent Name: \textbf{bind}\\ \phantom{aaa}partially applies a procedure to an argument, returning a procedure with one argument less\\[0.2cm] \noindent Usage: \begin{center} \textbf{bind}(\emph{proc}, \emph{ident}, \emph{obj}) : (\textsf{procedure}, \textsf{identifier type}, \textsf{any type}) $\rightarrow$ \textsf{procedure}\\ \end{center} Parameters: \begin{itemize} \item \emph{proc} is a procedure to be partially applied to an argument \item \emph{ident} is one of the formal arguments of \emph{proc} \item \emph{obj} is any \sollya object \emph{ident} is to be bound to \end{itemize} \noindent Description: \begin{itemize} \item \textbf{bind} allows a formal parameter \emph{ident} of a procedure \emph{proc} to be bound to an object \emph{obj}, hence \emph{proc} to be partially applied. The result of this curryfied application, returned by \textbf{bind}, is a procedure with one argument less. This way, \textbf{bind} permits specialization of a generic procedure, parameterized e.g. by a function or range. \item In the case when \emph{proc} does not have a formal parameter named \emph{ident}, \textbf{bind} prints a warning and returns the procedure \emph{proc} unmodified. \item \textbf{bind} always returns a procedure, even if \emph{proc} only has one argument, which gets bound to \emph{ident}. In this case, \textbf{bind} returns a procedure which does not take any argument. Hence evaluation, which might provoke side effects, is only performed once the procedure gets used. \item \textbf{bind} does not work on procedures with an arbitrary number of arguments. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure add(X,Y) { return X + Y; }; > succ = bind(add,X,1); > succ(5); 6 > succ; proc(Y) { nop; return (proc(X, Y) { nop; return (X) + (Y); })(1, Y); } \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure add(X,Y) { return X + Y; }; > succ = bind(add,X,1); > five = bind(succ,Y,4); > five(); 5 > five; proc() { nop; return (proc(Y) { nop; return (proc(X, Y) { nop; return (X) + (Y); })(1, Y); })(4); } \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > procedure add(X,Y) { return X + Y; }; > foo = bind(add,R,1); Warning: the given procedure has no argument named "R". The procedure is returne d unchanged. > foo; proc(X, Y) { nop; return (X) + (Y); } \end{Verbatim} \end{minipage}\end{center} See also: \textbf{procedure} (\ref{labprocedure}), \textbf{proc} (\ref{labproc}), \textbf{function} (\ref{labfunction}), \textbf{@} (\ref{labconcat}) sollya-6.0+ds/doc/boolean.tex000066400000000000000000000017751300174114700162020ustar00rootroot00000000000000\subsection{boolean} \label{labboolean} \noindent Name: \textbf{boolean}\\ \phantom{aaa}keyword representing a \textsf{boolean} type \\[0.2cm] \noindent Library name:\\ \verb| SOLLYA_EXTERNALPROC_TYPE_BOOLEAN|\\[0.2cm] \noindent Usage: \begin{center} \textbf{boolean} : \textsf{type type}\\ \end{center} \noindent Description: \begin{itemize} \item \textbf{boolean} represents the \textsf{boolean} type for declarations of external procedures by means of \textbf{externalproc}. Remark that in contrast to other indicators, type indicators like \textbf{boolean} cannot be handled outside the \textbf{externalproc} context. In particular, they cannot be assigned to variables. \end{itemize} See also: \textbf{externalproc} (\ref{labexternalproc}), \textbf{constant} (\ref{labconstant}), \textbf{function} (\ref{labfunction}), \textbf{integer} (\ref{labinteger}), \textbf{list of} (\ref{lablistof}), \textbf{range} (\ref{labrange}), \textbf{string} (\ref{labstring}), \textbf{object} (\ref{labobject}) sollya-6.0+ds/doc/canonical.tex000066400000000000000000000073021300174114700165020ustar00rootroot00000000000000\subsection{canonical} \label{labcanonical} \noindent Name: \textbf{canonical}\\ \phantom{aaa}brings all polynomial subexpressions of an expression to canonical form or activates, deactivates or checks canonical form printing\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_canonical_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_canonical(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_canonical(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_canonical()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{canonical}(\emph{function}) : \textsf{function} $\rightarrow$ \textsf{function}\\ \textbf{canonical} = \emph{activation value} : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{canonical} = \emph{activation value} ! : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents the expression to be rewritten in canonical form \item \emph{activation value} represents \textbf{on} or \textbf{off}, i.e. activation or deactivation \end{itemize} \noindent Description: \begin{itemize} \item The command \textbf{canonical} rewrites the expression representing the function \emph{function} in a way such that all polynomial subexpressions (or the whole expression itself, if it is a polynomial) are written in canonical form, i.e. as a sum of monomials in the canonical base. The canonical base is the base of the integer powers of the global free variable. The command \textbf{canonical} does not endanger the safety of computations even in \sollya's floating-point environment: the function returned is mathematically equal to the function \emph{function}. \item An assignment \textbf{canonical} = \emph{activation value}, where \emph{activation value} is one of \textbf{on} or \textbf{off}, activates respectively deactivates the automatic printing of polynomial expressions in canonical form, i.e. as a sum of monomials in the canonical base. If automatic printing in canonical form is deactivated, automatic printing yields to displaying polynomial subexpressions in Horner form. If the assignment \textbf{canonical} = \emph{activation value} is followed by an exclamation mark, no message indicating the new state is displayed. Otherwise the user is informed of the new state of the global mode by an indication. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(canonical(1 + x * (x + 3 * x^2))); 1 + x^2 + 3 * x^3 > print(canonical((x + 1)^7)); 1 + 7 * x + 21 * x^2 + 35 * x^3 + 35 * x^4 + 21 * x^5 + 7 * x^6 + x^7 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(canonical(exp((x + 1)^5) - log(asin(((x + 2) + x)^4 * (x + 1)) + x))); exp(1 + 5 * x + 10 * x^2 + 10 * x^3 + 5 * x^4 + x^5) - log(asin(16 + 80 * x + 16 0 * x^2 + 160 * x^3 + 80 * x^4 + 16 * x^5) + x) \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > canonical; off > (x + 2)^9; 512 + x * (2304 + x * (4608 + x * (5376 + x * (4032 + x * (2016 + x * (672 + x * (144 + x * (18 + x)))))))) > canonical = on; Canonical automatic printing output has been activated. > (x + 2)^9; 512 + 2304 * x + 4608 * x^2 + 5376 * x^3 + 4032 * x^4 + 2016 * x^5 + 672 * x^6 + 144 * x^7 + 18 * x^8 + x^9 > canonical; on > canonical = off!; > (x + 2)^9; 512 + x * (2304 + x * (4608 + x * (5376 + x * (4032 + x * (2016 + x * (672 + x * (144 + x * (18 + x)))))))) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{horner} (\ref{labhorner}), \textbf{print} (\ref{labprint}), \textbf{autosimplify} (\ref{labautosimplify}) sollya-6.0+ds/doc/ceil.tex000066400000000000000000000012711300174114700154660ustar00rootroot00000000000000\subsection{ceil} \label{labceil} \noindent Name: \textbf{ceil}\\ \phantom{aaa}the usual function ceil.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_ceil(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_ceil(sollya_obj_t)|\\ \verb| #define SOLLYA_CEIL(x) sollya_lib_build_function_ceil(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{ceil} is defined as usual: \textbf{ceil}($x$) is the smallest integer $y$ such that $y \ge x$. \item It is defined for every real number $x$. \end{itemize} See also: \textbf{floor} (\ref{labfloor}), \textbf{nearestint} (\ref{labnearestint}), \textbf{round} (\ref{labround}), \textbf{RU} (\ref{labru}) sollya-6.0+ds/doc/chebyshevform.tex000066400000000000000000000107231300174114700174200ustar00rootroot00000000000000\subsection{chebyshevform} \label{labchebyshevform} \noindent Name: \textbf{chebyshevform}\\ \phantom{aaa}computes a rigorous polynomial approximation\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_chebyshevform(sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t);|\\[0.2cm] \noindent Usage: \begin{center} \textbf{chebyshevform}(\emph{f}, \emph{n}, \emph{I}) : (\textsf{function}, \textsf{integer}, \textsf{range}) $\rightarrow$ \textsf{list}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is the function to be approximated. \item \emph{n} is the degree of the polynomial that must approximate \emph{f}. \item \emph{I} is the interval over which the function is to be approximated. This interval cannot be a point interval, i.e. its endpoints have to be different. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{WARNING:} \textbf{chebyshevform} is a certified command, not difficult to use but not completely straightforward to use either. In order to be sure to use it correctly, the reader is invited to carefully read this documentation entirely. \item \textbf{chebyshevform} computes an approximation polynomial and an interval error bound for a given function $f$. \\ More precisely, it returns a list $L = \left[p, \textrm{coeffErrors},\Delta,\textrm{chebCoeffs} \right]$ where:\begin{itemize} \item $p$ is an approximation polynomial of degree $n$ which is roughly speaking a numerical Chebyshev interpolation polynomial of $f$ over $I$ represented in monomial basis. \item coeffsErrors is a list of $n+1$ intervals. Each interval coeffsErrors[$i$] contains an enclosure of all the errors accumulated when computing the $i$-th coefficient of $p$. \item $\Delta$ is an interval that provides a bound for the approximation error between $p$ and $f$. See details below. \item $\textrm{chebCoeffs}$ is a list of $n+1$ intervals. These are the interval coefficients obtained for the representation of interpolation polynomial considered in Chebyshev basis. See details below.\end{itemize} \item The polynomial $p$ and the bound $\Delta$ are obtained using Chebyshev Models principles. \item More formally, the mathematical property ensured by the algorithm may be stated as follows: \\ Using monomial basis representation given by $p$: there exist (small) values $\varepsilon_i \in \textrm{coeffsErrors}[i]$ such that: $\forall x \in I, \exists \delta \in \Delta,\,$ $f(x)-p(x) = \sum\limits_{i=0}^{n} \varepsilon_i\, x^i + \delta$. \\ Using Chebyshev basis representation given by $\textrm{chebCoeffs}$: there exist values $\alpha_i \in \textrm{chebCoeffs}[i]$ such that: $\forall x \in I, \exists \delta \in \Delta,\,$ $f(x)-\sum\limits_{i=0}^{n} \alpha_i\, T_i(y)= \delta$, where $[a,b]=I, y=(2x-b-a)/(b-a)$ and $T_i(y)$ is the $i$-th Chebyshev polynomial over $[-1,1]$. \item The algorithm does not guarantee that by increasing the degree of the approximation, the remainder bound will become smaller. Moreover, it may even become larger due to the dependency phenomenon present with interval arithmetic. In order to reduce this phenomenon, a possible solution is to split the definition domain $I$ into several smaller intervals. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > TL=chebyshevform(exp(x), 10, [-1,1]); > p=TL[0]; > Delta=TL[2]; > p; Delta; 1.00000000000000000000000000000000000000000000000017 + x * (1.000000000273898191 9773953471453626764777115166417 + x * (0.500000000022767543680233268825420973654 11870042312 + x * (0.166666661190450656168988993421371510533693281444003 + x * ( 4.1666666211440433973188799509591566161569698904644e-2 + x * (8.3333639749825520 034240517636254576844423981913793e-3 + x * (1.3888914363614809070686210553721677 7944219976325265e-3 + x * (1.98342776066472142284727329700227389403558111865906e -4 + x * (2.47957727598277888282218067965324267955768146489014e-5 + x * (2.82540 33440982477266316370012542019511804700836066e-6 + x * 2.813698333371884313582809 1163040197490633045592362e-7))))))))) [-2.71406412827174505775085010461449926572460824320373e-11;2.7140641282717450577 5085010461449926572460824320373e-11] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{taylorform} (\ref{labtaylorform}), \textbf{diff} (\ref{labdiff}), \textbf{autodiff} (\ref{labautodiff}), \textbf{taylor} (\ref{labtaylor}), \textbf{remez} (\ref{labremez}) sollya-6.0+ds/doc/checkinfnorm.tex000066400000000000000000000062451300174114700172260ustar00rootroot00000000000000\subsection{checkinfnorm} \label{labcheckinfnorm} \noindent Name: \textbf{checkinfnorm}\\ \phantom{aaa}checks whether the infinity norm of a function is bounded by a value\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_checkinfnorm(sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{checkinfnorm}(\emph{function},\emph{range},\emph{constant}) : (\textsf{function}, \textsf{range}, \textsf{constant}) $\rightarrow$ \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents the function whose infinity norm is to be checked \item \emph{range} represents the infinity norm is to be considered on \item \emph{constant} represents the upper bound the infinity norm is to be checked to \end{itemize} \noindent Description: \begin{itemize} \item The command \textbf{checkinfnorm} checks whether the infinity norm of the given function \emph{function} in the range \emph{range} can be proven (by \sollya) to be less than the given bound \emph{bound}. This means, if \textbf{checkinfnorm} evaluates to \textbf{true}, the infinity norm has been proven (by \sollya's interval arithmetic) to be less than the bound. If \textbf{checkinfnorm} evaluates to \textbf{false}, there are two possibilities: either the bound is less than or equal to the infinity norm of the function or the bound is greater than the infinity norm but \sollya could not conclude using its internal interval arithmetic. \textbf{checkinfnorm} is sensitive to the global variable \textbf{diam}. The smaller \textbf{diam}, the more time \sollya will spend on the evaluation of \textbf{checkinfnorm} in order to prove the bound before returning \textbf{false} although the infinity norm is bounded by the bound. If \textbf{diam} is equal to $0$, \sollya will eventually spend infinite time on instances where the given bound \emph{bound} is less or equal to the infinity norm of the function \emph{function} in range \emph{range}. In contrast, with \textbf{diam} being zero, \textbf{checkinfnorm} evaluates to \textbf{true} iff the infinity norm of the function in the range is bounded by the given bound. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > checkinfnorm(sin(x),[0;1.75], 1); true > checkinfnorm(sin(x),[0;1.75], 1/2); checkinfnorm(sin(x),[0;20/39],1/2); false true \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p = remez(exp(x), 5, [-1;1]); > b = dirtyinfnorm(p - exp(x), [-1;1]); > checkinfnorm(p - exp(x), [-1;1], b); false > b1 = round(b, 15, RU); > checkinfnorm(p - exp(x), [-1;1], b1); true > b2 = round(b, 25, RU); > checkinfnorm(p - exp(x), [-1;1], b2); false > diam = 1b-20!; > checkinfnorm(p - exp(x), [-1;1], b2); true \end{Verbatim} \end{minipage}\end{center} See also: \textbf{infnorm} (\ref{labinfnorm}), \textbf{dirtyinfnorm} (\ref{labdirtyinfnorm}), \textbf{supnorm} (\ref{labsupnorm}), \textbf{accurateinfnorm} (\ref{labaccurateinfnorm}), \textbf{remez} (\ref{labremez}), \textbf{diam} (\ref{labdiam}) sollya-6.0+ds/doc/coeff.tex000066400000000000000000000023511300174114700156340ustar00rootroot00000000000000\subsection{coeff} \label{labcoeff} \noindent Name: \textbf{coeff}\\ \phantom{aaa}gives the coefficient of degree $n$ of a polynomial\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_coeff(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{coeff}(\emph{f},\emph{n}) : (\textsf{function}, \textsf{integer}) $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is a function (usually a polynomial). \item \emph{n} is an integer \end{itemize} \noindent Description: \begin{itemize} \item If \emph{f} is a polynomial, \textbf{coeff}(\emph{f}, \emph{n}) returns the coefficient of degree \emph{n} in \emph{f}. \item If \emph{f} is a function that is not a polynomial, \textbf{coeff}(\emph{f}, \emph{n}) returns 0. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > coeff((1+x)^5,3); 10 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > coeff(sin(x),0); 0 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{degree} (\ref{labdegree}), \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{subpoly} (\ref{labsubpoly}) sollya-6.0+ds/doc/composepolynomials.tex000066400000000000000000000066121300174114700205120ustar00rootroot00000000000000\subsection{composepolynomials} \label{labcomposepolynomials} \noindent Name: \textbf{composepolynomials}\\ \phantom{aaa}computes an approximation to the composition of two polynomials and bounds the error\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_composepolynomials(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{composepolynomials}(\emph{p},\emph{q}) : (\textsf{function}, \textsf{function}) $\rightarrow$ \textsf{structure}\\ \end{center} Parameters: \begin{itemize} \item \emph{p} and \emph{q} are polynomials \end{itemize} \noindent Description: \begin{itemize} \item Given two polynomials $p$ and $q$, \textbf{composepolynomials}(\emph{p}, \emph{q}) computes an approximation $r$ to the polynomial $(p \circ q)$ and bounds the error polynomial $r - (p \circ q)$ using interval arithmetic. \item \textbf{composepolynomials} always returns a structure containing two elements, \texttt{poly} and \texttt{radii}. The element \texttt{poly} is contains the approximate composed polynomial $r$. The element \texttt{radii} contains a list of $n + 1$ intervals $a_i$ bounding the coefficients of the error polynomial, which is of the same degree $n$ as is the composed polynomial $(p \circ q)$. This is, there exist $\alpha_i \in a_i$ such that $$\sum\limits_{i=0}^n \alpha_i \, x^i = r(x) - (p \circ q)(x).$$ \item In the case when either of $p$ or $q$ is not a polynomial, \textbf{composepolynomials} behaves like \textbf{substitute} used in a literate structure. The list of intervals bounding the coefficients of the error polynomial is returned empty. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > composepolynomials(1 + 2 * x + 3 * x^2 + 4 * x^3, 5 + 6 * x + 7 * x^2); { .radii = [|[0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0]|], .poly = 586 + x * (1992 + x * (4592 + x * (6156 + x * (6111 + x * (3528 + x * 1372))))) } \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(composepolynomials(1/5 * x + exp(17) + log(2) * x^2, x^4 + 1/3 * x^2)); { .radii = [|[-3.5873240686715317015647477332221852960774705712039e-43;3.5873240 686715317015647477332221852960774705712039e-43], [0;0], [-2.67276471009219564614 053646715148187881519688010505e-51;2.6727647100921956461405364671514818788151968 8010505e-51], [0;0], [-1.06910588403687825845621458686059275152607875204202e-50; 1.06910588403687825845621458686059275152607875204202e-50], [0;0], [-2.1382117680 7375651691242917372118550305215750408404e-50;2.138211768073756516912429173721185 50305215750408404e-50], [0;0], [-1.069105884036878258456214586860592751526078752 04202e-50;1.06910588403687825845621458686059275152607875204202e-50]|], .poly = 2 .41549527535752982147754351803858238798675673527228e7 + x^2 * (6.666666666666666 6666666666666666666666666666666666e-2 + x^2 * (0.2770163533955494788241369023842 418408972777927067 + x^2 * (0.46209812037329687294482141430545104538366675624017 + x^2 * 0.69314718055994530941723212145817656807550013436026))) } \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > composepolynomials(sin(x),x + x^2); { .radii = [| |], .poly = sin(x * (1 + x)) } \end{Verbatim} \end{minipage}\end{center} See also: \textbf{substitute} (\ref{labsubstitute}) sollya-6.0+ds/doc/concat.tex000066400000000000000000000064741300174114700160330ustar00rootroot00000000000000\subsection{@} \label{labconcat} \noindent Name: \textbf{@}\\ \phantom{aaa}concatenates two lists or strings or applies a list as arguments to a procedure\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_concat(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \emph{L1}\textbf{@}\emph{L2} : (\textsf{list}, \textsf{list}) $\rightarrow$ \textsf{list}\\ \emph{string1}\textbf{@}\emph{string2} : (\textsf{string}, \textsf{string}) $\rightarrow$ \textsf{string}\\ \emph{proc}\textbf{@}\emph{L1} : (\textsf{procedure}, \textsf{list}) $\rightarrow$ \textsf{any type}\\ \end{center} Parameters: \begin{itemize} \item \emph{L1} and \emph{L2} are two lists. \item \emph{string1} and \emph{string2} are two strings. \item \emph{proc} is a procedure or an external procedure. \end{itemize} \noindent Description: \begin{itemize} \item In its first usage form, \textbf{@} concatenates two lists or strings. \item In its second usage form, \textbf{@} applies the elements of a list as arguments to a procedure or an external procedure. In the case when \emph{proc} is a procedure or external procedure with a fixed number of arguments, a check is done if the number of elements in the list corresponds to the number of formal parameters of \emph{proc}. An empty list can therefore be applied only to a procedure that does not take any argument. In the case when \emph{proc} accepts an arbitrary number of arguments, no such check is performed. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [|1,...,3|]@[|7,8,9|]; [|1, 2, 3, 7, 8, 9|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > "Hello "@"World!"; Hello World! \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure cool(a,b,c) { write(a,", ", b," and ",c," are cool guys.\n"); }; > cool @ [| "Christoph", "Mioara", "Sylvain" |]; Christoph, Mioara and Sylvain are cool guys. \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure sayhello() { "Hello! how are you?"; }; > sayhello(); Hello! how are you? > sayhello @ [||]; Hello! how are you? \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > bashexecute("gcc -fPIC -Wall -c externalprocexample.c"); > bashexecute("gcc -fPIC -shared -o externalprocexample externalprocexample.o"); > externalproc(foo, "./externalprocexample", (integer, integer) -> integer); > foo; foo > foo @ [|5, 6|]; 11 \end{Verbatim} \end{minipage}\end{center} \noindent Example 6: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure add(L = ...) { var acc, i; acc = 0; for i in L do acc = i + acc; return acc; }; > add(1,2); 3 > add(1,2,3); 6 > add @ [|1, 2|]; 3 > add @ [|1, 2, 3|]; 6 > add @ [||]; 0 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{.:} (\ref{labprepend}), \textbf{:.} (\ref{labappend}), \textbf{procedure} (\ref{labprocedure}), \textbf{externalproc} (\ref{labexternalproc}), \textbf{proc} (\ref{labproc}), \textbf{bind} (\ref{labbind}), \textbf{getbacktrace} (\ref{labgetbacktrace}) sollya-6.0+ds/doc/constant.tex000066400000000000000000000017701300174114700164070ustar00rootroot00000000000000\subsection{constant} \label{labconstant} \noindent Name: \textbf{constant}\\ \phantom{aaa}keyword representing a \textsf{constant} type \\[0.2cm] \noindent Library name:\\ \verb| SOLLYA_EXTERNALPROC_TYPE_CONSTANT|\\[0.2cm] \noindent Usage: \begin{center} \textbf{constant} : \textsf{type type}\\ \end{center} \noindent Description: \begin{itemize} \item \textbf{constant} represents the \textsf{constant} type for declarations of external procedures \textbf{externalproc}. Remark that in contrast to other indicators, type indicators like \textbf{constant} cannot be handled outside the \textbf{externalproc} context. In particular, they cannot be assigned to variables. \end{itemize} See also: \textbf{externalproc} (\ref{labexternalproc}), \textbf{boolean} (\ref{labboolean}), \textbf{function} (\ref{labfunction}), \textbf{integer} (\ref{labinteger}), \textbf{list of} (\ref{lablistof}), \textbf{range} (\ref{labrange}), \textbf{string} (\ref{labstring}), \textbf{object} (\ref{labobject}) sollya-6.0+ds/doc/cos.tex000066400000000000000000000011031300174114700153300ustar00rootroot00000000000000\subsection{cos} \label{labcos} \noindent Name: \textbf{cos}\\ \phantom{aaa}the cosine function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_cos(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_cos(sollya_obj_t)|\\ \verb| #define SOLLYA_COS(x) sollya_lib_build_function_cos(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{cos} is the usual cosine function. \item It is defined for every real number $x$. \end{itemize} See also: \textbf{acos} (\ref{labacos}), \textbf{sin} (\ref{labsin}), \textbf{tan} (\ref{labtan}) sollya-6.0+ds/doc/cosh.tex000066400000000000000000000012421300174114700155040ustar00rootroot00000000000000\subsection{cosh} \label{labcosh} \noindent Name: \textbf{cosh}\\ \phantom{aaa}the hyperbolic cosine function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_cosh(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_cosh(sollya_obj_t)|\\ \verb| #define SOLLYA_COSH(x) sollya_lib_build_function_cosh(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{cosh} is the usual hyperbolic function: $\cosh(x) = \frac{e^x + e^{-x}}{2}$. \item It is defined for every real number $x$. \end{itemize} See also: \textbf{acosh} (\ref{labacosh}), \textbf{sinh} (\ref{labsinh}), \textbf{tanh} (\ref{labtanh}), \textbf{exp} (\ref{labexp}) sollya-6.0+ds/doc/d.tex000066400000000000000000000002321300174114700147710ustar00rootroot00000000000000\subsection{D} \label{labd} \noindent Name: \textbf{D}\\ \phantom{aaa}short form for \textbf{double}\\[0.2cm] See also: \textbf{double} (\ref{labdouble}) sollya-6.0+ds/doc/dd.tex000066400000000000000000000002571300174114700151440ustar00rootroot00000000000000\subsection{DD} \label{labdd} \noindent Name: \textbf{DD}\\ \phantom{aaa}short form for \textbf{doubledouble}\\[0.2cm] See also: \textbf{doubledouble} (\ref{labdoubledouble}) sollya-6.0+ds/doc/de.tex000066400000000000000000000002651300174114700151440ustar00rootroot00000000000000\subsection{DE} \label{labde} \noindent Name: \textbf{DE}\\ \phantom{aaa}short form for \textbf{doubleextended}\\[0.2cm] See also: \textbf{doubleextended} (\ref{labdoubleextended}) sollya-6.0+ds/doc/decimal.tex000066400000000000000000000014461300174114700161540ustar00rootroot00000000000000\subsection{decimal} \label{labdecimal} \noindent Name: \textbf{decimal}\\ \phantom{aaa}special value for global state \textbf{display}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_decimal()|\\ \verb| int sollya_lib_is_decimal(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{decimal} is a special value used for the global state \textbf{display}. If the global state \textbf{display} is equal to \textbf{decimal}, all data will be output in decimal notation. As any value it can be affected to a variable and stored in lists. \end{itemize} See also: \textbf{dyadic} (\ref{labdyadic}), \textbf{powers} (\ref{labpowers}), \textbf{hexadecimal} (\ref{labhexadecimal}), \textbf{binary} (\ref{labbinary}), \textbf{display} (\ref{labdisplay}) sollya-6.0+ds/doc/default.tex000066400000000000000000000021571300174114700162020ustar00rootroot00000000000000\subsection{default} \label{labdefault} \noindent Name: \textbf{default}\\ \phantom{aaa}default value for some commands.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_default()|\\ \verb| int sollya_lib_is_default(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{default} is a special value and is replaced by something depending on the context where it is used. It can often be used as a joker, when you want to specify one of the optional parameters of a command and not the others: set the value of uninteresting parameters to \textbf{default}. \item Global variables can be reset by affecting them the special value \textbf{default}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p = remez(exp(x),5,[0;1],default,1e-5); > q = remez(exp(x),5,[0;1],1,1e-5); > p==q; true \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec; 165 > prec=200; The precision has been set to 200 bits. \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/degree.tex000066400000000000000000000023321300174114700160040ustar00rootroot00000000000000\subsection{degree} \label{labdegree} \noindent Name: \textbf{degree}\\ \phantom{aaa}gives the degree of a polynomial.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_degree(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{degree}(\emph{f}) : \textsf{function} $\rightarrow$ \textsf{integer}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is a function (usually a polynomial). \end{itemize} \noindent Description: \begin{itemize} \item If \emph{f} is a polynomial, \textbf{degree}(\emph{f}) returns the degree of \emph{f}. \item Contrary to the usage, \sollya considers that the degree of the null polynomial is 0. \item If \emph{f} is a function that is not a polynomial, \textbf{degree}(\emph{f}) returns -1. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > degree((1+x)*(2+5*x^2)); 3 > degree(0); 0 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > degree(sin(x)); -1 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{coeff} (\ref{labcoeff}), \textbf{subpoly} (\ref{labsubpoly}), \textbf{roundcoefficients} (\ref{labroundcoefficients}) sollya-6.0+ds/doc/denominator.tex000066400000000000000000000033731300174114700170760ustar00rootroot00000000000000\subsection{denominator} \label{labdenominator} \noindent Name: \textbf{denominator}\\ \phantom{aaa}gives the denominator of an expression\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_denominator(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{denominator}(\emph{expr}) : \textsf{function} $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr} represents an expression \end{itemize} \noindent Description: \begin{itemize} \item If \emph{expr} represents a fraction \emph{expr1}/\emph{expr2}, \textbf{denominator}(\emph{expr}) returns the denominator of this fraction, i.e. \emph{expr2}. If \emph{expr} represents something else, \textbf{denominator}(\emph{expr}) returns 1. Note that for all expressions \emph{expr}, \textbf{numerator}(\emph{expr}) \textbf{/} \textbf{denominator}(\emph{expr}) is equal to \emph{expr}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > denominator(5/3); 3 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > denominator(exp(x)); 1 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a = 5/3; > b = numerator(a)/denominator(a); > print(a); 5 / 3 > print(b); 5 / 3 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a = exp(x/3); > b = numerator(a)/denominator(a); > print(a); exp(x / 3) > print(b); exp(x / 3) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{numerator} (\ref{labnumerator}), \textbf{rationalmode} (\ref{labrationalmode}) sollya-6.0+ds/doc/diam.tex000066400000000000000000000032371300174114700154700ustar00rootroot00000000000000\subsection{diam} \label{labdiam} \noindent Name: \textbf{diam}\\ \phantom{aaa}parameter used in safe algorithms of \sollya and controlling the maximal length of the involved intervals.\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_diam_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_diam(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_diam()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{diam} = \emph{width} : \textsf{constant} $\rightarrow$ \textsf{void}\\ \textbf{diam} = \emph{width} ! : \textsf{constant} $\rightarrow$ \textsf{void}\\ \textbf{diam} : \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{width} represents the maximal relative width of the intervals used \end{itemize} \noindent Description: \begin{itemize} \item \textbf{diam} is a global variable. Its value represents the maximal width allowed for intervals involved in safe algorithms of \sollya (namely \textbf{infnorm}, \textbf{checkinfnorm}, \textbf{accurateinfnorm}, \textbf{integral}, \textbf{findzeros}, \textbf{supnorm}). \item More precisely, \textbf{diam} is relative to the width of the input interval of the command. For instance, suppose that \textbf{diam}=1e-5: if \textbf{infnorm} is called on interval $[0,\,1]$, the maximal width of an interval will be 1e-5. But if it is called on interval $[0,\,1\mathrm{e}{-3}]$, the maximal width will be 1e-8. \end{itemize} See also: \textbf{infnorm} (\ref{labinfnorm}), \textbf{checkinfnorm} (\ref{labcheckinfnorm}), \textbf{accurateinfnorm} (\ref{labaccurateinfnorm}), \textbf{integral} (\ref{labintegral}), \textbf{findzeros} (\ref{labfindzeros}), \textbf{supnorm} (\ref{labsupnorm}) sollya-6.0+ds/doc/dieonerrormode.tex000066400000000000000000000073331300174114700175740ustar00rootroot00000000000000\subsection{dieonerrormode} \label{labdieonerrormode} \noindent Name: \textbf{dieonerrormode}\\ \phantom{aaa}global variable controlling if \sollya is exited on an error or not.\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_dieonerrormode_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_dieonerrormode(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_dieonerrormode()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{dieonerrormode} = \emph{activation value} : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{dieonerrormode} = \emph{activation value} ! : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{dieonerrormode} : \textsf{on$|$off}\\ \end{center} Parameters: \begin{itemize} \item \emph{activation value} controls if \sollya is exited on an error or not. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{dieonerrormode} is a global variable. When its value is \textbf{off}, which is the default, \sollya will not exit on any syntax, typing, side-effect errors. These errors will be caught by the tool, even if a memory might be leaked at that point. On evaluation, the \textbf{error} special value will be produced. \item When the value of the \textbf{dieonerrormode} variable is \textbf{on}, \sollya will exit on any syntax, typing, side-effect errors. A warning message will be printed in these cases at appropriate \textbf{verbosity} levels. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > dieonerrormode = off; Die-on-error mode has been deactivated. > for i from true to false do i + "Salut"; Warning: one of the arguments of the for loop does not evaluate to a constant. The for loop will not be executed. > exp(17); Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 2.41549527535752982147754351803858238798675673527224e7 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > dieonerrormode = off!; > 5 */ 4; Warning: syntax error, unexpected /. The last symbol read has been "/". Will skip input until next semicolon after the unexpected token. May leak memory . exp(17); Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 2.41549527535752982147754351803858238798675673527224e7 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > dieonerrormode; off > dieonerrormode = on!; > dieonerrormode; on > for i from true to false do i + "Salut"; Warning: one of the arguments of the for loop does not evaluate to a constant. The for loop will not be executed. Warning: some syntax, typing or side-effect error has occurred. As the die-on-error mode is activated, the tool will be exited. \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > dieonerrormode = on!; > 5 */ 4; Warning: syntax error, unexpected /. The last symbol read has been "/". Will skip input until next semicolon after the unexpected token. May leak memory . Warning: some syntax, typing or side-effect error has occurred. As the die-on-error mode is activated, the tool will be exited. \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 0!; > dieonerrormode = on!; > 5 */ 4; \end{Verbatim} \end{minipage}\end{center} See also: \textbf{on} (\ref{labon}), \textbf{off} (\ref{laboff}), \textbf{verbosity} (\ref{labverbosity}), \textbf{error} (\ref{laberror}) sollya-6.0+ds/doc/diff.tex000066400000000000000000000026351300174114700154670ustar00rootroot00000000000000\subsection{diff} \label{labdiff} \noindent Name: \textbf{diff}\\ \phantom{aaa}differentiation operator\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_diff(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{diff}(\emph{function}) : \textsf{function} $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents a function \end{itemize} \noindent Description: \begin{itemize} \item \textbf{diff}(\emph{function}) returns the symbolic derivative of the function \emph{function} by the global free variable. If \emph{function} represents a function symbol that is externally bound to some code by \textbf{library}, the derivative is performed as a symbolic annotation to the returned expression tree. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > diff(sin(x)); cos(x) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > diff(x); 1 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > diff(x^x); x^x * (1 + log(x)) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{library} (\ref{lablibrary}), \textbf{autodiff} (\ref{labautodiff}), \textbf{taylor} (\ref{labtaylor}), \textbf{taylorform} (\ref{labtaylorform}) sollya-6.0+ds/doc/dirtyfindzeros.tex000066400000000000000000000061671300174114700176420ustar00rootroot00000000000000\subsection{dirtyfindzeros} \label{labdirtyfindzeros} \noindent Name: \textbf{dirtyfindzeros}\\ \phantom{aaa}gives a list of numerical values listing the zeros of a function on an interval.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_dirtyfindzeros(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{dirtyfindzeros}(\emph{f},\emph{I}) : (\textsf{function}, \textsf{range}) $\rightarrow$ \textsf{list}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is a function. \item \emph{I} is an interval. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{dirtyfindzeros}(\emph{f},\emph{I}) returns a list containing some zeros of \emph{f} in the interval \emph{I}. The values in the list are numerical approximation of the exact zeros. The precision of these approximations is approximately the precision stored in \textbf{prec}. If \emph{f} does not have two zeros very close to each other, it can be expected that all zeros are listed. However, some zeros may be forgotten. This command should be considered as a numerical algorithm and should not be used if safety is critical. \item More precisely, the algorithm relies on global variables \textbf{prec} and \textbf{points} and it performs the following steps: let $n$ be the value of variable \textbf{points} and $t$ be the value of variable \textbf{prec}. \begin{itemize} \item Evaluate $|f|$ at $n$ evenly distributed points in the interval $I$. The working precision to be used is automatically chosen in order to ensure that the sign is correct. \item Whenever $f$ changes its sign for two consecutive points, find an approximation $x$ of its zero with precision $t$ using Newton's algorithm. The number of steps in Newton's iteration depends on $t$: the precision of the approximation is supposed to be doubled at each step. \item Add this value to the list. \end{itemize} \item The user should be aware that the list returned by \textbf{dirtyfindzeros} may contain a certain floating-point number twice. These repetitions reflect the existence of different zeros of the function the value of which rounds to the same floating-point number in the current working precision. In this case, increasing the working precision will end up making the two zeros distinguishable even in rounded floating-point arithmetic. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > dirtyfindzeros(sin(x),[-5;5]); [|-3.1415926535897932384626433832795028841971693993751, 0, 3.1415926535897932384 626433832795028841971693993751|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > L1=dirtyfindzeros(x^2*sin(1/x),[0;1]); > points=1000!; > L2=dirtyfindzeros(x^2*sin(1/x),[0;1]); > length(L1); length(L2); 18 25 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{prec} (\ref{labprec}), \textbf{points} (\ref{labpoints}), \textbf{findzeros} (\ref{labfindzeros}), \textbf{dirtyinfnorm} (\ref{labdirtyinfnorm}), \textbf{numberroots} (\ref{labnumberroots}) sollya-6.0+ds/doc/dirtyinfnorm.tex000066400000000000000000000055351300174114700173050ustar00rootroot00000000000000\subsection{dirtyinfnorm} \label{labdirtyinfnorm} \noindent Name: \textbf{dirtyinfnorm}\\ \phantom{aaa}computes a numerical approximation of the infinity norm of a function on an interval.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_dirtyinfnorm(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{dirtyinfnorm}(\emph{f},\emph{I}) : (\textsf{function}, \textsf{range}) $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is a function. \item \emph{I} is an interval. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{dirtyinfnorm}(\emph{f},\emph{I}) computes an approximation of the infinity norm of the given function $f$ on the interval $I$, e.g. $\max_{x \in I} \{|f(x)|\}$. \item The interval must be bound. If the interval contains one of -Inf or +Inf, the result of \textbf{dirtyinfnorm} is NaN. \item The result of this command depends on the global variables \textbf{prec} and \textbf{points}. Therefore, the returned result is generally a good approximation of the exact infinity norm, with precision \textbf{prec}. However, the result is generally underestimated and should not be used when safety is critical. Use \textbf{infnorm} instead. \item The following algorithm is used: let $n$ be the value of variable \textbf{points} and $t$ be the value of variable \textbf{prec}. \begin{itemize} \item Evaluate $|f|$ at $n$ evenly distributed points in the interval $I$. The evaluation are faithful roundings of the exact results at precision $t$. \item Whenever the derivative of $f$ changes its sign for two consecutive points, find an approximation $x$ of its zero with precision $t$. Then compute a faithful rounding of $|f(x)|$ at precision $t$. \item Return the maximum of all computed values. \end{itemize} \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > dirtyinfnorm(sin(x),[-10;10]); 1 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec=15!; > dirtyinfnorm(exp(cos(x))*sin(x),[0;5]); 1.45856 > prec=40!; > dirtyinfnorm(exp(cos(x))*sin(x),[0;5]); 1.458528537136 > prec=100!; > dirtyinfnorm(exp(cos(x))*sin(x),[0;5]); 1.458528537136237644438147455025 > prec=200!; > dirtyinfnorm(exp(cos(x))*sin(x),[0;5]); 1.458528537136237644438147455023841718299214087993682374094153 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > dirtyinfnorm(x^2, [log(0);log(1)]); NaN \end{Verbatim} \end{minipage}\end{center} See also: \textbf{prec} (\ref{labprec}), \textbf{points} (\ref{labpoints}), \textbf{infnorm} (\ref{labinfnorm}), \textbf{checkinfnorm} (\ref{labcheckinfnorm}), \textbf{supnorm} (\ref{labsupnorm}) sollya-6.0+ds/doc/dirtyintegral.tex000066400000000000000000000040271300174114700174350ustar00rootroot00000000000000\subsection{dirtyintegral} \label{labdirtyintegral} \noindent Name: \textbf{dirtyintegral}\\ \phantom{aaa}computes a numerical approximation of the integral of a function on an interval.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_dirtyintegral(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{dirtyintegral}(\emph{f},\emph{I}) : (\textsf{function}, \textsf{range}) $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is a function. \item \emph{I} is an interval. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{dirtyintegral}(\emph{f},\emph{I}) computes an approximation of the integral of \emph{f} on \emph{I}. \item The interval must be bound. If the interval contains one of -Inf or +Inf, the result of \textbf{dirtyintegral} is NaN, even if the integral has a meaning. \item The result of this command depends on the global variables \textbf{prec} and \textbf{points}. The method used is the trapezium rule applied at $n$ evenly distributed points in the interval, where $n$ is the value of global variable \textbf{points}. \item This command computes a numerical approximation of the exact value of the integral. It should not be used if safety is critical. In this case, use command \textbf{integral} instead. \item Warning: this command is currently known to be unsatisfactory. If you really need to compute integrals, think of using another tool or report a feature request to sylvain.chevillard@ens-lyon.org. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > sin(10); -0.54402111088936981340474766185137728168364301291622 > dirtyintegral(cos(x),[0;10]); -0.54400304905152629822448058882475382036536298356282 > points=2000!; > dirtyintegral(cos(x),[0;10]); -0.54401997751158321972222697312583199035995837926893 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{prec} (\ref{labprec}), \textbf{points} (\ref{labpoints}), \textbf{integral} (\ref{labintegral}) sollya-6.0+ds/doc/dirtysimplify.tex000066400000000000000000000033731300174114700174670ustar00rootroot00000000000000\subsection{dirtysimplify} \label{labdirtysimplify} \noindent Name: \textbf{dirtysimplify}\\ \phantom{aaa}simplifies an expression representing a function\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_dirtysimplify(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{dirtysimplify}(\emph{function}) : \textsf{function} $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents the expression to be simplified \end{itemize} \noindent Description: \begin{itemize} \item The command \textbf{dirtysimplify} simplifies constant subexpressions of the expression given in argument representing the function \emph{function}. Those constant subexpressions are evaluated using floating-point arithmetic with the global precision \textbf{prec}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(dirtysimplify(sin(pi * x))); sin(3.1415926535897932384626433832795028841971693993751 * x) > print(dirtysimplify(erf(exp(3) + x * log(4)))); erf(20.0855369231876677409285296545817178969879078385544 + x * 1.386294361119890 6188344642429163531361510002687205) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec = 20!; > t = erf(0.5); > s = dirtysimplify(erf(0.5)); > prec = 200!; > t; 0.520499877813046537682746653891964528736451575757963700058806 > s; 0.52050018310546875 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{simplify} (\ref{labsimplify}), \textbf{autosimplify} (\ref{labautosimplify}), \textbf{prec} (\ref{labprec}), \textbf{evaluate} (\ref{labevaluate}), \textbf{horner} (\ref{labhorner}), \textbf{rationalmode} (\ref{labrationalmode}) sollya-6.0+ds/doc/display.tex000066400000000000000000000067721300174114700162320ustar00rootroot00000000000000\subsection{display} \label{labdisplay} \noindent Name: \textbf{display}\\ \phantom{aaa}sets or inspects the global variable specifying number notation\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_display_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_display(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_display()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{display} = \emph{notation value} : \textsf{decimal$|$binary$|$dyadic$|$powers$|$hexadecimal} $\rightarrow$ \textsf{void}\\ \textbf{display} = \emph{notation value} ! : \textsf{decimal$|$binary$|$dyadic$|$powers$|$hexadecimal} $\rightarrow$ \textsf{void}\\ \textbf{display} : \textsf{decimal$|$binary$|$dyadic$|$powers$|$hexadecimal}\\ \end{center} Parameters: \begin{itemize} \item \emph{notation value} represents a variable of type \textsf{decimal$|$binary$|$dyadic$|$powers$|$hexadecimal} \end{itemize} \noindent Description: \begin{itemize} \item An assignment \textbf{display} = \emph{notation value}, where \emph{notation value} is one of \textbf{decimal}, \textbf{dyadic}, \textbf{powers}, \textbf{binary} or \textbf{hexadecimal}, activates the corresponding notation for output of values in \textbf{print}, \textbf{write} or at the \sollya prompt. If the global notation variable \textbf{display} is \textbf{decimal}, all numbers will be output in scientific decimal notation. If the global notation variable \textbf{display} is \textbf{dyadic}, all numbers will be output as dyadic numbers with Gappa notation. If the global notation variable \textbf{display} is \textbf{powers}, all numbers will be output as dyadic numbers with a notation compatible with Maple and PARI/GP. If the global notation variable \textbf{display} is \textbf{binary}, all numbers will be output in binary notation. If the global notation variable \textbf{display} is \textbf{hexadecimal}, all numbers will be output in C99/ IEEE754-2008 notation. All output notations can be parsed back by \sollya, inducing no error if the input and output precisions are the same (see \textbf{prec}). If the assignment \textbf{display} = \emph{notation value} is followed by an exclamation mark, no message indicating the new state is displayed. Otherwise the user is informed of the new state of the global mode by an indication. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display = decimal; Display mode is decimal numbers. > a = evaluate(sin(pi * x), 0.25); > a; 0.70710678118654752440084436210484903928483593768847 > display = binary; Display mode is binary numbers. > a; 1.011010100000100111100110011001111111001110111100110010010000100010110010111110 11000100110110011011101010100101010111110100111110001110101101111011000001011101 010001_2 * 2^(-1) > display = hexadecimal; Display mode is hexadecimal numbers. > a; 0x1.6a09e667f3bcc908b2fb1366ea957d3e3adec1751p-1 > display = dyadic; Display mode is dyadic numbers. > a; 33070006991101558613323983488220944360067107133265b-165 > display = powers; Display mode is dyadic numbers in integer-power-of-2 notation. > a; 33070006991101558613323983488220944360067107133265 * 2^(-165) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{print} (\ref{labprint}), \textbf{write} (\ref{labwrite}), \textbf{decimal} (\ref{labdecimal}), \textbf{dyadic} (\ref{labdyadic}), \textbf{powers} (\ref{labpowers}), \textbf{binary} (\ref{labbinary}), \textbf{hexadecimal} (\ref{labhexadecimal}), \textbf{prec} (\ref{labprec}) sollya-6.0+ds/doc/divide.tex000066400000000000000000000066451300174114700160300ustar00rootroot00000000000000\subsection{/} \label{labdivide} \noindent Name: \textbf{/}\\ \phantom{aaa}division function\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_div(sollya_obj_t, sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_div(sollya_obj_t, sollya_obj_t)|\\ \verb| #define SOLLYA_DIV(x,y) sollya_lib_build_function_div((x), (y))|\\[0.2cm] \noindent Usage: \begin{center} \emph{function1} \textbf{/} \emph{function2} : (\textsf{function}, \textsf{function}) $\rightarrow$ \textsf{function}\\ \emph{interval1} \textbf{/} \emph{interval2} : (\textsf{range}, \textsf{range}) $\rightarrow$ \textsf{range}\\ \emph{interval1} \textbf{/} \emph{constant} : (\textsf{range}, \textsf{constant}) $\rightarrow$ \textsf{range}\\ \emph{interval1} \textbf{/} \emph{constant} : (\textsf{constant}, \textsf{range}) $\rightarrow$ \textsf{range}\\ \end{center} Parameters: \begin{itemize} \item \emph{function1} and \emph{function2} represent functions \item \emph{interval1} and \emph{interval2} represent intervals (ranges) \item \emph{constant} represents a constant or constant expression \end{itemize} \noindent Description: \begin{itemize} \item \textbf{/} represents the division (function) on reals. The expression \emph{function1} \textbf{/} \emph{function2} stands for the function composed of the division function and the two functions \emph{function1} and \emph{function2}, where \emph{function1} is the numerator and \emph{function2} the denominator. \item \textbf{/} can be used for interval arithmetic on intervals (ranges). \textbf{/} will evaluate to an interval that safely encompasses all images of the division function with arguments varying in the given intervals. If the intervals given contain points where the division function is not defined, infinities and NaNs will be produced in the output interval. Any combination of intervals with intervals or constants (resp. constant expressions) is supported. However, it is not possible to represent families of functions using an interval as one argument and a function (varying in the free variable) as the other one. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 5 / 2; 2.5 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > x / 2; x * 0.5 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > x / x; 1 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 3 / 0; NaN \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > diff(sin(x) / exp(x)); (exp(x) * cos(x) - sin(x) * exp(x)) / exp(x)^2 \end{Verbatim} \end{minipage}\end{center} \noindent Example 6: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [1;2] / [3;4]; [0.25;0.66666666666666666666666666666666666666666666666668] > [1;2] / 17; [5.8823529411764705882352941176470588235294117647059e-2;0.1176470588235294117647 0588235294117647058823529412] > -13 / [4;17]; [-3.25;-0.76470588235294117647058823529411764705882352941175] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$+$} (\ref{labplus}), \textbf{$-$} (\ref{labminus}), \textbf{$*$} (\ref{labmult}), \textbf{$\mathbf{\hat{~}}$} (\ref{labpower}) sollya-6.0+ds/doc/double.tex000066400000000000000000000035771300174114700160370ustar00rootroot00000000000000\subsection{double} \label{labdouble} \noindent Names: \textbf{double}, \textbf{D}\\ \phantom{aaa}rounding to the nearest IEEE 754 double (binary64).\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_double(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_double_obj()|\\ \verb| int sollya_lib_is_double_obj(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_double(sollya_obj_t)|\\ \verb| #define SOLLYA_D(x) sollya_lib_build_function_double(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{double} is both a function and a constant. \item As a function, it rounds its argument to the nearest IEEE 754 double precision (i.e. IEEE754-2008 binary64) number. Subnormal numbers are supported as well as standard numbers: it is the real rounding described in the standard. \item As a constant, it symbolizes the double precision format. It is used in contexts when a precision format is necessary, e.g. in the commands \textbf{round}, \textbf{roundcoefficients} and \textbf{implementpoly}. See the corresponding help pages for examples. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > D(0.1); 1.100110011001100110011001100110011001100110011001101_2 * 2^(-4) > D(4.17); 1.000010101110000101000111101011100001010001111010111_2 * 2^(2) > D(1.011_2 * 2^(-1073)); 1.1_2 * 2^(-1073) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{halfprecision} (\ref{labhalfprecision}), \textbf{single} (\ref{labsingle}), \textbf{doubleextended} (\ref{labdoubleextended}), \textbf{doubledouble} (\ref{labdoubledouble}), \textbf{quad} (\ref{labquad}), \textbf{tripledouble} (\ref{labtripledouble}), \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{implementpoly} (\ref{labimplementpoly}), \textbf{round} (\ref{labround}), \textbf{printdouble} (\ref{labprintdouble}) sollya-6.0+ds/doc/doubledouble.tex000066400000000000000000000041301300174114700172140ustar00rootroot00000000000000\subsection{doubledouble} \label{labdoubledouble} \noindent Names: \textbf{doubledouble}, \textbf{DD}\\ \phantom{aaa}represents a number as the sum of two IEEE doubles.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_double_double(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_double_double_obj()|\\ \verb| int sollya_lib_is_double_double_obj(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_double_double(sollya_obj_t)|\\ \verb| #define SOLLYA_DD(x) sollya_lib_build_function_double_double(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{doubledouble} is both a function and a constant. \item As a function, it rounds its argument to the nearest number that can be written as the sum of two double precision numbers. \item The algorithm used to compute \textbf{doubledouble}($x$) is the following: let $x_h$ = \textbf{double}($x$) and let $x_l$ = \textbf{double}($x-x_h$). Return the number $x_h+x_l$. Note that if the current precision is not sufficient to exactly represent $x_h + x_l$, a rounding will occur and the result of \textbf{doubledouble}($x$) will be useless. \item As a constant, it symbolizes the double-double precision format. It is used in contexts when a precision format is necessary, e.g. in the commands \textbf{round}, \textbf{roundcoefficients} and \textbf{implementpoly}. See the corresponding help pages for examples. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > a = 1+ 2^(-100); > DD(a); 1.0000000000000000000000000000007888609052210118054 > prec=50!; > DD(a); 1.000000000000000000000000000000788860905 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{halfprecision} (\ref{labhalfprecision}), \textbf{single} (\ref{labsingle}), \textbf{double} (\ref{labdouble}), \textbf{doubleextended} (\ref{labdoubleextended}), \textbf{quad} (\ref{labquad}), \textbf{tripledouble} (\ref{labtripledouble}), \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{implementpoly} (\ref{labimplementpoly}), \textbf{round} (\ref{labround}) sollya-6.0+ds/doc/doubleextended.tex000066400000000000000000000062231300174114700175470ustar00rootroot00000000000000\subsection{doubleextended} \label{labdoubleextended} \noindent Names: \textbf{doubleextended}, \textbf{DE}\\ \phantom{aaa}computes the nearest number with 64 bits of mantissa.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_doubleextended(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_doubleextended_obj()|\\ \verb| int sollya_lib_is_doubleextended_obj(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_doubleextended(sollya_obj_t)|\\ \verb| #define SOLLYA_DE(x) sollya_lib_build_function_doubleextended(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{doubleextended} is a function that computes the nearest floating-point number with 64 bits of mantissa to a given number. Since it is a function, it can be composed with other \sollya functions such as \textbf{exp}, \textbf{sin}, etc. \item \textbf{doubleextended} now does handle subnormal numbers for a presumed exponent width of the double-extended format of 15 bits. This means, with respect to rounding, \textbf{doubleextended} behaves as a IEEE 754-2008 binary79 with a 64 bit significand (with a hidden bit normal range), one sign bit and a 15 bit exponent field would behave. This behavior may be different from the one observed on Intel-based IA32/Intel64 processors (or compatible versions from other vendors). However it is the one seen on HP/Intel Itanium when the precision specifier is double-extended and pseudo-denormals are activated. \item Since it is a function and not a command, its behavior is a bit different from the behavior of \textbf{round}(x,64,RN) even if the result is exactly the same. \textbf{round}(x,64,RN) is immediately evaluated whereas \textbf{doubleextended}(x) can be composed with other functions (and thus be plotted and so on). \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > DE(0.1); 1.100110011001100110011001100110011001100110011001100110011001101_2 * 2^(-4) > round(0.1,64,RN); 1.100110011001100110011001100110011001100110011001100110011001101_2 * 2^(-4) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > D(2^(-2000)); 0 > DE(2^(-20000)); 0 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > f = sin(DE(x)); > f(pi); Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. -5.016557612668332023557327080330757013831561670255e-20 > g = sin(round(x,64,RN)); Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. \end{Verbatim} \end{minipage}\end{center} See also: \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{halfprecision} (\ref{labhalfprecision}), \textbf{single} (\ref{labsingle}), \textbf{double} (\ref{labdouble}), \textbf{doubledouble} (\ref{labdoubledouble}), \textbf{quad} (\ref{labquad}), \textbf{tripledouble} (\ref{labtripledouble}), \textbf{round} (\ref{labround}) sollya-6.0+ds/doc/dyadic.tex000066400000000000000000000015071300174114700160110ustar00rootroot00000000000000\subsection{dyadic} \label{labdyadic} \noindent Name: \textbf{dyadic}\\ \phantom{aaa}special value for global state \textbf{display}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_dyadic()|\\ \verb| int sollya_lib_is_dyadic(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{dyadic} is a special value used for the global state \textbf{display}. If the global state \textbf{display} is equal to \textbf{dyadic}, all data will be output in dyadic notation with numbers displayed in Gappa format. As any value it can be affected to a variable and stored in lists. \end{itemize} See also: \textbf{decimal} (\ref{labdecimal}), \textbf{powers} (\ref{labpowers}), \textbf{hexadecimal} (\ref{labhexadecimal}), \textbf{binary} (\ref{labbinary}), \textbf{display} (\ref{labdisplay}) sollya-6.0+ds/doc/equal.tex000066400000000000000000000153211300174114700156620ustar00rootroot00000000000000\subsection{$==$} \label{labequal} \noindent Name: \textbf{$==$}\\ \phantom{aaa}equality test operator\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_cmp_equal(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \emph{expr1} \textbf{$==$} \emph{expr2} : (\textsf{any type}, \textsf{any type}) $\rightarrow$ \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr1} and \emph{expr2} represent expressions \end{itemize} \noindent Description: \begin{itemize} \item The test \emph{expr1} \textbf{$==$} \emph{expr2} returns \textbf{true} when \emph{expr1} and \emph{expr2} are syntactically equal and different from \textbf{error} and @NaN@. Conversely if \emph{expr1} and \emph{expr2} are objects that are mathematically different and \sollya manages to figure it out, the test returns \textbf{false}. In between these two cases, there is the grey zone of expressions that are not syntactically equal but are mathematically equal. In such a case, \sollya normally tries to determine if the expressions are mathematically equal and if it manages to prove it, it returns \textbf{true}, without a warning. In the case when \emph{expr1} and \emph{expr2} are two constant expressions, \sollya will in particular try to evaluate their difference: in the case when the difference is 0 or is so small that \sollya does not manage to obtain a faithful rounding of the real value, it will return \textbf{true} (with a warning if it has not been possible to actually prove that the real value is 0). In any other case, when both expressions are not syntactically equal and \sollya has not been able to prove that they are mathematically equal, it returns \textbf{false}. \item The level of simplifications performed by \sollya to determine if expressions are mathematically equal depends on the value of \textbf{autosimplify}. If it is \textbf{off}, no formal simplification is performed, hence expression trees as simple as x+1 and 1+x will be considered not equal. Conversely, if \textbf{autosimplify} is set to \textbf{on}, polynomial subexpressions that are mathematically equal will in general be recognized as being equal. \item The user should always keep in mind that a litteral constant written in decimal arithmetic (such as 0.1 for instance) is not considered as an exact constant by \sollya (unless it is exactly representable in binary without requiring too much precision) and is first correctly rounded at precision \textbf{prec}, prior to any other operation. Of course, this leads to a rounding warning, but it is important to remember that this is done before the expression trees are compared, possibly leading to two expressions comparing equal, while they are obviously mathematically different, just because they contain different constants that have been rounded to the same value at precision \textbf{prec}. As a general rule, to avoid this behavior, the user should represent constants in an exact format such as hexadecimal or represent decimal constants as integer fractions (e.g., 0.1 represented by the constant expression 1/10). \item Notice that @NaN@ and \textbf{error} share the property that they both compare equal and different to anything, i.e., if the variable \emph{a} contains @NaN@ or \textbf{error} and whatever the content of variable \emph{b} is, the tests \emph{a} \textbf{$==$} \emph{b} and \emph{a} \textbf{!$=$} \emph{b} both return \textbf{false}. The standard way of testing if \emph{a} contains @NaN@ or \textbf{error} is indeed to check if \emph{a} \textbf{$==$} \emph{a} returns false. In such a case, it is however impossible to determine what is the actual value of \emph{a} amongst both possibilities using only \textbf{$==$} or \textbf{!$=$}. The standard way to discriminate this situation is to use the match ... with ... construct. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > "Hello" == "Hello"; true > "Hello" == "Salut"; false > "Hello" == 5; false > 5 + x == 5 + x; true \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > asin(1) * 2 == pi; true > cos(3)^2 == 1 - sin(3)^2; Warning: the tool is unable to decide an equality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considere d to be equal. true > exp(5) == log(4); false \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > autosimplify=off; Automatic pure tree simplification has been deactivated. > exp(1+x) == exp(x+1); false > autosimplify=on; Automatic pure tree simplification has been activated. > exp(1+x) == exp(x+1); false > (1/3+x)^2 == x^2 + 1/9 + (5-3)*x/3; true > log(x)/log(10) == log10(x); false \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec = 12; The precision has been set to 12 bits. > verbosity = 1!; > 16384.1 == 16385.1; Warning: Rounding occurred when converting the constant "16384.1" to floating-po int with 12 bits. If safe computation is needed, try to increase the precision. Warning: Rounding occurred when converting the constant "16385.1" to floating-po int with 12 bits. If safe computation is needed, try to increase the precision. true > 16384 == 16384.25; false > 0.1 == 1/10; Warning: Rounding occurred when converting the constant "0.1" to floating-point with 12 bits. If safe computation is needed, try to increase the precision. false > 0.1 == round(1/10, prec, RN); Warning: Rounding occurred when converting the constant "0.1" to floating-point with 12 bits. If safe computation is needed, try to increase the precision. true \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > error == error; false > error != error; false > @NaN@ == @NaN@; false > @NaN@ != @NaN@; false > error == @NaN@; false > error != @NaN@; false > a = error; > match a with @NaN@ : ("a contains @NaN@") default:("a contains something else"); error > a = @NaN@; > match a with @NaN@ : ("a contains @NaN@") default:("a contains something else"); a contains @NaN@ \end{Verbatim} \end{minipage}\end{center} See also: \textbf{!$=$} (\ref{labneq}), \textbf{$>$} (\ref{labgt}), \textbf{$>=$} (\ref{labge}), \textbf{$<=$} (\ref{lable}), \textbf{$<$} (\ref{lablt}), \textbf{in} (\ref{labin}), \textbf{!} (\ref{labnot}), \textbf{$\&\&$} (\ref{laband}), \textbf{$||$} (\ref{labor}), \textbf{error} (\ref{laberror}), \textbf{prec} (\ref{labprec}), \textbf{autosimplify} (\ref{labautosimplify}) sollya-6.0+ds/doc/erf.tex000066400000000000000000000011611300174114700153240ustar00rootroot00000000000000\subsection{erf} \label{laberf} \noindent Name: \textbf{erf}\\ \phantom{aaa}the error function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_erf(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_erf(sollya_obj_t)|\\ \verb| #define SOLLYA_ERF(x) sollya_lib_build_function_erf(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{erf} is the error function defined by: $$\mathrm{erf}(x) = \frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2} {\rm d}t.$$ \item It is defined for every real number x. \end{itemize} See also: \textbf{erfc} (\ref{laberfc}), \textbf{exp} (\ref{labexp}) sollya-6.0+ds/doc/erfc.tex000066400000000000000000000011271300174114700154710ustar00rootroot00000000000000\subsection{erfc} \label{laberfc} \noindent Name: \textbf{erfc}\\ \phantom{aaa}the complementary error function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_erfc(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_erfc(sollya_obj_t)|\\ \verb| #define SOLLYA_ERFC(x) sollya_lib_build_function_erfc(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{erfc} is the complementary error function defined by $\mathrm{erfc}(x) = 1 - \mathrm{erf}(x)$. \item It is defined for every real number $x$. \end{itemize} See also: \textbf{erf} (\ref{laberf}) sollya-6.0+ds/doc/error.tex000066400000000000000000000041411300174114700157020ustar00rootroot00000000000000\subsection{error} \label{laberror} \noindent Name: \textbf{error}\\ \phantom{aaa}expression representing an input that is wrongly typed or that cannot be executed\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_error()|\\ \verb| int sollya_lib_obj_is_error(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{error} : \textsf{error}\\ \end{center} \noindent Description: \begin{itemize} \item The variable \textbf{error} represents an input during the evaluation of which a type or execution error has been detected or is to be detected. Inputs that are syntactically correct but wrongly typed evaluate to \textbf{error} at some stage. Inputs that are correctly typed but containing commands that depend on side-effects that cannot be performed or inputs that are wrongly typed at meta-level (cf. \textbf{parse}), evaluate to \textbf{error}. Remark that in contrast to all other elements of the \sollya language, \textbf{error} compares neither equal nor unequal to itself. This provides a means of detecting syntax errors inside the \sollya language itself without introducing issues of two different wrongly typed inputs being equal. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(5 + "foo"); error \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > error; error \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > error == error; false > error != error; false \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > correct = 5 + 6; > incorrect = 5 + "foo"; > correct == correct; true > incorrect == incorrect; false > errorhappened = !(incorrect == incorrect); > errorhappened; true \end{Verbatim} \end{minipage}\end{center} See also: \textbf{void} (\ref{labvoid}), \textbf{parse} (\ref{labparse}), \textbf{$==$} (\ref{labequal}), \textbf{!$=$} (\ref{labneq}) sollya-6.0+ds/doc/evaluate.tex000066400000000000000000000102051300174114700163550ustar00rootroot00000000000000\subsection{evaluate} \label{labevaluate} \noindent Name: \textbf{evaluate}\\ \phantom{aaa}evaluates a function at a constant point or in a range\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_evaluate(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{evaluate}(\emph{function}, \emph{constant}) : (\textsf{function}, \textsf{constant}) $\rightarrow$ \textsf{constant} $|$ \textsf{range}\\ \textbf{evaluate}(\emph{function}, \emph{range}) : (\textsf{function}, \textsf{range}) $\rightarrow$ \textsf{range}\\ \textbf{evaluate}(\emph{function}, \emph{function2}) : (\textsf{function}, \textsf{function}) $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents a function \item \emph{constant} represents a constant point \item \emph{range} represents a range \item \emph{function2} represents a function that is not constant \end{itemize} \noindent Description: \begin{itemize} \item If its second argument is a constant \emph{constant}, \textbf{evaluate} evaluates its first argument \emph{function} at the point indicated by \emph{constant}. This evaluation is performed in a way that the result is a faithful rounding of the real value of the \emph{function} at \emph{constant} to the current global precision. If such a faithful rounding is not possible, \textbf{evaluate} returns a range surely encompassing the real value of the function \emph{function} at \emph{constant}. If even interval evaluation is not possible because the expression is undefined or numerically unstable, NaN will be produced. \item If its second argument is a range \emph{range}, \textbf{evaluate} evaluates its first argument \emph{function} by interval evaluation on this range \emph{range}. This ensures that the image domain of the function \emph{function} on the preimage domain \emph{range} is surely enclosed in the returned range. \item In the case when the second argument is a range that is reduced to a single point (such that $[1;\,1]$ for instance), the evaluation is performed in the same way as when the second argument is a constant but it produces a range as a result: \textbf{evaluate} automatically adjusts the precision of the intern computations and returns a range that contains at most three floating-point consecutive numbers in precision \textbf{prec}. This corresponds to the same accuracy as a faithful rounding of the actual result. If such a faithful rounding is not possible, \textbf{evaluate} has the same behavior as in the case when the second argument is a constant. \item If its second argument is a function \emph{function2} that is not a constant, \textbf{evaluate} replaces all occurrences of the free variable in function \emph{function} by function \emph{function2}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > midpointmode=on!; > print(evaluate(sin(pi * x), 2.25)); 0.70710678118654752440084436210484903928483593768847 > print(evaluate(sin(pi * x), [2.25; 2.25])); 0.707106781186547524400844362104849039284835937688~4/5~ \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(evaluate(sin(pi * x), 2)); [-1.7298645251438126951650861503109812954283676799168e-12715;7.59411982011879631 45069564314525661706039084390068e-12716] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(evaluate(sin(pi * x), [2, 2.25])); [-5.143390272677254630046998919961912407349224165421e-50;0.707106781186547524400 84436210484903928483593768866] \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(evaluate(sin(pi * x), 2 + 0.25 * x)); sin((pi) * 2 + x * (pi) * 0.25) \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(evaluate(sin(pi * 1/x), 0)); [-1;1] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{isevaluable} (\ref{labisevaluable}) sollya-6.0+ds/doc/execute.tex000066400000000000000000000043351300174114700162200ustar00rootroot00000000000000\subsection{execute} \label{labexecute} \noindent Name: \textbf{execute}\\ \phantom{aaa}executes the content of a file\\[0.2cm] \noindent Library name:\\ \verb| void sollya_lib_execute(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{execute}(\emph{filename}) : \textsf{string} $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{filename} is a string representing a file name \end{itemize} \noindent Description: \begin{itemize} \item \textbf{execute} opens the file indicated by \emph{filename}, and executes the sequence of commands it contains. This command is evaluated at execution time: this way you can modify the file \emph{filename} (for instance using \textbf{bashexecute}) and execute it just after. \item If \emph{filename} contains a command \textbf{execute}, it will be executed recursively. \item If \emph{filename} contains a call to \textbf{restart}, it will be neglected. \item If \emph{filename} contains a call to \textbf{quit}, the commands following \textbf{quit} in \emph{filename} will be neglected. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a=2; > a; 2 > print("a=1;") > "example.sollya"; > execute("example.sollya"); > a; 1 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > print("a=1; restart; a=2;") > "example.sollya"; > execute("example.sollya"); Warning: a restart command has been used in a file read into another. This restart command will be neglected. > a; 2 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > print("a=1; quit; a=2;") > "example.sollya"; > execute("example.sollya"); Warning: the execution of a file read by execute demanded stopping the interpret ation but it is not stopped. > a; 1 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{parse} (\ref{labparse}), \textbf{readfile} (\ref{labreadfile}), \textbf{write} (\ref{labwrite}), \textbf{print} (\ref{labprint}), \textbf{bashexecute} (\ref{labbashexecute}), \textbf{quit} (\ref{labquit}), \textbf{restart} (\ref{labrestart}) sollya-6.0+ds/doc/exp.tex000066400000000000000000000012211300174114700153410ustar00rootroot00000000000000\subsection{exp} \label{labexp} \noindent Name: \textbf{exp}\\ \phantom{aaa}the exponential function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_exp(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_exp(sollya_obj_t)|\\ \verb| #define SOLLYA_EXP(x) sollya_lib_build_function_exp(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{exp} is the usual exponential function defined as the solution of the ordinary differential equation $y'=y$ with $y(0)=1$. \item \textbf{exp}(x) is defined for every real number $x$. \end{itemize} See also: \textbf{exp} (\ref{labexp}), \textbf{log} (\ref{lablog}) sollya-6.0+ds/doc/expand.tex000066400000000000000000000035631300174114700160370ustar00rootroot00000000000000\subsection{expand} \label{labexpand} \noindent Name: \textbf{expand}\\ \phantom{aaa}expands polynomial subexpressions\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_expand(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{expand}(\emph{function}) : \textsf{function} $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents a function \end{itemize} \noindent Description: \begin{itemize} \item \textbf{expand}(\emph{function}) expands all polynomial subexpressions in function \emph{function} as far as possible. Factors of sums are multiplied out, power operators with constant positive integer exponents are replaced by multiplications. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(expand(x^3)); x * x * x \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(expand((x + 2)^3 + 2 * x)); 8 + 12 * x + 6 * x * x + x * x * x + 2 * x \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(expand(exp((x + (x + 3))^5))); exp(243 + 405 * x + 270 * x * x + 90 * x * x * x + 15 * x * x * x * x + x * x * x * x * x + x * 405 + 108 * x * 5 * x + 54 * x * x * 5 * x + 12 * x * x * x * 5 * x + x * x * x * x * 5 * x + x * x * 270 + 27 * x * x * x * 10 + 9 * x * x * x * x * 10 + x * x * x * x * x * 10 + x * x * x * 90 + 6 * x * x * x * x * 10 + x * x * x * x * x * 10 + x * x * x * x * 5 * x + 15 * x * x * x * x + x * x * x * x * x) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{dirtysimplify} (\ref{labdirtysimplify}), \textbf{simplify} (\ref{labsimplify}), \textbf{horner} (\ref{labhorner}), \textbf{coeff} (\ref{labcoeff}), \textbf{degree} (\ref{labdegree}) sollya-6.0+ds/doc/expm1.tex000066400000000000000000000010561300174114700156050ustar00rootroot00000000000000\subsection{expm1} \label{labexpm1} \noindent Name: \textbf{expm1}\\ \phantom{aaa}shifted exponential function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_expm1(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_expm1(sollya_obj_t)|\\ \verb| #define SOLLYA_EXPM1(x) sollya_lib_build_function_expm1(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{expm1} is defined by ${\rm expm1}(x) = \exp(x)-1$. \item It is defined for every real number $x$. \end{itemize} See also: \textbf{exp} (\ref{labexp}) sollya-6.0+ds/doc/exponent.tex000066400000000000000000000020261300174114700164110ustar00rootroot00000000000000\subsection{exponent} \label{labexponent} \noindent Name: \textbf{exponent}\\ \phantom{aaa}returns the scaled binary exponent of a number.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_exponent(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{exponent}(\emph{x}) : \textsf{constant} $\rightarrow$ \textsf{integer}\\ \end{center} Parameters: \begin{itemize} \item \emph{x} is a dyadic number. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{exponent}(x) is by definition 0 if $x$ is one of 0, NaN, or Inf. \item If \emph{x} is not zero, it can be uniquely written as $x = m \cdot 2^e$ where $m$ is an odd integer and $e$ is an integer. \textbf{exponent}($x$) returns $e$. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a=round(Pi,20,RN); > e=exponent(a); > e; -17 > m=mantissa(a); > a-m*2^e; 0 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{mantissa} (\ref{labmantissa}), \textbf{precision} (\ref{labprecision}) sollya-6.0+ds/doc/externalplot.tex000066400000000000000000000104461300174114700172770ustar00rootroot00000000000000\subsection{externalplot} \label{labexternalplot} \noindent Name: \textbf{externalplot}\\ \phantom{aaa}plots the error of an external code with regard to a function\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_externalplot(sollya_obj_t, sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t, ...)|\\ \verb| void sollya_lib_v_externalplot(sollya_obj_t, sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t, va_list)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{externalplot}(\emph{filename}, \emph{mode}, \emph{function}, \emph{range}, \emph{precision}) : (\textsf{string}, \textsf{absolute$|$relative}, \textsf{function}, \textsf{range}, \textsf{integer}) $\rightarrow$ \textsf{void}\\ \textbf{externalplot}(\emph{filename}, \emph{mode}, \emph{function}, \emph{range}, \emph{precision}, \emph{perturb}) : (\textsf{string}, \textsf{absolute$|$relative}, \textsf{function}, \textsf{range}, \textsf{integer}, \textsf{perturb}) $\rightarrow$ \textsf{void}\\ \textbf{externalplot}(\emph{filename}, \emph{mode}, \emph{function}, \emph{range}, \emph{precision}, \emph{plot mode}, \emph{result filename}) : (\textsf{string}, \textsf{absolute$|$relative}, \textsf{function}, \textsf{range}, \textsf{integer}, \textsf{file$|$postscript$|$postscriptfile}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \textbf{externalplot}(\emph{filename}, \emph{mode}, \emph{function}, \emph{range}, \emph{precision}, \emph{perturb}, \emph{plot mode}, \emph{result filename}) : (\textsf{string}, \textsf{absolute$|$relative}, \textsf{function}, \textsf{range}, \textsf{integer}, \textsf{perturb}, \textsf{file$|$postscript$|$postscriptfile}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \end{center} \noindent Description: \begin{itemize} \item The command \textbf{externalplot} plots the error of an external function evaluation code sequence implemented in the object file named \emph{filename} with regard to the function \emph{function}. If \emph{mode} evaluates to \emph{absolute}, the difference of both functions is considered as an error function; if \emph{mode} evaluates to \emph{relative}, the difference is divided by the function \emph{function}. The resulting error function is plotted on all floating-point numbers with \emph{precision} significant mantissa bits in the range \emph{range}. If the sixth argument of the command \textbf{externalplot} is given and evaluates to \textbf{perturb}, each of the floating-point numbers the function is evaluated at gets perturbed by a random value that is uniformly distributed in $\pm1$ ulp around the original \emph{precision} bit floating-point variable. If a sixth and seventh argument, respectively a seventh and eighth argument in the presence of \textbf{perturb} as a sixth argument, are given that evaluate to a variable of type \textsf{file$|$postscript$|$postscriptfile} respectively to a character sequence of type \textsf{string}, \textbf{externalplot} will plot (additionally) to a file in the same way as the command \textbf{plot} does. See \textbf{plot} for details. The external function evaluation code given in the object file name \emph{filename} is supposed to define a function name \texttt{f} as follows (here in C syntax): \texttt{void f(mpfr\_t rop, mpfr\_t op)}. This function is supposed to evaluate \texttt{op} with an accuracy corresponding to the precision of \texttt{rop} and assign this value to \texttt{rop}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > bashexecute("gcc -fPIC -c externalplotexample.c"); > bashexecute("gcc -shared -o externalplotexample externalplotexample.o -lgmp -l mpfr"); > externalplot("./externalplotexample",relative,exp(x),[-1/2;1/2],12,perturb); \end{Verbatim} \end{minipage}\end{center} See also: \textbf{plot} (\ref{labplot}), \textbf{asciiplot} (\ref{labasciiplot}), \textbf{perturb} (\ref{labperturb}), \textbf{absolute} (\ref{lababsolute}), \textbf{relative} (\ref{labrelative}), \textbf{file} (\ref{labfile}), \textbf{postscript} (\ref{labpostscript}), \textbf{postscriptfile} (\ref{labpostscriptfile}), \textbf{bashexecute} (\ref{labbashexecute}), \textbf{externalproc} (\ref{labexternalproc}), \textbf{library} (\ref{lablibrary}) sollya-6.0+ds/doc/externalproc.tex000066400000000000000000000302201300174114700172540ustar00rootroot00000000000000\subsection{externalproc} \label{labexternalproc} \noindent Name: \textbf{externalproc}\\ \phantom{aaa}binds an external code to a \sollya procedure\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_externalprocedure(sollya_externalprocedure_type_t, |\\ \verb| sollya_externalprocedure_type_t *,|\\ \verb| int, char *, void *);|\\ \verb| sollya_obj_t sollya_lib_externalprocedure_with_data(|\\ \verb| sollya_externalprocedure_type_t, |\\ \verb| sollya_externalprocedure_type_t *,|\\ \verb| int, char *, void *, void *,|\\ \verb| void (*)(void *));|\\[0.2cm] \noindent Usage: \begin{center} \textbf{externalproc}(\emph{identifier}, \emph{filename}, \emph{argumenttype} \texttt{->} \emph{resulttype}) : (\textsf{identifier type}, \textsf{string}, \textsf{type type}, \textsf{type type}) $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{identifier} represents the identifier the code is to be bound to \item \emph{filename} of type \textsf{string} represents the name of the object file where the code of procedure can be found \item \emph{argumenttype} represents a definition of the types of the arguments of the \sollya procedure and the external code \item \emph{resulttype} represents a definition of the result type of the external code \end{itemize} \noindent Description: \begin{itemize} \item \textbf{externalproc} allows for binding the \sollya identifier \emph{identifier} to an external code. After this binding, when \sollya encounters \emph{identifier} applied to a list of actual parameters, it will evaluate these parameters and call the external code with these parameters. If the external code indicated success, it will receive the result produced by the external code, transform it to \sollya's internal representation and return it. In order to allow correct evaluation and typing of the data in parameter and in result to be passed to and received from the external code, \textbf{externalproc} has a third parameter \emph{argumenttype} \texttt{->} \emph{resulttype}. Both \emph{argumenttype} and \emph{resulttype} are one of \textbf{void}, \textbf{constant}, \textbf{function}, \textbf{object}, \textbf{range}, \textbf{integer}, \textbf{string}, \textbf{boolean}, \textbf{list of} \textbf{constant}, \textbf{list of} \textbf{function}, \textbf{list of} \textbf{object}, \textbf{list of} \textbf{range}, \textbf{list of} \textbf{integer}, \textbf{list of} \textbf{string}, \textbf{list of} \textbf{boolean}. It is worth mentionning that the difference between the data and result type \textbf{function} and the type \textbf{object} is minimal and due to support of legacy \sollya code. Both \sollya functions and \sollya objects are transferred from and to the external procedure thru the C type \texttt{sollya\_obj\_t}. The difference is that \sollya will check that a certain object is a mathematical function when \textbf{function} is used as a type, and will skip this test if the \textbf{object} type is used. Similarly, \sollya relies on an object produced by the external procedure to be a mathematical function when \textbf{function} is used and will not make this assumption for \textbf{object}. If upon a usage of a procedure bound to an external procedure the type of the actual parameters given or its number is not correct, \sollya produces a type error. An external function not applied to arguments represents itself and prints out with its argument and result types. The external function is supposed to return an integer indicating success. It returns its result depending on its \sollya result type as follows. Here, the external procedure is assumed to be implemented as a C function.\begin{itemize} \item If the \sollya result type is void, the C function has no pointer argument for the result. \item If the \sollya result type is \textbf{constant}, the first argument of the C function is of C type \texttt{mpfr\_t *}, the result is returned by affecting the MPFR variable. \item If the \sollya result type is \textbf{function}, the first argument of the C function is of C type \texttt{sollya\_obj\_t *}, the result is returned by affecting the \texttt{sollya\_obj\_t} variable. \item If the \sollya result type is \textbf{object}, the first argument of the C function is of C type \texttt{sollya\_obj\_t *}, the result is returned by affecting the \texttt{sollya\_obj\_t} variable. \item If the \sollya result type is \textbf{range}, the first argument of the C function is of C type \texttt{mpfi\_t *}, the result is returned by affecting the MPFI variable. \item If the \sollya result type is \textbf{integer}, the first argument of the C function is of C type \texttt{int *}, the result is returned by affecting the int variable. \item If the \sollya result type is \textbf{string}, the first argument of the C function is of C type \texttt{char **}, the result is returned by the \texttt{char *} pointed with a new \texttt{char *}. \item If the \sollya result type is \textbf{boolean}, the first argument of the C function is of C type \texttt{int *}, the result is returned by affecting the int variable with a boolean value. \item If the \sollya result type is \textbf{list of} type, the first argument of the C function is of a C type depending on the \sollya return type:\begin{itemize} \item For a list of \textbf{constant}: \verb|sollya_constant_list_t *| \item For a list of \textbf{function}: \verb|sollya_obj_list_t *| \item For a list of \textbf{object}: \verb|sollya_obj_list_t *| \item For a list of \textbf{range}: \verb|sollya_constant_list_t *| \item For a list of \textbf{integer}: \verb|sollya_int_list_t *| \item For a list of \textbf{string}: \verb|sollya_string_list_t *| \item For a list of \textbf{boolean}: \verb|sollya_boolean_list_t *| \end{itemize} \end{itemize} The external procedure affects its possible pointer argument if and only if it succeeds. This means, if the function returns an integer indicating failure, it does not leak any memory to the encompassing environment. The external procedure receives its arguments as follows: If the \sollya argument type is \textbf{void}, no argument array is given. Otherwise the C function receives a C \texttt{void **} argument representing an array of size equal to the arity of the function where each entry (of C type \texttt{void *}) represents a value with a C type depending on the corresponding \sollya type.\begin{itemize} \item If the \sollya type is \textbf{constant}, the \texttt{void *} is to be cast to \texttt{mpfr\_t *}. \item If the \sollya type is \textbf{function}, the \texttt{void *} is to be cast to \texttt{sollya\_obj\_t}. \item If the \sollya type is \textbf{object}, the \texttt{void *} is to be cast to \texttt{sollya\_obj\_t}. \item If the \sollya type is \textbf{range}, the \texttt{void *} is to be cast to \texttt{mpfi\_t *}. \item If the \sollya type is \textbf{integer}, the \texttt{void *} is to be cast to \texttt{int *}. \item If the \sollya type is \textbf{string}, the \texttt{void *} is to be cast to \texttt{char *}. \item If the \sollya type is \textbf{boolean}, the \texttt{void *} is to be cast to \texttt{int *}. \item If the \sollya type is \textbf{list of} type, the \texttt{void *} is to be cast to a list of a type depending on the type of the list argument:\begin{itemize} \item For a list of \textbf{constant}: \verb|sollya_constant_list_t| \item For a list of \textbf{function}: \verb|sollya_obj_list_t| \item For a list of \textbf{object}: \verb|sollya_obj_list_t| \item For a list of \textbf{range}: \verb|sollya_interval_list_t| \item For a list of \textbf{integer}: \verb|sollya_int_list_t| \item For a list of \textbf{string}: \verb|sollya_string_list_t| \item For a list of \textbf{boolean}: \verb|sollya_boolean_list_t| \end{itemize} \end{itemize} The external procedure is not supposed to alter the memory pointed by its array argument \texttt{void **}. In both directions (argument and result values), empty lists are represented by \texttt{NULL} pointers. Similarly to internal procedures, externally bounded procedures can be considered to be objects inside \sollya that can be assigned to other variables, stored in list etc. \item The user should be aware that they may use the \sollya library in external codes to be dynamically bound to \sollya using \textbf{externalproc}. On most systems, it suffices to include the header of the \sollya library into the source code of the external procedure. Linking with the actual \sollya library is not necessary on most systems; as the interactive \sollya executable contains a superset of the \sollya library functions. On some systems, linking with the \sollya library or some of its dependencies may be necessary. In particular, the \sollya library --~and, of course, its header file~-- contain a certain set of functions to manipulate lists with elements of certain types, such as \verb|sollya_constant_list_t|, \verb|sollya_obj_list_t| and so on. As explained above, these types are passed in argument to (and received back thru a reference from) an external procedure. These list manipulation functions are not strictly necessary to the use of the \sollya library in free-standing applications that do not use the functionality provided with \textbf{externalproc}. They are therefore provided as-is without any further documentation, besides the comments given in the \sollya library header file. \item The dynamic object file whose name is given to \textbf{externalproc} for binding of an external procedure may also define a destructor function \verb|int sollya_external_lib_close(void)|. If \sollya finds such a destructor function in the dynamic object file, it will call that function when closing the dynamic object file again. This happens when \sollya is terminated or when the current \sollya session is restarted using \textbf{restart}. The purpose of the destructor function is to allow the dynamically bound code to free any memory that it might have allocated before \sollya is terminated or restarted. The dynamic object file is not necessarily needed to define a destructor function. This ensure backward compatibility with older \sollya external library function object files. When defined, the destructor function is supposed to return an integer value indicating if an error has happened. Upon success, the destructor functions is to return a zero value, upon error a non-zero value. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > bashexecute("gcc -fPIC -Wall -c externalprocexample.c"); > bashexecute("gcc -fPIC -shared -o externalprocexample externalprocexample.o"); > externalproc(foo, "./externalprocexample", (integer, integer) -> integer); > foo; foo > foo(5, 6); 11 > verbosity = 1!; > foo(); Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. error > a = foo; > a(5,6); 11 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{library} (\ref{lablibrary}), \textbf{libraryconstant} (\ref{lablibraryconstant}), \textbf{externalplot} (\ref{labexternalplot}), \textbf{bashexecute} (\ref{labbashexecute}), \textbf{void} (\ref{labvoid}), \textbf{constant} (\ref{labconstant}), \textbf{function} (\ref{labfunction}), \textbf{range} (\ref{labrange}), \textbf{integer} (\ref{labinteger}), \textbf{string} (\ref{labstring}), \textbf{boolean} (\ref{labboolean}), \textbf{list of} (\ref{lablistof}), \textbf{object} (\ref{labobject}) sollya-6.0+ds/doc/false.tex000066400000000000000000000011701300174114700156420ustar00rootroot00000000000000\subsection{false} \label{labfalse} \noindent Name: \textbf{false}\\ \phantom{aaa}the boolean value representing the false.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_false()|\\ \verb| int sollya_lib_is_false(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{false} is the usual boolean value. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > true && false; false > 2<1; false \end{Verbatim} \end{minipage}\end{center} See also: \textbf{true} (\ref{labtrue}), \textbf{$\&\&$} (\ref{laband}), \textbf{$||$} (\ref{labor}) sollya-6.0+ds/doc/file.tex000066400000000000000000000016751300174114700155010ustar00rootroot00000000000000\subsection{file} \label{labfile} \noindent Name: \textbf{file}\\ \phantom{aaa}special value for commands \textbf{plot} and \textbf{externalplot}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_file()|\\ \verb| int sollya_lib_is_file(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{file} is a special value used in commands \textbf{plot} and \textbf{externalplot} to save the result of the command in a data file. \item As any value it can be affected to a variable and stored in lists. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > savemode=file; > name="plotSinCos"; > plot(sin(x),0,cos(x),[-Pi,Pi],savemode, name); \end{Verbatim} \end{minipage}\end{center} See also: \textbf{externalplot} (\ref{labexternalplot}), \textbf{plot} (\ref{labplot}), \textbf{postscript} (\ref{labpostscript}), \textbf{postscriptfile} (\ref{labpostscriptfile}) sollya-6.0+ds/doc/findzeros.tex000066400000000000000000000047531300174114700165650ustar00rootroot00000000000000\subsection{findzeros} \label{labfindzeros} \noindent Name: \textbf{findzeros}\\ \phantom{aaa}gives a list of intervals containing all zeros of a function on an interval.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_findzeros(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{findzeros}(\emph{f},\emph{I}) : (\textsf{function}, \textsf{range}) $\rightarrow$ \textsf{list}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is a function. \item \emph{I} is an interval. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{findzeros}(\emph{f},\emph{I}) returns a list of intervals $I_1, \dots, I_n$ such that, for every zero $z$ of $f$, there exists some $k$ such that $z \in I_k$. \item The list may contain intervals $I_k$ that do not contain any zero of \emph{f}. An interval \emph{Ik} may contain many zeros of \emph{f}. \item This command is meant for cases when safety is critical. If you want to be sure not to forget any zero, use \textbf{findzeros}. However, if you just want to know numerical values for the zeros of \emph{f}, \textbf{dirtyfindzeros} should be quite satisfactory and a lot faster. \item If $\delta$ denotes the value of global variable \textbf{diam}, the algorithm ensures that for each $k$, $|I_k| \le \delta \cdot |I|$. \item The algorithm used is basically a bisection algorithm. It is the same algorithm that the one used for \textbf{infnorm}. See the help page of this command for more details. In short, the behavior of the algorithm depends on global variables \textbf{prec}, \textbf{diam}, \textbf{taylorrecursions} and \textbf{hopitalrecursions}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > findzeros(sin(x),[-5;5]); [|[-3.14208984375;-3.140869140625], [-1.220703125e-3;1.220703125e-3], [3.1408691 40625;3.14208984375]|] > diam=1e-10!; > findzeros(sin(x),[-5;5]); [|[-3.14159265370108187198638916015625;-3.141592652536928653717041015625], [-1.1 6415321826934814453125e-9;1.16415321826934814453125e-9], [3.14159265253692865371 7041015625;3.14159265370108187198638916015625]|] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{dirtyfindzeros} (\ref{labdirtyfindzeros}), \textbf{infnorm} (\ref{labinfnorm}), \textbf{prec} (\ref{labprec}), \textbf{diam} (\ref{labdiam}), \textbf{taylorrecursions} (\ref{labtaylorrecursions}), \textbf{hopitalrecursions} (\ref{labhopitalrecursions}), \textbf{numberroots} (\ref{labnumberroots}) sollya-6.0+ds/doc/fixed.tex000066400000000000000000000021261300174114700156510ustar00rootroot00000000000000\subsection{fixed} \label{labfixed} \noindent Name: \textbf{fixed}\\ \phantom{aaa}indicates that fixed-point formats should be used for \textbf{fpminimax}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_fixed()|\\ \verb| int sollya_lib_is_fixed(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{fixed} : \textsf{fixed$|$floating}\\ \end{center} \noindent Description: \begin{itemize} \item The use of \textbf{fixed} in the command \textbf{fpminimax} indicates that the list of formats given as argument is to be considered to be a list of fixed-point formats. See \textbf{fpminimax} for details. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > fpminimax(cos(x),6,[|32,32,32,32,32,32,32|],[-1;1],fixed); 0.9999997480772435665130615234375 + x^2 * (-0.4999928693287074565887451171875 + x^2 * (4.163351492024958133697509765625e-2 + x^2 * (-1.3382239267230033874511718 75e-3))) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{fpminimax} (\ref{labfpminimax}), \textbf{floating} (\ref{labfloating}) sollya-6.0+ds/doc/floating.tex000066400000000000000000000025521300174114700163600ustar00rootroot00000000000000\subsection{floating} \label{labfloating} \noindent Name: \textbf{floating}\\ \phantom{aaa}indicates that floating-point formats should be used for \textbf{fpminimax}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_floating()|\\ \verb| int sollya_lib_is_floating(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{floating} : \textsf{fixed$|$floating}\\ \end{center} \noindent Description: \begin{itemize} \item The use of \textbf{floating} in the command \textbf{fpminimax} indicates that the list of formats given as argument is to be considered to be a list of floating-point formats. See \textbf{fpminimax} for details. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > fpminimax(cos(x),6,[|D...|],[-1;1],floating); 0.99999974816012215939053930924274027347564697265625 + x * (-2.79593179695850233 4440230695107655659202089892465e-15 + x * (-0.4999928698020140171998093592264922 3357439041137695 + x * (4.0484539189054105169841244454207387920433372507922e-14 + x * (4.1633515528919168291466235132247675210237503051758e-2 + x * (-4.01585881 8743733758578949218474363725507386355118e-14 + x * (-1.3382240885483781024645200 119493892998434603214264e-3)))))) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{fpminimax} (\ref{labfpminimax}), \textbf{fixed} (\ref{labfixed}) sollya-6.0+ds/doc/floor.tex000066400000000000000000000012771300174114700157010ustar00rootroot00000000000000\subsection{floor} \label{labfloor} \noindent Name: \textbf{floor}\\ \phantom{aaa}the usual function floor.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_floor(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_floor(sollya_obj_t)|\\ \verb| #define SOLLYA_FLOOR(x) sollya_lib_build_function_floor(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{floor} is defined as usual: \textbf{floor}($x$) is the greatest integer y such that $y \le x$. \item It is defined for every real number $x$. \end{itemize} See also: \textbf{ceil} (\ref{labceil}), \textbf{nearestint} (\ref{labnearestint}), \textbf{round} (\ref{labround}), \textbf{RD} (\ref{labrd}) sollya-6.0+ds/doc/fpminimax.tex000066400000000000000000000402631300174114700165460ustar00rootroot00000000000000\subsection{fpminimax} \label{labfpminimax} \noindent Name: \textbf{fpminimax}\\ \phantom{aaa}computes a good polynomial approximation with fixed-point or floating-point coefficients\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_fpminimax(sollya_obj_t, sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, ...)|\\ \verb| sollya_obj_t sollya_lib_v_fpminimax(sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t, va_list)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{fpminimax}(\emph{f}, \emph{n}, \emph{formats}, \emph{range}, \emph{indic1}, \emph{indic2}, \emph{indic3}, \emph{P}) : (\textsf{function}, \textsf{integer}, \textsf{list}, \textsf{range}, \textsf{absolute$|$relative} $|$ \textsf{fixed$|$floating} $|$ \textsf{function}, \textsf{absolute$|$relative} $|$ \textsf{fixed$|$floating} $|$ \textsf{function}, \textsf{absolute$|$relative} $|$ \textsf{fixed$|$floating} $|$ \textsf{function}, \textsf{function}) $\rightarrow$ \textsf{function}\\ \textbf{fpminimax}(\emph{f}, \emph{monomials}, \emph{formats}, \emph{range}, \emph{indic1}, \emph{indic2}, \emph{indic3}, \emph{P}) : (\textsf{function}, \textsf{list}, \textsf{list}, \textsf{range}, \textsf{absolute$|$relative} $|$ \textsf{fixed$|$floating} $|$ \textsf{function}, \textsf{absolute$|$relative} $|$ \textsf{fixed$|$floating} $|$ \textsf{function}, \textsf{absolute$|$relative} $|$ \textsf{fixed$|$floating} $|$ \textsf{function}, \textsf{function}) $\rightarrow$ \textsf{function}\\ \textbf{fpminimax}(\emph{f}, \emph{n}, \emph{formats}, \emph{L}, \emph{indic1}, \emph{indic2}, \emph{indic3}, \emph{P}) : (\textsf{function}, \textsf{integer}, \textsf{list}, \textsf{list}, \textsf{absolute$|$relative} $|$ \textsf{fixed$|$floating} $|$ \textsf{function}, \textsf{absolute$|$relative} $|$ \textsf{fixed$|$floating} $|$ \textsf{function}, \textsf{absolute$|$relative} $|$ \textsf{fixed$|$floating} $|$ \textsf{function}, \textsf{function}) $\rightarrow$ \textsf{function}\\ \textbf{fpminimax}(\emph{f}, \emph{monomials}, \emph{formats}, \emph{L}, \emph{indic1}, \emph{indic2}, \emph{indic3}, \emph{P}) : (\textsf{function}, \textsf{list}, \textsf{list}, \textsf{list}, \textsf{absolute$|$relative} $|$ \textsf{fixed$|$floating} $|$ \textsf{function}, \textsf{absolute$|$relative} $|$ \textsf{fixed$|$floating} $|$ \textsf{function}, \textsf{absolute$|$relative} $|$ \textsf{fixed$|$floating} $|$ \textsf{function}, \textsf{function}) $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is the function to be approximated \item \emph{n} is the degree of the polynomial that must approximate \emph{f} \item \emph{monomials} is a list of integers or a list of function. It indicates the basis for the approximation of~\emph{f} \item \emph{formats} is a list indicating the formats that the coefficients of the polynomial must have \item \emph{range} is the interval where the function must be approximated \item \emph{L} is a list of interpolation points used by the method \item \emph{indic1} (optional) is one of the optional indication parameters. See the detailed description below. \item \emph{indic2} (optional) is one of the optional indication parameters. See the detailed description below. \item \emph{indic3} (optional) is one of the optional indication parameters. See the detailed description below. \item \emph{P} (optional) is the minimax polynomial to be considered for solving the problem. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{fpminimax} uses a heuristic (but practically efficient) method to find a good polynomial approximation of a function \emph{f} on an interval \emph{range}. It implements the method published in the article:\\ Efficient polynomial $L^\infty$-approximations\\ Nicolas Brisebarre and Sylvain Chevillard\\ Proceedings of the 18th IEEE Symposium on Computer Arithmetic (ARITH 18)\\ pp. 169-176 \item The basic usage of this command is \textbf{fpminimax}(\emph{f}, \emph{n}, \emph{formats}, \emph{range}). It computes a polynomial approximation of $f$ with degree at most $n$ on the interval \emph{range}. \emph{formats} is a list of integers or format types (such as \textbf{double}, \textbf{doubledouble}, etc.). The polynomial returned by the command has its coefficients that fit the formats indications. For instance, if formats[0] is 35, the coefficient of degree 0 of the polynomial will fit a floating-point format of 35 bits. If formats[1] is D, the coefficient of degree 1 will be representable by a floating-point number with a precision of 53 bits (which is not necessarily an IEEE 754 double precision number. See the remark below), etc. \item The second argument may be either an integer, a list of integers or a list of functions. An integer indicates the degree of the desired polynomial approximation. A list of integers indicates the list of desired monomials. For instance, the list $[|0,\,2,\,4,\,6|]$ indicates that the polynomial must be even and of degree at most 6. Giving an integer $n$ as second argument is equivalent as giving $[|0,\,\dots,\,n|]$. Finally, a list of function $g_k$ indicates that the desired approximation must be a linear combination of the $g_k$.\\ The list of formats is interpreted with respect to the list of monomials. For instance, if the list of monomials is $[|0,\,2,\,4,\,6|]$ and the list of formats is $[|161,\,107,\,53,\,24|]$, the coefficients of degree 0 is searched as a floating-point number with precision 161, the coefficient of degree 2 is searched as a number of precision 107, and so on. \item The list of formats may contain either integers or format types (\textbf{halfprecision}, \textbf{single}, \textbf{double}, \textbf{doubledouble}, \textbf{tripledouble}, \textbf{doubleextended} and \textbf{quad}). The list may be too large or even infinite. Only the first indications will be considered. For instance, for a degree $n$ polynomial, $\mathrm{formats}[n+1]$ and above will be discarded. This lets one use elliptical indications for the last coefficients. \item The floating-point coefficients considered by \textbf{fpminimax} do not have an exponent range. In particular, in the format list, \textbf{double} is an exact synonym for 53. Currently, \textbf{fpminimax} only ensures that the corresponding coefficient has at most 53 bits of mantissa. It does not imply that it is an IEEE-754 double. \item By default, the list of formats is interpreted as a list of floating-point formats. This may be changed by passing \textbf{fixed} as an optional argument (see below). Let us take an example: \textbf{fpminimax}($f$,$2$, $[|107,$ DD, $53|]$, $[0;1]$). Here the optional argument is missing (we could have set it to \textbf{floating}). Thus, \textbf{fpminimax} will search for a polynomial of degree 2 with a constant coefficient that is a 107 bits floating-point number, etc.\\ Currently, \textbf{doubledouble} is just a synonym for 107 and \textbf{tripledouble} a synonym for 161. This behavior may change in the future (taking into account the fact that some double-doubles are not representable with 107 bits).\\ Second example: \textbf{fpminimax}($f$, $2$, $[|25,\,18,\,30|]$, $[0;1]$, \textbf{fixed}). In this case, \textbf{fpminimax} will search for a polynomial of degree 2 with a constant coefficient of the form $m/2^{25}$ where $m$ is an integer. In other words, it is a fixed-point number with 25 bits after the point. Note that even with argument \textbf{fixed}, the formats list is allowed to contain \textbf{halfprecision}, \textbf{single}, \textbf{double}, \textbf{doubleextended}, \textbf{doubledouble}, \textbf{quad} or \textbf{tripledouble}. In this this case, it is just a synonym for 11, 24, 53, 64, 107, 113 or 161. This is deprecated and may change in the future. \item The fourth argument may be a range or a list. Lists are for advanced users that know what they are doing. The core of the method is a kind of approximated interpolation. The list given here is a list of points that must be considered for the interpolation. It must contain at least as many points as unknown coefficients. If you give a list, it is also recommended that you provide the minimax polynomial as last argument. If you give a range, the list of points will be automatically computed. \item The fifth, sixth and seventh arguments are optional. By default, \textbf{fpminimax} will approximate $f$ while optimizing the relative error, and interpreting the list of formats as a list of floating-point formats.\\ This default behavior may be changed with these optional arguments. You may provide zero, one, two or three of the arguments in any order. This lets the user indicate only the non-default arguments.\\ The three possible arguments are: \begin{itemize} \item \textbf{relative} or \textbf{absolute}: the error to be optimized; \item \textbf{floating} or \textbf{fixed}: formats of the coefficients; \item a constrained part $q$. \end{itemize} The constrained part lets the user assign in advance some of the coefficients. For instance, for approximating $\exp(x)$, it may be interesting to search for a polynomial $p$ of the form $$p = 1 + x + \frac{x^2}{2} + a_3 x^3 + a_4 x^4.$$ Thus, there is a constrained part $q = 1 + x + x^2/2$ and the unknown polynomial should be considered in the monomial basis $[|3, 4|]$. Calling \textbf{fpminimax} with monomial basis $[|3,\,4|]$ and constrained part $q$, will return a polynomial with the right form. \item The last argument is for advanced users. It is the minimax polynomial that approximates the function $f$ in the given basis. If it is not given this polynomial will be automatically computed by \textbf{fpminimax}. \\ This minimax polynomial is used to compute the list of interpolation points required by the method. It is also used, when floating-point coefficients are desired, to give an initial assumption for the exponents of the coeffcients. In general, you do not have to provide this argument. But if you want to obtain several polynomials of the same degree that approximate the same function on the same range, just changing the formats, you should probably consider computing only once the minimax polynomial and the list of points instead of letting \textbf{fpminimax} recompute them each time. \\ Note that in the case when a constrained part is given, the minimax polynomial must take that into account. For instance, in the previous example, the minimax would be obtained by the following command: \begin{center}\verb~P = remez(1-(1+x+x^2/2)/exp(x), [|3,4|], range, 1/exp(x));~\end{center} Note that the constrained part is not to be added to $P$. \\ In the case when the second argument is an integer or a list of integers, there is no restriction for $P$, as long as it is a polynomial. However, when the second argument is a list of functions, and even if these functions are all polynomials, $P$ must be expanded in the given basis. For instance, if the second argument is $2$ or $[|0,\,1,\,2|]$, $P$ can be given in Horner form. However, if the second argument is $[|1,\,x,\,x^2|]$, $P$ must be written as a linear combination of $1$, $x$ and $x^2$, otherwise, the algorithm will fail to recover the coefficients of $P$ and will fail with an error message. \\ Please also note that recovering the coefficients of $P$ in an arbitrary basis is performed heuristically and no verification is performed to check that $P$ does not contain other functions than the functions of the basis. \item Note that \textbf{fpminimax} internally computes a minimax polynomial (using the same algorithm as \textbf{remez} command). Thus \textbf{fpminimax} may encounter the same problems as \textbf{remez}. In particular, it may be very slow when Haar condition is not fulfilled. Another consequence is that currently \textbf{fpminimax} has to be run with a sufficiently high working precision. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > P = fpminimax(cos(x),6,[|DD, DD, D...|],[-1b-5;1b-5]); > printexpansion(P); (0x3ff0000000000000 + 0xbc09fda15e029b00) + x * ((0x3af9eb57163024a8 + 0x37942c2 f3f3e3839) + x * (0xbfdfffffffffff98 + x * (0xbbd1693f9c028849 + x * (0x3fa55555 55145337 + x * (0x3c7a25f610ad9ebc + x * 0xbf56c138142da5b0))))) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > P = fpminimax(sin(x),6,[|32...|],[-1b-5;1b-5], fixed, absolute); > display = powers!; > P; x * (1 + x^2 * (-357913941 * 2^(-31) + x^2 * (35789873 * 2^(-32)))) \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > P = fpminimax(exp(x), [|3,4|], [|D,24|], [-1/256; 1/246], 1+x+x^2/2); > display = powers!; > P; 1 + x * (1 + x * (1 * 2^(-1) + x * (375300225001191 * 2^(-51) + x * (5592621 * 2 ^(-27))))) \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = cos(exp(x)); > pstar = remez(f, 5, [-1b-7;1b-7]); > listpoints = dirtyfindzeros(f-pstar, [-1b-7; 1b-7]); > P1 = fpminimax(f, 5, [|DD...|], listpoints, absolute, default, default, pstar) ; > P2 = fpminimax(f, 5, [|D...|], listpoints, absolute, default, default, pstar); > P3 = fpminimax(f, 5, [|D, D, D, 24...|], listpoints, absolute, default, defaul t, pstar); > print("Error of pstar: ", dirtyinfnorm(f-pstar, [-1b-7; 1b-7])); Error of pstar: 7.9048441259903026332577436001060063099817726177425e-16 > print("Error of P1: ", dirtyinfnorm(f-P1, [-1b-7; 1b-7])); Error of P1: 7.9048441259903026580081299123420463921479618202064e-16 > print("Error of P2: ", dirtyinfnorm(f-P2, [-1b-7; 1b-7])); Error of P2: 8.2477144579950871737109573536791331686347620955985e-16 > print("Error of P3: ", dirtyinfnorm(f-P3, [-1b-7; 1b-7])); Error of P3: 1.08454277156993282593701156841863009789063333951055e-15 \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > L = [|exp(x), sin(x), cos(x)-1, sin(x^3)|]; > g = (2^x-1)/x; > p = fpminimax(g, L, [|D...|], [-1/16;1/16],absolute); > display = powers!; > p; -3267884797436153 * 2^(-54) * sin(x^3) + 5247089102535885 * 2^(-53) * (cos(x) - 1) + -8159095033730771 * 2^(-54) * sin(x) + 6243315658446641 * 2^(-53) * exp(x) \end{Verbatim} \end{minipage}\end{center} \noindent Example 6: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > n = 9; > T = [|1, x|]; > for i from 2 to n do T[i] = canonical(2*x*T[i-1]-T[i-2]); > g = (2^x-1)/x; > PCheb = fpminimax(g, T, [|DD,DE...|], [-1/16;1/16],absolute); > display = dyadic!; > print(PCheb); 8733930098894247371b-98 * (9 * x + -120 * x^3 + 432 * x^5 + -576 * x^7 + 256 * x ^9) + 15750497046710770365b-94 * (1 + -32 * x^2 + 160 * x^4 + -256 * x^6 + 128 * x^8) + 6467380330985872933b-88 * (-7 * x + 56 * x^3 + -112 * x^5 + 64 * x^7) + 9342762606926218927b-84 * (-1 + 18 * x^2 + -48 * x^4 + 32 * x^6) + 1181452136745 6461131b-80 * (5 * x + -20 * x^3 + 16 * x^5) + 6405479474328570593b-75 * (1 + -8 * x^2 + 8 * x^4) + 11584457324781949889b-72 * (-3 * x + 4 * x^3) + 167797053124 47201161b-69 * (-1 + 2 * x^2) + 18265014280997359319b-66 * x + 11705449744817514 3902009975397253b-107 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{remez} (\ref{labremez}), \textbf{dirtyfindzeros} (\ref{labdirtyfindzeros}), \textbf{absolute} (\ref{lababsolute}), \textbf{relative} (\ref{labrelative}), \textbf{fixed} (\ref{labfixed}), \textbf{floating} (\ref{labfloating}), \textbf{default} (\ref{labdefault}), \textbf{halfprecision} (\ref{labhalfprecision}), \textbf{single} (\ref{labsingle}), \textbf{double} (\ref{labdouble}), \textbf{doubleextended} (\ref{labdoubleextended}), \textbf{doubledouble} (\ref{labdoubledouble}), \textbf{quad} (\ref{labquad}), \textbf{tripledouble} (\ref{labtripledouble}), \textbf{implementpoly} (\ref{labimplementpoly}), \textbf{coeff} (\ref{labcoeff}), \textbf{degree} (\ref{labdegree}), \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{guessdegree} (\ref{labguessdegree}) sollya-6.0+ds/doc/fullparentheses.tex000066400000000000000000000043171300174114700177620ustar00rootroot00000000000000\subsection{fullparentheses} \label{labfullparentheses} \noindent Name: \textbf{fullparentheses}\\ \phantom{aaa}activates, deactivates or inspects the state variable controlling output with full parenthesising\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_fullparentheses_and_print(sollya_obj_t);|\\ \verb| void sollya_lib_set_fullparentheses(sollya_obj_t);|\\ \verb| sollya_obj_t sollya_lib_get_fullparentheses();|\\[0.2cm] \noindent Usage: \begin{center} \textbf{fullparentheses} = \emph{activation value} : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{fullparentheses} = \emph{activation value} ! : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{activation value} represents \textbf{on} or \textbf{off}, i.e. activation or deactivation \end{itemize} \noindent Description: \begin{itemize} \item An assignment \textbf{fullparentheses} = \emph{activation value}, where \emph{activation value} is one of \textbf{on} or \textbf{off}, activates respectively deactivates the output of expressions with full parenthesising. In full parenthesising mode, \sollya commands like \textbf{print}, \textbf{write} and the implicit command when an expression is given at the prompt will output expressions with parenthesising at all places where it is necessary for expressions containing infix operators to be parsed back with the same result. Otherwise parentheses around associative operators are omitted. If the assignment \textbf{fullparentheses} = \emph{activation value} is followed by an exclamation mark, no message indicating the new state is displayed. Otherwise the user is informed of the new state of the global mode by an indication. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > autosimplify = off!; > fullparentheses = off; Full parentheses mode has been deactivated. > print(1 + 2 + 3); 1 + 2 + 3 > fullparentheses = on; Full parentheses mode has been activated. > print(1 + 2 + 3); (1 + 2) + 3 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{print} (\ref{labprint}), \textbf{write} (\ref{labwrite}), \textbf{autosimplify} (\ref{labautosimplify}) sollya-6.0+ds/doc/function.tex000066400000000000000000000116361300174114700164050ustar00rootroot00000000000000\subsection{function} \label{labfunction} \noindent Name: \textbf{function}\\ \phantom{aaa}keyword for declaring a procedure-based function or a keyword representing a \textsf{function} type \\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_procedurefunction(sollya_obj_t, sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_procedurefunction(sollya_obj_t,|\\ \verb| sollya_obj_t)|\\ \verb| SOLLYA_EXTERNALPROC_TYPE_FUNCTION|\\[0.2cm] \noindent Usage: \begin{center} \textbf{function}(\emph{procedure}) : \textsf{procedure} $\rightarrow$ \textsf{function}\\ \textbf{function} : \textsf{type type}\\ \end{center} Parameters: \begin{itemize} \item \emph{procedure} is a procedure of type (\textsf{range}, \textsf{integer}, \textsf{integer}) $\rightarrow$ \textsf{range} \end{itemize} \noindent Description: \begin{itemize} \item For the sake of safety and mathematical consistency, \sollya distinguishes clearly between functions, seen in the mathematical sense of the term, i.e. mappings, and procedures, seen in the sense Computer Science gives to functions, i.e. pieces of code that compute results for arguments following an algorithm. In some cases however, it is interesting to use such Computer Science procedures as realisations of mathematical functions, e.g. in order to plot them or even to perform polynomial approximation on them. The \textbf{function} keyword allows for such a transformation of a \sollya procedure into a \sollya function. \item The procedure to be used as a function through \textbf{function}(\emph{procedure}) must be of type (\textsf{range}, \textsf{integer}, \textsf{integer}) $\rightarrow$ \textsf{range}. This means it must take in argument an interval $X$, a degree of differentiation $n$ and a working precision $p$. It must return in result an interval $Y$ encompassing the image $f^{(n)}(X)$ of the $n$-th derivative of the implemented function $f$, i.e. $f^{(n)}(X) \subseteq Y$. In order to allow \sollya's algorithms to work properly, the procedure must ensure that, whenever $(p, \textrm{diam}(X))$ tends to $(+\infty,\,0)$, the computed over-estimated bounding $Y$ tends to the actual image $f^{(n)}(X)$. \item The user must be aware that they are responsible of the correctness of the procedure. If, for some $n$ and $X$, \emph{procedure} returns an interval $Y$ such that $f^{(n)}(X) \not\subseteq Y$, \textbf{function} will successfully return a function without any complain, but this function might behave inconsistently in further computations. \item For cases when the procedure does not have the correct signature or does not return a finite interval as a result \textbf{function}(\emph{procedure}) evaluates to Not-A-Number (resp. to an interval of Not-A-Numbers for interval evaluation). \item \textbf{function} also represents the \textsf{function} type for declarations of external procedures by means of \textbf{externalproc}. Remark that in contrast to other indicators, type indicators like \textbf{function} cannot be handled outside the \textbf{externalproc} context. In particular, they cannot be assigned to variables. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure EXP(X,n,p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; }; > f = function(EXP); > f(1); 2.7182818284590452353602874713526624977572470937 > exp(1); 2.7182818284590452353602874713526624977572470937 > f(x + 3); (function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; }))(3 + x) > diff(f); diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })) > (diff(f))(0); 1 > g = f(sin(x)); > g(17); 0.38235816999386683402690554641655641359573458342088 > diff(g); (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(sin(x)) * cos(x) > (diff(g))(1); 1.25338076749344683697237458088447611474812675164344 > p = remez(f,3,[-1/2;1/2]); > p; 0.99967120901420646830315493949039176881764871951833 + x * (0.999737029835711401 34762682913614052309208076875596 + x * (0.51049729360282624921622721654643510358 3073053437 + x * 0.169814324607133287588897694747370380479108785868016)) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{proc} (\ref{labproc}), \textbf{library} (\ref{lablibrary}), \textbf{procedure} (\ref{labprocedure}), \textbf{externalproc} (\ref{labexternalproc}), \textbf{boolean} (\ref{labboolean}), \textbf{constant} (\ref{labconstant}), \textbf{integer} (\ref{labinteger}), \textbf{list of} (\ref{lablistof}), \textbf{range} (\ref{labrange}), \textbf{string} (\ref{labstring}), \textbf{object} (\ref{labobject}) sollya-6.0+ds/doc/ge.tex000066400000000000000000000034301300174114700151440ustar00rootroot00000000000000\subsection{$>=$} \label{labge} \noindent Name: \textbf{$>=$}\\ \phantom{aaa}greater-than-or-equal-to operator\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_cmp_greater_equal(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \emph{expr1} \textbf{$>=$} \emph{expr2} : (\textsf{constant}, \textsf{constant}) $\rightarrow$ \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr1} and \emph{expr2} represent constant expressions \end{itemize} \noindent Description: \begin{itemize} \item The operator \textbf{$>=$} evaluates to true iff its operands \emph{expr1} and \emph{expr2} evaluate to two floating-point numbers $a_1$ respectively $a_2$ with the global precision \textbf{prec} and $a_1$ is greater than or equal to $a_2$. The user should be aware of the fact that because of floating-point evaluation, the operator \textbf{$>=$} is not exactly the same as the mathematical operation \emph{greater-than-or-equal-to}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 5 >= 4; true > 5 >= 5; true > 5 >= 6; false > exp(2) >= exp(1); true > log(1) >= exp(2); false \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec = 12; The precision has been set to 12 bits. > 16384.1 >= 16385.1; true \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$==$} (\ref{labequal}), \textbf{!$=$} (\ref{labneq}), \textbf{$>$} (\ref{labgt}), \textbf{$<=$} (\ref{lable}), \textbf{$<$} (\ref{lablt}), \textbf{in} (\ref{labin}), \textbf{!} (\ref{labnot}), \textbf{$\&\&$} (\ref{laband}), \textbf{$||$} (\ref{labor}), \textbf{prec} (\ref{labprec}), \textbf{max} (\ref{labmax}), \textbf{min} (\ref{labmin}) sollya-6.0+ds/doc/getbacktrace.tex000066400000000000000000000063041300174114700171730ustar00rootroot00000000000000\subsection{getbacktrace} \label{labgetbacktrace} \noindent Name: \textbf{getbacktrace}\\ \phantom{aaa}returns the list of \sollya procedures currently run\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_getbacktrace();|\\[0.2cm] \noindent Usage: \begin{center} \textbf{getbacktrace}() : \textsf{void} $\rightarrow$ \textsf{list}\\ \end{center} \noindent Description: \begin{itemize} \item The \textbf{getbacktrace} command allows the stack of \sollya procedures that are currently run to be inspected. When called, \textbf{getbacktrace} returns an ordered list of structures, each of which contains an element \verb|passed_args| and an element \verb|called_proc|. The element \verb|called_proc| contains the \sollya object representing the procedure being run. The element \verb|passed_args| contains an ordered list of all effective arguments passed to the procedure when it was called. The procedure called last (\emph{i.e.}, on top of the stack) comes first in the list returned by \textbf{getbacktrace}. When any of the procedure called takes no arguments, the \verb|passed_args| element of the corresponding structure evaluates to an empty list. \item When called from outside any procedure (at toplevel), \textbf{getbacktrace} returns an empty list. \item When called for a stack containing a call to a variadic procedure that was called with an infinite number of effective arguments, the corresponding \verb|passed_args| element evaluates to an end-elliptic list. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure testA() { "Current backtrace:"; getbacktrace(); }; > procedure testB(X) { "X = ", X; testA(); }; > procedure testC(X, Y) { "X = ", X, ", Y = ", Y; testB(Y); }; > testC(17, 42); X = 17, Y = 42 X = 42 Current backtrace: [|{ .passed_args = [| |], .called_proc = proc() { "Current backtrace:"; getbacktrace(); return void; } }, { .passed_args = [|42|], .called_proc = proc(X) { "X = ", X; testA(); return void; } }, { .passed_args = [|17, 42|], .called_proc = proc(X, Y) { "X = ", X, ", Y = ", Y; testB(Y); return void; } }|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > getbacktrace(); [| |] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure printnumargs(X) { var L, t; "number of arguments: ", X; L = getbacktrace(); "Backtrace:"; for t in L do { " " @ objectname(t.called_proc) @ ", ", t.passed_args; }; }; > procedure numargs(l = ...) { "l[17] = ", l[17]; printnumargs(length(l)); }; > procedure test() { numargs @ [|25, 26, 27 ...|]; }; > test(); l[17] = 42 number of arguments: infty Backtrace: printnumargs, [|infty|] numargs, [|25, 26, 27...|] test, [| |] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{proc} (\ref{labproc}), \textbf{procedure} (\ref{labprocedure}), \textbf{objectname} (\ref{labobjectname}), \textbf{bind} (\ref{labbind}), \textbf{@} (\ref{labconcat}) sollya-6.0+ds/doc/getsuppressedmessages.tex000066400000000000000000000064331300174114700212040ustar00rootroot00000000000000\subsection{getsuppressedmessages} \label{labgetsuppressedmessages} \noindent Name: \textbf{getsuppressedmessages}\\ \phantom{aaa}returns a list of numbers of messages that have been suppressed from message output\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_getsuppressedmessages();|\\[0.2cm] \noindent Usage: \begin{center} \textbf{getsuppressedmessages}() : \textsf{void} $\rightarrow$ \textsf{list}\\ \end{center} \noindent Description: \begin{itemize} \item The \textbf{getsuppressedmessages} command allows the user to inspect the state of warning and information message suppression. When called, \textbf{getsuppressedmessages} returns a list of integers numbers that stand for the warning and information messages that have been suppressed. If no message is suppressed, \textbf{getsuppressedmessages} returns an empty list. \item Every \sollya warning or information message (that is not fatal to the tool's execution) has a message number. By default, these numbers are not displayed when a message is output. When message number displaying is activated using \textbf{showmessagenumbers}, the message numbers are displayed together with the message. This allows the user to match the numbers returned in a list by \textbf{getsuppressedmessages} with the actual warning and information messages. \item The list of message numbers returned by \textbf{getsuppressedmessages} is suitable to be fed into the \textbf{unsuppressmessage} command. This way, the user may unsuppress all warning and information messages that have been suppressed. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1; The verbosity level has been set to 1. > 0.1; Warning: Rounding occurred when converting the constant "0.1" to floating-point with 165 bits. If safe computation is needed, try to increase the precision. 0.1 > suppressmessage(174); > 0.1; 0.1 > suppressmessage(407); > 0.1; 0.1 > getsuppressedmessages(); [|174, 407|] > suppressmessage(207, 196); > getsuppressedmessages(); [|174, 196, 207, 407|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > suppressmessage(174, 209, 13, 24, 196); > suppressmessage([| 16, 17 |]); > suppressmessage(19); > unsuppressmessage([| 13, 17 |]); > getsuppressedmessages(); [|16, 19, 24, 174, 196, 209|] > unsuppressmessage(getsuppressedmessages()); > getsuppressedmessages(); [| |] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 12; The verbosity level has been set to 12. > suppressmessage(174); > exp(x * 0.1); Information: no Horner simplification will be performed because the given tree i s already in Horner form. exp(x * 0.1) > getsuppressedmessages(); [|174|] > verbosity = 0; The verbosity level has been set to 0. > exp(x * 0.1); exp(x * 0.1) > getsuppressedmessages(); [|174|] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{getsuppressedmessages} (\ref{labgetsuppressedmessages}), \textbf{suppressmessage} (\ref{labsuppressmessage}), \textbf{unsuppressmessage} (\ref{labunsuppressmessage}), \textbf{verbosity} (\ref{labverbosity}), \textbf{roundingwarnings} (\ref{labroundingwarnings}) sollya-6.0+ds/doc/gt.tex000066400000000000000000000033461300174114700151710ustar00rootroot00000000000000\subsection{$>$} \label{labgt} \noindent Name: \textbf{$>$}\\ \phantom{aaa}greater-than operator\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_cmp_greater(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \emph{expr1} \textbf{$>$} \emph{expr2} : (\textsf{constant}, \textsf{constant}) $\rightarrow$ \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr1} and \emph{expr2} represent constant expressions \end{itemize} \noindent Description: \begin{itemize} \item The operator \textbf{$>$} evaluates to true iff its operands \emph{expr1} and \emph{expr2} evaluate to two floating-point numbers $a_1$ respectively $a_2$ with the global precision \textbf{prec} and $a_1$ is greater than $a_2$. The user should be aware of the fact that because of floating-point evaluation, the operator \textbf{$>$} is not exactly the same as the mathematical operation \emph{greater-than}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 5 > 4; true > 5 > 5; false > 5 > 6; false > exp(2) > exp(1); true > log(1) > exp(2); false \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec = 12; The precision has been set to 12 bits. > 16385.1 > 16384.1; false \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$==$} (\ref{labequal}), \textbf{!$=$} (\ref{labneq}), \textbf{$>=$} (\ref{labge}), \textbf{$<=$} (\ref{lable}), \textbf{$<$} (\ref{lablt}), \textbf{in} (\ref{labin}), \textbf{!} (\ref{labnot}), \textbf{$\&\&$} (\ref{laband}), \textbf{$||$} (\ref{labor}), \textbf{prec} (\ref{labprec}), \textbf{max} (\ref{labmax}), \textbf{min} (\ref{labmin}) sollya-6.0+ds/doc/guessdegree.tex000066400000000000000000000061031300174114700170530ustar00rootroot00000000000000\subsection{guessdegree} \label{labguessdegree} \noindent Name: \textbf{guessdegree}\\ \phantom{aaa}returns the minimal degree needed for a polynomial to approximate a function with a certain error on an interval.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_guessdegree(sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, ...)|\\ \verb| sollya_obj_t sollya_lib_v_guessdegree(sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, va_list)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{guessdegree}(\emph{f},\emph{I},\emph{eps},\emph{w},\emph{bound}) : (\textsf{function}, \textsf{range}, \textsf{constant}, \textsf{function}, \textsf{constant}) $\rightarrow$ \textsf{range}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is the function to be approximated. \item \emph{I} is the interval where the function must be approximated. \item \emph{eps} is the maximal acceptable error. \item \emph{w} (optional) is a weight function. Default is 1. \item \emph{bound} (optional) is a bound on the degree. Default is currently 128. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{guessdegree} tries to find the minimal degree needed to approximate \emph{f} on \emph{I} by a polynomial with an error $\epsilon=p w - f$ whose infinity norm not greater than \emph{eps}. More precisely, it finds $n$ minimal such that there exists a polynomial $p$ of degree $n$ such that $\|p w-f\|_{\infty} < \mathrm{eps}$. \item \textbf{guessdegree} returns an interval: for common cases, this interval is reduced to a single number (i.e. the minimal degree). But in certain cases, \textbf{guessdegree} does not succeed in finding the minimal degree. In such cases the returned interval is of the form $[n,\,p]$ such that: \begin{itemize} \item no polynomial of degree $n-1$ gives an error less than \emph{eps}. \item there exists a polynomial of degree $p$ giving an error less than \emph{eps}. \end{itemize} \item The fifth optional argument \emph{bound} is used to prevent \textbf{guessdegree} from trying to find too large degrees. If \textbf{guessdegree} does not manage to find a degree $n$ satisfying the error and such that $n \le \textrm{bound}$, an interval of the form $[\cdot,\,+\infty]$ is returned. Note that \emph{bound} must be a positive integer. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > guessdegree(exp(x),[-1;1],1e-10); [10;10] \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > guessdegree(exp(x),[-1;1],1e-10,default, 9); [10;infty] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > guessdegree(1, [-1;1], 1e-8, 1/exp(x)); [8;9] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{dirtyinfnorm} (\ref{labdirtyinfnorm}), \textbf{remez} (\ref{labremez}), \textbf{fpminimax} (\ref{labfpminimax}), \textbf{degree} (\ref{labdegree}) sollya-6.0+ds/doc/halfprecision.tex000066400000000000000000000036501300174114700174030ustar00rootroot00000000000000\subsection{halfprecision} \label{labhalfprecision} \noindent Names: \textbf{halfprecision}, \textbf{HP}\\ \phantom{aaa}rounding to the nearest IEEE 754 half-precision number (binary16).\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_halfprecision(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_halfprecision_obj()|\\ \verb| int sollya_lib_is_halfprecision_obj(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_halfprecision(sollya_obj_t)|\\ \verb| #define SOLLYA_HP(x) sollya_lib_build_function_halfprecision(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{halfprecision} is both a function and a constant. \item As a function, it rounds its argument to the nearest IEEE 754 half-precision (i.e. IEEE754-2008 binary16) number. Subnormal numbers are supported as well as standard numbers: it is the real rounding described in the standard. \item As a constant, it symbolizes the half-precision format. It is used in contexts when a precision format is necessary, e.g. in the commands \textbf{round} and \textbf{roundcoefficients}. It is not supported for \textbf{implementpoly}. See the corresponding help pages for examples. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > HP(0.1); 1.100110011_2 * 2^(-4) > HP(4.17); 1.00001011_2 * 2^(2) > HP(1.011_2 * 2^(-23)); 1.1_2 * 2^(-23) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{single} (\ref{labsingle}), \textbf{double} (\ref{labdouble}), \textbf{doubleextended} (\ref{labdoubleextended}), \textbf{doubledouble} (\ref{labdoubledouble}), \textbf{quad} (\ref{labquad}), \textbf{tripledouble} (\ref{labtripledouble}), \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{fpminimax} (\ref{labfpminimax}), \textbf{implementpoly} (\ref{labimplementpoly}), \textbf{round} (\ref{labround}), \textbf{printsingle} (\ref{labprintsingle}) sollya-6.0+ds/doc/head.tex000066400000000000000000000015111300174114700154500ustar00rootroot00000000000000\subsection{head} \label{labhead} \noindent Name: \textbf{head}\\ \phantom{aaa}gives the first element of a list.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_head(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{head}(\emph{L}) : \textsf{list} $\rightarrow$ \textsf{any type}\\ \end{center} Parameters: \begin{itemize} \item \emph{L} is a list. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{head}(\emph{L}) returns the first element of the list \emph{L}. It is equivalent to L[0]. \item If \emph{L} is empty, the command will fail with an error. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > head([|1,2,3|]); 1 > head([|1,2...|]); 1 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{tail} (\ref{labtail}) sollya-6.0+ds/doc/hexadecimal.tex000066400000000000000000000015221300174114700170150ustar00rootroot00000000000000\subsection{hexadecimal} \label{labhexadecimal} \noindent Name: \textbf{hexadecimal}\\ \phantom{aaa}special value for global state \textbf{display}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_hexadecimal()|\\ \verb| int sollya_lib_is_hexadecimal(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{hexadecimal} is a special value used for the global state \textbf{display}. If the global state \textbf{display} is equal to \textbf{hexadecimal}, all data will be output in hexadecimal C99/ IEEE 754-2008 notation. As any value it can be affected to a variable and stored in lists. \end{itemize} See also: \textbf{decimal} (\ref{labdecimal}), \textbf{dyadic} (\ref{labdyadic}), \textbf{powers} (\ref{labpowers}), \textbf{binary} (\ref{labbinary}), \textbf{display} (\ref{labdisplay}) sollya-6.0+ds/doc/honorcoeffprec.tex000066400000000000000000000043421300174114700175560ustar00rootroot00000000000000\subsection{honorcoeffprec} \label{labhonorcoeffprec} \noindent Name: \textbf{honorcoeffprec}\\ \phantom{aaa}indicates the (forced) honoring the precision of the coefficients in \textbf{implementpoly}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_honorcoeffprec()|\\ \verb| int sollya_lib_is_honorcoeffprec(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{honorcoeffprec} : \textsf{honorcoeffprec}\\ \end{center} \noindent Description: \begin{itemize} \item Used with command \textbf{implementpoly}, \textbf{honorcoeffprec} makes \textbf{implementpoly} honor the precision of the given polynomial. This means if a coefficient needs a double-double or a triple-double to be exactly stored, \textbf{implementpoly} will allocate appropriate space and use a double-double or triple-double operation even if the automatic (heuristic) determination implemented in command \textbf{implementpoly} indicates that the coefficient could be stored on less precision or, respectively, the operation could be performed with less precision. See \textbf{implementpoly} for details. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > q = implementpoly(1 - dirtysimplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,"p" ,"implementation.c"); Warning: at least one of the coefficients of the given polynomial has been round ed in a way that the target precision can be achieved at lower cost. Nevertheless, the imple mented polynomial is different from the given one. > printexpansion(q); 0x3ff0000000000000 + x^2 * 0xbfc5555555555555 > r = implementpoly(1 - dirtysimplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,"p" ,"implementation.c",honorcoeffprec); Warning: the inferred precision of the 2th coefficient of the polynomial is grea ter than the necessary precision computed for this step. This may make the automatic dete rmination of precisions useless. > printexpansion(r); 0x3ff0000000000000 + x^2 * (0xbfc5555555555555 + 0xbc65555555555555 + 0xb9055555 55555555) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{implementpoly} (\ref{labimplementpoly}), \textbf{printexpansion} (\ref{labprintexpansion}), \textbf{fpminimax} (\ref{labfpminimax}) sollya-6.0+ds/doc/hopitalrecursions.tex000066400000000000000000000050251300174114700203300ustar00rootroot00000000000000\subsection{hopitalrecursions} \label{labhopitalrecursions} \noindent Name: \textbf{hopitalrecursions}\\ \phantom{aaa}controls the number of recursion steps when applying L'Hopital's rule.\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_hopitalrecursions_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_hopitalrecursions(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_hopitalrecursions()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{hopitalrecursions} = \emph{n} : \textsf{integer} $\rightarrow$ \textsf{void}\\ \textbf{hopitalrecursions} = \emph{n} ! : \textsf{integer} $\rightarrow$ \textsf{void}\\ \textbf{hopitalrecursions} : \textsf{integer}\\ \end{center} Parameters: \begin{itemize} \item \emph{n} represents the number of recursions \end{itemize} \noindent Description: \begin{itemize} \item \textbf{hopitalrecursions} is a global variable. Its value represents the number of steps of recursion that are tried when applying L'Hopital's rule. This rule is applied by the interval evaluator present in the core of \sollya (and particularly visible in commands like \textbf{infnorm}). \item If an expression of the form $f/g$ has to be evaluated by interval arithmetic on an interval $I$ and if $f$ and $g$ have a common zero in $I$, a direct evaluation leads to NaN. \sollya implements a safe heuristic to avoid this, based on L'Hopital's rule: in such a case, it can be shown that $(f/g)(I) \subseteq (f'/g')(I)$. Since the same problem may exist for $f'/g'$, the rule is applied recursively. The number of step in this recursion process is controlled by \textbf{hopitalrecursions}. \item Setting \textbf{hopitalrecursions} to 0 makes \sollya use this rule only once; setting it to 1 makes \sollya use the rule twice, and so on. In particular: the rule is always applied at least once, if necessary. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > hopitalrecursions=0; The number of recursions for Hopital's rule has been set to 0. > evaluate(log(1+x)^2/x^2,[-1/2; 1]); [-infty;infty] > hopitalrecursions=1; The number of recursions for Hopital's rule has been set to 1. > evaluate(log(1+x)^2/x^2,[-1/2; 1]); [-2.5225887222397812376689284858327062723020005374411;6.772588722239781237668928 4858327062723020005374412] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{taylorrecursions} (\ref{labtaylorrecursions}), \textbf{infnorm} (\ref{labinfnorm}), \textbf{findzeros} (\ref{labfindzeros}), \textbf{evaluate} (\ref{labevaluate}) sollya-6.0+ds/doc/horner.tex000066400000000000000000000034171300174114700160530ustar00rootroot00000000000000\subsection{horner} \label{labhorner} \noindent Name: \textbf{horner}\\ \phantom{aaa}brings all polynomial subexpressions of an expression to Horner form\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_horner(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{horner}(\emph{function}) : \textsf{function} $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents the expression to be rewritten in Horner form \end{itemize} \noindent Description: \begin{itemize} \item The command \textbf{horner} rewrites the expression representing the function \emph{function} in a way such that all polynomial subexpressions (or the whole expression itself, if it is a polynomial) are written in Horner form. The command \textbf{horner} does not endanger the safety of computations even in \sollya's floating-point environment: the function returned is mathematically equal to the function \emph{function}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(horner(1 + 2 * x + 3 * x^2)); 1 + x * (2 + x * 3) > print(horner((x + 1)^7)); 1 + x * (7 + x * (21 + x * (35 + x * (35 + x * (21 + x * (7 + x)))))) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(horner(exp((x + 1)^5) - log(asin(x + x^3) + x))); exp(1 + x * (5 + x * (10 + x * (10 + x * (5 + x))))) - log(asin(x * (1 + x^2)) + x) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{canonical} (\ref{labcanonical}), \textbf{print} (\ref{labprint}), \textbf{coeff} (\ref{labcoeff}), \textbf{degree} (\ref{labdegree}), \textbf{autosimplify} (\ref{labautosimplify}), \textbf{simplify} (\ref{labsimplify}) sollya-6.0+ds/doc/hp.tex000066400000000000000000000002621300174114700151600ustar00rootroot00000000000000\subsection{HP} \label{labhp} \noindent Name: \textbf{HP}\\ \phantom{aaa}short form for \textbf{halfprecision}\\[0.2cm] See also: \textbf{halfprecision} (\ref{labhalfprecision}) sollya-6.0+ds/doc/implementconstant.tex000066400000000000000000000243301300174114700203170ustar00rootroot00000000000000\subsection{implementconstant} \label{labimplementconstant} \noindent Name: \textbf{implementconstant}\\ \phantom{aaa}implements a constant in arbitrary precision\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_implementconstant(sollya_obj_t, ...);|\\ \verb| void sollya_lib_v_implementconstant(sollya_obj_t, va_list);|\\[0.2cm] \noindent Usage: \begin{center} \textbf{implementconstant}(\emph{expr}) : \textsf{constant} $\rightarrow$ \textsf{void}\\ \textbf{implementconstant}(\emph{expr},\emph{filename}) : (\textsf{constant}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \textbf{implementconstant}(\emph{expr},\emph{filename},\emph{functionname}) : (\textsf{constant}, \textsf{string}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \end{center} \noindent Description: \begin{itemize} \item The command \textbf{implementconstant} implements the constant expression \emph{expr} in arbitrary precision. More precisely, it generates the source code (written in C, and using MPFR) of a C function \texttt{const\_something} with the following signature: \begin{center} \texttt{void const\_something (mpfr\_ptr y, mp\_prec\_t prec)} \end{center} Let us denote by $c$ the exact mathematical value of the constant defined by the expression \emph{expr}. When called with arguments $y$ and prec (where the variable $y$ is supposed to be already initialized), the function \texttt{mpfr\_const\_something} sets the precision of $y$ to a suitable precision and stores in it an approximate value of $c$ such that $$|y-c| \le |c|\,2^{1-\mathrm{prec}}.$$ \item When no filename \emph{filename} is given or if \textbf{default} is given as \emph{filename}, the source code produced by \textbf{implementconstant} is printed on standard output. Otherwise, when \emph{filename} is given as a string of characters, the source code is output to a file named \emph{filename}. If that file cannot be opened and/or written to, \textbf{implementconstant} fails and has no other effect. \item When \emph{functionname} is given as an argument to \textbf{implementconstant} and \emph{functionname} evaluates to a string of characters, the default name for the C function \texttt{const\_something} is replaced by \emph{functionname}. When \textbf{default} is given as \emph{functionname}, the default name is used nevertheless, as if no \emph{functionname} argument were given. When choosing a character sequence for \emph{functionname}, the user should keep attention to the fact that \emph{functionname} must be a valid C identifier in order to enable error-free compilation of the produced code. \item If \emph{expr} refers to a constant defined with \textbf{libraryconstant}, the produced code uses the external code implementing this constant. The user should keep in mind that it is up to them to make sure the symbol for that external code can get resolved when the newly generated code is to be loaded. \item If a subexpression of \emph{expr} evaluates to $0$, \textbf{implementconstant} will most likely fail with an error message. \item \textbf{implementconstant} is unable to implement constant expressions \emph{expr} that contain procedure-based functions, i.e. functions created from \sollya procedures using the \textbf{function} construct. If \emph{expr} contains such a procedure-based function, \textbf{implementconstant} prints a warning and fails silently. The reason for this lack of functionality is that the produced C source code, which is supposed to be compiled, would have to call back to the \sollya interpreter in order to evaluate the procedure-based function. \item Similarly, \textbf{implementconstant} is currently unable to implement constant expressions \emph{expr} that contain library-based functions, i.e. functions dynamically bound to \sollya using the \textbf{library} construct. If \emph{expr} contains such a library-based function, \textbf{implementconstant} prints a warning and fails silently. Support for this feature is in principle feasible from a technical standpoint and might be added in a future release of \sollya. \item Currently, non-differentiable functions such as \textbf{double}, \textbf{doubledouble}, \textbf{tripledouble}, \textbf{single}, \textbf{halfprecision}, \textbf{quad}, \textbf{doubleextended}, \textbf{floor}, \textbf{ceil}, \textbf{nearestint} are not supported by \textbf{implementconstant}. If \textbf{implementconstant} encounters one of them, a warning message is displayed and no code is produced. However, if \textbf{autosimplify} equals on, it is possible that \sollya silently simplifies subexpressions of \emph{expr} containing such functions and that \textbf{implementconstant} successfully produces code for evaluating \emph{expr}. \item While it produces an MPFR-based C source code for \emph{expr}, \textbf{implementconstant} takes architectural and system-dependent parameters into account. For example, it checks whether literal constants figuring in \emph{expr} can be represented on a C \texttt{long int} type or if they must be stored in a different manner not to affect their accuracy. These tests, performed by \sollya during execution of \textbf{implementconstant}, depend themselves on the architecture \sollya is running on. Users should keep this matter in mind, especially when trying to compile source code on one machine whilst it has been produced on another. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single,commandchars=\\\|\~] > implementconstant(exp(1)+log(2)/sqrt(1/10)); \alert|\textrm|\emph|[ The first 100 lines of the output have been removed ]~~~ #include void const_something (mpfr_ptr y, mp_prec_t prec) { /* Declarations */ mpfr_t tmp1; mpfr_t tmp2; mpfr_t tmp3; mpfr_t tmp4; mpfr_t tmp5; mpfr_t tmp6; mpfr_t tmp7; /* Initializations */ mpfr_init2 (tmp2, prec+5); mpfr_init2 (tmp1, prec+3); mpfr_init2 (tmp4, prec+8); mpfr_init2 (tmp3, prec+7); mpfr_init2 (tmp6, prec+11); mpfr_init2 (tmp7, prec+11); mpfr_init2 (tmp5, prec+11); /* Core */ mpfr_set_prec (tmp2, prec+4); mpfr_set_ui (tmp2, 1, MPFR_RNDN); mpfr_set_prec (tmp1, prec+3); mpfr_exp (tmp1, tmp2, MPFR_RNDN); mpfr_set_prec (tmp4, prec+8); mpfr_set_ui (tmp4, 2, MPFR_RNDN); mpfr_set_prec (tmp3, prec+7); mpfr_log (tmp3, tmp4, MPFR_RNDN); mpfr_set_prec (tmp6, prec+11); mpfr_set_ui (tmp6, 1, MPFR_RNDN); mpfr_set_prec (tmp7, prec+11); mpfr_set_ui (tmp7, 10, MPFR_RNDN); mpfr_set_prec (tmp5, prec+11); mpfr_div (tmp5, tmp6, tmp7, MPFR_RNDN); mpfr_set_prec (tmp4, prec+7); mpfr_sqrt (tmp4, tmp5, MPFR_RNDN); mpfr_set_prec (tmp2, prec+5); mpfr_div (tmp2, tmp3, tmp4, MPFR_RNDN); mpfr_set_prec (y, prec+3); mpfr_add (y, tmp1, tmp2, MPFR_RNDN); /* Cleaning stuff */ mpfr_clear(tmp1); mpfr_clear(tmp2); mpfr_clear(tmp3); mpfr_clear(tmp4); mpfr_clear(tmp5); mpfr_clear(tmp6); mpfr_clear(tmp7); } \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single,commandchars=\\\|\~] > implementconstant(sin(13/17),"sine_of_thirteen_seventeenth.c"); > bashevaluate("tail -n 30 sine_of_thirteen_seventeenth.c"); #include void const_something (mpfr_ptr y, mp_prec_t prec) { /* Declarations */ mpfr_t tmp1; mpfr_t tmp2; mpfr_t tmp3; /* Initializations */ mpfr_init2 (tmp2, prec+6); mpfr_init2 (tmp3, prec+6); mpfr_init2 (tmp1, prec+6); /* Core */ mpfr_set_prec (tmp2, prec+6); mpfr_set_ui (tmp2, 13, MPFR_RNDN); mpfr_set_prec (tmp3, prec+6); mpfr_set_ui (tmp3, 17, MPFR_RNDN); mpfr_set_prec (tmp1, prec+6); mpfr_div (tmp1, tmp2, tmp3, MPFR_RNDN); mpfr_set_prec (y, prec+2); mpfr_sin (y, tmp1, MPFR_RNDN); /* Cleaning stuff */ mpfr_clear(tmp1); mpfr_clear(tmp2); mpfr_clear(tmp3); } \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single,commandchars=\\\|\~] > implementconstant(asin(1/3 * pi),default,"arcsin_of_one_third_pi"); \alert|\textrm|\emph|[ The first 100 lines of the output have been removed ]~~~ #include void arcsin_of_one_third_pi (mpfr_ptr y, mp_prec_t prec) { /* Declarations */ mpfr_t tmp1; mpfr_t tmp2; mpfr_t tmp3; /* Initializations */ mpfr_init2 (tmp2, prec+8); mpfr_init2 (tmp3, prec+8); mpfr_init2 (tmp1, prec+8); /* Core */ mpfr_set_prec (tmp2, prec+8); mpfr_const_pi (tmp2, MPFR_RNDN); mpfr_set_prec (tmp3, prec+8); mpfr_set_ui (tmp3, 3, MPFR_RNDN); mpfr_set_prec (tmp1, prec+8); mpfr_div (tmp1, tmp2, tmp3, MPFR_RNDN); mpfr_set_prec (y, prec+2); mpfr_asin (y, tmp1, MPFR_RNDN); /* Cleaning stuff */ mpfr_clear(tmp1); mpfr_clear(tmp2); mpfr_clear(tmp3); } \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single,commandchars=\\\|\~] > implementconstant(ceil(log(19 + 1/3)),"constant_code.c","magic_constant"); > bashevaluate("tail -n -9 constant_code.c"); void magic_constant (mpfr_ptr y, mp_prec_t prec) { /* Initializations */ /* Core */ mpfr_set_prec (y, prec); mpfr_set_ui (y, 3, MPFR_RNDN); } \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single,commandchars=\\\|\~] > bashexecute("gcc -fPIC -Wall -c libraryconstantexample.c -I$HOME/.local/includ e"); > bashexecute("gcc -shared -o libraryconstantexample libraryconstantexample.o -l gmp -lmpfr"); > euler_gamma = libraryconstant("./libraryconstantexample"); > implementconstant(euler_gamma^(1/3), "euler.c"); > bashevaluate("tail -n -17 euler.c"); void const_something (mpfr_ptr y, mp_prec_t prec) { /* Declarations */ mpfr_t tmp1; /* Initializations */ mpfr_init2 (tmp1, prec+1); /* Core */ euler_gamma (tmp1, prec+1); mpfr_set_prec (y, prec+2); mpfr_root (y, tmp1, 3, MPFR_RNDN); /* Cleaning stuff */ mpfr_clear(tmp1); } \end{Verbatim} \end{minipage}\end{center} See also: \textbf{implementpoly} (\ref{labimplementpoly}), \textbf{libraryconstant} (\ref{lablibraryconstant}), \textbf{library} (\ref{lablibrary}), \textbf{function} (\ref{labfunction}), \textbf{bashevaluate} (\ref{labbashevaluate}) sollya-6.0+ds/doc/implementpoly.tex000066400000000000000000000242631300174114700174560ustar00rootroot00000000000000\subsection{implementpoly} \label{labimplementpoly} \noindent Name: \textbf{implementpoly}\\ \phantom{aaa}implements a polynomial using double, double-double and triple-double arithmetic and generates a Gappa proof\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_implementpoly(sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t, ...)|\\ \verb| sollya_obj_t sollya_lib_v_implementpoly(sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t, va_list)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{implementpoly}(\emph{polynomial}, \emph{range}, \emph{error bound}, \emph{format}, \emph{functionname}, \emph{filename}) : (\textsf{function}, \textsf{range}, \textsf{constant}, \textsf{D$|$double$|$DD$|$doubledouble$|$TD$|$tripledouble}, \textsf{string}, \textsf{string}) $\rightarrow$ \textsf{function}\\ \textbf{implementpoly}(\emph{polynomial}, \emph{range}, \emph{error bound}, \emph{format}, \emph{functionname}, \emph{filename}, \emph{honor coefficient precisions}) : (\textsf{function}, \textsf{range}, \textsf{constant}, \textsf{D$|$double$|$DD$|$doubledouble$|$TD$|$tripledouble}, \textsf{string}, \textsf{string}, \textsf{honorcoeffprec}) $\rightarrow$ \textsf{function}\\ \textbf{implementpoly}(\emph{polynomial}, \emph{range}, \emph{error bound}, \emph{format}, \emph{functionname}, \emph{filename}, \emph{proof filename}) : (\textsf{function}, \textsf{range}, \textsf{constant}, \textsf{D$|$double$|$DD$|$doubledouble$|$TD$|$tripledouble}, \textsf{string}, \textsf{string}, \textsf{string}) $\rightarrow$ \textsf{function}\\ \textbf{implementpoly}(\emph{polynomial}, \emph{range}, \emph{error bound}, \emph{format}, \emph{functionname}, \emph{filename}, \emph{honor coefficient precisions}, \emph{proof filename}) : (\textsf{function}, \textsf{range}, \textsf{constant}, \textsf{D$|$double$|$DD$|$doubledouble$|$TD$|$tripledouble}, \textsf{string}, \textsf{string}, \textsf{honorcoeffprec}, \textsf{string}) $\rightarrow$ \textsf{function}\\ \end{center} \noindent Description: \begin{itemize} \item The command \textbf{implementpoly} implements the polynomial \emph{polynomial} in range \emph{range} as a function called \emph{functionname} in \texttt{C} code using double, double-double and triple-double arithmetic in a way that the rounding error (estimated at its first order) is bounded by \emph{error bound}. The produced code is output in a file named \emph{filename}. The argument \emph{format} indicates the double, double-double or triple-double format of the variable in which the polynomial varies, influencing also in the signature of the \texttt{C} function. If a seventh or eighth argument \emph{proof filename} is given and if this argument evaluates to a variable of type \textsf{string}, the command \textbf{implementpoly} will produce a \texttt{Gappa} proof that the rounding error is less than the given bound. This proof will be output in \texttt{Gappa} syntax in a file name \emph{proof filename}. The command \textbf{implementpoly} returns the polynomial that has been implemented. As the command \textbf{implementpoly} tries to adapt the precision needed in each evaluation step to its strict minimum and as it applies renormalization to double-double and triple-double precision coefficients to bring them to a round-to-nearest expansion form, the returned polynomial may differ from the polynomial \emph{polynomial}. Nevertheless the difference will be small enough that the rounding error bound with regard to the polynomial \emph{polynomial} (estimated at its first order) will be less than the given error bound. If a seventh argument \emph{honor coefficient precisions} is given and evaluates to a variable \textbf{honorcoeffprec} of type \textsf{honorcoeffprec}, \textbf{implementpoly} will honor the precision of the given polynomial \emph{polynomials}. This means if a coefficient needs a double-double or a triple-double to be exactly stored, \textbf{implementpoly} will allocate appropriate space and use a double-double or triple-double operation even if the automatic (heuristic) determination implemented in command \textbf{implementpoly} indicates that the coefficient could be stored on less precision or, respectively, the operation could be performed with less precision. The use of \textbf{honorcoeffprec} has advantages and disadvantages. If the polynomial \emph{polynomial} given has not been determined by a process considering directly polynomials with floating-point coefficients, \textbf{honorcoeffprec} should not be indicated. The \textbf{implementpoly} command can then determine the needed precision using the same error estimation as used for the determination of the precisions of the operations. Generally, the coefficients will get rounded to double, double-double and triple-double precision in a way that minimizes their number and respects the rounding error bound \emph{error bound}. Indicating \textbf{honorcoeffprec} may in this case short-circuit most precision estimations leading to sub-optimal code. On the other hand, if the polynomial \emph{polynomial} has been determined with floating-point precisions in mind, \textbf{honorcoeffprec} should be indicated because such polynomials often are very sensitive in terms of error propagation with regard to their coefficients' values. Indicating \textbf{honorcoeffprec} prevents the \textbf{implementpoly} command from rounding the coefficients and altering by many orders of magnitude the approximation error of the polynomial with regard to the function it approximates. The implementer behind the \textbf{implementpoly} command makes some assumptions on its input and verifies them. If some assumption cannot be verified, the implementation will not succeed and \textbf{implementpoly} will evaluate to a variable \textbf{error} of type \textsf{error}. The same behaviour is observed if some file is not writable or some other side-effect fails, e.g. if the implementer runs out of memory. As error estimation is performed only on the first order, the code produced by the \textbf{implementpoly} command should be considered valid iff a \texttt{Gappa} proof has been produced and successfully run in \texttt{Gappa}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > implementpoly(1 - 1/6 * x^2 + 1/120 * x^4, [-1b-10;1b-10], 1b-30, D, "p","impl ementation.c"); 1 + x^2 * (-0.166666666666666657414808128123695496469736099243164 + x^2 * 8.3333 333333333332176851016015461937058717012405396e-3) > bashevaluate("tail -n -29 implementation.c"); #define p_coeff_0h 1.00000000000000000000000000000000000000000000000000000000000 000000000000000000000e+00 #define p_coeff_2h -1.6666666666666665741480812812369549646973609924316406250000 0000000000000000000000e-01 #define p_coeff_4h 8.33333333333333321768510160154619370587170124053955078125000 000000000000000000000e-03 void p(double *p_resh, double x) { double p_x_0_pow2h; p_x_0_pow2h = x * x; double p_t_1_0h; double p_t_2_0h; double p_t_3_0h; double p_t_4_0h; double p_t_5_0h; p_t_1_0h = p_coeff_4h; p_t_2_0h = p_t_1_0h * p_x_0_pow2h; p_t_3_0h = p_coeff_2h + p_t_2_0h; p_t_4_0h = p_t_3_0h * p_x_0_pow2h; p_t_5_0h = p_coeff_0h + p_t_4_0h; *p_resh = p_t_5_0h; } \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > implementpoly(1 - 1/6 * x^2 + 1/120 * x^4, [-1b-10;1b-10], 1b-30, D, "p","impl ementation.c","implementation.gappa"); 1 + x^2 * (-0.166666666666666657414808128123695496469736099243164 + x^2 * 8.3333 333333333332176851016015461937058717012405396e-3) \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > q = implementpoly(1 - dirtysimplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,"p" ,"implementation.c"); Warning: at least one of the coefficients of the given polynomial has been round ed in a way that the target precision can be achieved at lower cost. Nevertheless, the imple mented polynomial is different from the given one. > printexpansion(q); 0x3ff0000000000000 + x^2 * 0xbfc5555555555555 > r = implementpoly(1 - dirtysimplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,"p" ,"implementation.c",honorcoeffprec); Warning: the inferred precision of the 2th coefficient of the polynomial is grea ter than the necessary precision computed for this step. This may make the automatic dete rmination of precisions useless. > printexpansion(r); 0x3ff0000000000000 + x^2 * (0xbfc5555555555555 + 0xbc65555555555555 + 0xb9055555 55555555) \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p = 0x3ff0000000000000 + x * (0x3ff0000000000000 + x * (0x3fe0000000000000 + x * (0x3fc5555555555559 + x * (0x3fa55555555555bd + x * (0x3f811111111106e2 + x * (0x3f56c16c16bf5eb7 + x * (0x3f2a01a01a292dcd + x * (0x3efa01a0218a016a + x * (0x3ec71de360331aad + x * (0x3e927e42e3823bf3 + x * (0x3e5ae6b2710c2c9a + x * (0x3e2203730c0a7c1d + x * 0x3de5da557e0781df)))))))))))); > q = implementpoly(p,[-1/2;1/2],1b-60,D,"p","implementation.c",honorcoeffprec," implementation.gappa"); > if (q != p) then print("During implementation, rounding has happened.") else p rint("Polynomial implemented as given."); Polynomial implemented as given. \end{Verbatim} \end{minipage}\end{center} See also: \textbf{honorcoeffprec} (\ref{labhonorcoeffprec}), \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{double} (\ref{labdouble}), \textbf{doubledouble} (\ref{labdoubledouble}), \textbf{tripledouble} (\ref{labtripledouble}), \textbf{bashevaluate} (\ref{labbashevaluate}), \textbf{printexpansion} (\ref{labprintexpansion}), \textbf{error} (\ref{laberror}), \textbf{remez} (\ref{labremez}), \textbf{fpminimax} (\ref{labfpminimax}), \textbf{taylor} (\ref{labtaylor}), \textbf{implementconstant} (\ref{labimplementconstant}) sollya-6.0+ds/doc/in.tex000066400000000000000000000040621300174114700151610ustar00rootroot00000000000000\subsection{in} \label{labin} \noindent Name: \textbf{in}\\ \phantom{aaa}containment test operator\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_cmp_in(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \emph{expr} \textbf{in} \emph{range1} : (\textsf{constant}, \textsf{range}) $\rightarrow$ \textsf{boolean}\\ \emph{range1} \textbf{in} \emph{range2} : (\textsf{range}, \textsf{range}) $\rightarrow$ \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr} represents a constant expression \item \emph{range1} and \emph{range2} represent ranges (intervals) \end{itemize} \noindent Description: \begin{itemize} \item When its first operand is a constant expression \emph{expr}, the operator \textbf{in} evaluates to true iff the constant value of the expression \emph{expr} is contained in the interval \emph{range1}. \item When both its operands are ranges (intervals), the operator \textbf{in} evaluates to true iff all values in \emph{range1} are contained in the interval \emph{range2}. \item \textbf{in} is also used as a keyword for loops over the different elements of a list. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 5 in [-4;7]; true > 4 in [-1;1]; false > 0 in sin([-17;17]); true \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [5;7] in [2;8]; true > [2;3] in [4;5]; false > [2;3] in [2.5;5]; false \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > for i in [|1,...,5|] do print(i); 1 2 3 4 5 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$==$} (\ref{labequal}), \textbf{!$=$} (\ref{labneq}), \textbf{$>=$} (\ref{labge}), \textbf{$>$} (\ref{labgt}), \textbf{$<=$} (\ref{lable}), \textbf{$<$} (\ref{lablt}), \textbf{!} (\ref{labnot}), \textbf{$\&\&$} (\ref{laband}), \textbf{$||$} (\ref{labor}), \textbf{prec} (\ref{labprec}), \textbf{print} (\ref{labprint}) sollya-6.0+ds/doc/inf.tex000066400000000000000000000026041300174114700153270ustar00rootroot00000000000000\subsection{inf} \label{labinf} \noindent Name: \textbf{inf}\\ \phantom{aaa}gives the lower bound of an interval.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_inf(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{inf}(\emph{I}) : \textsf{range} $\rightarrow$ \textsf{constant}\\ \textbf{inf}(\emph{x}) : \textsf{constant} $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{I} is an interval. \item \emph{x} is a real number. \end{itemize} \noindent Description: \begin{itemize} \item Returns the lower bound of the interval \emph{I}. Each bound of an interval has its own precision, so this command is exact, even if the current precision is too small to represent the bound. \item When called on a real number \emph{x}, \textbf{inf} behaves like the identity. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > inf([1;3]); 1 > inf(0); 0 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > I=[0.111110000011111_2; 1]; > inf(I); 1.11110000011111_2 * 2^(-1) > prec=12!; > inf(I); 1.11110000011111_2 * 2^(-1) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{mid} (\ref{labmid}), \textbf{sup} (\ref{labsup}), \textbf{max} (\ref{labmax}), \textbf{min} (\ref{labmin}) sollya-6.0+ds/doc/infnorm.tex000066400000000000000000000154151300174114700162270ustar00rootroot00000000000000\subsection{infnorm} \label{labinfnorm} \noindent Name: \textbf{infnorm}\\ \phantom{aaa}computes an interval bounding the infinity norm of a function on an interval.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_infnorm(sollya_obj_t, sollya_obj_t, ...)|\\ \verb| sollya_obj_t sollya_lib_v_infnorm(sollya_obj_t, sollya_obj_t, va_list)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{infnorm}(\emph{f},\emph{I},\emph{filename},\emph{Ilist}) : (\textsf{function}, \textsf{range}, \textsf{string}, \textsf{list}) $\rightarrow$ \textsf{range}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is a function. \item \emph{I} is an interval. \item \emph{filename} (optional) is the name of the file into a proof will be saved. \item \emph{IList} (optional) is a list of intervals to be excluded. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{infnorm}(\emph{f},\emph{range}) computes an interval bounding the infinity norm of the given function $f$ on the interval $I$, e.g. computes an interval $J$ such that $\max_{x \in I} \{|f(x)|\} \subseteq J$. \item If \emph{filename} is given, a proof in English will be produced (and stored in file called \emph{filename}) proving that $\max_{x \in I} \{|f(x)|\} \subseteq J$. \item If a list \emph{IList} of intervals $I_1, \dots, I_n$ is given, the infinity norm will be computed on $I \backslash (I_1 \cup \dots \cup I_n)$. \item The function \emph{f} is assumed to be at least twice continuous on \emph{I}. More generally, if \emph{f} is $\mathcal{C}^k$, global variables \textbf{hopitalrecursions} and \textbf{taylorrecursions} must have values not greater than $k$. \item If the interval is reduced to a single point, the result of \textbf{infnorm} is an interval containing the exact absolute value of \emph{f} at this point. \item If the interval is not bound, the result will be $[0,\,+\infty]$ which is correct but perfectly useless. \textbf{infnorm} is not meant to be used with infinite intervals. \item The result of this command depends on the global variables \textbf{prec}, \textbf{diam}, \textbf{taylorrecursions} and \textbf{hopitalrecursions}. The contribution of each variable is not easy even to analyse. \begin{itemize} \item The algorithm uses interval arithmetic with precision \textbf{prec}. The precision should thus be set high enough to ensure that no critical cancellation will occur. \item When an evaluation is performed on an interval $[a,\,b]$, if the result is considered being too large, the interval is split into $[a,\,\frac{a+b}{2}]$ and $[\frac{a+b}{2},\,b]$ and so on recursively. This recursion step is not performed if the $(b-a) < \delta \cdot |I|$ where $\delta$ is the value of variable \textbf{diam}. In other words, \textbf{diam} controls the minimum length of an interval during the algorithm. \item To perform the evaluation of a function on an interval, Taylor's rule is applied, e.g. $f([a,b]) \subseteq f(m) + [a-m,\,b-m] \cdot f'([a,\,b])$ where $m=\frac{a+b}{2}$. This rule is recursively applied $n$ times where $n$ is the value of variable \textbf{taylorrecursions}. Roughly speaking, the evaluations will avoid decorrelation up to order $n$. \item When a function of the form $\frac{g}{h}$ has to be evaluated on an interval $[a,\,b]$ and when $g$ and $h$ vanish at a same point $z$ of the interval, the ratio may be defined even if the expression $\frac{g(z)}{h(z)}=\frac{0}{0}$ does not make any sense. In this case, L'Hopital's rule may be used and $\left(\frac{g}{h}\right)([a,\,b]) \subseteq \left(\frac{g'}{h'}\right)([a,\,b])$. Since the same can occur with the ratio $\frac{g'}{h'}$, the rule is applied recursively. The variable \textbf{hopitalrecursions} controls the number of recursion steps. \end{itemize} \item The algorithm used for this command is quite complex to be explained here. Please find a complete description in the following article:\\ S. Chevillard and C. Lauter\\ A certified infinity norm for the implementation of elementary functions\\ LIP Research Report number RR2007-26\\ http://prunel.ccsd.cnrs.fr/ensl-00119810\\ \item Users should be aware about the fact that the algorithm behind \textbf{infnorm} is inefficient in most cases and that other, better suited algorithms, such as \textbf{supnorm}, are available inside \sollya. As a matter of fact, while \textbf{infnorm} is maintained for compatibility reasons with legacy \sollya codes, users are advised to avoid using \textbf{infnorm} in new \sollya scripts and to replace it, where possible, by the \textbf{supnorm} command. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > infnorm(exp(x),[-2;3]); [20.085536923187667740928529654581717896987907838554;20.085536923187667740928529 6545817178969879078385544] \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > infnorm(exp(x),[-2;3],"proof.txt"); [20.085536923187667740928529654581717896987907838554;20.085536923187667740928529 6545817178969879078385544] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > infnorm(exp(x),[-2;3],[| [0;1], [2;2.5] |]); [20.085536923187667740928529654581717896987907838554;20.085536923187667740928529 6545817178969879078385544] \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > infnorm(exp(x),[-2;3],"proof.txt", [| [0;1], [2;2.5] |]); [20.085536923187667740928529654581717896987907838554;20.085536923187667740928529 6545817178969879078385544] \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > infnorm(exp(x),[1;1]); [2.7182818284590452353602874713526624977572470936999;2.7182818284590452353602874 713526624977572470937] \end{Verbatim} \end{minipage}\end{center} \noindent Example 6: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > infnorm(exp(x), [log(0);log(1)]); [0;infty] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{prec} (\ref{labprec}), \textbf{diam} (\ref{labdiam}), \textbf{hopitalrecursions} (\ref{labhopitalrecursions}), \textbf{taylorrecursions} (\ref{labtaylorrecursions}), \textbf{dirtyinfnorm} (\ref{labdirtyinfnorm}), \textbf{checkinfnorm} (\ref{labcheckinfnorm}), \textbf{supnorm} (\ref{labsupnorm}), \textbf{findzeros} (\ref{labfindzeros}), \textbf{diff} (\ref{labdiff}), \textbf{taylorrecursions} (\ref{labtaylorrecursions}), \textbf{autodiff} (\ref{labautodiff}), \textbf{numberroots} (\ref{labnumberroots}), \textbf{taylorform} (\ref{labtaylorform}) sollya-6.0+ds/doc/integer.tex000066400000000000000000000017571300174114700162200ustar00rootroot00000000000000\subsection{integer} \label{labinteger} \noindent Name: \textbf{integer}\\ \phantom{aaa}keyword representing a machine integer type \\[0.2cm] \noindent Library name:\\ \verb| SOLLYA_EXTERNALPROC_TYPE_INTEGER|\\[0.2cm] \noindent Usage: \begin{center} \textbf{integer} : \textsf{type type}\\ \end{center} \noindent Description: \begin{itemize} \item \textbf{integer} represents the machine integer type for declarations of external procedures \textbf{externalproc}. Remark that in contrast to other indicators, type indicators like \textbf{integer} cannot be handled outside the \textbf{externalproc} context. In particular, they cannot be assigned to variables. \end{itemize} See also: \textbf{externalproc} (\ref{labexternalproc}), \textbf{boolean} (\ref{labboolean}), \textbf{constant} (\ref{labconstant}), \textbf{function} (\ref{labfunction}), \textbf{list of} (\ref{lablistof}), \textbf{range} (\ref{labrange}), \textbf{string} (\ref{labstring}), \textbf{object} (\ref{labobject}) sollya-6.0+ds/doc/integral.tex000066400000000000000000000035611300174114700163630ustar00rootroot00000000000000\subsection{integral} \label{labintegral} \noindent Name: \textbf{integral}\\ \phantom{aaa}computes an interval bounding the integral of a function on an interval.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_integral(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{integral}(\emph{f},\emph{I}) : (\textsf{function}, \textsf{range}) $\rightarrow$ \textsf{range}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is a function. \item \emph{I} is an interval. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{integral}(\emph{f},\emph{I}) returns an interval $J$ such that the exact value of the integral of \emph{f} on \emph{I} lies in $J$. \item This command is safe but very inefficient. Use \textbf{dirtyintegral} if you just want an approximate value. \item The result of this command depends on the global variable \textbf{diam}. The method used is the following: \emph{I} is cut into intervals of length not greater then $\delta \cdot |I|$ where $\delta$ is the value of global variable \textbf{diam}. On each small interval \emph{J}, an evaluation of \emph{f} by interval is performed. The result is multiplied by the length of \emph{J}. Finally all values are summed. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > sin(10); -0.54402111088936981340474766185137728168364301291622 > integral(cos(x),[0;10]); [-0.54710197983579690224097637163525943075698599257333;-0.5409401513001318384815 0540881373370744053741191729] > diam=1e-5!; > integral(cos(x),[0;10]); [-0.54432915685955427101857780295936956775293876382777;-0.5437130640124996950803 9644221927489010425803173555] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{diam} (\ref{labdiam}), \textbf{dirtyintegral} (\ref{labdirtyintegral}), \textbf{prec} (\ref{labprec}) sollya-6.0+ds/doc/introExample1.tex000066400000000000000000000005151300174114700173020ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = sin(x)/x; > g = cos(y)-1; Warning: the identifier "y" is neither assigned to, nor bound to a library funct ion nor external procedure, nor equal to the current free variable. Will interpret "y" as "x". > g; cos(x) - 1 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample10.tex000066400000000000000000000007701300174114700173650ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec=30!; > a = 17.25; > display=decimal; Display mode is decimal numbers. > a; 17.25 > display=binary; Display mode is binary numbers. > a; 1.000101_2 * 2^(4) > display=powers; Display mode is dyadic numbers in integer-power-of-2 notation. > a; 69 * 2^(-2) > display=dyadic; Display mode is dyadic numbers. > a; 69b-2 > display=hexadecimal; Display mode is hexadecimal numbers. > a; 0x1.14p4 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample11.tex000066400000000000000000000002571300174114700173660ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > printdouble(a); 0x4031400000000000 > printsingle(a); 0x418a0000 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample12.tex000066400000000000000000000020171300174114700173630ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = exp(x); > f; exp(x) > a = "Hello world"; > a; Hello world > b = 5; > f(b); Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 148.41315910257660342111558004055227962348766759388 > {var b; b = 4; f(b); }; Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 54.598150033144239078110261202860878402790737038614 > {var x; x = 3; }; Warning: the identifier "x" is already bound to the current free variable. It cannot be declared as a local variable. The declaration of "x" will have no e ffect. Warning: the identifier "x" is already bound to the free variable, to a library function, library constant or to an external procedure. The command will have no effect. Warning: the last assignment will have no effect. > {var a, b; a=5; b=3; {var a; var b; b = true; a = 1; a; b;}; a; b; }; 1 true 5 3 > a; Hello world \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample13.tex000066400000000000000000000001761300174114700173700ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 1+x==1+x; true \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample14.tex000066400000000000000000000012101300174114700173570ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec=12!; > 4097.1; Warning: Rounding occurred when converting the constant "4097.1" to floating-poi nt with 12 bits. If safe computation is needed, try to increase the precision. 4098 > 4098.1; Warning: Rounding occurred when converting the constant "4098.1" to floating-poi nt with 12 bits. If safe computation is needed, try to increase the precision. 4098 > 4097.1+1; Warning: Rounding occurred when converting the constant "4097.1" to floating-poi nt with 12 bits. If safe computation is needed, try to increase the precision. 4099 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample15.tex000066400000000000000000000011521300174114700173650ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec = 50!; > a = 4097.1; Warning: Rounding occurred when converting the constant "4097.1" to floating-poi nt with 50 bits. If safe computation is needed, try to increase the precision. > prec = 12!; > f = x + a; > g = x + 4097.1; Warning: Rounding occurred when converting the constant "4097.1" to floating-poi nt with 12 bits. If safe computation is needed, try to increase the precision. > prec = 120; The precision has been set to 120 bits. > f; 4097.099999999998544808477163314819336 + x > g; 4098 + x \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample16.tex000066400000000000000000000012271300174114700173710ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > d=[1;2]; > d2=[1,1+1]; > d==d2; true > prec=12!; > 8095.1; Warning: Rounding occurred when converting the constant "8095.1" to floating-poi nt with 12 bits. If safe computation is needed, try to increase the precision. 8096 > [8095.1; 8096.1]; Warning: Rounding occurred when converting the constant "8095.1" to floating-poi nt with 12 bits. The inclusion property is nevertheless satisfied. Warning: Rounding occurred when converting the constant "8096.1" to floating-poi nt with 12 bits. The inclusion property is nevertheless satisfied. [8094;8098] \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample17.tex000066400000000000000000000014021300174114700173650ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec = 300!; > a = 4097.1; Warning: Rounding occurred when converting the constant "4097.1" to floating-poi nt with 300 bits. If safe computation is needed, try to increase the precision. > prec = 12!; > d = [4097.1; a]; Warning: Rounding occurred when converting the constant "4097.1" to floating-poi nt with 12 bits. The inclusion property is nevertheless satisfied. > prec = 300!; > d; [4096;4097.1] > prec = 30!; > [-pi;pi]; Warning: at least one of the given expressions is not a constant but requires ev aluation. Evaluation is guaranteed to ensure the inclusion property. The approximate resul t is at least 30 bit accurate. [-3.141592655;3.141592655] \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample18.tex000066400000000000000000000002341300174114700173700ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > d=[1;3]; > inf(d); 1 > mid(d); 2 > sup(4); 4 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample19.tex000066400000000000000000000007021300174114700173710ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > prec=12!; > a=pi; > a; Warning: rounding has happened. The value displayed is a faithful rounding to 12 bits of the true result. 1.10010010001_2 * 2^(1) > prec=30!; > a; Warning: rounding has happened. The value displayed is a faithful rounding to 30 bits of the true result. 1.10010010000111111011010101001_2 * 2^(1) \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample2.tex000066400000000000000000000005221300174114700173010ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > x = 3; Warning: the identifier "x" is already bound to the free variable, to a library function, library constant or to an external procedure. The command will have no effect. Warning: the last assignment will have no effect. \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample20.tex000066400000000000000000000002771300174114700173700ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > s1 = "Hello "; s2 = "World!"; > s = s1@s2; > length(s); 12 > s[0]; H > s[11]; ! \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample21.tex000066400000000000000000000003551300174114700173660ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > L = [| "foo" |]; > L = L:.1; > L = "bar".:L; > L; [|"bar", "foo", 1|] > L[1]; foo > L@L; [|"bar", "foo", 1, "bar", "foo", 1|] \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample22.tex000066400000000000000000000002431300174114700173630ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > L = [|1,2,3,4,5|]; > L; [|1, 2, 3, 4, 5|] > L[3]; 4 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample23.tex000066400000000000000000000010661300174114700173700ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [|1,...,5|]; [|1, 2, 3, 4, 5|] > [|-5,...,5|]; [|-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5|] > [|3,...,1|]; Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. error > [|true,...,false|]; Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. error \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample24.tex000066400000000000000000000004341300174114700173670ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > L = [|1,2,true,3...|]; > L; [|1, 2, true, 3...|] > L[2]; true > L[3]; 3 > L[4]; 4 > L[1200]; 1200 > L = [|1,...,5,true...|]; > L; [|1, 2, 3, 4, 5, true...|] > L[1200]; true \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample25.tex000066400000000000000000000013701300174114700173700ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > autosimplify = off; Automatic pure tree simplification has been deactivated. > i = 1000; > i = i + 1; > print(i); 1000 + 1 > i := i + 1; > print(i); 1002 > L = [|1,...,5|]; > print(L); [|1, 2, 3, 4, 5|] > L[3] = L[3] + 1; > L[4] := L[4] + 1; > print(L); [|1, 2, 3, 4 + 1, 6|] > L[5] = true; > L; [|1, 2, 3, 5, 6, true|] > s = "Hello world"; > s; Hello world > s[1] = "a"; > s; Hallo world > s[2] = "foo"; Warning: the string to be assigned is not of length 1. This command will have no effect. > L = [|true,1,...,5,9...|]; > L; [|true, 1, 2, 3, 4, 5, 9...|] > L[13] = "Hello"; > L; [|true, 1, 2, 3, 4, 5, 9, 10, 11, 12, 13, 14, 15, "Hello", 17...|] \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample26.tex000066400000000000000000000005131300174114700173670ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a = 3; > b = 4; > if (a == b) then print("Hello world"); > b = 3; > if (a == b) then print("Hello world"); Hello world > if (a == b) then print("You are telling the truth") else print("Liar!"); You are telling the truth \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample27.tex000066400000000000000000000004201300174114700173650ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 0!; > prec = 30!; > i = 5; > while (expm1(i) > 0) do { expm1(i); i := i - 1; }; 147.4131591 53.59815 19.08553693 6.3890561 1.718281828 > print(i); 0 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample28.tex000066400000000000000000000005061300174114700173730ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > for i from 1 to 5 do print ("Hello world",i); Hello world 1 Hello world 2 Hello world 3 Hello world 4 Hello world 5 > for i from 2 to 1 by -0.5 do print("Hello world",i); Hello world 2 Hello world 1.5 Hello world 1 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample29.tex000066400000000000000000000003211300174114700173670ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > L = [|true, false, 1,...,4, "Hello", exp(x)|]; > for i in L do i; true false 1 2 3 4 Hello exp(x) \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample3.tex000066400000000000000000000003331300174114700173020ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > rename(x,y); Information: the free variable has been renamed from "x" to "y". > g; cos(y) - 1 > x=3; > x; 3 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample30.tex000066400000000000000000000002651300174114700173660ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > for i from 1 to 5 do { if (i == 3) then i = 4 else i; }; 1 2 5 > i; 6 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample31.tex000066400000000000000000000003321300174114700173620ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > succ = proc(n) { return n + 1; }; > succ(5); 6 > 3 + succ(0); 4 > succ; proc(n) { nop; return (n) + (1); } \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample32.tex000066400000000000000000000011331300174114700173630ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = exp(x) + 5; > f(-infty); 5 > evaluate(f,[-infty;infty]); [5;infty] > f(infty); infty > [-infty;5] * [3;4]; [-infty;20] > -infty < 5; true > log(0); -infty > [log(0);17]; Warning: inclusion property is satisfied but the diameter may be greater than th e least possible. Warning: at least one of the given expressions is not a constant but requires ev aluation. Evaluation is guaranteed to ensure the inclusion property. The approximate resul t is at least 165 bit accurate. [-infty;17] > \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample33.tex000066400000000000000000000012331300174114700173650ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 3/0; Warning: the given expression is undefined or numerically unstable. NaN > (-3)/0; Warning: the given expression is undefined or numerically unstable. NaN > infty/infty; Warning: the given expression is undefined or numerically unstable. NaN > infty + infty; infty > infty - infty; Warning: the given expression is undefined or numerically unstable. NaN > f = exp(x) + 5; > f(NaN); NaN > NaN == 5; false > NaN == NaN; false > NaN != NaN; false > X = "Vive la Republique!"; > !(X == X); false > X = 5; > !(X == X); false > X = NaN; > !(X == X); true > \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample34.tex000066400000000000000000000024461300174114700173750ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 1/3 - 1/7; Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 0.19047619047619047619047619047619047619047619047619 > rationalmode = on; Rational mode has been activated. > 1/3 - 1/7; 4 / 21 > (2 + 1/7)^2 + (6/7)^2 + 2 * (2 + 1/7) * 6/7; 9 > rationalmode = off; Rational mode has been deactivated. > (2 + 1/7)^2 + (6/7)^2 + 2 * (2 + 1/7) * 6/7; Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 9 > rationalmode = on; Rational mode has been activated. > asin(1)/pi; Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 0.5 > sin(1/6 * pi); Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 0.5 > exp(1/7 - 3/21) / 7; 1 / 7 > rationalmode = off; Rational mode has been deactivated. > exp(1/7 - 3/21) / 7; Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 0.142857142857142857142857142857142857142857142857145 > print(1/7 - 3/21); 1 / 7 - 3 / 21 > rationalmode = on; Rational mode has been activated. > print(1/7 - 3/21); 0 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample35.tex000066400000000000000000000005171300174114700173730ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > add = proc(m,n) { var res; res := m + n; return res; }; > add(5,6); 11 > hey = proc() { print("Hello world."); }; > hey(); Hello world. > print(hey()); Hello world. void > hey; proc() { print("Hello world."); return void; } \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample36.tex000066400000000000000000000005301300174114700173670ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > fac = proc(n) { var res; if (n == 0) then res := 1 else res := n * fac(n - 1); return res; }; > fac(5); 120 > fac(11); 39916800 > fac; proc(n) { var res; if (n) == (0) then res := 1 else res := (n) * (fac((n) - (1))); return res; } \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample37.tex000066400000000000000000000006261300174114700173760ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > sumall = proc(args = ...) { var i, acc; acc = 0; for i in args do acc = acc + i; return acc; }; > sumall; proc(args = ...) { var i, acc; acc = 0; for i in args do acc = (acc) + (i); return acc; } > sumall(); 0 > sumall(1); 1 > sumall(1,5); 6 > sumall(1,5,9); 15 > sumall @ [|1,5,9,4,8|]; 27 > \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample37bis.tex000066400000000000000000000007661300174114700201010ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > ChebPolynomials = proc(n) { var i, res; if (n<0) then res = [||] else if (n==0) then res = [|1|] else { res = [|1, _x_|]; for i from 2 to n do res[i] = horner(2*_x_*res[i-1]-res[i-2]); }; return res; }; > > f = sin(x); > T = ChebPolynomials(4); > canonical = on!; > for i from 0 to 4 do T[i]; 1 x -1 + 2 * x^2 -3 * x + 4 * x^3 1 + -8 * x^2 + 8 * x^4 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample38.tex000066400000000000000000000011221300174114700173670ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [3]; [3;3] > [1/7]; Warning: at least one of the given expressions is not a constant but requires ev aluation. Evaluation is guaranteed to ensure the inclusion property. The approximate resul t is at least 24 bit accurate. [0.14285713;0.14285715] > [exp(8)]; Warning: at least one of the given expressions is not a constant but requires ev aluation. Evaluation is guaranteed to ensure the inclusion property. The approximate resul t is at least 24 bit accurate. [2980.9578;2980.958] \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample39.tex000066400000000000000000000011671300174114700174010ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > evaluate(exp(x),[-infty;0]); [0;1] > dirtyinfnorm(exp(x),[-infty;0]); Warning: a bound of the interval is infinite or NaN. This command cannot handle such intervals. NaN > > f = log(x); > [f(0); f(1)]; Warning: inclusion property is satisfied but the diameter may be greater than th e least possible. Warning: at least one of the given expressions is not a constant but requires ev aluation. Evaluation is guaranteed to ensure the inclusion property. The approximate resul t is at least 165 bit accurate. [-infty;0] > \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample3bis.tex000066400000000000000000000002071300174114700200000ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f == sin(_x_)/_x_; true \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample4.tex000066400000000000000000000005361300174114700173100ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f(-2); Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 0.45464871341284084769800993295587242135112748572394 > evaluate(f,-2); 0.45464871341284084769800993295587242135112748572394 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample40.tex000066400000000000000000000015511300174114700173660ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > midpointmode = off; Midpoint mode has been deactivated. > [17;17]; [17;17] > [exp(pi);exp(pi)]; Warning: at least one of the given expressions is not a constant but requires ev aluation. Evaluation is guaranteed to ensure the inclusion property. The approximate resul t is at least 165 bit accurate. [23.1406926327792690057290863679485473802661062426;23.14069263277926900572908636 7948547380266106242601] > midpointmode = on; Midpoint mode has been activated. > [17;17]; [17] > [exp(pi);exp(pi)]; Warning: at least one of the given expressions is not a constant but requires ev aluation. Evaluation is guaranteed to ensure the inclusion property. The approximate resul t is at least 165 bit accurate. 0.231406926327792690057290863679485473802661062426~0/1~e2 > \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample41.tex000066400000000000000000000003621300174114700173660ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > midpointmode = on!; > [1.725e4;1.75e4]; 0.17~2/5~e5 > 0.17~2/5~e5; 0.17~2/5~e5 > midpointmode = off!; > 0.17~2/5~e5; [17200;17500] \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample42.tex000066400000000000000000000003351300174114700173670ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [1;2] + [3;4]; [4;6] > [1;2] * [3;4]; [3;8] > sqrt([9;25]); [3;5] > exp(sin([10;100])); [0.36787942;2.718282] \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample43.tex000066400000000000000000000005731300174114700173740ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = x - sin(x); > [-1b-10;1b-10] - sin([-1b-10;1b-10]); [-1.95312484477957829894e-3;1.95312484477957829894e-3] > f([-1b-10;1b-10]); [-1.552204217011176269e-10;1.552204217011176269e-10] > evaluate(f,[-1b-10;1b-10]); [-1.552204217011176269e-10;1.552204217011176269e-10] \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample44.tex000066400000000000000000000023261300174114700173730ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec = 24; The precision has been set to 24 bits. > a = 0.1; Warning: Rounding occurred when converting the constant "0.1" to floating-point with 24 bits. If safe computation is needed, try to increase the precision. > b = 33554433; > prec = 64; The precision has been set to 64 bits. > display = binary; Display mode is binary numbers. > a; 1.10011001100110011001101_2 * 2^(-4) > 0.1; Warning: Rounding occurred when converting the constant "0.1" to floating-point with 64 bits. If safe computation is needed, try to increase the precision. 1.100110011001100110011001100110011001100110011001100110011001101_2 * 2^(-4) > %24%0.1; Warning: Rounding occurred when converting the constant "0.1" to floating-point with 24 bits. If safe computation is needed, try to increase the precision. 1.10011001100110011001101_2 * 2^(-4) > c = 33554433; > b; 1.0000000000000000000000001_2 * 2^(25) > c; 1.0000000000000000000000001_2 * 2^(25) > %24%33554433; Warning: Rounding occurred when converting the constant "33554433" to floating-p oint with 24 bits. If safe computation is needed, try to increase the precision. 1_2 * 2^(25) > > \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample45.tex000066400000000000000000000007101300174114700173670ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > L = [| 1, 2, [|"a", "b", [|true, false|] |] |]; > L[2][2][1]; false > L[2][2][1] = true; Warning: the first element of the left-hand side is not an identifier. This command will have no effect. > L[2][2] = "c"; Warning: the first element of the left-hand side is not an identifier. This command will have no effect. > L[2] = 3; > L; [|1, 2, 3|] \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample46.tex000066400000000000000000000006231300174114700173730ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > s.a = 17; > s.b = exp(x); > s.a; 17 > s.b; exp(x) > s.b(1); Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 2.7182818284590452353602874713526624977572470937 > s.d.a = [-1;1]; > s.d.b = sin(x); > inf(s.d.a); -1 > diff(s.d.b); cos(x) \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample47.tex000066400000000000000000000007701300174114700173770ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a = { .f = exp(x), .dom = [-1;1] }; > a; { .f = exp(x), .dom = [-1;1] } > a.f; exp(x) > a.dom; [-1;1] > b.f = sin(x); > b.dom = [-1b-5;1b-5]; > b; { .dom = [-3.125e-2;3.125e-2], .f = sin(x) } > { .f = asin(x), .dom = [-1;1] }.f(1); Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 1.57079632679489661923132169163975144209858469968754 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample48.tex000066400000000000000000000014751300174114700174030ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > restart; The tool has been restarted. > a.f = exp(x); > a.dom = [-1;1]; > a.info.text = "My akrnoximation problem"; > a; { .info = { .text = "My akrnoximation problem" }, .dom = [-1;1], .f = exp(x) } > > a.info.text = "My approximation problem"; > a; { .info = { .text = "My approximation problem" }, .dom = [-1;1], .f = exp(x) } > > b = exp(x); > b.a = 5; Warning: cannot modify an element of something that is not a structure. Warning: the last assignment will have no effect. > b; exp(x) > > a.dom.a = -1; Warning: cannot modify an element of something that is not a structure. Warning: the last assignment will have no effect. > a; { .info = { .text = "My approximation problem" }, .dom = [-1;1], .f = exp(x) } \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample49.tex000066400000000000000000000010501300174114700173710ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a = { .f = exp(x), .a = -1, .b = 1 }; > a; { .f = exp(x), .a = -1, .b = 1 } > a.info = "My function"; > a; { .info = "My function", .f = exp(x), .a = -1, .b = 1 } > > b = { .a = -1, .f = exp(x), .info = "My function", .b = 1 }; > b; { .a = -1, .f = exp(x), .info = "My function", .b = 1 } > > a == b; true > > b.info = "My other function"; > a == b; false > > b.info = "My function"; > a == b; true > b.something = true; > a == b; false \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample5.tex000066400000000000000000000005561300174114700173130ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec; 165 > prec=200; The precision has been set to 200 bits. > prec; 200 > f(-2); Warning: rounding has happened. The value displayed is a faithful rounding to 20 0 bits of the true result. 0.4546487134128408476980099329558724213511274857239451341894865 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample50.tex000066400000000000000000000025521300174114700173710ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > match exp(x) with exp(x) : (1) sin(x) : (2) default : (3); 1 > > match sin(x) with exp(x) : (1) sin(x) : (2) default : (3); 2 > > match exp(sin(x)) with exp(x) : ("Exponential of x") exp(sin(x)) : ("Exponential of sine of x") default : ("Something else"); Exponential of sine of x > > match exp(sin(x)) with exp(x) : ("Exponential of x") exp(a) : ("Exponential of " @ a) default : ("Something else"); Exponential of sin(x) > > > procedure differentiate(f) { return match f with g + h : (differentiate(g) + differentiate(h)) g * h : (differentiate(g) * h + differentiate(h) * g) g / h : ((differentiate(g) * h - differentiate(h) * g) / (h^2)) exp(_x_) : (exp(_x_)) sin(_x_) : (cos(_x_)) cos(_x_) : (-sin(_x_)) g(h) : ((differentiate(g))(h) * differentiate(h)) _x_ : (1) h(_x_) : (NaN) c : (0); }; > > rename(x,y); Information: the free variable has been renamed from "x" to "y". > differentiate(exp(sin(y + y))); exp(sin(y * 2)) * cos(y * 2) * 2 > diff(exp(sin(y + y))); exp(sin(y * 2)) * cos(y * 2) * 2 > \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample51.tex000066400000000000000000000031301300174114700173630ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > match exp(sin(x)) with exp(a) : { write("Exponential of ", a, "\n"); return a; } sin(x) : { var foo; foo = 17; write("Sine of x\n"); return foo; } default : { write("Something else\n"); bashexecute("LANG=C date"); return true; }; Exponential of sin(x) sin(x) > > match sin(x) with exp(a) : { write("Exponential of ", a, "\n"); return a; } sin(x) : { var foo; foo = 17; write("Sine of x\n"); return foo; } default : { write("Something else\n"); bashexecute("LANG=C date"); return true; }; Sine of x 17 > > match acos(17 * pi * x) with exp(a) : { write("Exponential of ", a, "\n"); return a; } sin(x) : { var foo; foo = 17; write("Sine of x\n"); return foo; } default : { write("Something else\n"); bashexecute("LANG=C date"); return true; }; Something else Mon Oct 17 09:47:15 CEST 2016 true \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample52.tex000066400000000000000000000020171300174114700173670ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a = 5; > b = 6; > match exp(x + 3) with exp(a + b) : { print("Exponential"); print("a = ", a); print("b = ", b); } sin(x) : { print("Sine of x"); }; Exponential a = x b = 3 > print("a = ", a, ", b = ", b); a = 5 , b = 6 > > a = 5; > b = 6; > match exp(x + 3) with exp(a + b) : { var a, c; a = 17; c = "Hallo"; print("Exponential"); print("a = ", a); print("b = ", b); print("c = ", c); } sin(x) : { print("Sine of x"); }; Exponential a = 17 b = 3 c = Hallo > print("a = ", a, ", b = ", b); a = 5 , b = 6 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample53.tex000066400000000000000000000013711300174114700173720ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > match exp(sin(x)) + sin(x) with exp(a) + a : { print("Winner"); print("a = ", a); } default : { print("Loser"); }; Winner a = sin(x) > > match exp(sin(x)) + sin(3 * x) with exp(a) + a : { print("Winner"); print("a = ", a); } default : { print("Loser"); }; Loser > > f = exp(x); > match f with sin(x) : (1) cos(x) : (2) exp(x) : (3) default : (4); 3 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample54.tex000066400000000000000000000016271300174114700173770ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > match 5 + 1 with 1 + 5 : ("One plus five") 6 : ("Six") 5 + 1 : ("Five plus one"); Five plus one > > match 6 with 1 + 5 : ("One plus five") 6 : ("Six") 5 + 1 : ("Five plus one"); Six > > match 1 + 5 with 1 + 5 : ("One plus five") 6 : ("Six") 5 + 1 : ("Five plus one"); One plus five > > match [1; 5 + 1] with [1; 1 + 5] : ("Interval from one to one plus five") [1; 6] : ("Interval from one to six") [1; 5 + 1] : ("Interval from one to five plus one"); Interval from one to one plus five > > match [1; 6] with [1; 1 + 5] : ("Interval from one to one plus five") [1; 6] : ("Interval from one to six") [1; 5 + 1] : ("Interval from one to five plus one"); Interval from one to one plus five > \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample55.tex000066400000000000000000000020051300174114700173670ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > match exp(x) with sin(x) : ("Sine of x") atan(x^2) : ("Arctangent of square of x") default : ("Something else") exp(x) : ("Exponential of x"); Something else > > match atan(x^2) with sin(x) : ("Sine of x") atan(default^2) : ("Arctangent of the square of something") default : ("Something else"); Arctangent of the square of something > > match atan(exp(x)^2) with sin(x) : ("Sine of x") atan(default^2) : ("Arctangent of the square of something") default : ("Something else"); Arctangent of the square of something > > match exp("Hello world") with exp(default) : ("A miracle has happened") default : ("Something else"); Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. error \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample56.tex000066400000000000000000000035671300174114700174060ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure detector(obj) { match obj with exp(a * x) : { "Exponential of ", a, " times x"; } [ a; 17 ] : { "An interval from ", a, " to 17"; } [| |] : { "Empty list"; } [| a, b, 2, exp(c) |] : { "A list of ", a, ", ", b, ", 2 and ", "exponential of ", c; } a @ [| 2, 3 |] : { "Concatenation of the list ", a, " and ", "the list of 2 and 3"; } a .: [| 9 ... |] : { a, " prepended to all integers >= 9"; } "Hello" @ w : { "Hello concatenated with ", w; } { .a = sin(b); .b = [c;d] } : { "A structure containing as .a the ", "sine of ", b, " and as .b the range from ", c, " to ", d; } perturb : { "The special object perturb"; } default : { "Something else"; }; }; > > detector(exp(5 * x)); Exponential of 5 times x > detector([3.25;17]); An interval from 3.25 to 17 > detector([||]); Empty list > detector([| sin(x), nearestint(x), 2, exp(5 * atan(x)) |]); A list of sin(x), nearestint(x), 2 and exponential of 5 * atan(x) > detector([| sin(x), cos(5 * x), "foo", 2, 3 |]); Concatenation of the list [|sin(x), cos(x * 5), "foo"|] and the list of 2 and 3 > detector([| DE, 9... |]); doubleextended prepended to all integers >= 9 > detector("Hello world"); Hello concatenated with world > detector({ .a = sin(x); .c = "Hello"; .b = [9;10] }); A structure containing as .a the sine of x and as .b the range from 9 to 10 > detector(perturb); The special object perturb > detector([13;19]); Something else \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample57.tex000066400000000000000000000020301300174114700173670ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > match exp([1;2]) with [a;b] : { a,", ",b; } default : { "Something else"; }; 2.7182818284590452353602874713526624977572470936999, 7.3890560989306502272304274 605750078131803155705519 > > match exp([1;2]) with exp([a;b]) : { a,", ", b; } default : { "Something else"; }; Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. error > > match exp([1;2]) with exp(a) : { "Exponential of ", a; } default : { "Something else"; }; Something else \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample58.tex000066400000000000000000000016271300174114700174030ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > match [| exp(sin(x)), sin(x), 4, DE(x), 9... |] with exp(a) .: (a .: (([||] :. 4) @ (b @ [| 13... |]))) : { "a = ", a, ", b = ", b; }; a = sin(x), b = [|doubleextended(x), 9, 10, 11, 12|] > > match [| 1, 2, 3, 4, D... |] with a @ [| 4, D...|] : (a); [|1, 2, 3|] > > match [| 1, 2, 3, 4, D... |] with a @ [| D...|] : (a); [|1, 2, 3, 4|] > > match [| 1, 2, 3, 4... |] with a @ [| 3...|] : (a); [|1, 2|] > > match [| 1, 2, 3, 4... |] with a @ [| 4...|] : (a); [|1, 2, 3|] > > match [| 1, 2, 3, 4... |] with a @ [| 17...|] : (a); [|1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16|] > > match [| 1, 2, 3, 4... |] with a @ [| 17, 18, 19 |] : (a) default : ("Something else"); Something else \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample59.tex000066400000000000000000000031041300174114700173740ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > structure.f = exp(x); > structure.dom = [1;2]; > structure.formats = [| DD, D, D, D |]; > match structure with { .f = sin(x); .dom = [a;b] } : { "Sine, ",a,", ",b; } { .f = exp(c); .dom = [a;b]; .point = default } : { "Exponential, ",a, ", ", b, ", ", c; } { .f = exp(x); .dom = [a;b] } : { "Exponential, ",a, ", ", b; } default : { "Something else"; }; Exponential, 1, 2 > > structure.f = sin(x); > match structure with { .f = sin(x); .dom = [a;b] } : { "Sine, ",a,", ",b; } { .f = exp(c); .dom = [a;b]; .point = default } : { "Exponential, ",a, ", ", b, ", ", c; } { .f = exp(x); .dom = [a;b] } : { "Exponential, ",a, ", ", b; } default : { "Something else"; }; Sine, 1, 2 > > structure.f = exp(x + 2); > structure.point = 23; > match structure with { .f = sin(x); .dom = [a;b] } : { "Sine, ",a,", ",b; } { .f = exp(c); .dom = [a;b]; .point = default } : { "Exponential, ",a, ", ", b, ", ", c; } { .f = exp(x); .dom = [a;b] } : { "Exponential, ",a, ", ", b; } default : { "Something else"; }; Exponential, 1, 2, 2 + x \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample6.tex000066400000000000000000000004461300174114700173120ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > log2(5)/log2(17) - log(5)/log(17); Warning: rounding may have happened. If there is rounding, the displayed value is *NOT* guaranteed to be a faithful r ounding of the true result. 0 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample7.tex000066400000000000000000000001711300174114700173060ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > sin(0); 0 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample8.tex000066400000000000000000000013621300174114700173120ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > restart; The tool has been restarted. > prec=50; The precision has been set to 50 bits. > f=cos(2*exp(x)); > d=[-1/8;1/8]; > p=remez(f,2,d); > derivativeZeros = dirtyfindzeros(diff(p-f),d); > derivativeZeros = inf(d).:derivativeZeros:.sup(d); > maximum=0; > for t in derivativeZeros do { r = evaluate(abs(p-f), t); if r > maximum then { maximum=r; argmaximum=t; }; }; > print("The infinity norm of", p-f, "is", maximum, "and is reached at", argmaxi mum); The infinity norm of -3.89710727796949e-2 * x^2 + -1.79806720921853 * x + (-0.41 62655728752966) - cos(2 * exp(x)) is 8.6306594443227e-4 and is reached at 6.6635 5088071379e-2 \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/introExample9.tex000066400000000000000000000002571300174114700173150ustar00rootroot00000000000000\begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec=30; The precision has been set to 30 bits. > prec=30!; > \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/isbound.tex000066400000000000000000000046231300174114700162210ustar00rootroot00000000000000\subsection{isbound} \label{labisbound} \noindent Name: \textbf{isbound}\\ \phantom{aaa}indicates whether a variable is bound or not.\\[0.2cm] \noindent Usage: \begin{center} \textbf{isbound}(\emph{ident}) : \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{ident} is a name. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{isbound}(\emph{ident}) returns a boolean value indicating whether the name \emph{ident} is used or not to represent a variable. It returns true when \emph{ident} is the name used to represent the global variable or if the name is currently used to refer to a (possibly local) variable. \item When a variable is defined in a block and has not been defined outside, \textbf{isbound} returns true when called inside the block, and false outside. Note that \textbf{isbound} returns true as soon as a variable has been declared with \textbf{var}, even if no value is actually stored in it. \item If \emph{ident1} is bound to a variable and if \emph{ident2} refers to the global variable, the command \textbf{rename}(\emph{ident2}, \emph{ident1}) hides the value of \emph{ident1} which becomes the global variable. However, if the global variable is again renamed, \emph{ident1} gets its value back. In this case, \textbf{isbound}(\emph{ident1}) returns true. If \emph{ident1} was not bound before, \textbf{isbound}(\emph{ident1}) returns false after that \emph{ident1} has been renamed. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > isbound(x); false > isbound(f); false > isbound(g); false > f=sin(x); > isbound(x); true > isbound(f); true > isbound(g); false \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > isbound(a); false > { var a; isbound(a); }; true > isbound(a); false \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f=sin(x); > isbound(x); true > rename(x,y); > isbound(x); false \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > x=1; > f=sin(y); > rename(y,x); > f; sin(x) > x; x > isbound(x); true > rename(x,y); > isbound(x); true > x; 1 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{rename} (\ref{labrename}) sollya-6.0+ds/doc/isevaluable.tex000066400000000000000000000047171300174114700170560ustar00rootroot00000000000000\subsection{isevaluable} \label{labisevaluable} \noindent Name: \textbf{isevaluable}\\ \phantom{aaa}tests whether a function can be evaluated at a point \\[0.2cm] \noindent Usage: \begin{center} \textbf{isevaluable}(\emph{function}, \emph{constant}) : (\textsf{function}, \textsf{constant}) $\rightarrow$ \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents a function \item \emph{constant} represents a constant point \end{itemize} \noindent Description: \begin{itemize} \item \textbf{isevaluable} applied to function \emph{function} and a constant \emph{constant} returns a boolean indicating whether or not a subsequent call to \textbf{evaluate} on the same function \emph{function} and constant \emph{constant} will produce a numerical result or NaN. This means \textbf{isevaluable} returns false iff \textbf{evaluate} will return NaN. \item The command \textbf{isevaluable} is now considered DEPRECATED in \sollya. As checks for NaNs are now possible in Sollya, the command \textbf{isevaluable} can be fully emulated with a call to evaluate and a couple of tests, as shown below in the last example. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > isevaluable(sin(pi * 1/x), 0.75); true > print(evaluate(sin(pi * 1/x), 0.75)); -0.86602540378443864676372317075293618347140262690519 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > isevaluable(sin(pi * 1/x), 0.5); true > print(evaluate(sin(pi * 1/x), 0.5)); [-1.7298645251438126951650861503109812954283676799168e-12715;7.59411982011879631 45069564314525661706039084390068e-12716] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > isevaluable(sin(pi * 1/x), 0); true > print(evaluate(sin(pi * 1/x), 0)); [-1;1] \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure isEvaluableEmulation(f, c) { return match evaluate(f, c) with NaN : (false) [NaN;NaN] : (false) default : (true); }; > isEvaluableEmulation(sin(pi * 1/x), 0.75); true > isEvaluableEmulation(sin(pi * 1/x), 0.5); true > isEvaluableEmulation(sin(pi * 1/x), 0); true \end{Verbatim} \end{minipage}\end{center} See also: \textbf{evaluate} (\ref{labevaluate}) sollya-6.0+ds/doc/le.tex000066400000000000000000000034141300174114700151530ustar00rootroot00000000000000\subsection{$<=$} \label{lable} \noindent Name: \textbf{$<=$}\\ \phantom{aaa}less-than-or-equal-to operator\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_cmp_less_equal(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \emph{expr1} \textbf{$<=$} \emph{expr2} : (\textsf{constant}, \textsf{constant}) $\rightarrow$ \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr1} and \emph{expr2} represent constant expressions \end{itemize} \noindent Description: \begin{itemize} \item The operator \textbf{$<=$} evaluates to true iff its operands \emph{expr1} and \emph{expr2} evaluate to two floating-point numbers $a_1$ respectively $a_2$ with the global precision \textbf{prec} and $a_1$ is less than or equal to $a_2$. The user should be aware of the fact that because of floating-point evaluation, the operator \textbf{$<=$} is not exactly the same as the mathematical operation \emph{less-than-or-equal-to}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 5 <= 4; false > 5 <= 5; true > 5 <= 6; true > exp(2) <= exp(1); false > log(1) <= exp(2); true \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec = 12; The precision has been set to 12 bits. > 16385.1 <= 16384.1; true \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$==$} (\ref{labequal}), \textbf{!$=$} (\ref{labneq}), \textbf{$>=$} (\ref{labge}), \textbf{$>$} (\ref{labgt}), \textbf{$<$} (\ref{lablt}), \textbf{in} (\ref{labin}), \textbf{!} (\ref{labnot}), \textbf{$\&\&$} (\ref{laband}), \textbf{$||$} (\ref{labor}), \textbf{prec} (\ref{labprec}), \textbf{max} (\ref{labmax}), \textbf{min} (\ref{labmin}) sollya-6.0+ds/doc/length.tex000066400000000000000000000026171300174114700160400ustar00rootroot00000000000000\subsection{length} \label{lablength} \noindent Name: \textbf{length}\\ \phantom{aaa}computes the length of a list or string.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_length(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{length}(\emph{L}) : \textsf{list} $\rightarrow$ \textsf{integer}\\ \textbf{length}(\emph{s}) : \textsf{string} $\rightarrow$ \textsf{integer}\\ \end{center} Parameters: \begin{itemize} \item \emph{L} is a list. \item \emph{s} is a string. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{length} returns the length of a list or a string, e.g. the number of elements or letters. \item The empty list or string have length 0. If \emph{L} is an end-elliptic list, \textbf{length} returns +Inf. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > length("Hello World!"); 12 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > length([|1,...,5|]); 5 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > length([| |]); 0 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > length([|1,2...|]); infty \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/library.tex000066400000000000000000000136551300174114700162270ustar00rootroot00000000000000\subsection{library} \label{lablibrary} \noindent Name: \textbf{library}\\ \phantom{aaa}binds an external mathematical function to a variable in \sollya\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_libraryfunction(sollya_obj_t, char *,|\\ \verb| int (*)(mpfi_t, mpfi_t, int))|\\ \verb| sollya_obj_t sollya_lib_build_function_libraryfunction(sollya_obj_t, char *,|\\ \verb| int (*)(mpfi_t,|\\ \verb| mpfi_t, int))|\\ \verb| sollya_obj_t sollya_lib_libraryfunction_with_data(|\\ \verb| sollya_obj_t, char *,|\\ \verb| int (*)(mpfi_t, mpfi_t, int, void *),|\\ \verb| void *, void (*)(void *))|\\ \verb| sollya_obj_t sollya_lib_build_function_libraryfunction_with_data(|\\ \verb| sollya_obj_t, char *,|\\ \verb| int (*)(mpfi_t,|\\ \verb| mpfi_t, int, void *),|\\ \verb| void *, void (*)(void *))|\\[0.2cm] \noindent Usage: \begin{center} \textbf{library}(\emph{path}) : \textsf{string} $\rightarrow$ \textsf{function}\\ \end{center} \noindent Description: \begin{itemize} \item The command \textbf{library} lets you extend the set of mathematical functions known to \sollya. By default, \sollya knows the most common mathematical functions such as \textbf{exp}, \textbf{sin}, \textbf{erf}, etc. Within \sollya, these functions may be composed. This way, \sollya should satisfy the needs of a lot of users. However, for particular applications, one may want to manipulate other functions such as Bessel functions, or functions defined by an integral or even a particular solution of an ODE. \item \textbf{library} makes it possible to let \sollya know about new functions. In order to let it know, you have to provide an implementation of the function you are interested in. This implementation is a C file containing a function of the form: \begin{verbatim} int my_ident(sollya_mpfi_t result, sollya_mpfi_t op, int n)\end{verbatim} The semantic of this function is the following: it is an implementation of the function and its derivatives in interval arithmetic. \verb|my_ident(result, I, n)| shall store in \verb|result| an enclosure of the image set of the $n$-th derivative of the function f over \verb|I|: $f^{(n)}(I) \subseteq \mathrm{result}$. \item The integer value returned by the function implementation currently has no meaning. \item You do not need to provide a working implementation for any \verb|n|. Most functions of \sollya requires a relevant implementation only for $f$, $f'$ and $f''$. For higher derivatives, its is not so critical and the implementation may just store $[-\infty,\,+\infty]$ in result whenever $n>2$. \item Note that you should respect somehow interval-arithmetic standards in your implementation: \verb|result| has its own precision and you should perform the intermediate computations so that \verb|result| is as tight as possible. \item You can include sollya.h in your implementation and use library functionnalities of \sollya for your implementation. However, this requires to have compiled \sollya with \texttt{-fPIC} in order to make the \sollya executable code position independent and to use a system on with programs, using \texttt{dlopen} to open dynamic routines can dynamically open themselves. \item To bind your function into \sollya, you must use the same identifier as the function name used in your implementation file (\verb|my_ident| in the previous example). Once the function code has been bound to an identifier, you can use a simple assignment to assign the bound identifier to yet another identifier. This way, you may use convenient names inside \sollya even if your implementation environment requires you to use a less convenient name. \item The dynamic object file whose name is given to \textbf{library} for binding of an external library function may also define a destructor function \verb|int sollya_external_lib_close(void)|. If \sollya finds such a destructor function in the dynamic object file, it will call that function when closing the dynamic object file again. This happens when \sollya is terminated or when the current \sollya session is restarted using \textbf{restart}. The purpose of the destructor function is to allow the dynamically bound code to free any memory that it might have allocated before \sollya is terminated or restarted. The dynamic object file is not necessarily needed to define a destructor function. This ensure backward compatibility with older \sollya external library function object files. When defined, the destructor function is supposed to return an integer value indicating if an error has happened. Upon success, the destructor functions is to return a zero value, upon error a non-zero value. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > bashexecute("gcc -fPIC -Wall -c libraryexample.c -I$HOME/.local/include"); > bashexecute("gcc -shared -o libraryexample libraryexample.o -lgmp -lmpfr"); > myownlog = library("./libraryexample"); > evaluate(log(x), 2); 0.69314718055994530941723212145817656807550013436025 > evaluate(myownlog(x), 2); 0.69314718055994530941723212145817656807550013436025 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{function} (\ref{labfunction}), \textbf{bashexecute} (\ref{labbashexecute}), \textbf{externalproc} (\ref{labexternalproc}), \textbf{externalplot} (\ref{labexternalplot}), \textbf{diff} (\ref{labdiff}), \textbf{evaluate} (\ref{labevaluate}), \textbf{libraryconstant} (\ref{lablibraryconstant}) sollya-6.0+ds/doc/libraryconstant.tex000066400000000000000000000134631300174114700177760ustar00rootroot00000000000000\subsection{libraryconstant} \label{lablibraryconstant} \noindent Name: \textbf{libraryconstant}\\ \phantom{aaa}binds an external mathematical constant to a variable in \sollya\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_libraryconstant(char *, void (*)(mpfr_t, mp_prec_t))|\\ \verb| sollya_obj_t sollya_lib_build_function_libraryconstant(char *,|\\ \verb| void (*)(mpfr_t,|\\ \verb| mp_prec_t))|\\ \verb| sollya_obj_t sollya_lib_libraryconstant_with_data(char *,|\\ \verb| void (*)(mpfr_t,|\\ \verb| mp_prec_t,|\\ \verb| void *),|\\ \verb| void *,|\\ \verb| void (*)(void *))|\\ \verb| sollya_obj_t sollya_lib_build_function_libraryconstant_with_data(|\\ \verb| char *,|\\ \verb| void (*)(mpfr_t,|\\ \verb| mp_prec_t,|\\ \verb| void *),|\\ \verb| void *,|\\ \verb| void (*)(void *))|\\[0.2cm] \noindent Usage: \begin{center} \textbf{libraryconstant}(\emph{path}) : \textsf{string} $\rightarrow$ \textsf{function}\\ \end{center} \noindent Description: \begin{itemize} \item The command \textbf{libraryconstant} lets you extend the set of mathematical constants known to \sollya. By default, the only mathematical constant known by \sollya is \textbf{pi}. For particular applications, one may want to manipulate other constants, such as Euler's gamma constant, for instance. \item \textbf{libraryconstant} makes it possible to let \sollya know about new constants. In order to let it know, you have to provide an implementation of the constant you are interested in. This implementation is a C file containing a function of the form: \begin{verbatim} void my_ident(mpfr_t result, mp_prec_t prec)\end{verbatim} The semantic of this function is the following: it is an implementation of the constant in arbitrary precision. \verb|my_ident(result, prec)| shall set the precision of the variable result to a suitable precision (the variable is assumed to be already initialized) and store in result an approximate value of the constant with a relative error not greater than $2^{1-\mathrm{prec}}$. More precisely, if $c$ is the exact value of the constant, the value stored in result should satisfy $$|\mathrm{result}-c| \le |c|\,2^{1-\mathrm{prec}}.$$ \item You can include sollya.h in your implementation and use library functionnalities of \sollya for your implementation. However, this requires to have compiled \sollya with \texttt{-fPIC} in order to make the \sollya executable code position independent and to use a system on with programs, using \texttt{dlopen} to open dynamic routines can dynamically open themselves. \item To bind your constant into \sollya, you must use the same identifier as the function name used in your implementation file (\verb|my_ident| in the previous example). Once the function code has been bound to an identifier, you can use a simple assignment to assign the bound identifier to yet another identifier. This way, you may use convenient names inside \sollya even if your implementation environment requires you to use a less convenient name. \item Once your constant is bound, it is considered by \sollya as an infinitely accurate constant (i.e. a 0-ary function, exactly like \textbf{pi}). \item The dynamic object file whose name is given to \textbf{libraryconstant} for binding of an external library constant may also define a destructor function \verb|int sollya_external_lib_close(void)|. If \sollya finds such a destructor function in the dynamic object file, it will call that function when closing the dynamic object file again. This happens when \sollya is terminated or when the current \sollya session is restarted using \textbf{restart}. The purpose of the destructor function is to allow the dynamically bound code to free any memory that it might have allocated before \sollya is terminated or restarted. The dynamic object file is not necessarily needed to define a destructor function. This ensure backward compatibility with older \sollya external library function object files. When defined, the destructor function is supposed to return an integer value indicating if an error has happened. Upon success, the destructor functions is to return a zero value, upon error a non-zero value. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > bashexecute("gcc -fPIC -Wall -c libraryconstantexample.c -I$HOME/.local/includ e"); > bashexecute("gcc -shared -o libraryconstantexample libraryconstantexample.o -l gmp -lmpfr"); > euler_gamma = libraryconstant("./libraryconstantexample"); > prec = 20!; > euler_gamma; 0.577215 > prec = 100!; > euler_gamma; 0.577215664901532860606512090082 > midpointmode = on; Midpoint mode has been activated. > [euler_gamma]; 0.57721566490153286060651209008~2/4~ \end{Verbatim} \end{minipage}\end{center} See also: \textbf{bashexecute} (\ref{labbashexecute}), \textbf{externalproc} (\ref{labexternalproc}), \textbf{externalplot} (\ref{labexternalplot}), \textbf{pi} (\ref{labpi}), \textbf{library} (\ref{lablibrary}), \textbf{evaluate} (\ref{labevaluate}), \textbf{implementconstant} (\ref{labimplementconstant}) sollya-6.0+ds/doc/listof.tex000066400000000000000000000023041300174114700160500ustar00rootroot00000000000000\subsection{list of} \label{lablistof} \noindent Name: \textbf{list of}\\ \phantom{aaa}keyword used in combination with a type keyword\\[0.2cm] \noindent Library names:\\ \verb| SOLLYA_EXTERNALPROC_TYPE_CONSTANT_LIST|\\ \verb| SOLLYA_EXTERNALPROC_TYPE_FUNCTION_LIST|\\ \verb| SOLLYA_EXTERNALPROC_TYPE_RANGE_LIST|\\ \verb| SOLLYA_EXTERNALPROC_TYPE_INTEGER_LIST|\\ \verb| SOLLYA_EXTERNALPROC_TYPE_STRING_LIST|\\ \verb| SOLLYA_EXTERNALPROC_TYPE_BOOLEAN_LIST|\\ \verb| SOLLYA_EXTERNALPROC_TYPE_OBJECT_LIST|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{list of} is used in combination with one of the following keywords for indicating lists of the respective type in declarations of external procedures using \textbf{externalproc}: \textbf{boolean}, \textbf{constant}, \textbf{function}, \textbf{integer}, \textbf{range}, \textbf{object} and \textbf{string}. \end{itemize} See also: \textbf{externalproc} (\ref{labexternalproc}), \textbf{boolean} (\ref{labboolean}), \textbf{constant} (\ref{labconstant}), \textbf{function} (\ref{labfunction}), \textbf{integer} (\ref{labinteger}), \textbf{range} (\ref{labrange}), \textbf{string} (\ref{labstring}), \textbf{object} (\ref{labobject}) sollya-6.0+ds/doc/log.tex000066400000000000000000000012721300174114700153340ustar00rootroot00000000000000\subsection{log} \label{lablog} \noindent Name: \textbf{log}\\ \phantom{aaa}natural logarithm.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_log(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_log(sollya_obj_t)|\\ \verb| #define SOLLYA_LOG(x) sollya_lib_build_function_log(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{log} is the natural logarithm defined as the inverse of the exponential function: $\log(y)$ is the unique real number $x$ such that $\exp(x)=y$. \item It is defined only for $y \in [0; +\infty]$. \end{itemize} See also: \textbf{exp} (\ref{labexp}), \textbf{log2} (\ref{lablog2}), \textbf{log10} (\ref{lablog10}) sollya-6.0+ds/doc/log10.tex000066400000000000000000000011441300174114700154730ustar00rootroot00000000000000\subsection{log10} \label{lablog10} \noindent Name: \textbf{log10}\\ \phantom{aaa}decimal logarithm.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_log10(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_log10(sollya_obj_t)|\\ \verb| #define SOLLYA_LOG10(x) sollya_lib_build_function_log10(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{log10} is the decimal logarithm defined by: ${\rm log10}(x) = \log(x)/\log(10)$. \item It is defined only for $x \in [0; +\infty]$. \end{itemize} See also: \textbf{log} (\ref{lablog}), \textbf{log2} (\ref{lablog2}) sollya-6.0+ds/doc/log1p.tex000066400000000000000000000010701300174114700155710ustar00rootroot00000000000000\subsection{log1p} \label{lablog1p} \noindent Name: \textbf{log1p}\\ \phantom{aaa}translated logarithm.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_log1p(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_log1p(sollya_obj_t)|\\ \verb| #define SOLLYA_LOG1P(x) sollya_lib_build_function_log1p(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{log1p} is the function defined by ${\rm log1p}(x) = \log(1+x)$. \item It is defined only for $x \in [-1; +\infty]$. \end{itemize} See also: \textbf{log} (\ref{lablog}) sollya-6.0+ds/doc/log2.tex000066400000000000000000000011321300174114700154110ustar00rootroot00000000000000\subsection{log2} \label{lablog2} \noindent Name: \textbf{log2}\\ \phantom{aaa}binary logarithm.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_log2(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_log2(sollya_obj_t)|\\ \verb| #define SOLLYA_LOG2(x) sollya_lib_build_function_log2(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{log2} is the binary logarithm defined by: ${\rm log2}(x) = \log(x)/\log(2)$. \item It is defined only for $x \in [0; +\infty]$. \end{itemize} See also: \textbf{log} (\ref{lablog}), \textbf{log10} (\ref{lablog10}) sollya-6.0+ds/doc/lt.tex000066400000000000000000000033321300174114700151710ustar00rootroot00000000000000\subsection{$<$} \label{lablt} \noindent Name: \textbf{$<$}\\ \phantom{aaa}less-than operator\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_cmp_less(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \emph{expr1} \textbf{$<$} \emph{expr2} : (\textsf{constant}, \textsf{constant}) $\rightarrow$ \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr1} and \emph{expr2} represent constant expressions \end{itemize} \noindent Description: \begin{itemize} \item The operator \textbf{$<$} evaluates to true iff its operands \emph{expr1} and \emph{expr2} evaluate to two floating-point numbers $a_1$ respectively $a_2$ with the global precision \textbf{prec} and $a_1$ is less than $a_2$. The user should be aware of the fact that because of floating-point evaluation, the operator \textbf{$<$} is not exactly the same as the mathematical operation \emph{less-than}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 5 < 4; false > 5 < 5; false > 5 < 6; true > exp(2) < exp(1); false > log(1) < exp(2); true \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec = 12; The precision has been set to 12 bits. > 16384.1 < 16385.1; false \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$==$} (\ref{labequal}), \textbf{!$=$} (\ref{labneq}), \textbf{$>=$} (\ref{labge}), \textbf{$>$} (\ref{labgt}), \textbf{$<=$} (\ref{lable}), \textbf{in} (\ref{labin}), \textbf{!} (\ref{labnot}), \textbf{$\&\&$} (\ref{laband}), \textbf{$||$} (\ref{labor}), \textbf{prec} (\ref{labprec}), \textbf{max} (\ref{labmax}), \textbf{min} (\ref{labmin}) sollya-6.0+ds/doc/mantissa.tex000066400000000000000000000020221300174114700163640ustar00rootroot00000000000000\subsection{mantissa} \label{labmantissa} \noindent Name: \textbf{mantissa}\\ \phantom{aaa}returns the integer mantissa of a number.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_mantissa(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{mantissa}(\emph{x}) : \textsf{constant} $\rightarrow$ \textsf{integer}\\ \end{center} Parameters: \begin{itemize} \item \emph{x} is a dyadic number. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{mantissa}($x$) is by definition $x$ if $x$ equals 0, NaN, or Inf. \item If \emph{x} is not zero, it can be uniquely written as $x = m \cdot 2^e$ where $m$ is an odd integer and $e$ is an integer. \textbf{mantissa}(x) returns $m$. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a=round(Pi,20,RN); > e=exponent(a); > m=mantissa(a); > m; 411775 > a-m*2^e; 0 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{exponent} (\ref{labexponent}), \textbf{precision} (\ref{labprecision}) sollya-6.0+ds/doc/max.tex000066400000000000000000000061601300174114700153410ustar00rootroot00000000000000\subsection{max} \label{labmax} \noindent Name: \textbf{max}\\ \phantom{aaa}determines which of given constant expressions has maximum value\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_max(sollya_obj_t, ...)|\\ \verb| sollya_obj_t sollya_lib_v_max(sollya_obj_t, va_list)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{max}(\emph{expr1},\emph{expr2},...,\emph{exprn}) : (\textsf{constant}, \textsf{constant}, ..., \textsf{constant}) $\rightarrow$ \textsf{constant}\\ \textbf{max}(\emph{l}) : \textsf{list} $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr} are constant expressions. \item \emph{l} is a list of constant expressions. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{max} determines which of a given set of constant expressions \emph{expr} has maximum value. To do so, \textbf{max} tries to increase the precision used for evaluation until it can decide the ordering or some maximum precision is reached. In the latter case, a warning is printed indicating that there might actually be another expression that has a greater value. \item Even though \textbf{max} determines the maximum expression by evaluation, it returns the expression that is maximum as is, i.e. as an expression tree that might be evaluated to any accuracy afterwards. \item \textbf{max} can be given either an arbitrary number of constant expressions in argument or a list of constant expressions. The list however must not be end-elliptic. \item Users should be aware that the behavior of \textbf{max} follows the IEEE 754-2008 standard with respect to NaNs. In particular, \textbf{max} evaluates to NaN if and only if all arguments of \textbf{max} are NaNs. This means that NaNs may disappear during computations. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > max(1,2,3,exp(5),log(0.25)); 148.41315910257660342111558004055227962348766759388 > max(17); 17 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > l = [|1,2,3,exp(5),log(0.25)|]; > max(l); 148.41315910257660342111558004055227962348766759388 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(max(exp(17),sin(62))); exp(17) \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > print(max(17 + log2(13)/log2(9),17 + log(13)/log(9))); Warning: the tool is unable to decide a maximum computation by evaluation even t hough faithful evaluation of the terms has been possible. The terms will be cons idered to be equal. 17 + log2(13) / log2(9) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{min} (\ref{labmin}), \textbf{$==$} (\ref{labequal}), \textbf{!$=$} (\ref{labneq}), \textbf{$>=$} (\ref{labge}), \textbf{$>$} (\ref{labgt}), \textbf{$<$} (\ref{lablt}), \textbf{$<=$} (\ref{lable}), \textbf{in} (\ref{labin}), \textbf{inf} (\ref{labinf}), \textbf{sup} (\ref{labsup}) sollya-6.0+ds/doc/mid.tex000066400000000000000000000020371300174114700153240ustar00rootroot00000000000000\subsection{mid} \label{labmid} \noindent Name: \textbf{mid}\\ \phantom{aaa}gives the middle of an interval.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_mid(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{mid}(\emph{I}) : \textsf{range} $\rightarrow$ \textsf{constant}\\ \textbf{mid}(\emph{x}) : \textsf{constant} $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{I} is an interval. \item \emph{x} is a real number. \end{itemize} \noindent Description: \begin{itemize} \item Returns the middle of the interval \emph{I}. If the middle is not exactly representable at the current precision, the value is returned as an unevaluated expression. \item When called on a real number \emph{x}, \textbf{mid} behaves like the identity. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > mid([1;3]); 2 > mid(17); 17 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{inf} (\ref{labinf}), \textbf{sup} (\ref{labsup}) sollya-6.0+ds/doc/midpointmode.tex000066400000000000000000000034631300174114700172470ustar00rootroot00000000000000\subsection{midpointmode} \label{labmidpointmode} \noindent Name: \textbf{midpointmode}\\ \phantom{aaa}global variable controlling the way intervals are displayed.\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_midpointmode_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_midpointmode(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_midpointmode()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{midpointmode} = \emph{activation value} : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{midpointmode} = \emph{activation value} ! : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{midpointmode} : \textsf{on$|$off}\\ \end{center} Parameters: \begin{itemize} \item \emph{activation value} enables or disables the mode. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{midpointmode} is a global variable. When its value is \textbf{off}, intervals are displayed as usual (in the form $\left[ a;b\right]$). When its value is \textbf{on}, and if $a$ and $b$ have the same first significant digits, the interval in displayed in a way that lets one immediately see the common digits of the two bounds. \item This mode is supported only with \textbf{display} set to \textbf{decimal}. In other modes of display, \textbf{midpointmode} value is simply ignored. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a = round(Pi,30,RD); > b = round(Pi,30,RU); > d = [a,b]; > d; [3.1415926516056060791015625;3.1415926553308963775634765625] > midpointmode=on!; > d; 0.314159265~1/6~e1 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{on} (\ref{labon}), \textbf{off} (\ref{laboff}), \textbf{roundingwarnings} (\ref{labroundingwarnings}), \textbf{display} (\ref{labdisplay}), \textbf{decimal} (\ref{labdecimal}) sollya-6.0+ds/doc/min.tex000066400000000000000000000061571300174114700153450ustar00rootroot00000000000000\subsection{min} \label{labmin} \noindent Name: \textbf{min}\\ \phantom{aaa}determines which of given constant expressions has minimum value\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_min(sollya_obj_t, ...)|\\ \verb| sollya_obj_t sollya_lib_v_min(sollya_obj_t, va_list)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{min}(\emph{expr1},\emph{expr2},...,\emph{exprn}) : (\textsf{constant}, \textsf{constant}, ..., \textsf{constant}) $\rightarrow$ \textsf{constant}\\ \textbf{min}(\emph{l}) : \textsf{list} $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr} are constant expressions. \item \emph{l} is a list of constant expressions. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{min} determines which of a given set of constant expressions \emph{expr} has minimum value. To do so, \textbf{min} tries to increase the precision used for evaluation until it can decide the ordering or some maximum precision is reached. In the latter case, a warning is printed indicating that there might actually be another expression that has a lesser value. \item Even though \textbf{min} determines the minimum expression by evaluation, it returns the expression that is minimum as is, i.e. as an expression tree that might be evaluated to any accuracy afterwards. \item \textbf{min} can be given either an arbitrary number of constant expressions in argument or a list of constant expressions. The list however must not be end-elliptic. \item Users should be aware that the behavior of \textbf{min} follows the IEEE 754-2008 standard with respect to NaNs. In particular, \textbf{min} evaluates to NaN if and only if all arguments of \textbf{min} are NaNs. This means that NaNs may disappear during computations. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > min(1,2,3,exp(5),log(0.25)); -1.3862943611198906188344642429163531361510002687205 > min(17); 17 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > l = [|1,2,3,exp(5),log(0.25)|]; > min(l); -1.3862943611198906188344642429163531361510002687205 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(min(exp(17),sin(62))); sin(62) \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > print(min(17 + log2(13)/log2(9),17 + log(13)/log(9))); Warning: the tool is unable to decide a minimum computation by evaluation even t hough faithful evaluation of the terms has been possible. The terms will be cons idered to be equal. 17 + log(13) / log(9) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{max} (\ref{labmax}), \textbf{$==$} (\ref{labequal}), \textbf{!$=$} (\ref{labneq}), \textbf{$>=$} (\ref{labge}), \textbf{$>$} (\ref{labgt}), \textbf{$<$} (\ref{lablt}), \textbf{$<=$} (\ref{lable}), \textbf{in} (\ref{labin}), \textbf{inf} (\ref{labinf}), \textbf{sup} (\ref{labsup}) sollya-6.0+ds/doc/minus.tex000066400000000000000000000070001300174114700157010ustar00rootroot00000000000000\subsection{$-$} \label{labminus} \noindent Name: \textbf{$-$}\\ \phantom{aaa}subtraction function\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_sub(sollya_obj_t, sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_sub(sollya_obj_t, sollya_obj_t)|\\ \verb| #define SOLLYA_SUB(x,y) sollya_lib_build_function_sub((x), (y))|\\ \verb| sollya_obj_t sollya_lib_neg(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_neg(sollya_obj_t)|\\ \verb| #define SOLLYA_NEG(x) sollya_lib_build_function_neg(x)|\\[0.2cm] \noindent Usage: \begin{center} \emph{function1} \textbf{$-$} \emph{function2} : (\textsf{function}, \textsf{function}) $\rightarrow$ \textsf{function}\\ \emph{interval1} \textbf{$-$} \emph{interval2} : (\textsf{range}, \textsf{range}) $\rightarrow$ \textsf{range}\\ \emph{interval1} \textbf{$-$} \emph{constant} : (\textsf{range}, \textsf{constant}) $\rightarrow$ \textsf{range}\\ \emph{interval1} \textbf{$-$} \emph{constant} : (\textsf{constant}, \textsf{range}) $\rightarrow$ \textsf{range}\\ \textbf{$-$} \emph{function1} : \textsf{function} $\rightarrow$ \textsf{function}\\ \textbf{$-$} \emph{interval1} : \textsf{range} $\rightarrow$ \textsf{range}\\ \end{center} Parameters: \begin{itemize} \item \emph{function1} and \emph{function2} represent functions \item \emph{interval1} and \emph{interval2} represent intervals (ranges) \item \emph{constant} represents a constant or constant expression \end{itemize} \noindent Description: \begin{itemize} \item \textbf{$-$} represents the subtraction (function) on reals. The expression \emph{function1} \textbf{$-$} \emph{function2} stands for the function composed of the subtraction function and the two functions \emph{function1} and \emph{function2}, where \emph{function1} is the subtrahend and \emph{function2} the subtractor. \item \textbf{$-$} can be used for interval arithmetic on intervals (ranges). \textbf{$-$} will evaluate to an interval that safely encompasses all images of the subtraction function with arguments varying in the given intervals. Any combination of intervals with intervals or constants (resp. constant expressions) is supported. However, it is not possible to represent families of functions using an interval as one argument and a function (varying in the free variable) as the other one. \item \textbf{$-$} stands also for the negation function. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 5 - 2; 3 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > x - 2; -2 + x \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > x - x; 0 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > diff(sin(x) - exp(x)); cos(x) - exp(x) \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [1;2] - [3;4]; [-3;-1] > [1;2] - 17; [-16;-15] > 13 - [-4;17]; [-4;17] \end{Verbatim} \end{minipage}\end{center} \noindent Example 6: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > -exp(x); -exp(x) > -13; -13 > -[13;17]; [-17;-13] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$+$} (\ref{labplus}), \textbf{$*$} (\ref{labmult}), \textbf{/} (\ref{labdivide}), \textbf{$\mathbf{\hat{~}}$} (\ref{labpower}) sollya-6.0+ds/doc/mult.tex000066400000000000000000000055721300174114700155430ustar00rootroot00000000000000\subsection{$*$} \label{labmult} \noindent Name: \textbf{$*$}\\ \phantom{aaa}multiplication function\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_mul(sollya_obj_t, sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_mul(sollya_obj_t, sollya_obj_t)|\\ \verb| #define SOLLYA_MUL(x,y) sollya_lib_build_function_mul((x), (y))|\\[0.2cm] \noindent Usage: \begin{center} \emph{function1} \textbf{$*$} \emph{function2} : (\textsf{function}, \textsf{function}) $\rightarrow$ \textsf{function}\\ \emph{interval1} \textbf{$*$} \emph{interval2} : (\textsf{range}, \textsf{range}) $\rightarrow$ \textsf{range}\\ \emph{interval1} \textbf{$*$} \emph{constant} : (\textsf{range}, \textsf{constant}) $\rightarrow$ \textsf{range}\\ \emph{interval1} \textbf{$*$} \emph{constant} : (\textsf{constant}, \textsf{range}) $\rightarrow$ \textsf{range}\\ \end{center} Parameters: \begin{itemize} \item \emph{function1} and \emph{function2} represent functions \item \emph{interval1} and \emph{interval2} represent intervals (ranges) \item \emph{constant} represents a constant or constant expression \end{itemize} \noindent Description: \begin{itemize} \item \textbf{$*$} represents the multiplication (function) on reals. The expression \emph{function1} \textbf{$*$} \emph{function2} stands for the function composed of the multiplication function and the two functions \emph{function1} and \emph{function2}. \item \textbf{$*$} can be used for interval arithmetic on intervals (ranges). \textbf{$*$} will evaluate to an interval that safely encompasses all images of the multiplication function with arguments varying in the given intervals. Any combination of intervals with intervals or constants (resp. constant expressions) is supported. However, it is not possible to represent families of functions using an interval as one argument and a function (varying in the free variable) as the other one. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 5 * 2; 10 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > x * 2; x * 2 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > x * x; x^2 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > diff(sin(x) * exp(x)); sin(x) * exp(x) + exp(x) * cos(x) \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [1;2] * [3;4]; [3;8] > [1;2] * 17; [17;34] > 13 * [-4;17]; [-52;221] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$+$} (\ref{labplus}), \textbf{$-$} (\ref{labminus}), \textbf{/} (\ref{labdivide}), \textbf{$\mathbf{\hat{~}}$} (\ref{labpower}) sollya-6.0+ds/doc/nearestint.tex000066400000000000000000000015421300174114700167270ustar00rootroot00000000000000\subsection{nearestint} \label{labnearestint} \noindent Name: \textbf{nearestint}\\ \phantom{aaa}the function mapping the reals to the integers nearest to them.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_nearestint(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_nearestint(sollya_obj_t)|\\ \verb| #define SOLLYA_NEARESTINT(x) sollya_lib_build_function_nearestint(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{nearestint} is defined as usual: \textbf{nearestint}($x$) is the integer nearest to $x$, with the special rule that the even integer is chosen if there exist two integers equally near to $x$. \item It is defined for every real number $x$. \end{itemize} See also: \textbf{ceil} (\ref{labceil}), \textbf{floor} (\ref{labfloor}), \textbf{round} (\ref{labround}), \textbf{RN} (\ref{labrn}) sollya-6.0+ds/doc/neq.tex000066400000000000000000000063531300174114700153430ustar00rootroot00000000000000\subsection{!$=$} \label{labneq} \noindent Name: \textbf{!$=$}\\ \phantom{aaa}negated equality test operator\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_cmp_not_equal(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \emph{expr1} \textbf{!$=$} \emph{expr2} : (\textsf{any type}, \textsf{any type}) $\rightarrow$ \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr1} and \emph{expr2} represent expressions \end{itemize} \noindent Description: \begin{itemize} \item The operator \textbf{!$=$} evaluates to true iff its operands \emph{expr1} and \emph{expr2} are syntactically unequal and both different from \textbf{error}, constant expressions that are not constants and that evaluate to two different floating-point number with the global precision \textbf{prec} or polynomials that are unequal while automatic expression simplification is activated. The user should be aware of the fact that because of floating-point evaluation, the operator \textbf{!$=$} is not exactly the same as the negation of the mathematical equality. Further, expressions that are polynomials may not be structurally equal when \textbf{!$=$} evaluates to \textbf{false}; in order to obtain purely structural tests, the user should deactivate automatic simplification using \textbf{autosimplify}. Note that the expressions \textbf{!}(\emph{expr1} \textbf{!$=$} \emph{expr2}) and \emph{expr1} \textbf{$==$} \emph{expr2} do not evaluate to the same boolean value. See \textbf{error} for details. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > "Hello" != "Hello"; false > "Hello" != "Salut"; true > "Hello" != 5; true > 5 + x != 5 + x; false \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 1 != exp(0); false > asin(1) * 2 != pi; false > exp(5) != log(4); true \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > sin(pi/6) != 1/2 * sqrt(3); true \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec = 12; The precision has been set to 12 bits. > 16384.1 != 16385.1; false \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > error != error; false \end{Verbatim} \end{minipage}\end{center} \noindent Example 6: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p = x + x^2; > q = x * (1 + x); > autosimplify = on; Automatic pure tree simplification has been activated. > p != q; false > autosimplify = off; Automatic pure tree simplification has been deactivated. > p != q; true \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$==$} (\ref{labequal}), \textbf{$>$} (\ref{labgt}), \textbf{$>=$} (\ref{labge}), \textbf{$<=$} (\ref{lable}), \textbf{$<$} (\ref{lablt}), \textbf{in} (\ref{labin}), \textbf{!} (\ref{labnot}), \textbf{$\&\&$} (\ref{laband}), \textbf{$||$} (\ref{labor}), \textbf{error} (\ref{laberror}), \textbf{prec} (\ref{labprec}), \textbf{autosimplify} (\ref{labautosimplify}) sollya-6.0+ds/doc/nop.tex000066400000000000000000000031551300174114700153510ustar00rootroot00000000000000\subsection{nop} \label{labnop} \noindent Name: \textbf{nop}\\ \phantom{aaa}no operation\\[0.2cm] \noindent Usage: \begin{center} \textbf{nop} : \textsf{void} $\rightarrow$ \textsf{void}\\ \textbf{nop}() : \textsf{void} $\rightarrow$ \textsf{void}\\ \textbf{nop}(\emph{n}) : \textsf{integer} $\rightarrow$ \textsf{void}\\ \end{center} \noindent Description: \begin{itemize} \item The command \textbf{nop} does nothing. This means it is an explicit parse element in the \sollya language that finally does not produce any result or side-effect. \item The command \textbf{nop} may take an optional positive integer argument \emph{n}. The argument controls how much (useless) multiprecision floating-point multiplications \sollya performs while doing nothing. With this behaviour, \textbf{nop} can be used for calibration of timing tests. \item The keyword \textbf{nop} is implicit in some procedure definitions. Procedures without imperative body get parsed as if they had an imperative body containing one \textbf{nop} statement. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > nop; \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > nop(100); \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > succ = proc(n) { return n + 1; }; > succ; proc(n) { nop; return (n) + (1); } > succ(5); 6 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{proc} (\ref{labproc}), \textbf{time} (\ref{labtime}) sollya-6.0+ds/doc/not.tex000066400000000000000000000017601300174114700153550ustar00rootroot00000000000000\subsection{!} \label{labnot} \noindent Name: \textbf{!}\\ \phantom{aaa}boolean NOT operator\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_negate(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{!} \emph{expr} : \textsf{boolean} $\rightarrow$ \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr} represents a boolean expression \end{itemize} \noindent Description: \begin{itemize} \item \textbf{!} evaluates to the boolean NOT of the boolean expression \emph{expr}. \textbf{!} \emph{expr} evaluates to true iff \emph{expr} does not evaluate to true. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > ! false; true \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > ! (1 == exp(0)); false \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$\&\&$} (\ref{laband}), \textbf{$||$} (\ref{labor}) sollya-6.0+ds/doc/numberroots.tex000066400000000000000000000072061300174114700171350ustar00rootroot00000000000000\subsection{numberroots} \label{labnumberroots} \noindent Name: \textbf{numberroots}\\ \phantom{aaa}Computes the number of roots of a polynomial in a given range.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_numberroots(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{numberroots}(\emph{p}, \emph{I}) : (\textsf{function}, \textsf{range}) $\rightarrow$ \textsf{integer}\\ \end{center} Parameters: \begin{itemize} \item \emph{p} is a polynomial. \item \emph{I} is an interval. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{numberroots} rigorously computes the number of roots of polynomial the $p$ in the interval $I$. The technique used is Sturm's algorithm. The value returned is not just a numerical estimation of the number of roots of $p$ in $I$: it is the exact number of roots. \item The command \textbf{findzeros} computes safe enclosures of all the zeros of a function, without forgetting any, but it is not guaranteed to separate them all in distinct intervals. \textbf{numberroots} is more accurate since it guarantees the exact number of roots. However, it does not compute them. It may be used, for instance, to certify that \textbf{findzeros} did not put two distinct roots in the same interval. \item Multiple roots are counted only once. \item The interval $I$ must be bounded. The algorithm cannot handle unbounded intervals. Moreover, the interval is considered as a closed interval: if one (or both) of the endpoints of $I$ are roots of $p$, they are counted. \item The argument $p$ can be any expression, but if \sollya fails to prove that it is a polynomial an error is produced. Also, please note that if the coefficients of $p$ or the endpoints of $I$ are not exactly representable, they are first numerically evaluated, before the algorithm is used. In that case, the counted number of roots corresponds to the rounded polynomial on the rounded interval \textbf{and not} to the exact parameters given by the user. A warning is displayed to inform the user. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > numberroots(1+x-x^2, [1,2]); 1 > findzeros(1+x-x^2, [1,2]); [|[1.617919921875;1.6180419921875]|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > numberroots((1+x)*(1-x), [-1,1]); 2 > numberroots(x^2, [-1,1]); 1 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > numberroots(x-pi, [0,4]); Warning: the 0th coefficient of the polynomial is neither a floating point constant nor can be evaluated without rounding to a floating point constant. Will faithfully evaluate it with the current precision (165 bits) 1 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > numberroots(1+x-x^2, [0, @Inf@]); Warning: the given interval must have finite bounds. Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. error > numberroots(exp(x), [0, 1]); Warning: the given function must be a polynomial in this context. Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. error \end{Verbatim} \end{minipage}\end{center} See also: \textbf{dirtyfindzeros} (\ref{labdirtyfindzeros}), \textbf{findzeros} (\ref{labfindzeros}) sollya-6.0+ds/doc/numerator.tex000066400000000000000000000034241300174114700165700ustar00rootroot00000000000000\subsection{numerator} \label{labnumerator} \noindent Name: \textbf{numerator}\\ \phantom{aaa}gives the numerator of an expression\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_numerator(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{numerator}(\emph{expr}) : \textsf{function} $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr} represents an expression \end{itemize} \noindent Description: \begin{itemize} \item If \emph{expr} represents a fraction \emph{expr1}/\emph{expr2}, \textbf{numerator}(\emph{expr}) returns the numerator of this fraction, i.e. \emph{expr1}. If \emph{expr} represents something else, \textbf{numerator}(\emph{expr}) returns the expression itself, i.e. \emph{expr}. Note that for all expressions \emph{expr}, \textbf{numerator}(\emph{expr}) \textbf{/} \textbf{denominator}(\emph{expr}) is equal to \emph{expr}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > numerator(5/3); 5 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > numerator(exp(x)); exp(x) \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a = 5/3; > b = numerator(a)/denominator(a); > print(a); 5 / 3 > print(b); 5 / 3 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a = exp(x/3); > b = numerator(a)/denominator(a); > print(a); exp(x / 3) > print(b); exp(x / 3) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{denominator} (\ref{labdenominator}), \textbf{rationalmode} (\ref{labrationalmode}) sollya-6.0+ds/doc/object.tex000066400000000000000000000017501300174114700160220ustar00rootroot00000000000000\subsection{object} \label{labobject} \noindent Name: \textbf{object}\\ \phantom{aaa}keyword representing a \sollya object type \\[0.2cm] \noindent Library name:\\ \verb| SOLLYA_EXTERNALPROC_TYPE_OBJECT|\\[0.2cm] \noindent Usage: \begin{center} \textbf{object} : \textsf{type type}\\ \end{center} \noindent Description: \begin{itemize} \item \textbf{object} represents the \sollya object type for declarations of external procedures \textbf{externalproc}. Remark that in contrast to other indicators, type indicators like \textbf{object} cannot be handled outside the \textbf{externalproc} context. In particular, they cannot be assigned to variables. \end{itemize} See also: \textbf{externalproc} (\ref{labexternalproc}), \textbf{boolean} (\ref{labboolean}), \textbf{constant} (\ref{labconstant}), \textbf{function} (\ref{labfunction}), \textbf{list of} (\ref{lablistof}), \textbf{range} (\ref{labrange}), \textbf{string} (\ref{labstring}), \textbf{integer} (\ref{labinteger}) sollya-6.0+ds/doc/objectname.tex000066400000000000000000000111301300174114700166540ustar00rootroot00000000000000\subsection{objectname} \label{labobjectname} \noindent Name: \textbf{objectname}\\ \phantom{aaa}returns, given a \sollya object, a string that can be reparsed to the object\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_objectname(sollya_obj_t);|\\[0.2cm] \noindent Usage: \begin{center} \textbf{objectname}(\emph{obj}) : \textsf{any type} $\rightarrow$ \textsf{string}\\ \end{center} \noindent Description: \begin{itemize} \item \textbf{objectname}(\emph{obj}) queries the \sollya symbol table in order to recover the name of an identifier the object \emph{obj} is assigned to. If it succeeds, it returns a string containing the recovered identifier. In contrast, if it does not succeed, it returns a string simply containing a textual representation of~\emph{obj}. \item The only condition for an identifier to be eligible to be returned by \textbf{objectname}(\emph{obj}) is to be accessible in the scope \textbf{objectname} is executed in, \emph{i.e.}, not to be shadowed by an identifier of the same name which does not hold the object \emph{obj}. \item In any case, if the string returned by \textbf{objectname} is given to the \textbf{parse} command in the same scope, the original object \emph{obj} is recovered. \item \textbf{objectname} is particularly useful in combination with \textbf{getbacktrace}, when the \sollya procedure stack is to be displayed in a fashion, where procedures are identified by their name and not their procedural content. \item \textbf{objectname} may also be used to get a string representation of the free mathematical variable. \item If an object is simply to be cast into a string, without trying to retrieve an identifier for it, \textbf{objectname} is not appropriate. In this case, it suffices to concatenate it to an empty string with the \textbf{@} operator. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > s = "Hello"; > objectname("Hello"); s \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = exp(x); > g = sin(x); > [| objectname(exp(x)), objectname(sin(x)), objectname(cos(x)) |]; [|"f", "g", "cos(x)"|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > o = { .f = exp(x), .I = [-1;1] }; > s1 = o@""; s1; { .f = exp(x), .I = [-1;1] } > s2 = objectname({ .I = [-1;1], .f = exp(x)}); s2; o > parse(s1) == parse(s2); true > write("s2 = \"", s2, "\" parses to ", parse(s2), "\n"); s2 = "o" parses to { .f = exp(x), .I = [-1;1] } \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > n = 1664; > objectname(n); n \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = exp(x); > g = sin(x); > procedure test() { var f; var h; f = tan(x); h = cos(x); [| objectname(exp(x)), objectname(sin(x)), objectname(cos(x)), objectname( tan(x)) |]; }; > test(); [|"exp(x)", "g", "h", "f"|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 6: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure apply_proc(p, a, b) { return p(a, b); }; > procedure show_trace_and_add(n, m) { var i, bt; bt = getbacktrace(); write("Procedure stack:\n"); for i from 0 to length(bt) - 1 do { write(" Procedure ", objectname((bt[i]).called_proc), " called with ", length((bt[i]).passed_args), " arguments\n"); }; write("\n"); return n + m; }; > procedure show_and_succ(u) { return apply_proc(show_trace_and_add, u, 1); }; > show_and_succ(16); Procedure stack: Procedure show_trace_and_add called with 2 arguments Procedure apply_proc called with 3 arguments Procedure show_and_succ called with 1 arguments 17 \end{Verbatim} \end{minipage}\end{center} \noindent Example 7: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = exp(three_decker_sauerkraut_and_toadstool_sandwich_with_arsenic_sauce); > g = sin(_x_); > h = f(g); > h; exp(sin(three_decker_sauerkraut_and_toadstool_sandwich_with_arsenic_sauce)) > objectname(_x_); three_decker_sauerkraut_and_toadstool_sandwich_with_arsenic_sauce \end{Verbatim} \end{minipage}\end{center} See also: \textbf{parse} (\ref{labparse}), \textbf{var} (\ref{labvar}), \textbf{getbacktrace} (\ref{labgetbacktrace}), \textbf{proc} (\ref{labproc}), \textbf{procedure} (\ref{labprocedure}), \textbf{@} (\ref{labconcat}) sollya-6.0+ds/doc/off.tex000066400000000000000000000023631300174114700153270ustar00rootroot00000000000000\subsection{off} \label{laboff} \noindent Name: \textbf{off}\\ \phantom{aaa}special value for certain global variables.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_off()|\\ \verb| int sollya_lib_is_off(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{off} is a special value used to deactivate certain functionnalities of \sollya. \item As any value it can be affected to a variable and stored in lists. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > canonical=on; Canonical automatic printing output has been activated. > p=1+x+x^2; > mode=off; > p; 1 + x + x^2 > canonical=mode; Canonical automatic printing output has been deactivated. > p; 1 + x * (1 + x) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{on} (\ref{labon}), \textbf{autosimplify} (\ref{labautosimplify}), \textbf{canonical} (\ref{labcanonical}), \textbf{timing} (\ref{labtiming}), \textbf{fullparentheses} (\ref{labfullparentheses}), \textbf{midpointmode} (\ref{labmidpointmode}), \textbf{rationalmode} (\ref{labrationalmode}), \textbf{roundingwarnings} (\ref{labroundingwarnings}), \textbf{timing} (\ref{labtiming}), \textbf{dieonerrormode} (\ref{labdieonerrormode}) sollya-6.0+ds/doc/on.tex000066400000000000000000000022431300174114700151660ustar00rootroot00000000000000\subsection{on} \label{labon} \noindent Name: \textbf{on}\\ \phantom{aaa}special value for certain global variables.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_on()|\\ \verb| int sollya_lib_is_on(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{on} is a special value used to activate certain functionnalities of \sollya. \item As any value it can be affected to a variable and stored in lists. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p=1+x+x^2; > mode=on; > p; 1 + x * (1 + x) > canonical=mode; Canonical automatic printing output has been activated. > p; 1 + x + x^2 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{off} (\ref{laboff}), \textbf{autosimplify} (\ref{labautosimplify}), \textbf{canonical} (\ref{labcanonical}), \textbf{timing} (\ref{labtiming}), \textbf{fullparentheses} (\ref{labfullparentheses}), \textbf{midpointmode} (\ref{labmidpointmode}), \textbf{rationalmode} (\ref{labrationalmode}), \textbf{roundingwarnings} (\ref{labroundingwarnings}), \textbf{timing} (\ref{labtiming}), \textbf{dieonerrormode} (\ref{labdieonerrormode}) sollya-6.0+ds/doc/or.tex000066400000000000000000000021611300174114700151710ustar00rootroot00000000000000\subsection{$||$} \label{labor} \noindent Name: \textbf{$||$}\\ \phantom{aaa}boolean OR operator\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_or(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \emph{expr1} \textbf{$||$} \emph{expr2} : (\textsf{boolean}, \textsf{boolean}) $\rightarrow$ \textsf{boolean}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr1} and \emph{expr2} represent boolean expressions \end{itemize} \noindent Description: \begin{itemize} \item \textbf{$||$} evaluates to the boolean OR of the two boolean expressions \emph{expr1} and \emph{expr2}. \textbf{$||$} evaluates to true iff at least one of \emph{expr1} or \emph{expr2} evaluates to true. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > false || false; false \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > (1 == exp(0)) || (0 == log(1)); true \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$\&\&$} (\ref{laband}), \textbf{!} (\ref{labnot}) sollya-6.0+ds/doc/parse.tex000066400000000000000000000052111300174114700156620ustar00rootroot00000000000000\subsection{parse} \label{labparse} \noindent Name: \textbf{parse}\\ \phantom{aaa}parses an expression contained in a string\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_parse(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{parse}(\emph{string}) : \textsf{string} $\rightarrow$ \textsf{function} $|$ \textsf{error}\\ \end{center} Parameters: \begin{itemize} \item \emph{string} represents a character sequence \end{itemize} \noindent Description: \begin{itemize} \item \textbf{parse}(\emph{string}) parses the character sequence \emph{string} containing an expression built on constants and base functions. If the character sequence does not contain a well-defined expression, a warning is displayed indicating a syntax error and \textbf{parse} returns a \textbf{error} of type \textsf{error}. \item The character sequence to be parsed by \textbf{parse} may contain commands that return expressions, including \textbf{parse} itself. Those commands get executed after the string has been parsed. \textbf{parse}(\emph{string}) will return the expression computed by the commands contained in the character sequence \emph{string}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > parse("exp(x)"); exp(x) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > text = "remez(exp(x),5,[-1;1])"; > print("The string", text, "gives", parse(text)); The string remez(exp(x),5,[-1;1]) gives 8.73819098827562036768683157316876049039 64388498642e-3 * x^5 + 4.3793696379596015478233171265365272893795005588381e-2 * x^4 + 0.16642465614952768185129433844012193925654065755905 * x^3 + 0.49919698262 963614991826575452094101562044819693772 * x^2 + 1.000038346505998154663400680582 31011540878088492516 * x + 1.00004475029559502606203712816558243384077522932213 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > parse("5 + * 3"); Warning: syntax error, unexpected *. Will try to continue parsing (expecting ";" ). May leak memory. Warning: the string "5 + * 3" could not be parsed by the miniparser. Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. error \end{Verbatim} \end{minipage}\end{center} See also: \textbf{execute} (\ref{labexecute}), \textbf{readfile} (\ref{labreadfile}), \textbf{print} (\ref{labprint}), \textbf{error} (\ref{laberror}), \textbf{dieonerrormode} (\ref{labdieonerrormode}) sollya-6.0+ds/doc/perturb.tex000066400000000000000000000022451300174114700162370ustar00rootroot00000000000000\subsection{perturb} \label{labperturb} \noindent Name: \textbf{perturb}\\ \phantom{aaa}indicates random perturbation of sampling points for \textbf{externalplot}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_perturb()|\\ \verb| int sollya_lib_is_perturb(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{perturb} : \textsf{perturb}\\ \end{center} \noindent Description: \begin{itemize} \item The use of \textbf{perturb} in the command \textbf{externalplot} enables the addition of some random noise around each sampling point in \textbf{externalplot}. See \textbf{externalplot} for details. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > bashexecute("gcc -fPIC -c externalplotexample.c"); > bashexecute("gcc -shared -o externalplotexample externalplotexample.o -lgmp -l mpfr"); > externalplot("./externalplotexample",relative,exp(x),[-1/2;1/2],12,perturb); \end{Verbatim} \end{minipage}\end{center} See also: \textbf{externalplot} (\ref{labexternalplot}), \textbf{absolute} (\ref{lababsolute}), \textbf{relative} (\ref{labrelative}), \textbf{bashexecute} (\ref{labbashexecute}) sollya-6.0+ds/doc/pi.tex000066400000000000000000000042541300174114700151660ustar00rootroot00000000000000\subsection{pi} \label{labpi} \noindent Name: \textbf{pi}\\ \phantom{aaa}the constant $\pi$.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_pi()|\\ \verb| int sollya_lib_is_pi(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_pi()|\\ \verb| #define SOLLYA_PI (sollya_lib_build_function_pi())|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{pi} is the constant $\pi$, defined as half the period of sine and cosine. \item In \sollya, \textbf{pi} is considered a 0-ary function. This way, the constant is not evaluated at the time of its definition but at the time of its use. For instance, when you define a constant or a function relating to $\pi$, the current precision at the time of the definition does not matter. What is important is the current precision when you evaluate the function or the constant value. \item Remark that when you define an interval, the bounds are first evaluated and then the interval is defined. In this case, \textbf{pi} will be evaluated as any other constant value at the definition time of the interval, thus using the current precision at this time. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; prec=12!; > a = 2*pi; > a; Warning: rounding has happened. The value displayed is a faithful rounding to 12 bits of the true result. 6.283 > prec=20!; > a; Warning: rounding has happened. The value displayed is a faithful rounding to 20 bits of the true result. 6.28319 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary; Display mode is binary numbers. > prec=12!; > d = [pi; 5]; > d; [1.1001001_2 * 2^(1);1.01_2 * 2^(2)] > prec=20!; > d; [1.1001001_2 * 2^(1);1.01_2 * 2^(2)] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{cos} (\ref{labcos}), \textbf{sin} (\ref{labsin}), \textbf{tan} (\ref{labtan}), \textbf{asin} (\ref{labasin}), \textbf{acos} (\ref{labacos}), \textbf{atan} (\ref{labatan}), \textbf{evaluate} (\ref{labevaluate}), \textbf{prec} (\ref{labprec}), \textbf{libraryconstant} (\ref{lablibraryconstant}) sollya-6.0+ds/doc/plot.tex000066400000000000000000000122021300174114700155240ustar00rootroot00000000000000\subsection{plot} \label{labplot} \noindent Name: \textbf{plot}\\ \phantom{aaa}plots one or several functions\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_plot(sollya_obj_t, sollya_obj_t, ...)|\\ \verb| void sollya_lib_v_plot(sollya_obj_t, sollya_obj_t, va_list)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{plot}(\emph{f1}, ... ,\emph{fn}, \emph{I}) : (\textsf{function}, ... ,\textsf{function}, \textsf{range}) $\rightarrow$ \textsf{void}\\ \textbf{plot}(\emph{f1}, ... ,\emph{fn}, \emph{I}, \textbf{file}, \emph{name}) : (\textsf{function}, ... ,\textsf{function}, \textsf{range}, \textbf{file}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \textbf{plot}(\emph{f1}, ... ,\emph{fn}, \emph{I}, \textbf{postscript}, \emph{name}) : (\textsf{function}, ... ,\textsf{function}, \textsf{range}, \textbf{postscript}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \textbf{plot}(\emph{f1}, ... ,\emph{fn}, \emph{I}, \textbf{postscriptfile}, \emph{name}) : (\textsf{function}, ... ,\textsf{function}, \textsf{range}, \textbf{postscriptfile}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \textbf{plot}(\emph{L}, \emph{I}) : (\textsf{list}, \textsf{range}) $\rightarrow$ \textsf{void}\\ \textbf{plot}(\emph{L}, \emph{I}, \textbf{file}, \emph{name}) : (\textsf{list}, \textsf{range}, \textbf{file}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \textbf{plot}(\emph{L}, \emph{I}, \textbf{postscript}, \emph{name}) : (\textsf{list}, \textsf{range}, \textbf{postscript}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \textbf{plot}(\emph{L}, \emph{I}, \textbf{postscriptfile}, \emph{name}) : (\textsf{list}, \textsf{range}, \textbf{postscriptfile}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{f1}, ..., \emph{fn} are functions to be plotted. \item \emph{L} is a list of functions to be plotted. \item \emph{I} is the interval where the functions have to be plotted. \item \emph{name} is a string representing the name of a file. \end{itemize} \noindent Description: \begin{itemize} \item This command plots one or several functions \emph{f1}, ... ,\emph{fn} on an interval \emph{I}. Functions can be either given as parameters of \textbf{plot} or as a list \emph{L} which elements are functions. The functions are drawn on the same plot with different colors. \item If \emph{L} contains an element that is not a function (or a constant), an error occurs. \item \textbf{plot} relies on the value of global variable \textbf{points}. Let $n$ be the value of this variable. The algorithm is the following: each function is evaluated at $n$ evenly distributed points in \emph{I}. At each point, the computed value is a faithful rounding of the exact value with a sufficiently high precision. Each point is finally plotted. This should avoid numerical artefacts such as critical cancellations. \item You can save the function plot either as a data file or as a postscript file. \item If you use argument \textbf{file} with a string \emph{name}, \sollya will save a data file called name.dat and a gnuplot directives file called name.p. Invoking gnuplot on name.p will plot the data stored in name.dat. \item If you use argument \textbf{postscript} with a string \emph{name}, \sollya will save a postscript file called name.eps representing your plot. \item If you use argument \textbf{postscriptfile} with a string \emph{name}, \sollya will produce the corresponding name.dat, name.p and name.eps. \item This command uses gnuplot to produce the final plot. If your terminal is not graphic (typically if you use \sollya through ssh without -X) gnuplot should be able to detect that and produce an ASCII-art version on the standard output. If it is not the case, you can either store the plot in a postscript file to view it locally, or use \textbf{asciiplot} command. \item If every function is constant, \textbf{plot} will not plot them but just display their value. \item If the interval is reduced to a single point, \textbf{plot} will just display the value of the functions at this point. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > plot(sin(x),0,cos(x),[-Pi,Pi]); \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > plot(sin(x),0,cos(x),[-Pi,Pi],postscriptfile,"plotSinCos"); \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > plot(exp(0), sin(1), [0;1]); 1 0.84147098480789650665250232163029899962256306079837 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > plot(sin(x), cos(x), [1;1]); 0.84147098480789650665250232163029899962256306079837 0.54030230586813971740093660744297660373231042061792 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{externalplot} (\ref{labexternalplot}), \textbf{asciiplot} (\ref{labasciiplot}), \textbf{file} (\ref{labfile}), \textbf{postscript} (\ref{labpostscript}), \textbf{postscriptfile} (\ref{labpostscriptfile}), \textbf{points} (\ref{labpoints}) sollya-6.0+ds/doc/plus.tex000066400000000000000000000055161300174114700155430ustar00rootroot00000000000000\subsection{$+$} \label{labplus} \noindent Name: \textbf{$+$}\\ \phantom{aaa}addition function\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_add(sollya_obj_t, sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_add(sollya_obj_t, sollya_obj_t)|\\ \verb| #define SOLLYA_ADD(x,y) sollya_lib_build_function_add((x), (y))|\\[0.2cm] \noindent Usage: \begin{center} \emph{function1} \textbf{$+$} \emph{function2} : (\textsf{function}, \textsf{function}) $\rightarrow$ \textsf{function}\\ \emph{interval1} \textbf{$+$} \emph{interval2} : (\textsf{range}, \textsf{range}) $\rightarrow$ \textsf{range}\\ \emph{interval1} \textbf{$+$} \emph{constant} : (\textsf{range}, \textsf{constant}) $\rightarrow$ \textsf{range}\\ \emph{interval1} \textbf{$+$} \emph{constant} : (\textsf{constant}, \textsf{range}) $\rightarrow$ \textsf{range}\\ \end{center} Parameters: \begin{itemize} \item \emph{function1} and \emph{function2} represent functions \item \emph{interval1} and \emph{interval2} represent intervals (ranges) \item \emph{constant} represents a constant or constant expression \end{itemize} \noindent Description: \begin{itemize} \item \textbf{$+$} represents the addition (function) on reals. The expression \emph{function1} \textbf{$+$} \emph{function2} stands for the function composed of the addition function and the two functions \emph{function1} and \emph{function2}. \item \textbf{$+$} can be used for interval arithmetic on intervals (ranges). \textbf{$+$} will evaluate to an interval that safely encompasses all images of the addition function with arguments varying in the given intervals. Any combination of intervals with intervals or constants (resp. constant expressions) is supported. However, it is not possible to represent families of functions using an interval as one argument and a function (varying in the free variable) as the other one. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 1 + 2; 3 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > x + 2; 2 + x \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > x + x; x * 2 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > diff(sin(x) + exp(x)); cos(x) + exp(x) \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [1;2] + [3;4]; [4;6] > [1;2] + 17; [18;19] > 13 + [-4;17]; [9;30] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$-$} (\ref{labminus}), \textbf{$*$} (\ref{labmult}), \textbf{/} (\ref{labdivide}), \textbf{$\mathbf{\hat{~}}$} (\ref{labpower}) sollya-6.0+ds/doc/points.tex000066400000000000000000000040721300174114700160700ustar00rootroot00000000000000\subsection{points} \label{labpoints} \noindent Name: \textbf{points}\\ \phantom{aaa}controls the number of points chosen by \sollya in certain commands.\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_points_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_points(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_points()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{points} = \emph{n} : \textsf{integer} $\rightarrow$ \textsf{void}\\ \textbf{points} = \emph{n} ! : \textsf{integer} $\rightarrow$ \textsf{void}\\ \textbf{points} : \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{n} represents the number of points \end{itemize} \noindent Description: \begin{itemize} \item \textbf{points} is a global variable. Its value represents the number of points used in numerical algorithms of \sollya (namely \textbf{dirtyinfnorm}, \textbf{dirtyintegral}, \textbf{dirtyfindzeros}, \textbf{plot}). \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f=x^2*sin(1/x); > points=10; The number of points has been set to 10. > dirtyfindzeros(f, [0;1]); [|0, 0.31830988618379067153776752674502872406891929148092|] > points=100; The number of points has been set to 100. > dirtyfindzeros(f, [0;1]); [|0, 2.4485375860291590118289809749617594159147637806224e-2, 3.97887357729738339 42220940843128590508614911435115e-2, 4.54728408833986673625382181064326748669884 70211559e-2, 5.3051647697298445256294587790838120678153215246819e-2, 6.366197723 6758134307553505349005744813783858296184e-2, 7.957747154594766788444188168625718 101722982287023e-2, 0.106103295394596890512589175581676241356306430493638, 0.159 15494309189533576888376337251436203445964574046, 0.31830988618379067153776752674 502872406891929148092|] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{dirtyinfnorm} (\ref{labdirtyinfnorm}), \textbf{dirtyintegral} (\ref{labdirtyintegral}), \textbf{dirtyfindzeros} (\ref{labdirtyfindzeros}), \textbf{plot} (\ref{labplot}), \textbf{diam} (\ref{labdiam}), \textbf{prec} (\ref{labprec}) sollya-6.0+ds/doc/postscript.tex000066400000000000000000000017411300174114700167660ustar00rootroot00000000000000\subsection{postscript} \label{labpostscript} \noindent Name: \textbf{postscript}\\ \phantom{aaa}special value for commands \textbf{plot} and \textbf{externalplot}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_postscript()|\\ \verb| int sollya_lib_is_postscript(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{postscript} is a special value used in commands \textbf{plot} and \textbf{externalplot} to save the result of the command in a postscript file. \item As any value it can be affected to a variable and stored in lists. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > savemode=postscript; > name="plotSinCos"; > plot(sin(x),0,cos(x),[-Pi,Pi],savemode, name); \end{Verbatim} \end{minipage}\end{center} See also: \textbf{externalplot} (\ref{labexternalplot}), \textbf{plot} (\ref{labplot}), \textbf{file} (\ref{labfile}), \textbf{postscriptfile} (\ref{labpostscriptfile}) sollya-6.0+ds/doc/postscriptfile.tex000066400000000000000000000020051300174114700176200ustar00rootroot00000000000000\subsection{postscriptfile} \label{labpostscriptfile} \noindent Name: \textbf{postscriptfile}\\ \phantom{aaa}special value for commands \textbf{plot} and \textbf{externalplot}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_postscriptfile()|\\ \verb| int sollya_lib_is_postscriptfile(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{postscriptfile} is a special value used in commands \textbf{plot} and \textbf{externalplot} to save the result of the command in a data file and a postscript file. \item As any value it can be affected to a variable and stored in lists. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > savemode=postscriptfile; > name="plotSinCos"; > plot(sin(x),0,cos(x),[-Pi,Pi],savemode, name); \end{Verbatim} \end{minipage}\end{center} See also: \textbf{externalplot} (\ref{labexternalplot}), \textbf{plot} (\ref{labplot}), \textbf{file} (\ref{labfile}), \textbf{postscript} (\ref{labpostscript}) sollya-6.0+ds/doc/power.tex000066400000000000000000000104701300174114700157070ustar00rootroot00000000000000\subsection{$\mathbf{\hat{~}}$} \label{labpower} \noindent Name: \textbf{$\mathbf{\hat{~}}$}\\ \phantom{aaa}power function\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_pow(sollya_obj_t, sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_pow(sollya_obj_t, sollya_obj_t)|\\ \verb| #define SOLLYA_POW(x,y) sollya_lib_build_function_pow((x), (y))|\\[0.2cm] \noindent Usage: \begin{center} \emph{function1} \textbf{$\mathbf{\hat{~}}$} \emph{function2} : (\textsf{function}, \textsf{function}) $\rightarrow$ \textsf{function}\\ \emph{interval1} \textbf{$\mathbf{\hat{~}}$} \emph{interval2} : (\textsf{range}, \textsf{range}) $\rightarrow$ \textsf{range}\\ \emph{interval1} \textbf{$\mathbf{\hat{~}}$} \emph{constant} : (\textsf{range}, \textsf{constant}) $\rightarrow$ \textsf{range}\\ \emph{interval1} \textbf{$\mathbf{\hat{~}}$} \emph{constant} : (\textsf{constant}, \textsf{range}) $\rightarrow$ \textsf{range}\\ \end{center} Parameters: \begin{itemize} \item \emph{function1} and \emph{function2} represent functions \item \emph{interval1} and \emph{interval2} represent intervals (ranges) \item \emph{constant} represents a constant or constant expression \end{itemize} \noindent Description: \begin{itemize} \item \textbf{$\mathbf{\hat{~}}$} represents the power (function) on reals. The expression \emph{function1} \textbf{$\mathbf{\hat{~}}$} \emph{function2} stands for the function composed of the power function and the two functions \emph{function1} and \emph{function2}, where \emph{function1} is the base and \emph{function2} the exponent. If \emph{function2} is a constant integer, \textbf{$\mathbf{\hat{~}}$} is defined on negative values of \emph{function1}. Otherwise \textbf{$\mathbf{\hat{~}}$} is defined as $e^{y \cdot \ln x}$. \item Note that whenever several \textbf{$\mathbf{\hat{~}}$} are composed, the priority goes to the last \textbf{$\mathbf{\hat{~}}$}. This corresponds to the natural way of thinking when a tower of powers is written on a paper. Thus, \verb|2^3^5| is read as $2^{3^5}$ and is interpreted as $2^{(3^5)}$. \item \textbf{$\mathbf{\hat{~}}$} can be used for interval arithmetic on intervals (ranges). \textbf{$\mathbf{\hat{~}}$} will evaluate to an interval that safely encompasses all images of the power function with arguments varying in the given intervals. If the intervals given contain points where the power function is not defined, infinities and NaNs will be produced in the output interval. Any combination of intervals with intervals or constants (resp. constant expressions) is supported. However, it is not possible to represent families of functions using an interval as one argument and a function (varying in the free variable) as the other one. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 5 ^ 2; 25 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > x ^ 2; x^2 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 3 ^ (-5); 4.1152263374485596707818930041152263374485596707819e-3 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > (-3) ^ (-2.5); NaN \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > diff(sin(x) ^ exp(x)); sin(x)^exp(x) * ((cos(x) * exp(x)) / sin(x) + exp(x) * log(sin(x))) \end{Verbatim} \end{minipage}\end{center} \noindent Example 6: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 2^3^5; 1.4134776518227074636666380005943348126619871175005e73 > (2^3)^5; 32768 > 2^(3^5); 1.4134776518227074636666380005943348126619871175005e73 \end{Verbatim} \end{minipage}\end{center} \noindent Example 7: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [1;2] ^ [3;4]; [1;16.000000000000000000000000000000000000000000000001] > [1;2] ^ 17; [1;131072] > 13 ^ [-4;17]; [3.501277966457757081334687160813696999404782745702e-5;8650415919381337933] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{$+$} (\ref{labplus}), \textbf{$-$} (\ref{labminus}), \textbf{$*$} (\ref{labmult}), \textbf{/} (\ref{labdivide}) sollya-6.0+ds/doc/powers.tex000066400000000000000000000015441300174114700160740ustar00rootroot00000000000000\subsection{powers} \label{labpowers} \noindent Name: \textbf{powers}\\ \phantom{aaa}special value for global state \textbf{display}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_powers()|\\ \verb| int sollya_lib_is_powers(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{powers} is a special value used for the global state \textbf{display}. If the global state \textbf{display} is equal to \textbf{powers}, all data will be output in dyadic notation with numbers displayed in a Maple and PARI/GP compatible format. As any value it can be affected to a variable and stored in lists. \end{itemize} See also: \textbf{decimal} (\ref{labdecimal}), \textbf{dyadic} (\ref{labdyadic}), \textbf{hexadecimal} (\ref{labhexadecimal}), \textbf{binary} (\ref{labbinary}), \textbf{display} (\ref{labdisplay}) sollya-6.0+ds/doc/prec.tex000066400000000000000000000023521300174114700155040ustar00rootroot00000000000000\subsection{prec} \label{labprec} \noindent Name: \textbf{prec}\\ \phantom{aaa}controls the precision used in numerical computations.\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_prec_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_prec(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_prec()|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{prec} is a global variable. Its value represents the precision of the floating-point format used in numerical computations. \item Many commands try to adapt their working precision in order to have approximately $n$ correct bits in output, where $n$ is the value of \textbf{prec}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > prec=50; The precision has been set to 50 bits. > dirtyinfnorm(exp(x),[1;2]); 1.110110001110011001001011100011010100110111011011_2 * 2^(2) > prec=100; The precision has been set to 100 bits. > dirtyinfnorm(exp(x),[1;2]); 1.110110001110011001001011100011010100110111011010110111001100001100111010001110 11101000100000011011_2 * 2^(2) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{evaluate} (\ref{labevaluate}), \textbf{diam} (\ref{labdiam}) sollya-6.0+ds/doc/precision.tex000066400000000000000000000030571300174114700165510ustar00rootroot00000000000000\subsection{precision} \label{labprecision} \noindent Name: \textbf{precision}\\ \phantom{aaa}returns the precision necessary to represent a number.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_precision(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{precision}(\emph{x}) : \textsf{constant} $\rightarrow$ \textsf{integer}\\ \end{center} Parameters: \begin{itemize} \item \emph{x} is a dyadic number. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{precision}(x) is by definition $\vert x \vert$ if x equals 0, NaN, or Inf. \item If \emph{x} is not zero, it can be uniquely written as $x = m \cdot 2^e$ where $m$ is an odd integer and $e$ is an integer. \textbf{precision}(x) returns the number of bits necessary to write $m$ in binary (i.e. $1+ \lfloor \log_2(m) \rfloor$). \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a=round(Pi,20,RN); > precision(a); 19 > m=mantissa(a); > 1+floor(log2(m)); 19 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a=255; > precision(a); 8 > m=mantissa(a); > 1+floor(log2(m)); 8 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a=256; > precision(a); 1 > m=mantissa(a); > 1+floor(log2(m)); 1 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{mantissa} (\ref{labmantissa}), \textbf{exponent} (\ref{labexponent}), \textbf{round} (\ref{labround}) sollya-6.0+ds/doc/prepend.tex000066400000000000000000000024041300174114700162060ustar00rootroot00000000000000\subsection{.:} \label{labprepend} \noindent Name: \textbf{.:}\\ \phantom{aaa}add an element at the beginning of a list.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_prepend(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \emph{x}\textbf{.:}\emph{L} : (\textsf{any type}, \textsf{list}) $\rightarrow$ \textsf{list}\\ \end{center} Parameters: \begin{itemize} \item \emph{x} is an object of any type. \item \emph{L} is a list (possibly empty). \end{itemize} \noindent Description: \begin{itemize} \item \textbf{.:} adds the element \emph{x} at the beginning of the list \emph{L}. \item Note that since \emph{x} may be of any type, it can be in particular a list. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 1.:[|2,3,4|]; [|1, 2, 3, 4|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > [|1,2,3|].:[|4,5,6|]; [|[|1, 2, 3|], 4, 5, 6|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > 1.:[||]; [|1|] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{:.} (\ref{labappend}), \textbf{@} (\ref{labconcat}) sollya-6.0+ds/doc/print.tex000066400000000000000000000124371300174114700157140ustar00rootroot00000000000000\subsection{print} \label{labprint} \noindent Name: \textbf{print}\\ \phantom{aaa}prints an expression\\[0.2cm] \noindent Usage: \begin{center} \textbf{print}(\emph{expr1},...,\emph{exprn}) : (\textsf{any type},..., \textsf{any type}) $\rightarrow$ \textsf{void}\\ \textbf{print}(\emph{expr1},...,\emph{exprn}) $>$ \emph{filename} : (\textsf{any type},..., \textsf{any type}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \textbf{print}(\emph{expr1},...,\emph{exprn}) $>>$ \emph{filename} : (\textsf{any type},...,\textsf{any type}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr} represents an expression \item \emph{filename} represents a character sequence indicating a file name \end{itemize} \noindent Description: \begin{itemize} \item \textbf{print}(\emph{expr1},...,\emph{exprn}) prints the expressions \emph{expr1} through \emph{exprn} separated by spaces and followed by a newline. If a second argument \emph{filename} is given after a single "$>$", the displaying is not output on the standard output of \sollya but if in the file \emph{filename} that get newly created or overwritten. If a double "$>>$" is given, the output will be appended to the file \emph{filename}. The global variables \textbf{display}, \textbf{midpointmode} and \textbf{fullparentheses} have some influence on the formatting of the output (see \textbf{display}, \textbf{midpointmode} and \textbf{fullparentheses}). Remark that if one of the expressions \emph{expri} given in argument is of type \textsf{string}, the character sequence \emph{expri} evaluates to is displayed. However, if \emph{expri} is of type \textsf{list} and this list contains a variable of type \textsf{string}, the expression for the list is displayed, i.e. all character sequences get displayed surrounded by double quotes ("). Nevertheless, escape sequences used upon defining character sequences are interpreted immediately. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(x + 2 + exp(sin(x))); x + 2 + exp(sin(x)) > print("Hello","world"); Hello world > print("Hello","you", 4 + 3, "other persons."); Hello you 7 other persons. \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print("Hello"); Hello > print([|"Hello"|]); [|"Hello"|] > s = "Hello"; > print(s,[|s|]); Hello [|"Hello"|] > t = "Hello\tyou"; > print(t,[|t|]); Hello you [|"Hello\tyou"|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(x + 2 + exp(sin(x))) > "foo.sol"; > readfile("foo.sol"); x + 2 + exp(sin(x)) \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(x + 2 + exp(sin(x))) >> "foo.sol"; \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display = decimal; Display mode is decimal numbers. > a = evaluate(sin(pi * x), 0.25); > b = evaluate(sin(pi * x), [0.25; 0.25 + 1b-50]); > print(a); 0.70710678118654752440084436210484903928483593768847 > display = binary; Display mode is binary numbers. > print(a); 1.011010100000100111100110011001111111001110111100110010010000100010110010111110 11000100110110011011101010100101010111110100111110001110101101111011000001011101 010001_2 * 2^(-1) > display = hexadecimal; Display mode is hexadecimal numbers. > print(a); 0x1.6a09e667f3bcc908b2fb1366ea957d3e3adec1751p-1 > display = dyadic; Display mode is dyadic numbers. > print(a); 33070006991101558613323983488220944360067107133265b-165 > display = powers; Display mode is dyadic numbers in integer-power-of-2 notation. > print(a); 33070006991101558613323983488220944360067107133265 * 2^(-165) > display = decimal; Display mode is decimal numbers. > midpointmode = off; Midpoint mode has been deactivated. > print(b); [0.70710678118654752440084436210484903928483593768845;0.707106781186549497437217 82517557347782646274417049] > midpointmode = on; Midpoint mode has been activated. > print(b); 0.7071067811865~4/5~ > display = dyadic; Display mode is dyadic numbers. > print(b); [2066875436943847413332748968013809022504194195829b-161;165350034955508254441962 37019385936414432675156571b-164] > display = decimal; Display mode is decimal numbers. > autosimplify = off; Automatic pure tree simplification has been deactivated. > fullparentheses = off; Full parentheses mode has been deactivated. > print(x + x * ((x + 1) + 1)); x + x * (x + 1 + 1) > fullparentheses = on; Full parentheses mode has been activated. > print(x + x * ((x + 1) + 1)); x + (x * ((x + 1) + 1)) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{write} (\ref{labwrite}), \textbf{printexpansion} (\ref{labprintexpansion}), \textbf{printdouble} (\ref{labprintdouble}), \textbf{printsingle} (\ref{labprintsingle}), \textbf{printxml} (\ref{labprintxml}), \textbf{readfile} (\ref{labreadfile}), \textbf{autosimplify} (\ref{labautosimplify}), \textbf{display} (\ref{labdisplay}), \textbf{midpointmode} (\ref{labmidpointmode}), \textbf{fullparentheses} (\ref{labfullparentheses}), \textbf{evaluate} (\ref{labevaluate}), \textbf{rationalmode} (\ref{labrationalmode}) sollya-6.0+ds/doc/printdouble.tex000066400000000000000000000032161300174114700171020ustar00rootroot00000000000000\subsection{printdouble} \label{labprintdouble} \noindent Name: \textbf{printdouble}\\ \phantom{aaa}prints a constant value as a hexadecimal double precision number\\[0.2cm] \noindent Library name:\\ \verb| void sollya_lib_printdouble(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{printdouble}(\emph{constant}) : \textsf{constant} $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{constant} represents a constant \end{itemize} \noindent Description: \begin{itemize} \item Prints a constant value as a hexadecimal number on 16 hexadecimal digits. The hexadecimal number represents the integer equivalent to the 64 bit memory representation of the constant considered as a double precision number. If the constant value does not hold on a double precision number, it is first rounded to the nearest double precision number before displayed. A warning is displayed in this case. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > printdouble(3); 0x4008000000000000 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec=100!; > verbosity = 1!; > printdouble(exp(5)); Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation to 100 bits will be used. Warning: rounding down occurred before printing a value as a double. 0x40628d389970338f \end{Verbatim} \end{minipage}\end{center} See also: \textbf{printsingle} (\ref{labprintsingle}), \textbf{printexpansion} (\ref{labprintexpansion}), \textbf{double} (\ref{labdouble}) sollya-6.0+ds/doc/printexpansion.tex000066400000000000000000000074411300174114700176400ustar00rootroot00000000000000\subsection{printexpansion} \label{labprintexpansion} \noindent Name: \textbf{printexpansion}\\ \phantom{aaa}prints a polynomial in Horner form with its coefficients written as a expansions of double precision numbers\\[0.2cm] \noindent Library name:\\ \verb| void sollya_lib_printexpansion(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{printexpansion}(\emph{polynomial}) : \textsf{function} $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{polynomial} represents the polynomial to be printed \end{itemize} \noindent Description: \begin{itemize} \item The command \textbf{printexpansion} prints the polynomial \emph{polynomial} in Horner form writing its coefficients as expansions of double precision numbers. The double precision numbers themselves are displayed in hexadecimal memory notation (see \textbf{printdouble}). If some of the coefficients of the polynomial \emph{polynomial} are not floating-point constants but constant expressions, they are evaluated to floating-point constants using the global precision \textbf{prec}. If a rounding occurs in this evaluation, a warning is displayed. If the exponent range of double precision is not sufficient to display all the mantissa bits of a coefficient, the coefficient is displayed rounded and a warning is displayed. If the argument \emph{polynomial} does not a polynomial, nothing but a warning or a newline is displayed. Constants can be displayed using \textbf{printexpansion} since they are polynomials of degree $0$. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > printexpansion(roundcoefficients(taylor(exp(x),5,0),[|DD...|])); 0x3ff0000000000000 + x * (0x3ff0000000000000 + x * (0x3fe0000000000000 + x * ((0 x3fc5555555555555 + 0x3c65555555555555) + x * ((0x3fa5555555555555 + 0x3c4555555 5555555) + x * (0x3f81111111111111 + 0x3c01111111111111))))) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > printexpansion(remez(exp(x),5,[-1;1])); (0x3ff0002eec90e5a6 + 0x3c9ea6a6a0087757 + 0xb8eb3e644ef44998) + x * ((0x3ff0002 8358fd3ac + 0x3c8ffa7d96c95f7a + 0xb91da9809b13dd54 + 0x35c0000000000000) + x * ((0x3fdff2d7e6a9fea5 + 0x3c74460e4c0e4fe2 + 0x38fcd1b6b4e85bb0 + 0x3590000000000 000) + x * ((0x3fc54d6733b4839e + 0x3c6654e4d8614a44 + 0xb905c7a26b66ea92 + 0xb5 98000000000000) + x * ((0x3fa66c209b7150a8 + 0x3c34b1bba8f78092 + 0xb8c75f6eb90d ae02 + 0x3560000000000000) + x * (0x3f81e554242ab128 + 0xbc23e920a76e760c + 0x38 c0589c2cae6caf + 0x3564000000000000))))) \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > prec = 3500!; > printexpansion(pi); (0x400921fb54442d18 + 0x3ca1a62633145c07 + 0xb92f1976b7ed8fbc + 0x35c4cf98e80417 7d + 0x32631d89cd9128a5 + 0x2ec0f31c6809bbdf + 0x2b5519b3cd3a431b + 0x27e8158536 f92f8a + 0x246ba7f09ab6b6a9 + 0xa0eedd0dbd2544cf + 0x1d779fb1bd1310ba + 0x1a1a63 7ed6b0bff6 + 0x96aa485fca40908e + 0x933e501295d98169 + 0x8fd160dbee83b4e0 + 0x8c 59b6d799ae131c + 0x08f6cf70801f2e28 + 0x05963bf0598da483 + 0x023871574e69a459 + 0x8000000005702db3 + 0x8000000000000000) Warning: the expansion is not complete because of the limited exponent range of double precision. Warning: rounding occurred while printing. \end{Verbatim} \end{minipage}\end{center} See also: \textbf{printdouble} (\ref{labprintdouble}), \textbf{horner} (\ref{labhorner}), \textbf{print} (\ref{labprint}), \textbf{prec} (\ref{labprec}), \textbf{remez} (\ref{labremez}), \textbf{taylor} (\ref{labtaylor}), \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{fpminimax} (\ref{labfpminimax}), \textbf{implementpoly} (\ref{labimplementpoly}) sollya-6.0+ds/doc/printsingle.tex000066400000000000000000000031161300174114700171100ustar00rootroot00000000000000\subsection{printsingle} \label{labprintsingle} \noindent Name: \textbf{printsingle}\\ \phantom{aaa}prints a constant value as a hexadecimal single precision number\\[0.2cm] \noindent Library name:\\ \verb| void sollya_lib_printsingle(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{printsingle}(\emph{constant}) : \textsf{constant} $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{constant} represents a constant \end{itemize} \noindent Description: \begin{itemize} \item Prints a constant value as a hexadecimal number on 8 hexadecimal digits. The hexadecimal number represents the integer equivalent to the 32 bit memory representation of the constant considered as a single precision number. If the constant value does not hold on a single precision number, it is first rounded to the nearest single precision number before it is displayed. A warning is displayed in this case. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > printsingle(3); 0x40400000 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec=100!; > verbosity = 1!; > printsingle(exp(5)); Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation to 100 bits will be used. Warning: rounding up occurred before printing a value as a single. 0x431469c5 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{printdouble} (\ref{labprintdouble}), \textbf{single} (\ref{labsingle}) sollya-6.0+ds/doc/printxml.tex000066400000000000000000000056661300174114700164430ustar00rootroot00000000000000\subsection{printxml} \label{labprintxml} \noindent Name: \textbf{printxml}\\ \phantom{aaa}prints an expression as an MathML-Content-Tree\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_printxml(sollya_obj_t)|\\ \verb| void sollya_lib_printxml_newfile(sollya_obj_t, sollya_obj_t)|\\ \verb| void sollya_lib_printxml_appendfile(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{printxml}(\emph{expr}) : \textsf{function} $\rightarrow$ \textsf{void}\\ \textbf{printxml}(\emph{expr}) $>$ \emph{filename} : (\textsf{function}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \textbf{printxml}(\emph{expr}) $>$ $>$ \emph{filename} : (\textsf{function}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr} represents a functional expression \item \emph{filename} represents a character sequence indicating a file name \end{itemize} \noindent Description: \begin{itemize} \item \textbf{printxml}(\emph{expr}) prints the functional expression \emph{expr} as a tree of MathML Content Definition Markups. This XML tree can be re-read in external tools or by usage of the \textbf{readxml} command. If a second argument \emph{filename} is given after a single $>$, the MathML tree is not output on the standard output of \sollya but if in the file \emph{filename} that get newly created or overwritten. If a double $>$ $>$ is given, the output will be appended to the file \emph{filename}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > printxml(x + 2 + exp(sin(x))); x x 2 x (x + 1b1) + exp(sin(x)) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > printxml(x + 2 + exp(sin(x))) > "foo.xml"; \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > printxml(x + 2 + exp(sin(x))) >> "foo.xml"; \end{Verbatim} \end{minipage}\end{center} See also: \textbf{readxml} (\ref{labreadxml}), \textbf{print} (\ref{labprint}), \textbf{write} (\ref{labwrite}) sollya-6.0+ds/doc/proc.tex000066400000000000000000000224201300174114700155140ustar00rootroot00000000000000\subsection{proc} \label{labproc} \noindent Name: \textbf{proc}\\ \phantom{aaa}defines a \sollya procedure\\[0.2cm] \noindent Usage: \begin{center} \textbf{proc}(\emph{formal parameter1}, \emph{formal parameter2},..., \emph{formal parameter n}) \key{$\lbrace$} \emph{procedure body} \key{$\rbrace$} : \textsf{void} $\rightarrow$ \textsf{procedure}\\ \textbf{proc}(\emph{formal parameter1}, \emph{formal parameter2},..., \emph{formal parameter n}) \key{$\lbrace$} \emph{procedure body} \textbf{return} \emph{expression}; \key{$\rbrace$} : \textsf{void} $\rightarrow$ \textsf{procedure}\\ \textbf{proc}(\emph{formal list parameter} = ...) \key{$\lbrace$} \emph{procedure body} \key{$\rbrace$} : \textsf{void} $\rightarrow$ \textsf{procedure}\\ \textbf{proc}(\emph{formal list parameter} = ...) \key{$\lbrace$} \emph{procedure body} \textbf{return} \emph{expression}; \key{$\rbrace$} : \textsf{void} $\rightarrow$ \textsf{procedure}\\ \end{center} Parameters: \begin{itemize} \item \emph{formal parameter1}, \emph{formal parameter2} through \emph{formal parameter n} represent identifiers used as formal parameters \item \emph{formal list parameter} represents an identifier used as a formal parameter for the list of an arbitrary number of parameters \item \emph{procedure body} represents the imperative statements in the body of the procedure \item \emph{expression} represents the expression \textbf{proc} shall evaluate to \end{itemize} \noindent Description: \begin{itemize} \item The \textbf{proc} keyword allows for defining procedures in the \sollya language. These procedures are common \sollya objects that can be applied to actual parameters after definition. Upon such an application, the \sollya interpreter applies the actual parameters to the formal parameters \emph{formal parameter1} through \emph{formal parameter n} (resp. builds up the list of arguments and applies it to the list \emph{formal list parameter}) and executes the \emph{procedure body}. The procedure applied to actual parameters evaluates then to the expression \emph{expression} in the \textbf{return} statement after the \emph{procedure body} or to \textbf{void}, if no return statement is given (i.e. a \textbf{return} \textbf{void} statement is implicitly given). \item \sollya procedures defined by \textbf{proc} have no name. They can be bound to an identifier by assigning the procedure object a \textbf{proc} expression produces to an identifier. However, it is possible to use procedures without giving them any name. For instance, \sollya procedures, i.e. procedure objects, can be elements of lists. They can even be given as an argument to other internal \sollya procedures. See also \textbf{procedure} on this subject. \item Upon definition of a \sollya procedure using \textbf{proc}, no type check is performed. More precisely, the statements in \emph{procedure body} are merely parsed but not interpreted upon procedure definition with \textbf{proc}. Type checks are performed once the procedure is applied to actual parameters or to \textbf{void}. At this time, if the procedure was defined using several different formal parameters \emph{formal parameter 1} through \emph{formal parameter n}, it is checked whether the number of actual parameters corresponds to the number of formal parameters. If the procedure was defined using the syntax for a procedure with an arbitrary number of parameters by giving a \emph{formal list parameter}, the number of actual arguments is not checked but only a list \emph{formal list parameter} of appropriate length is built up. Type checks are further performed upon execution of each statement in \emph{procedure body} and upon evaluation of the expression \emph{expression} to be returned. Procedures defined by \textbf{proc} containing a \textbf{quit} or \textbf{restart} command cannot be executed (i.e. applied). Upon application of a procedure, the \sollya interpreter checks beforehand for such a statement. If one is found, the application of the procedure to its arguments evaluates to \textbf{error}. A warning is displayed. Remark that in contrast to other type or semantic correctness checks, this check is really performed before interpreting any other statement in the body of the procedure. \item Through the \textbf{var} keyword it is possible to declare local variables and thus to have full support of recursive procedures. This means a procedure defined using \textbf{proc} may contain in its \emph{procedure body} an application of itself to some actual parameters: it suffices to assign the procedure (object) to an identifier with an appropriate name. \item \sollya procedures defined using \textbf{proc} may return other procedures. Further \emph{procedure body} may contain assignments of locally defined procedure objects to identifiers. See \textbf{var} for the particular behaviour of local and global variables. \item The expression \emph{expression} returned by a procedure is evaluated with regard to \sollya commands, procedures and external procedures. Simplification may be performed. However, an application of a procedure defined by \textbf{proc} to actual parameters evaluates to the expression \emph{expression} that may contain the free global variable or that may be composed. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > succ = proc(n) { return n + 1; }; > succ(5); 6 > 3 + succ(0); 4 > succ; proc(n) { nop; return (n) + (1); } \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > add = proc(m,n) { var res; res := m + n; return res; }; > add(5,6); 11 > add; proc(m, n) { var res; res := (m) + (n); return res; } > verbosity = 1!; > add(3); Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. error > add(true,false); Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. Warning: the given expression or command could not be handled. error \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > succ = proc(n) { return n + 1; }; > succ(5); 6 > succ(x); 1 + x \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > hey = proc() { print("Hello world."); }; > hey(); Hello world. > print(hey()); Hello world. void > hey; proc() { print("Hello world."); return void; } \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > fac = proc(n) { var res; if (n == 0) then res := 1 else res := n * fac(n - 1); return res; }; > fac(5); 120 > fac(11); 39916800 > fac; proc(n) { var res; if (n) == (0) then res := 1 else res := (n) * (fac((n) - (1))); return res; } \end{Verbatim} \end{minipage}\end{center} \noindent Example 6: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > myprocs = [| proc(m,n) { return m + n; }, proc(m,n) { return m - n; } |]; > (myprocs[0])(5,6); 11 > (myprocs[1])(5,6); -1 > succ = proc(n) { return n + 1; }; > pred = proc(n) { return n - 1; }; > applier = proc(p,n) { return p(n); }; > applier(succ,5); 6 > applier(pred,5); 4 \end{Verbatim} \end{minipage}\end{center} \noindent Example 7: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1!; > myquit = proc(n) { print(n); quit; }; > myquit; proc(n) { print(n); quit; return void; } > myquit(5); Warning: a quit or restart command may not be part of a procedure body. The procedure will not be executed. Warning: an error occurred while executing a procedure. Warning: the given expression or command could not be handled. error \end{Verbatim} \end{minipage}\end{center} \noindent Example 8: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > printsucc = proc(n) { var succ; succ = proc(n) { return n + 1; }; print("Succe ssor of",n,"is",succ(n)); }; > printsucc(5); Successor of 5 is 6 \end{Verbatim} \end{minipage}\end{center} \noindent Example 9: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > makeadd = proc(n) { var add; print("n =",n); add = proc(m,n) { return n + m; } ; return add; }; > makeadd(4); n = 4 proc(m, n) { nop; return (n) + (m); } > (makeadd(4))(5,6); n = 4 11 \end{Verbatim} \end{minipage}\end{center} \noindent Example 10: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > sumall = proc(L = ...) { var acc, i; acc = 0; for i in L do acc = acc + i; ret urn acc; }; > sumall; proc(L = ...) { var acc, i; acc = 0; for i in L do acc = (acc) + (i); return acc; } > sumall(); 0 > sumall(2); 2 > sumall(2,5); 7 > sumall(2,5,7,9,16); 39 > sumall @ [|1,...,10|]; 55 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{return} (\ref{labreturn}), \textbf{externalproc} (\ref{labexternalproc}), \textbf{void} (\ref{labvoid}), \textbf{quit} (\ref{labquit}), \textbf{restart} (\ref{labrestart}), \textbf{var} (\ref{labvar}), \textbf{@} (\ref{labconcat}), \textbf{bind} (\ref{labbind}), \textbf{getbacktrace} (\ref{labgetbacktrace}), \textbf{error} (\ref{laberror}) sollya-6.0+ds/doc/procedure.tex000066400000000000000000000055301300174114700165440ustar00rootroot00000000000000\subsection{procedure} \label{labprocedure} \noindent Name: \textbf{procedure}\\ \phantom{aaa}defines and assigns a \sollya procedure\\[0.2cm] \noindent Usage: \begin{center} \textbf{procedure} \emph{identifier}(\emph{formal parameter1}, \emph{formal parameter2},..., \emph{formal parameter n}) \key{$\lbrace$} \emph{procedure body} \key{$\rbrace$} : \textsf{void} $\rightarrow$ \textsf{void}\\ \textbf{procedure} \emph{identifier}(\emph{formal parameter1}, \emph{formal parameter2},..., \emph{formal parameter n}) \key{$\lbrace$} \emph{procedure body} \textbf{return} \emph{expression}; \key{$\rbrace$} : \textsf{void} $\rightarrow$ \textsf{void}\\ \textbf{procedure} \emph{identifier}(\emph{formal list parameter} = ...) \key{$\lbrace$} \emph{procedure body} \key{$\rbrace$} : \textsf{void} $\rightarrow$ \textsf{void}\\ \textbf{procedure} \emph{identifier}(\emph{formal list parameter} = ...) \key{$\lbrace$} \emph{procedure body} \textbf{return} \emph{expression}; \key{$\rbrace$} : \textsf{void} $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{identifier} represents the name of the procedure to be defined and assigned \item \emph{formal parameter1}, \emph{formal parameter2} through \emph{formal parameter n} represent identifiers used as formal parameters \item \emph{formal list parameter} represents an identifier used as a formal parameter for the list of an arbitrary number of parameters \item \emph{procedure body} represents the imperative statements in the body of the procedure \item \emph{expression} represents the expression \textbf{procedure} shall evaluate to \end{itemize} \noindent Description: \begin{itemize} \item The \textbf{procedure} keyword allows for defining and assigning procedures in the \sollya language. It is an abbreviation to a procedure definition using \textbf{proc} with the same formal parameters, procedure body and return-expression followed by an assignment of the procedure (object) to the identifier \emph{identifier}. In particular, all rules concerning local variables declared using the \textbf{var} keyword apply for \textbf{procedure}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure succ(n) { return n + 1; }; > succ(5); 6 > 3 + succ(0); 4 > succ; proc(n) { nop; return (n) + (1); } \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure myprint(L = ...) { var i; for i in L do i; }; > myprint("Lyon","Nancy","Beaverton","Coye-la-Foret","Amberg","Nizhny Novgorod", "Cluj-Napoca"); Lyon Nancy Beaverton Coye-la-Foret Amberg Nizhny Novgorod Cluj-Napoca \end{Verbatim} \end{minipage}\end{center} See also: \textbf{proc} (\ref{labproc}), \textbf{var} (\ref{labvar}), \textbf{bind} (\ref{labbind}), \textbf{getbacktrace} (\ref{labgetbacktrace}) sollya-6.0+ds/doc/qd.tex000066400000000000000000000002271300174114700151560ustar00rootroot00000000000000\subsection{QD} \label{labqd} \noindent Name: \textbf{QD}\\ \phantom{aaa}short form for \textbf{quad}\\[0.2cm] See also: \textbf{quad} (\ref{labquad}) sollya-6.0+ds/doc/quad.tex000066400000000000000000000040571300174114700155110ustar00rootroot00000000000000\subsection{quad} \label{labquad} \noindent Names: \textbf{quad}, \textbf{QD}\\ \phantom{aaa}rounding to the nearest IEEE 754 quad (binary128).\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_quad(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_quad_obj()|\\ \verb| int sollya_lib_is_quad_obj(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_quad(sollya_obj_t)|\\ \verb| #define SOLLYA_QD(x) sollya_lib_build_function_quad(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{quad} is both a function and a constant. \item As a function, it rounds its argument to the nearest IEEE 754 quad precision (i.e. IEEE754-2008 binary128) number. Subnormal numbers are supported as well as standard numbers: it is the real rounding described in the standard. \item As a constant, it symbolizes the quad precision format. It is used in contexts when a precision format is necessary, e.g. in the commands \textbf{round} and \textbf{roundcoefficients}. It is not supported for \textbf{implementpoly}. See the corresponding help pages for examples. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > QD(0.1); 1.100110011001100110011001100110011001100110011001100110011001100110011001100110 011001100110011001100110011001101_2 * 2^(-4) > QD(4.17); 1.000010101110000101000111101011100001010001111010111000010100011110101110000101 000111101011100001010001111010111_2 * 2^(2) > QD(1.011_2 * 2^(-16493)); 1.1_2 * 2^(-16493) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{halfprecision} (\ref{labhalfprecision}), \textbf{single} (\ref{labsingle}), \textbf{double} (\ref{labdouble}), \textbf{doubleextended} (\ref{labdoubleextended}), \textbf{doubledouble} (\ref{labdoubledouble}), \textbf{tripledouble} (\ref{labtripledouble}), \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{implementpoly} (\ref{labimplementpoly}), \textbf{fpminimax} (\ref{labfpminimax}), \textbf{round} (\ref{labround}), \textbf{printsingle} (\ref{labprintsingle}) sollya-6.0+ds/doc/quit.tex000066400000000000000000000022651300174114700155400ustar00rootroot00000000000000\subsection{quit} \label{labquit} \noindent Name: \textbf{quit}\\ \phantom{aaa}quits \sollya\\[0.2cm] \noindent Usage: \begin{center} \textbf{quit} : \textsf{void} $\rightarrow$ \textsf{void}\\ \end{center} \noindent Description: \begin{itemize} \item The command \textbf{quit}, when executed, stops the execution of a \sollya script and leaves the \sollya interpreter unless the \textbf{quit} command is executed in a \sollya script read into a main \sollya script by \textbf{execute} or $\#$include. Upon exiting the \sollya interpreter, all state is thrown away, all memory is deallocated, all bound libraries are unbound and the temporary files produced by \textbf{plot} and \textbf{externalplot} are deleted. If the \textbf{quit} command does not lead to a halt of the \sollya interpreter, a warning is displayed. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > quit; \end{Verbatim} \end{minipage}\end{center} See also: \textbf{restart} (\ref{labrestart}), \textbf{execute} (\ref{labexecute}), \textbf{plot} (\ref{labplot}), \textbf{externalplot} (\ref{labexternalplot}), \textbf{return} (\ref{labreturn}) sollya-6.0+ds/doc/range.tex000066400000000000000000000017571300174114700156570ustar00rootroot00000000000000\subsection{range} \label{labrange} \noindent Name: \textbf{range}\\ \phantom{aaa}keyword representing a \textsf{range} type \\[0.2cm] \noindent Library name:\\ \verb| SOLLYA_EXTERNALPROC_TYPE_RANGE|\\[0.2cm] \noindent Usage: \begin{center} \textbf{range} : \textsf{type type}\\ \end{center} \noindent Description: \begin{itemize} \item \textbf{range} represents the \textsf{range} type for declarations of external procedures by means of \textbf{externalproc}. Remark that in contrast to other indicators, type indicators like \textbf{range} cannot be handled outside the \textbf{externalproc} context. In particular, they cannot be assigned to variables. \end{itemize} See also: \textbf{externalproc} (\ref{labexternalproc}), \textbf{boolean} (\ref{labboolean}), \textbf{constant} (\ref{labconstant}), \textbf{function} (\ref{labfunction}), \textbf{integer} (\ref{labinteger}), \textbf{list of} (\ref{lablistof}), \textbf{string} (\ref{labstring}), \textbf{object} (\ref{labobject}) sollya-6.0+ds/doc/rationalapprox.tex000066400000000000000000000055471300174114700176270ustar00rootroot00000000000000\subsection{rationalapprox} \label{labrationalapprox} \noindent Name: \textbf{rationalapprox}\\ \phantom{aaa}returns a fraction close to a given number.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_rationalapprox(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{rationalapprox}(\emph{x},\emph{n}) : (\textsf{constant}, \textsf{integer}) $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{x} is a number to approximate. \item \emph{n} is a integer (representing a format). \end{itemize} \noindent Description: \begin{itemize} \item \textbf{rationalapprox}(\emph{x},\emph{n}) returns a constant function of the form $a/b$ where $a$ and $b$ are integers. The value $a/b$ is an approximation of \emph{x}. The quality of this approximation is determined by the parameter \emph{n} that indicates the number of correct bits that $a/b$ should have. \item The command is not safe in the sense that it is not ensured that the error between $a/b$ and \emph{x} is less than $2^{-n}$. \item The following algorithm is used: \emph{x} is first rounded downwards and upwards to a format of \emph{n} bits, thus obtaining an interval $[x_l,\,x_u]$. This interval is then developed into a continued fraction as far as the representation is the same for every elements of $[x_l,\,x_u]$. The corresponding fraction is returned. \item Since rational numbers are not a primitive object of \sollya, the fraction is returned as a constant function. This can be quite amazing, because \sollya immediately simplifies a constant function by evaluating it when the constant has to be displayed. To avoid this, you can use \textbf{print} (that displays the expression representing the constant and not the constant itself) or the commands \textbf{numerator} and \textbf{denominator}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > pi10 = rationalapprox(Pi,10); > pi50 = rationalapprox(Pi,50); > pi100 = rationalapprox(Pi,100); > print( pi10, ": ", dirtysimplify(floor(-log2(abs(pi10-Pi)/Pi))), "bits." ); 3.140625 : 11 bits. > print( pi50, ": ", dirtysimplify(floor(-log2(abs(pi50-Pi)/Pi))), "bits." ); 85563208 / 27235615 : 51 bits. > print( pi100, ": ", dirtysimplify(floor(-log2(abs(pi100-Pi)/Pi))), "bits." ); 4422001152019829 / 1407566683404023 : 100 bits. \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a=0.1; > b=rationalapprox(a,4); > numerator(b); denominator(b); 1 10 > print(dirtysimplify(floor(-log2(abs((b-a)/a)))), "bits."); 166 bits. \end{Verbatim} \end{minipage}\end{center} See also: \textbf{print} (\ref{labprint}), \textbf{numerator} (\ref{labnumerator}), \textbf{denominator} (\ref{labdenominator}), \textbf{rationalmode} (\ref{labrationalmode}) sollya-6.0+ds/doc/rationalmode.tex000066400000000000000000000052771300174114700172420ustar00rootroot00000000000000\subsection{rationalmode} \label{labrationalmode} \noindent Name: \textbf{rationalmode}\\ \phantom{aaa}global variable controlling if rational arithmetic is used or not.\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_rationalmode_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_rationalmode(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_rationalmode()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{rationalmode} = \emph{activation value} : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{rationalmode} = \emph{activation value} ! : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{rationalmode} : \textsf{on$|$off}\\ \end{center} Parameters: \begin{itemize} \item \emph{activation value} controls if rational arithmetic should be used or not \end{itemize} \noindent Description: \begin{itemize} \item \textbf{rationalmode} is a global variable. When its value is \textbf{off}, which is the default, \sollya will not use rational arithmetic to simplify expressions. All computations, including the evaluation of constant expressions given on the \sollya prompt, will be performed using floating-point and interval arithmetic. Constant expressions will be approximated by floating-point numbers, which are in most cases faithful roundings of the expressions, when shown at the prompt. \item When the value of the global variable \textbf{rationalmode} is \textbf{on}, \sollya will use rational arithmetic when simplifying expressions. Constant expressions, given at the \sollya prompt, will be simplified to rational numbers and displayed as such when they are in the set of the rational numbers. Otherwise, flaoting-point and interval arithmetic will be used to compute a floating-point approximation, which is in most cases a faithful rounding of the constant expression. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > rationalmode=off!; > 19/17 + 3/94; 1.1495619524405506883604505632040050062578222778473 > rationalmode=on!; > 19/17 + 3/94; 1837 / 1598 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > rationalmode=off!; > exp(19/17 + 3/94); 3.1568097739551413675470920894482427634032816281442 > rationalmode=on!; > exp(19/17 + 3/94); 3.1568097739551413675470920894482427634032816281442 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{on} (\ref{labon}), \textbf{off} (\ref{laboff}), \textbf{numerator} (\ref{labnumerator}), \textbf{denominator} (\ref{labdenominator}), \textbf{simplify} (\ref{labsimplify}), \textbf{rationalapprox} (\ref{labrationalapprox}), \textbf{autosimplify} (\ref{labautosimplify}) sollya-6.0+ds/doc/rd.tex000066400000000000000000000015121300174114700151550ustar00rootroot00000000000000\subsection{RD} \label{labrd} \noindent Name: \textbf{RD}\\ \phantom{aaa}constant representing rounding-downwards mode.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_round_down()|\\ \verb| int sollya_lib_is_round_down(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{RD} is used in command \textbf{round} to specify that the value $x$ must be rounded to the greatest floating-point number $y$ such that $y \le x$. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > round(Pi,20,RD); 1.1001001000011111101_2 * 2^(1) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{RZ} (\ref{labrz}), \textbf{RU} (\ref{labru}), \textbf{RN} (\ref{labrn}), \textbf{round} (\ref{labround}), \textbf{floor} (\ref{labfloor}) sollya-6.0+ds/doc/readfile.tex000066400000000000000000000031751300174114700163320ustar00rootroot00000000000000\subsection{readfile} \label{labreadfile} \noindent Name: \textbf{readfile}\\ \phantom{aaa}reads the content of a file into a string variable\\[0.2cm] \noindent Usage: \begin{center} \textbf{readfile}(\emph{filename}) : \textsf{string} $\rightarrow$ \textsf{string}\\ \end{center} Parameters: \begin{itemize} \item \emph{filename} represents a character sequence indicating a file name \end{itemize} \noindent Description: \begin{itemize} \item \textbf{readfile} opens the file indicated by \emph{filename}, reads it and puts its contents in a character sequence of type \textsf{string} that is returned. If the file indicated by \emph{filename} cannot be opened for reading, a warning is displayed and \textbf{readfile} evaluates to an \textbf{error} variable of type \textsf{error}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print("Hello world") > "myfile.txt"; > t = readfile("myfile.txt"); > t; Hello world \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > readfile("afile.txt"); Warning: the file "afile.txt" could not be opened for reading. Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. error \end{Verbatim} \end{minipage}\end{center} See also: \textbf{parse} (\ref{labparse}), \textbf{execute} (\ref{labexecute}), \textbf{write} (\ref{labwrite}), \textbf{print} (\ref{labprint}), \textbf{bashexecute} (\ref{labbashexecute}), \textbf{error} (\ref{laberror}) sollya-6.0+ds/doc/readxml.tex000066400000000000000000000030651300174114700162110ustar00rootroot00000000000000\subsection{readxml} \label{labreadxml} \noindent Name: \textbf{readxml}\\ \phantom{aaa}reads an expression written as a MathML-Content-Tree in a file\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_readxml(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{readxml}(\emph{filename}) : \textsf{string} $\rightarrow$ \textsf{function} $|$ \textsf{error}\\ \end{center} Parameters: \begin{itemize} \item \emph{filename} represents a character sequence indicating a file name \end{itemize} \noindent Description: \begin{itemize} \item \textbf{readxml}(\emph{filename}) reads the first occurrence of a lambda application with one bounded variable on applications of the supported basic functions in file \emph{filename} and returns it as a \sollya functional expression. If the file \emph{filename} does not contain a valid MathML-Content tree, \textbf{readxml} tries to find an "annotation encoding" markup of type "sollya/text". If this annotation contains a character sequence that can be parsed by \textbf{parse}, \textbf{readxml} returns that expression. Otherwise \textbf{readxml} displays a warning and returns an \textbf{error} variable of type \textsf{error}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > readxml("readxmlexample.xml"); 2 + _x_ + exp(sin(_x_)) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{printxml} (\ref{labprintxml}), \textbf{readfile} (\ref{labreadfile}), \textbf{parse} (\ref{labparse}), \textbf{error} (\ref{laberror}) sollya-6.0+ds/doc/relative.tex000066400000000000000000000031461300174114700163700ustar00rootroot00000000000000\subsection{relative} \label{labrelative} \noindent Name: \textbf{relative}\\ \phantom{aaa}indicates a relative error for \textbf{externalplot}, \textbf{fpminimax} or \textbf{supnorm}\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_relative()|\\ \verb| int sollya_lib_is_relative(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{relative} : \textsf{absolute$|$relative}\\ \end{center} \noindent Description: \begin{itemize} \item The use of \textbf{relative} in the command \textbf{externalplot} indicates that during plotting in \textbf{externalplot} a relative error is to be considered. See \textbf{externalplot} for details. \item Used with \textbf{fpminimax}, \textbf{relative} indicates that \textbf{fpminimax} must try to minimize the relative error. See \textbf{fpminimax} for details. \item When given in argument to \textbf{supnorm}, \textbf{relative} indicates that a relative error is to be considered for supremum norm computation. See \textbf{supnorm} for details. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > bashexecute("gcc -fPIC -c externalplotexample.c"); > bashexecute("gcc -shared -o externalplotexample externalplotexample.o -lgmp -l mpfr"); > externalplot("./externalplotexample",absolute,exp(x),[-1/2;1/2],12,perturb); \end{Verbatim} \end{minipage}\end{center} See also: \textbf{externalplot} (\ref{labexternalplot}), \textbf{fpminimax} (\ref{labfpminimax}), \textbf{absolute} (\ref{lababsolute}), \textbf{bashexecute} (\ref{labbashexecute}), \textbf{supnorm} (\ref{labsupnorm}) sollya-6.0+ds/doc/remez.tex000066400000000000000000000174001300174114700156750ustar00rootroot00000000000000\subsection{remez} \label{labremez} \noindent Name: \textbf{remez}\\ \phantom{aaa}computes the minimax of a function on an interval.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_remez(sollya_obj_t, sollya_obj_t, sollya_obj_t, ...)|\\ \verb| sollya_obj_t sollya_lib_v_remez(sollya_obj_t, sollya_obj_t, sollya_obj_t,|\\ \verb| va_list)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{remez}(\emph{f}, \emph{n}, \emph{range}, \emph{w}, \emph{quality}, \emph{bounds}) : (\textsf{function}, \textsf{integer}, \textsf{range}, \textsf{function}, \textsf{constant}, \textsf{range}) $\rightarrow$ \textsf{function}\\ \textbf{remez}(\emph{f}, \emph{L}, \emph{range}, \emph{w}, \emph{quality}, \emph{bounds}) : (\textsf{function}, \textsf{list}, \textsf{range}, \textsf{function}, \textsf{constant}, \textsf{range}) $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is the function to be approximated \item \emph{n} is the degree of the polynomial that must approximate \emph{f} \item \emph{L} is a list of integers or a list of functions and indicates the basis for the approximation of \emph{f} \item \emph{range} is the interval where the function must be approximated \item \emph{w} (optional) is a weight function. Default is 1. \item \emph{quality} (optional) is a parameter that controls the quality of the returned polynomial \emph{p}, with respect to the exact minimax $p^\star$. Default is 1e-5. \item \emph{bounds} (optional) is a parameter that allows the user to make the algorithm stop earlier, whenever a given accuracy is reached or a given accuracy is proved unreachable. Default is $[0,\,+\infty]$. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{remez} computes an approximation of the function $f$ with respect to the weight function $w$ on the interval \emph{range}. More precisely, it searches $p$ such that $\|pw-f\|_{\infty}$ is (almost) minimal among all $p$ of a certain form. The norm is the infinity norm, e.g. $\|g\|_{\infty} = \max \{|g(x)|, x \in \mathrm{range}\}.$ \item If $w=1$ (the default case), it consists in searching the best polynomial approximation of $f$ with respect to the absolute error. If $f=1$ and $w$ is of the form $1/g$, it consists in searching the best polynomial approximation of $g$ with respect to the relative error. \item If $n$ is given, $p$ is searched among the polynomials with degree not greater than $n$. If \emph{L} is given and is a list of integers, $p$ is searched as a linear combination of monomials $X^k$ where $k$ belongs to \emph{L}. In the case when \emph{L} is a list of integers, it may contain ellipses but cannot be end-elliptic. If \emph{L} is given and is a list of functions $g_k$, $p$ is searched as a linear combination of the $g_k$. In that case \emph{L} cannot contain ellipses. It is the user responsibility to check that the $g_k$ are linearly independent over the interval \emph{range}. Moreover, the functions $w\cdot g_k$ must be at least twice differentiable over \emph{range}. If these conditions are not fulfilled, the algorithm might fail or even silently return a result as if it successfully found the minimax, though the returned $p$ is not optimal. \item The polynomial is obtained by a convergent iteration called Remez' algorithm (and an extension of this algorithm, due to Stiefel). The algorithm computes a sequence $p_1,\dots ,p_k,\dots$ such that $e_k = \|p_k w-f\|_{\infty}$ converges towards the optimal value $e$. The algorithm is stopped when the relative error between $e_k$ and $e$ is less than \emph{quality}. \item The optional argument \emph{bounds} is an interval $[\varepsilon_\ell,\,\varepsilon_u]$ with the following behavior:\begin{itemize} \item if, during the algorithm, we manage to prove that $\varepsilon_u$ is unreachable, we stop the algorithm returning the last computed polynomial. \item if, during the algorithm, we obtain a polynomial with an error smaller than $\varepsilon_\ell$, we stop the algorithm returning that polynomial. \item otherwise we loop until we find an optimal polynomial with the required quality, as usual.\end{itemize} Examples of use:\\ $[0,\,+\infty]$ (compute the optimal polynomial with the required quality)\\ $[\varepsilon_u]$ (stops as soon as a polynomial achieving $\varepsilon_u$ is obtained or as soon as such a polynomial is proved not to exist).\\ $[0,\,\varepsilon_u]$ (finds the optimal polynomial, but provided that its error is smaller than $\varepsilon_u$).\\ $[\varepsilon_\ell,\,+\infty]$ (stops as soon as a polynomial achieving $\varepsilon_\ell$ is obtained. If such a polynomial does not exist, returns the optimal polynomial). \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p = remez(exp(x),5,[0;1]); > degree(p); 5 > dirtyinfnorm(p-exp(x),[0;1]); 1.1295698151096148707171193829266077607222634589363e-6 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p = remez(1,[|0,2,4,6,8|],[0,Pi/4],1/cos(x)); > canonical=on!; > p; 0.99999999994393732180959690352543887130348096061124 + -0.4999999957155685776877 2053063721544670949467222259 * x^2 + 4.16666132334736330099410594805702758701132 20089059e-2 * x^4 + -1.3886529147145693651355523880319714051047635695061e-3 * x^ 6 + 2.4372679177224179934800328511009205218114284220126e-5 * x^8 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p1 = remez(exp(x),5,[0;1],default,1e-5); > p2 = remez(exp(x),5,[0;1],default,1e-10); > p3 = remez(exp(x),5,[0;1],default,1e-15); > dirtyinfnorm(p1-exp(x),[0;1]); 1.1295698151096148707171193829266077607222634589363e-6 > dirtyinfnorm(p2-exp(x),[0;1]); 1.12956980227478675612619255125474525171079325793124e-6 > dirtyinfnorm(p3-exp(x),[0;1]); 1.12956980227478675612619255125474525171079325793124e-6 \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > L = [|exp(x), sin(x), cos(x)-1, sin(x^3)|]; > g = (2^x-1)/x; > p1 = remez(g, L, [-1/16;1/16]); > p2 = remez(g, 3, [-1/16;1/16]); > dirtyinfnorm(p1 - g, [-1/16;1/16]); 9.8841323829271038137685646777951687620288462194746e-8 > dirtyinfnorm(p2 - g, [-1/16;1/16]); 2.54337800593461418356437401152248866818783932027105e-9 \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = sin(x); > I = [-3b-5;-1b-1074]; > time(popt = remez(1, [|1, 3, 4, 5, 7, 8, 9|], I, 1/f)); 0.120993371000000000000000000000000000003813720457345 > time(p1 = remez(1, [|1, 3, 4, 5, 7, 8, 9|], I, 1/f, default, [0, 1b-73])); 8.8805625999999999999999999999999999996325253443736e-2 > time(p2 = remez(1, [|1, 3, 4, 5, 7, 8, 9|], I, 1/f, default, [3b-72, +@Inf@])) ; 0.112476623000000000000000000000000000001996009720239 > dirtyinfnorm(popt/f-1, I); 2.06750931454112835098093903810531156576504665659064e-22 > dirtyinfnorm(p1/f-1, I); 2.49711266837493110470637913808914046704452778960875e-22 > dirtyinfnorm(p2/f-1, I); 5.4567247553615435246376977231253834265248756996947e-22 > 1b-73; 1.05879118406787542383540312584955245256423950195312e-22 > 3b-72; 6.3527471044072525430124187550973147153854370117187e-22 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{dirtyinfnorm} (\ref{labdirtyinfnorm}), \textbf{infnorm} (\ref{labinfnorm}), \textbf{fpminimax} (\ref{labfpminimax}), \textbf{guessdegree} (\ref{labguessdegree}), \textbf{taylorform} (\ref{labtaylorform}), \textbf{taylor} (\ref{labtaylor}) sollya-6.0+ds/doc/rename.tex000066400000000000000000000047611300174114700160300ustar00rootroot00000000000000\subsection{rename} \label{labrename} \noindent Name: \textbf{rename}\\ \phantom{aaa}rename the free variable.\\[0.2cm] \noindent Library name:\\ \verb| void sollya_lib_name_free_variable(const char *)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{rename}(\emph{ident1},\emph{ident2}) : \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{ident1} is the current name of the free variable. \item \emph{ident2} is a fresh name. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{rename} permits a change of the name of the free variable. \sollya can handle only one free variable at a time. The first time in a session that an unbound name is used in a context where it can be interpreted as a free variable, the name is used to represent the free variable of \sollya. In the following, this name can be changed using \textbf{rename}. \item Be careful: if \emph{ident2} has been set before, its value will be lost. Use the command \textbf{isbound} to know if \emph{ident2} is already used or not. \item If \emph{ident1} is not the current name of the free variable, an error occurs. \item If \textbf{rename} is used at a time when the name of the free variable has not been defined, \emph{ident1} is just ignored and the name of the free variable is set to \emph{ident2}. \item It is always possible to use the special keyword \verb|_x_| to denote the free variable. Hence \emph{ident1} can be \verb|_x_|. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f=sin(x); > f; sin(x) > rename(x,y); > f; sin(y) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a=1; > f=sin(x); > rename(x,a); > a; a > f; sin(a) \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > f=sin(x); > rename(y, z); Warning: the current free variable is named "x" and not "y". Can only rename the free variable. The last command will have no effect. > rename(_x_, z); Information: the free variable has been renamed from "x" to "z". \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > rename(x,y); Information: the free variable has been named "y". > isbound(x); false > isbound(y); true \end{Verbatim} \end{minipage}\end{center} See also: \textbf{isbound} (\ref{labisbound}) sollya-6.0+ds/doc/restart.tex000066400000000000000000000045031300174114700162370ustar00rootroot00000000000000\subsection{restart} \label{labrestart} \noindent Name: \textbf{restart}\\ \phantom{aaa}brings \sollya back to its initial state\\[0.2cm] \noindent Usage: \begin{center} \textbf{restart} : \textsf{void} $\rightarrow$ \textsf{void}\\ \end{center} \noindent Description: \begin{itemize} \item The command \textbf{restart} brings \sollya back to its initial state. All current state is abandoned, all libraries unbound and all memory freed. The \textbf{restart} command has no effect when executed inside a \sollya script read into a main \sollya script using \textbf{execute}. It is executed in a \sollya script included by a $\#$include macro. Using the \textbf{restart} command in nested elements of imperative programming like for or while loops is possible. Since in most cases abandoning the current state of \sollya means altering a loop invariant, warnings for the impossibility of continuing a loop may follow unless the state is rebuilt. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(exp(x)); exp(x) > a = 3; > restart; The tool has been restarted. > print(x); x > a; Warning: the identifier "a" is neither assigned to, nor bound to a library funct ion nor external procedure, nor equal to the current free variable. Will interpret "a" as "x". x \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(exp(x)); exp(x) > for i from 1 to 10 do { print(i); if (i == 5) then restart; }; 1 2 3 4 5 The tool has been restarted. Warning: the tool has been restarted inside a for loop. The for loop will no longer be executed. \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(exp(x)); exp(x) > a = 3; > for i from 1 to 10 do { print(i); if (i == 5) then { restart; i = 7; }; }; 1 2 3 4 5 The tool has been restarted. 8 9 10 > print(x); x > a; Warning: the identifier "a" is neither assigned to, nor bound to a library funct ion nor external procedure, nor equal to the current free variable. Will interpret "a" as "x". x \end{Verbatim} \end{minipage}\end{center} See also: \textbf{quit} (\ref{labquit}), \textbf{execute} (\ref{labexecute}) sollya-6.0+ds/doc/return.tex000066400000000000000000000034651300174114700161000ustar00rootroot00000000000000\subsection{return} \label{labreturn} \noindent Name: \textbf{return}\\ \phantom{aaa}indicates an expression to be returned in a procedure\\[0.2cm] \noindent Usage: \begin{center} \textbf{return} \emph{expression} : \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{expression} represents the expression to be returned \end{itemize} \noindent Description: \begin{itemize} \item The keyword \textbf{return} allows for returning the (evaluated) expression \emph{expression} at the end of a begin-end-block ({}-block) used as a \sollya procedure body. See \textbf{proc} for further details concerning \sollya procedure definitions. Statements for returning expressions using \textbf{return} are only possible at the end of a begin-end-block used as a \sollya procedure body. Only one \textbf{return} statement can be given per begin-end-block. \item If at the end of a procedure definition using \textbf{proc} no \textbf{return} statement is given, a \textbf{return} \textbf{void} statement is implicitly added. Procedures, i.e. procedure objects, when printed out in \sollya defined with an implicit \textbf{return} \textbf{void} statement are displayed with this statement explicitly given. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > succ = proc(n) { var res; res := n + 1; return res; }; > succ(5); 6 > succ; proc(n) { var res; res := (n) + (1); return res; } \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > hey = proc(s) { print("Hello",s); }; > hey("world"); Hello world > hey; proc(s) { print("Hello", s); return void; } \end{Verbatim} \end{minipage}\end{center} See also: \textbf{proc} (\ref{labproc}), \textbf{void} (\ref{labvoid}) sollya-6.0+ds/doc/revert.tex000066400000000000000000000016721300174114700160660ustar00rootroot00000000000000\subsection{revert} \label{labrevert} \noindent Name: \textbf{revert}\\ \phantom{aaa}reverts a list.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_revert(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{revert}(\emph{L}) : \textsf{list} $\rightarrow$ \textsf{list}\\ \end{center} Parameters: \begin{itemize} \item \emph{L} is a list. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{revert}(\emph{L}) returns the same list, but with its elements in reverse order. \item If \emph{L} is an end-elliptic list, \textbf{revert} will fail with an error. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > revert([| |]); [| |] \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > revert([|2,3,5,2,1,4|]); [|4, 1, 2, 5, 3, 2|] \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/rn.tex000066400000000000000000000015211300174114700151670ustar00rootroot00000000000000\subsection{RN} \label{labrn} \noindent Name: \textbf{RN}\\ \phantom{aaa}constant representing rounding-to-nearest mode.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_round_to_nearest()|\\ \verb| int sollya_lib_is_round_to_nearest(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{RN} is used in command \textbf{round} to specify that the value must be rounded to the nearest representable floating-point number. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > round(Pi,20,RN); 1.100100100001111111_2 * 2^(1) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{RD} (\ref{labrd}), \textbf{RU} (\ref{labru}), \textbf{RZ} (\ref{labrz}), \textbf{round} (\ref{labround}), \textbf{nearestint} (\ref{labnearestint}) sollya-6.0+ds/doc/round.tex000066400000000000000000000075641300174114700157140ustar00rootroot00000000000000\subsection{round} \label{labround} \noindent Name: \textbf{round}\\ \phantom{aaa}rounds a number to a floating-point format.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_round(sollya_obj_t, sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{round}(\emph{x},\emph{n},\emph{mode}) : (\textsf{constant}, \textsf{integer}, \textsf{RN$|$RZ$|$RU$|$RD}) $\rightarrow$ \textsf{constant}\\ \textbf{round}(\emph{x},\emph{format},\emph{mode}) : (\textsf{constant}, \textsf{HP$|$halfprecision$|$SG$|$single$|$D$|$double$|$DE$|$doubleextended$|$DD$|$doubledouble$|$QD$|$quad$|$TD$|$tripledouble}, \textsf{RN$|$RZ$|$RU$|$RD}) $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{x} is a constant to be rounded. \item \emph{n} is the precision of the target format. \item \emph{format} is the name of a supported floating-point format. \item \emph{mode} is the desired rounding mode. \end{itemize} \noindent Description: \begin{itemize} \item If used with an integer parameter \emph{n}, \textbf{round}(\emph{x},\emph{n},\emph{mode}) rounds \emph{x} to a floating-point number with precision \emph{n}, according to rounding-mode \emph{mode}. \item If used with a format parameter \emph{format}, \textbf{round}(\emph{x},\emph{format},\emph{mode}) rounds \emph{x} to a floating-point number in the floating-point format \emph{format}, according to rounding-mode \emph{mode}. \item Subnormal numbers are handled for the case when \emph{format} is one of \textbf{halfprecision}, \textbf{single}, \textbf{double}, \textbf{doubleextended}, \textbf{doubledouble}, \textbf{quad} or \textbf{tripledouble}. Otherwise, when \emph{format} is an integer, \textbf{round} does not take any exponent range into consideration, i.e. typically uses the full exponent range of the underlying MPFR library. \item It is worth mentionning that the result of \textbf{round} does not depend on the current global precision of \sollya, unless a warning is displayed. As a matter of fact, \textbf{round} rounds the given constant or constant expression \emph{x} applying all rules of IEEE 754 correct rounding, unless a warning is displayed. The result of \textbf{round} is hence the floating-point value of the given precision \emph{n} or format \emph{format} that is nearest to \emph{x} (resp. just below or just above, depending on \emph{mode}), computed as if infinite precision were used for evaluating the constant \emph{x}, unless a warning is displayed. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > round(Pi,20,RN); 1.100100100001111111_2 * 2^(1) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > printdouble(round(exp(17),53,RU)); 0x417709348c0ea4f9 > printdouble(D(exp(17))); 0x417709348c0ea4f9 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > a=2^(-1100); > round(a,53,RN); 1_2 * 2^(-1100) > round(a,D,RN); 0 > double(a); 0 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{RN} (\ref{labrn}), \textbf{RD} (\ref{labrd}), \textbf{RU} (\ref{labru}), \textbf{RZ} (\ref{labrz}), \textbf{halfprecision} (\ref{labhalfprecision}), \textbf{single} (\ref{labsingle}), \textbf{double} (\ref{labdouble}), \textbf{doubleextended} (\ref{labdoubleextended}), \textbf{doubledouble} (\ref{labdoubledouble}), \textbf{quad} (\ref{labquad}), \textbf{tripledouble} (\ref{labtripledouble}), \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{roundcorrectly} (\ref{labroundcorrectly}), \textbf{printdouble} (\ref{labprintdouble}), \textbf{printsingle} (\ref{labprintsingle}), \textbf{ceil} (\ref{labceil}), \textbf{floor} (\ref{labfloor}), \textbf{nearestint} (\ref{labnearestint}) sollya-6.0+ds/doc/roundcoefficients.tex000066400000000000000000000115251300174114700202660ustar00rootroot00000000000000\subsection{roundcoefficients} \label{labroundcoefficients} \noindent Name: \textbf{roundcoefficients}\\ \phantom{aaa}rounds the coefficients of a polynomial to classical formats.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_roundcoefficients(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{roundcoefficients}(\emph{p},\emph{L}) : (\textsf{function}, \textsf{list}) $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{p} is a function. Usually a polynomial. \item \emph{L} is a list of formats. \end{itemize} \noindent Description: \begin{itemize} \item If \emph{p} is a polynomial and \emph{L} a list of floating-point formats, \textbf{roundcoefficients}(\emph{p},\emph{L}) rounds each coefficient of \emph{p} to the corresponding format in \emph{L}. \item If \emph{p} is not a polynomial, \textbf{roundcoefficients} does not do anything. \item If \emph{L} contains other elements than \textbf{HP}, \textbf{halfprecision}, \textbf{SG}, \textbf{single}, \textbf{D}, \textbf{double}, \textbf{DE}, \textbf{doubleextended}, \textbf{DD}, \textbf{doubledouble}, \textbf{QD}, \textbf{quad}, \textbf{TD} and \textbf{tripledouble}, an error occurs. \item The coefficients in \emph{p} corresponding to $X^i$ is rounded to the format L[i]. If \emph{L} does not contain enough elements (e.g. if \textbf{length}(L) $<$ \textbf{degree}(p)+1), a warning is displayed. However, the coefficients corresponding to an element of \emph{L} are rounded. The trailing coefficients (that do not have a corresponding element in \emph{L}) are kept with their own precision. If \emph{L} contains too much elements, the trailing useless elements are ignored. In particular \emph{L} may be end-elliptic in which case \textbf{roundcoefficients} has the natural behavior. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p=exp(1) + x*(exp(2) + x*exp(3)); > display=binary!; > roundcoefficients(p,[|DD,D,D|]); 1.010110111111000010101000101100010100010101110110100101010011010101011111101110 001010110001000000010011101_2 * 2^(1) + x * (1.110110001110011001001011100011010 100110111011010111_2 * 2^(2) + x * (1.010000010101111001011011111101101111101100 010000011_2 * 2^(4))) > roundcoefficients(p,[|DD,D...|]); 1.010110111111000010101000101100010100010101110110100101010011010101011111101110 001010110001000000010011101_2 * 2^(1) + x * (1.110110001110011001001011100011010 100110111011010111_2 * 2^(2) + x * (1.010000010101111001011011111101101111101100 010000011_2 * 2^(4))) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f=sin(exp(1)*x); > display=binary!; > f; sin(x * (1.010110111111000010101000101100010100010101110110100101010011010101011 11110111000101011000100000001001110011110100111100111100011101100010111001110001 01100000111101_2 * 2^(1))) > roundcoefficients(f,[|D...|]); sin(x * (1.010110111111000010101000101100010100010101110110100101010011010101011 11110111000101011000100000001001110011110100111100111100011101100010111001110001 01100000111101_2 * 2^(1))) \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p=exp(1) + x*(exp(2) + x*exp(3)); > verbosity=1!; > display=binary!; > roundcoefficients(p,[|DD,D|]); Warning: the number of the given formats does not correspond to the degree of th e given polynomial. Warning: the 0th coefficient of the given polynomial does not evaluate to a floa ting-point constant without any rounding. Will evaluate the coefficient in the current precision in floating-point before rounding to the target format. Warning: the 1th coefficient of the given polynomial does not evaluate to a floa ting-point constant without any rounding. Will evaluate the coefficient in the current precision in floating-point before rounding to the target format. Warning: rounding may have happened. 1.010110111111000010101000101100010100010101110110100101010011010101011111101110 001010110001000000010011101_2 * 2^(1) + x * (1.110110001110011001001011100011010 100110111011010111_2 * 2^(2) + x * (1.010000010101111001011011111101101111101100 01000001011111001011010100101111011111110001010011011101000100110000111010001110 010000010110000101100000111001011100101001_2 * 2^(4))) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{halfprecision} (\ref{labhalfprecision}), \textbf{single} (\ref{labsingle}), \textbf{double} (\ref{labdouble}), \textbf{doubleextended} (\ref{labdoubleextended}), \textbf{doubledouble} (\ref{labdoubledouble}), \textbf{quad} (\ref{labquad}), \textbf{tripledouble} (\ref{labtripledouble}), \textbf{fpminimax} (\ref{labfpminimax}), \textbf{remez} (\ref{labremez}), \textbf{implementpoly} (\ref{labimplementpoly}), \textbf{subpoly} (\ref{labsubpoly}) sollya-6.0+ds/doc/roundcorrectly.tex000066400000000000000000000031111300174114700176230ustar00rootroot00000000000000\subsection{roundcorrectly} \label{labroundcorrectly} \noindent Name: \textbf{roundcorrectly}\\ \phantom{aaa}rounds an approximation range correctly to some precision\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_roundcorrectly(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{roundcorrectly}(\emph{range}) : \textsf{range} $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{range} represents a range in which an exact value lies \end{itemize} \noindent Description: \begin{itemize} \item Let \emph{range} be a range of values, determined by some approximation process, safely bounding an unknown value $v$. The command \textbf{roundcorrectly}(\emph{range}) determines a precision such that for this precision, rounding to the nearest any value in \emph{range} yields to the same result, i.e. to the correct rounding of $v$. If no such precision exists, a warning is displayed and \textbf{roundcorrectly} evaluates to NaN. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > printbinary(roundcorrectly([1.010001_2; 1.0101_2])); 1.01_2 > printbinary(roundcorrectly([1.00001_2; 1.001_2])); 1_2 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > roundcorrectly([-1; 1]); NaN \end{Verbatim} \end{minipage}\end{center} See also: \textbf{round} (\ref{labround}), \textbf{mantissa} (\ref{labmantissa}), \textbf{exponent} (\ref{labexponent}), \textbf{precision} (\ref{labprecision}) sollya-6.0+ds/doc/roundingwarnings.tex000066400000000000000000000047111300174114700201520ustar00rootroot00000000000000\subsection{roundingwarnings} \label{labroundingwarnings} \noindent Name: \textbf{roundingwarnings}\\ \phantom{aaa}global variable controlling whether or not a warning is displayed when roundings occur.\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_roundingwarnings_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_roundingwarnings(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_roundingwarnings()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{roundingwarnings} = \emph{activation value} : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{roundingwarnings} = \emph{activation value} ! : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{roundingwarnings} : \textsf{on$|$off}\\ \end{center} Parameters: \begin{itemize} \item \emph{activation value} controls if warnings should be shown or not \end{itemize} \noindent Description: \begin{itemize} \item \textbf{roundingwarnings} is a global variable. When its value is \textbf{on}, warnings are emitted in appropriate verbosity modes (see \textbf{verbosity}) when roundings occur. When its value is \textbf{off}, these warnings are suppressed. \item This mode depends on a verbosity of at least 1. See \textbf{verbosity} for more details. \item Default is \textbf{on} when the standard input is a terminal and \textbf{off} when \sollya input is read from a file. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > roundingwarnings = on; Rounding warning mode has been activated. > exp(0.1); Warning: Rounding occurred when converting the constant "0.1" to floating-point with 165 bits. If safe computation is needed, try to increase the precision. Warning: rounding has happened. The value displayed is a faithful rounding to 16 5 bits of the true result. 1.1051709180756476248117078264902466682245471947375 > roundingwarnings = off; Rounding warning mode has been deactivated. > exp(0.1); 1.1051709180756476248117078264902466682245471947375 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{on} (\ref{labon}), \textbf{off} (\ref{laboff}), \textbf{verbosity} (\ref{labverbosity}), \textbf{midpointmode} (\ref{labmidpointmode}), \textbf{rationalmode} (\ref{labrationalmode}), \textbf{suppressmessage} (\ref{labsuppressmessage}), \textbf{unsuppressmessage} (\ref{labunsuppressmessage}), \textbf{showmessagenumbers} (\ref{labshowmessagenumbers}), \textbf{getsuppressedmessages} (\ref{labgetsuppressedmessages}) sollya-6.0+ds/doc/ru.tex000066400000000000000000000015011300174114700151740ustar00rootroot00000000000000\subsection{RU} \label{labru} \noindent Name: \textbf{RU}\\ \phantom{aaa}constant representing rounding-upwards mode.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_round_up()|\\ \verb| int sollya_lib_is_round_up(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{RU} is used in command \textbf{round} to specify that the value $x$ must be rounded to the smallest floating-point number $y$ such that $x \le y$. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > round(Pi,20,RU); 1.100100100001111111_2 * 2^(1) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{RZ} (\ref{labrz}), \textbf{RD} (\ref{labrd}), \textbf{RN} (\ref{labrn}), \textbf{round} (\ref{labround}), \textbf{ceil} (\ref{labceil}) sollya-6.0+ds/doc/rz.tex000066400000000000000000000016531300174114700152110ustar00rootroot00000000000000\subsection{RZ} \label{labrz} \noindent Name: \textbf{RZ}\\ \phantom{aaa}constant representing rounding-to-zero mode.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_round_towards_zero()|\\ \verb| int sollya_lib_is_round_towards_zero(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{RZ} is used in command \textbf{round} to specify that the value must be rounded to the closest floating-point number towards zero. It just consists in truncating the value to the desired format. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > round(Pi,20,RZ); 1.1001001000011111101_2 * 2^(1) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{RD} (\ref{labrd}), \textbf{RU} (\ref{labru}), \textbf{RN} (\ref{labrn}), \textbf{round} (\ref{labround}), \textbf{floor} (\ref{labfloor}), \textbf{ceil} (\ref{labceil}) sollya-6.0+ds/doc/searchgal.tex000066400000000000000000000103241300174114700165020ustar00rootroot00000000000000\subsection{searchgal} \label{labsearchgal} \noindent Name: \textbf{searchgal}\\ \phantom{aaa}searches for a preimage of a function such that the rounding the image yields an error smaller than a constant\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_searchgal(sollya_obj_t, sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{searchgal}(\emph{function}, \emph{start}, \emph{preimage precision}, \emph{steps}, \emph{format}, \emph{error bound}) : (\textsf{function}, \textsf{constant}, \textsf{integer}, \textsf{integer}, \textsf{HP$|$halfprecision$|$SG$|$single$|$D$|$double$|$DE$|$doubleextended$|$DD$|$doubledouble$|$QD$|$quad$|$TD$|$tripledouble}, \textsf{constant}) $\rightarrow$ \textsf{list}\\ \textbf{searchgal}(\emph{list of functions}, \emph{start}, \emph{preimage precision}, \emph{steps}, \emph{list of format}, \emph{list of error bounds}) : (\textsf{list}, \textsf{constant}, \textsf{integer}, \textsf{integer}, \textsf{list}, \textsf{list}) $\rightarrow$ \textsf{list}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents the function to be considered \item \emph{start} represents a value around which the search is to be performed \item \emph{preimage precision} represents the precision (discretization) for the eligible preimage values \item \emph{steps} represents the binary logarithm ($\log_2$) of the number of search steps to be performed \item \emph{format} represents the format the image of the function is to be rounded to \item \emph{error bound} represents a upper bound on the relative rounding error when rounding the image \item \emph{list of functions} represents the functions to be considered \item \emph{list of formats} represents the respective formats the images of the functions are to be rounded to \item \emph{list of error bounds} represents a upper bound on the relative rounding error when rounding the image \end{itemize} \noindent Description: \begin{itemize} \item The command \textbf{searchgal} searches for a preimage $z$ of function \emph{function} or a list of functions \emph{list of functions} such that $z$ is a floating-point number with \emph{preimage precision} significant mantissa bits and the image $y$ of the function, respectively each image $y_i$ of the functions, rounds to format \emph{format} respectively to the corresponding format in \emph{list of format} with a relative rounding error less than \emph{error bound} respectively the corresponding value in \emph{list of error bounds}. During this search, at most $2^{steps}$ attempts are made. The search starts with a preimage value equal to \emph{start}. This value is then increased and decreased by $1$ ulp in precision \emph{preimage precision} until a value is found or the step limit is reached. If the search finds an appropriate preimage $z$, \textbf{searchgal} evaluates to a list containing this value. Otherwise, \textbf{searchgal} evaluates to an empty list. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > searchgal(log(x),2,53,15,DD,1b-112); [| |] > searchgal(log(x),2,53,18,DD,1b-112); [|2.0000000000384972054234822280704975128173828125|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = exp(x); > s = searchgal(f,2,53,18,DD,1b-112); > if (s != [||]) then { v = s[0]; print("The rounding error is 2^(",evaluate(log2(abs(DD(f)/f - 1)),v),")"); } else print("No value found"); The rounding error is 2^( -112.106878438809380148206984258358542322113874177832 ) \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > searchgal([|sin(x),cos(x)|],1,53,15,[|D,D|],[|1b-62,1b-60|]); [|1.00000000000159494639717649988597258925437927246094|] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{round} (\ref{labround}), \textbf{double} (\ref{labdouble}), \textbf{doubledouble} (\ref{labdoubledouble}), \textbf{tripledouble} (\ref{labtripledouble}), \textbf{evaluate} (\ref{labevaluate}), \textbf{worstcase} (\ref{labworstcase}) sollya-6.0+ds/doc/sg.tex000066400000000000000000000002351300174114700151620ustar00rootroot00000000000000\subsection{SG} \label{labsg} \noindent Name: \textbf{SG}\\ \phantom{aaa}short form for \textbf{single}\\[0.2cm] See also: \textbf{single} (\ref{labsingle}) sollya-6.0+ds/doc/showmessagenumbers.tex000066400000000000000000000106561300174114700205020ustar00rootroot00000000000000\subsection{showmessagenumbers} \label{labshowmessagenumbers} \noindent Name: \textbf{showmessagenumbers}\\ \phantom{aaa}activates, deactivates or inspects the state variable controlling the displaying of numbers for messages\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_showmessagenumbers_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_showmessagenumbers(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_showmessagenumbers()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{showmessagenumbers} = \emph{activation value} : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{showmessagenumbers} = \emph{activation value} ! : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{showmessagenumbers} : \textsf{on$|$off}\\ \end{center} Parameters: \begin{itemize} \item \emph{activation value} represents \textbf{on} or \textbf{off}, i.e. activation or deactivation \end{itemize} \noindent Description: \begin{itemize} \item An assignment \textbf{showmessagenumbers} = \emph{activation value}, where \emph{activation value} is one of \textbf{on} or \textbf{off}, activates respectively deactivates the displaying of numbers for warning and information messages. Every \sollya warning or information message (that is not fatal to the tool's execution) has a message number. By default, these numbers are not displayed when a message is output. When message number displaying is activated, the message numbers are displayed together with the message. This allows the user to recover the number of a particular message in order to suppress resp. unsuppress the displaying of this particular message (see \textbf{suppressmessage} and \textbf{unsuppressmessage}). \item The user should be aware of the fact that message number display activation resp. deactivation through \textbf{showmessagenumbers} does not affect message displaying in general. For instance, even with message number displaying activated, messages with only displayed when general verbosity and rounding warning mode are set accordingly. \item If the assignment \textbf{showmessagenumbers} = \emph{activation value} is followed by an exclamation mark, no message indicating the new state is displayed. Otherwise the user is informed of the new state of the global mode by an indication. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1; The verbosity level has been set to 1. > 0.1; Warning: Rounding occurred when converting the constant "0.1" to floating-point with 165 bits. If safe computation is needed, try to increase the precision. 0.1 > showmessagenumbers = on; Displaying of message numbers has been activated. > 0.1; Warning (174): Rounding occurred when converting the constant "0.1" to floating- point with 165 bits. If safe computation is needed, try to increase the precision. 0.1 > showmessagenumbers; on > showmessagenumbers = off!; > 0.1; Warning: Rounding occurred when converting the constant "0.1" to floating-point with 165 bits. If safe computation is needed, try to increase the precision. 0.1 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > showmessagenumbers = on; Displaying of message numbers has been activated. > verbosity = 1; The verbosity level has been set to 1. > diff(0.1 * x + 1.5 * x^2); Warning (174): Rounding occurred when converting the constant "0.1" to floating- point with 165 bits. If safe computation is needed, try to increase the precision. 0.1 + x * 3 > verbosity = 0; The verbosity level has been set to 0. > diff(0.1 * x + 1.5 * x^2); 0.1 + x * 3 > verbosity = 12; The verbosity level has been set to 12. > diff(0.1 * x + 1.5 * x^2); Warning (174): Rounding occurred when converting the constant "0.1" to floating- point with 165 bits. If safe computation is needed, try to increase the precision. Information (196): formally differentiating a function. Information (197): differentiating the expression '0.1 * x + 1.5 * x^2' Information (195): expression '0.1 + 2 * 1.5 * x' has been simplified to express ion '0.1 + 3 * x'. 0.1 + x * 3 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{getsuppressedmessages} (\ref{labgetsuppressedmessages}), \textbf{suppressmessage} (\ref{labsuppressmessage}), \textbf{unsuppressmessage} (\ref{labunsuppressmessage}), \textbf{verbosity} (\ref{labverbosity}), \textbf{roundingwarnings} (\ref{labroundingwarnings}) sollya-6.0+ds/doc/simplify.tex000066400000000000000000000034571300174114700164160ustar00rootroot00000000000000\subsection{simplify} \label{labsimplify} \noindent Name: \textbf{simplify}\\ \phantom{aaa}simplifies an expression representing a function\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_simplify(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{simplify}(\emph{function}) : \textsf{function} $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents the expression to be simplified \end{itemize} \noindent Description: \begin{itemize} \item The command \textbf{simplify} simplifies the expression given in argument representing the function \emph{function}. The command \textbf{simplify} does not endanger the safety of computations even in \sollya's floating-point environment: the function returned is mathematically equal to the function \emph{function}. Remark that the simplification provided by \textbf{simplify} is not perfect: they may exist simpler equivalent expressions for expressions returned by \textbf{simplify}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(simplify((6 + 2) + (5 + exp(0)) * x)); 8 + 6 * x \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(simplify((log(x - x + 1) + asin(1)))); (pi) / 2 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(simplify((log(x - x + 1) + asin(1)) - (atan(1) * 2))); (pi) / 2 - (pi) / 4 * 2 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{dirtysimplify} (\ref{labdirtysimplify}), \textbf{autosimplify} (\ref{labautosimplify}), \textbf{rationalmode} (\ref{labrationalmode}), \textbf{horner} (\ref{labhorner}) sollya-6.0+ds/doc/sin.tex000066400000000000000000000010771300174114700153470ustar00rootroot00000000000000\subsection{sin} \label{labsin} \noindent Name: \textbf{sin}\\ \phantom{aaa}the sine function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_sin(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_sin(sollya_obj_t)|\\ \verb| #define SOLLYA_SIN(x) sollya_lib_build_function_sin(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{sin} is the usual sine function. \item It is defined for every real number $x$. \end{itemize} See also: \textbf{asin} (\ref{labasin}), \textbf{cos} (\ref{labcos}), \textbf{tan} (\ref{labtan}) sollya-6.0+ds/doc/single.tex000066400000000000000000000035221300174114700160340ustar00rootroot00000000000000\subsection{single} \label{labsingle} \noindent Names: \textbf{single}, \textbf{SG}\\ \phantom{aaa}rounding to the nearest IEEE 754 single (binary32).\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_single(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_single_obj()|\\ \verb| int sollya_lib_is_single_obj(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_single(sollya_obj_t)|\\ \verb| #define SOLLYA_SG(x) sollya_lib_build_function_single(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{single} is both a function and a constant. \item As a function, it rounds its argument to the nearest IEEE 754 single precision (i.e. IEEE754-2008 binary32) number. Subnormal numbers are supported as well as standard numbers: it is the real rounding described in the standard. \item As a constant, it symbolizes the single precision format. It is used in contexts when a precision format is necessary, e.g. in the commands \textbf{round} and \textbf{roundcoefficients}. In is not supported for \textbf{implementpoly}. See the corresponding help pages for examples. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > SG(0.1); 1.10011001100110011001101_2 * 2^(-4) > SG(4.17); 1.000010101110000101001_2 * 2^(2) > SG(1.011_2 * 2^(-1073)); 0 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{halfprecision} (\ref{labhalfprecision}), \textbf{double} (\ref{labdouble}), \textbf{doubleextended} (\ref{labdoubleextended}), \textbf{doubledouble} (\ref{labdoubledouble}), \textbf{quad} (\ref{labquad}), \textbf{tripledouble} (\ref{labtripledouble}), \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{implementpoly} (\ref{labimplementpoly}), \textbf{round} (\ref{labround}), \textbf{printsingle} (\ref{labprintsingle}) sollya-6.0+ds/doc/sinh.tex000066400000000000000000000012101300174114700155040ustar00rootroot00000000000000\subsection{sinh} \label{labsinh} \noindent Name: \textbf{sinh}\\ \phantom{aaa}the hyperbolic sine function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_sinh(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_sinh(sollya_obj_t)|\\ \verb| #define SOLLYA_SINH(x) sollya_lib_build_function_sinh(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{sinh} is the usual hyperbolic sine function: $\sinh(x) = \frac{e^x - e^{-x}}{2}$. \item It is defined for every real number $x$. \end{itemize} See also: \textbf{asinh} (\ref{labasinh}), \textbf{cosh} (\ref{labcosh}), \textbf{tanh} (\ref{labtanh}) sollya-6.0+ds/doc/sollya.tex000066400000000000000000005420561300174114700160700ustar00rootroot00000000000000\documentclass[a4paper]{article} \usepackage[T1]{fontenc} \usepackage[utf8]{inputenc} \usepackage[english]{babel} \usepackage[naturalnames]{hyperref} \usepackage{fullpage} \usepackage{xspace} \usepackage{amssymb} \usepackage{fancyvrb} \usepackage{cmap} \usepackage{lmodern} \usepackage{color} \usepackage{tocloft} \setlength{\cftsubsecnumwidth}{2.7em} \newcommand{\com}[1]{\texttt{#1}} \newcommand{\key}[1]{\texttt{#1}} \newcommand{\sollya}{\texttt{Sollya}\xspace} \newcommand{\rlwrap}{\texttt{rlwrap}\xspace} \newcommand{\alert}[1]{\textcolor{red}{#1}} \newcommand{\csi}{\xi} % Workaround before dealing with commands of the form % \xsomething in .shlp files. \newcommand{\code}[1]{ \begin{center} \begin{tabular}{|p{14.8cm}|} \hline #1 \hline \end{tabular} \end{center} } \newcommand{\ligne}[1]{\texttt{#1}\\} \title{Users' manual for the \sollya tool \\ {\large Release 6.0}} \author{Sylvain Chevillard \\ \small{\url{sylvain.chevillard@ens-lyon.org}} \and Christoph Lauter \\ \small{\url{christoph.lauter@ens-lyon.org}} \and Mioara Jolde\c{s} \\ \small{\url{joldes@laas.fr}}} \date{\today} \begin{document} \pagenumbering{gobble} \null % Empty line \nointerlineskip % No skip for prev line \vfill \let\snewpage \newpage \let\newpage \relax \maketitle \let \newpage \snewpage \vfill \break % page break \section*{License} The \sollya tool is Copyright \copyright~2006-2016 by \vspace{2mm} \\ \indent Laboratoire de l'Informatique du Parall\'elisme,\\ \indent UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668\\ \indent Lyon, France, \vspace{2mm} \\ \indent LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), Nancy, France, \vspace{2mm} \\ \indent Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN\\ \indent Sorbonne Universités\\ \indent UPMC Univ Paris 06\\ \indent UMR 7606, LIP6\\ \indent Boîte Courrier 169\\ \indent 4, place Jussieu\\ \indent F-75252 Paris Cedex 05\\ \indent France, \vspace{2mm} \\ \indent CNRS, LIP6, UPMC \\ \indent Sorbonne Universités, UPMC Univ Paris 06, \\ \indent CNRS, LIP6 UMR 7606, 4 place Jussieu 75005 Paris \vspace{2mm}\\ and by \vspace{2mm} \\ \indent INRIA Sophia-Antipolis M\'editerran\'ee, APICS Team,\\ \indent Sophia-Antipolis, France. \vspace{2mm}\\ All rights reserved.\\[0.2cm] \noindent This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL \url{http://www.cecill.info}. \noindent As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. \noindent In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. \noindent The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. \noindent This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. \clearpage \pagenumbering{roman} \tableofcontents \newpage \pagenumbering{arabic} \section{Compilation and installation of \sollya} \sollya comes in two flavors: \begin{itemize} \item Either as an interactive tool. This is achieved by running the \sollya executable file. \item Or as a C library that provides all the features of the tool within the C programming language. \end{itemize} The installation of the tool and the library follow the same steps, desribed below. The present documentation focuses more on the interactive tool. As a matter of fact, the library works exactly the same way as the tool, so it is necessary to know a little about the tool in order to correctly use the library. The reader who is only interested in the library should at least read the following Sections~\ref{sec:introduction}, \ref{sec:general_principles} and \ref{sec:data_types}. A documentation specifically describing the library usage is available in Appendix~\ref{Libsollya} at the end of the present documentation. \subsection{Compilation dependencies} The \sollya distribution can be compiled and installed using the usual \texttt{./configure}, \texttt{make}, \texttt{make install} procedure. Besides a \texttt{C} and a \texttt{C++} compiler, \sollya needs the following software libraries and tools to be installed. The \texttt{./configure} script checks for the installation of the libraries. However \sollya will build without error if some of its external tools are not installed. In this case an error will be displayed at runtime. \begin{itemize} \item \texttt{GMP} \item \texttt{MPFR} \item \texttt{MPFI} \item \texttt{fplll} \item \texttt{libxml2} \item \texttt{gnuplot} (external tool) \end{itemize} The use of the external tool \texttt{rlwrap} is highly recommended but not required to use the \sollya interactive tool. Use the \texttt{-A} option of \texttt{rlwrap} for correctly displayed ANSI X3.64/ ISO/IEC 6429 colored prompts (see below). \subsection{\sollya command line options} \sollya can read input on standard input or in a file whose name is given as an argument when \sollya is invoked. The tool will always produce its output on standard output, unless specificly instructed by a particular \sollya command that writes to a file. The following lines are valid invocations of \sollya, assuming that \texttt{bash} is used as a shell: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] ~/% sollya ... ~/% sollya myfile.sollya ... ~/% sollya < myfile.sollya \end{Verbatim} \end{minipage}\end{center} If a file given as an input does not exist, an error message is displayed. All configurations of the internal state of the tool are done by commands given on the \sollya prompt or in \sollya scripts. Nevertheless, some command line options are supported; they work at a very basic I/O-level and can therefore not be implemented as commands. The following options are supported when calling \sollya: \begin{itemize} \item \texttt{-{}-args}: This special argument indicates to \sollya that subsequent command line arguments are no longer to be interpreted but are to be passed as-is to the predefined \sollya variable \texttt{\_\_argv}. The \texttt{-{}-args} argument is implicitly assumed if a \sollya script filename has already been specified with a preceding command line argument and none of the subsequent command line arguments is one of the special options given in this list. \item \texttt{-{}-donotmodifystacksize}: When invoked, \sollya trys to increase the stack size that is available to a user process to the maximum size supported by the kernel. On some systems, the correspondent \texttt{ioctl} does not work properly. Use the option to prevent \sollya from changing the stack size. \item \texttt{-{}-flush}: When this option is given, \sollya will flush all its input and output buffers after parsing and executing each command resp. sequence of commands. This option is needed when pipes are used to communicate with \sollya from another program. \item \texttt{-{}-help}: Prints help on the usage of the tool and quits. \item \texttt{-{}-nocolor}: \sollya supports coloring of the output using ANSI X3.64/ ISO/IEC 6429 escape sequences. Coloring is deactivated when \sollya is connected on standard input to a file that is not a terminal. This option forces the deactivation of ANSI coloring. This might be necessary on very old grey-scale terminals or when encountering problems with old versions of \texttt{rlwrap}. \item \texttt{-{}-noprompt}: \sollya prints a prompt symbol when connected on standard input to a pseudo-file that is a terminal. The option deactivates the prompt. \item \texttt{-{}-oldautoprint}: The behaviour of an undocumented feature for displaying values has changed in \sollya from version 1.1 to version 2.0. The old feature is deprecated. If you wish to use it nevertheless, use this deprecated option. \item \texttt{-{}-oldexternalprocprint}: The behavior of an undocumented feature for displaying \sollya objects representing external procedures upon automatic printing at the \sollya prompt has been changed in \sollya from version 4.1 to version 5.0. The old feature is deprecated. If you wish to use it nevertheless, use this deprecated option. \item \texttt{-{}-oldrlwrapcompatible}: This option is deprecated. It makes \sollya emit a non ANSI X3.64 compliant coloring escape sequence for making it compatible with versions of \texttt{rlwrap} that do not support the \texttt{-A} option. The option is considered a hack since it is known to garble the output of the tool under some particular circumstances. \item \texttt{-{}-warninfile[append] }: Normally, \sollya emits warning and information messages together with all other displayed information on either standard output or standard error. This option allows all warning and information messages to get redirected to a file. The filename to be used must be given after the option. When \texttt{-{}-warninfile} is used, the existing content (if any) of the file is first removed before writing to the file. With \texttt{-{}-warninfileappend}, the messages are appended to an existing file. Even if coloring is used for the displaying all other \sollya output, no coloring sequences are ever written to the file. Let us emphasize on the fact that any file of a unixoid system can be used for output, for instance also a named pipe. This allows for error messaging to be performed on a separate terminal. The use of this option is mutually exclusive with the \texttt{-{}-warnonstderr} option. \item \texttt{-{}-warnonstderr}: Normally, \sollya prints warning and information messages on standard output, using a warning color when coloring is activated. When this option is given, \sollya will output all warning and information messages on standard error. Coloring will be used even on standard error, when activated. The use of this option is mutually exclusive with the \texttt{-{}-warninfile[append]} option. \end{itemize} \section{Introduction} \label{sec:introduction} \sollya is an interactive tool for handling numerical functions and working with arbitrary precision. It can evaluate functions accurately, compute polynomial approximations of functions, automatically implement polynomials for use in math libraries, plot functions, compute infinity norms, etc. \sollya is also a full-featured script programming language with support for procedures~etc. Let us begin this manual with an example. \sollya does not allow command line edition; since this may quickly become uncomfortable, we highly suggest to use the \rlwrap tool with \sollya: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] ~/% rlwrap -A sollya > \end{Verbatim} \end{minipage}\end{center} \sollya manipulates only functions in one variable. The first time that an unbound variable is used, this name is fixed. It will be used to refer to the free variable. For instance, try \input{introExample1} Now, the name $x$ can only be used to refer to the free variable: \input{introExample2} If you really want to unbind $x$, you can use the \com{rename} command and change the name of the free variable: \input{introExample3} \sollya has a reserved keyword that can always be used to refer to the free variable. This keyword is \verb|_x_|. This is particularly useful in contexts when the name of the variable is not known: typically when refering to the free variable in a pattern matching or inside a procedure. \input{introExample3bis} As you have seen, you can name functions and easily work with them. The basic thing to do with a function is to evaluate it at some point: \input{introExample4} The printed value is generally a faithful rounding of the exact value at the working precision (\emph{i.e.}, one of the two floating-point numbers enclosing the exact value). Internally \sollya represents numbers as floating-point numbers in arbitrary precision with radix~$2$: the fact that a faithful rounding is performed in binary does not imply much on the exactness of the digits displayed in decimal. The working precision is controlled by the global variable \com{prec}: \input{introExample5} Sometimes a faithful rounding cannot easily be computed. In such a case, a value is printed that was obtained using floating-point approximations without control on the final accuracy: \input{introExample6} The philosophy of \sollya is: \emph{Whenever something is not exact, print a warning}. This explains the warnings in the previous examples. If the result can be shown to be exact, there is no warning: \input{introExample7} Let us finish this Section with a small complete example that shows a bit of what can be done with~\sollya: % Warning: this file must be manually corrected: delete the extra ">" \input{introExample8} In this example, we define a function $f$, an interval $d$ and we compute the best degree-2 polynomial approximation of $f$ on $d$ with respect to the infinity norm. In other words, $\max_{x \in d} \{|p(x)-f(x)|\}$ is minimal amongst polynomials with degree not greater than $2$. Then, we compute the list of the zeros of the derivative of $p-f$ and add the bounds of $d$ to this list. Finally, we evaluate $|p-f|$ for each point in the list and store the maximum and the point where it is reached. We conclude by printing the result in a formatted way. Let us mention as a sidenote that you do not really need to use such a script for computing an infinity norm; as we will see, the command \com{dirtyinfnorm} does this for you. \section{General principles}\label{sec:general_principles} The first purpose of \sollya is to help people using numerical functions and numerical algorithms in a safe way. It is first designed to be used interactively but it can also be used in scripts\footnote{Remark: some of the behaviors of \sollya slightly change when it is used in scripts. For example, no prompt is printed.}. One of the particularities of \sollya is to work with multi-precision arithmetic (it uses the \texttt{MPFR} library). For safety purposes, \sollya knows how to use interval arithmetic. It uses interval arithmetic to produce tight and safe results with the precision required by the user. The general philosophy of \sollya is: \emph{When you can perform a computation exactly and sufficiently quickly, do it; when you cannot, do not, unless you have been explicitly asked for.} The precision of the tool is set by the global variable \key{prec}. In general, the variable \key{prec} determines the precision of the outputs of commands: more precisely, the command will internally determine how much precision should be used during the computations in order to ensure that the output is a faithfully rounded result with \key{prec} bits. For decidability and efficiency reasons, this general principle cannot be applied every time, so be careful. Moreover certain commands are known to be unsafe: they give in general excellent results and give almost \key{prec} correct bits in output for everyday examples. However they are merely based on heuristics and should not be used when the result must be safe. See the documentation of each command to know precisely how confident you can be with their result. A second principle (that comes together with the first one) is the following one: \emph{When a computation leads to inexact results, inform the user with a warning}. This can be quite irritating in some circumstances: in particular if you are using \sollya within other scripts. The global variable \key{verbosity} lets you change the level of verbosity of \sollya. When the variable is set to $0$, \sollya becomes completely silent on standard output and prints only very important messages on standard error. Increase \key{verbosity} if you want more information about what \sollya is doing. Please keep in mind that when you affect a value to a global variable, a message is always printed even if \com{verbosity} is set to $0$. In order to silently affect a global variable, use~\texttt{!}: \input{introExample9} For conviviality reasons, values are displayed in decimal by default. This lets a normal human being understand the numbers they manipulate. But since constants are internally represented in binary, this causes permanent conversions that are sources of roundings. Thus you are loosing in accuracy and \sollya is always complaining about inexact results. If you just want to store or communicate your results (to another tools for instance) you can use bit-exact representations available in \sollya. The global variable \key{display} defines the way constants are displayed. Here is an example of the five available modes: \input{introExample10} Please keep in mind that it is possible to maintain the general verbosity level at some higher setting while deactivating all warnings on roundings. This feature is controlled using the \key{roundingwarnings} global variable. It may be set to \key{on} or \key{off}. By default, the warnings are activated (\key{roundingwarnings = on}) when \sollya is connected on standard input to a pseudo-file that represents a terminal. They are deactivated when \sollya is connected on standard input to a real file. See \ref{labroundingwarnings} for further details; the behavior is illustrated with examples there. As always, the symbol \texttt{e} means $\times 10^\square $. The same way the symbol \texttt{b} means $\times 2^\square $. The symbol \texttt{p} means $\times 16^\square$ and is used only with the \texttt{0x} prefix. The prefix \texttt{0x} indicates that the digits of the following number until a symbol \texttt{p} or white-space are hexadecimal. The suffix \texttt{\_2} indicates to \sollya that the previous number has been written in binary. \sollya can parse these notations even if you are not in the corresponding \key{display} mode, so you can always use them. You can also use memory-dump hexadecimal notation frequently used to represent IEEE 754 \texttt{double} and \texttt{single} precision numbers. Since this notation does not allow for exactly representing numbers with arbitrary precision, there is no corresponding \key{display} mode. However, the commands \com{printdouble} respectively \com{printsingle} round the value to the nearest \texttt{double} respectively \texttt{single}. The number is then printed in hexadecimal as the integer number corresponding to the memory representation of the IEEE 754 \texttt{double} or \texttt{single} number: \input{introExample11} \sollya can parse these memory-dump hexadecimal notation back in any \key{display} mode. The difference of this memory-dump notation with the hexadecimal notation (as defined above) is made by the presence or absence of a \texttt{p} indicator. \section{Variables}\label{variables} As already explained, \sollya can manipulate variate functional expressions in one variable. These expressions contain a unique free variable the name of which is fixed by its first usage in an expression that is not a left-hand-side of an assignment. This global and unique free variable is a variable in the mathematical sense of the term. \sollya also provides variables in the sense programming languages give to the term. These variables, which must be different in their name from the global free variable, may be global or declared and attached to a block of statements, \emph{i.e.}, a begin-end-block. These programming language variables may hold any object of the \sollya language, as for example functional expressions, strings, intervals, constant values, procedures, external functions and procedures, etc. Global variables need not to be declared. They start existing, \emph{i.e.}, can be correctly used in expressions that are not left-hand-sides of assignments, when they are assigned a value in an assignment. Since they are global, this kind of variables is recommended only for small \sollya scripts. Larger scripts with code reuse should use declared variables in order to avoid name clashes for example in loop variables. Declared variables are attached to a begin-end-block. The block structure builds scopes for declared variables. Declared variables in inner scopes shadow (global and declared) variables of outer scopes. The global free variable, \emph{i.e.}, the mathematical variable for variate functional expressions in one variable, cannot be shadowed. Variables are declared using the \key{var} keyword. See Section~\ref{labvar} for details on its usage and semantic. The following code examples illustrate the use of variables. \input{introExample12} Let us state that a variable identifier, just as every identifier in \sollya, contains at least one character, starts with a ASCII letter and continues with ASCII letters or numerical digits. Two predefined variables exist when \sollya is started: \begin{itemize} \item \texttt{\_\_argv} : This variable contains, on \sollya startup and after the execution of the \texttt{restart} command, a list of character strings that correspond to the command line options given to \sollya after the (implicit) command line argument \texttt{-{}-args} (see above). \item \texttt{\_\_unique\_id} : This variable contains, on \sollya startup and after the execution of the \texttt{restart} command, a character string that uniquely identifies the given \sollya session on a system. It hence allows for concurrent execution of \sollya scripts that use temporary files for communication with other tools. The character string is made of alphanumeric characters ([0-9a-zA-Z]) and dashes~(-) and underscores~(\_). In particular, it does not contain any space. After the execution of the \texttt{restart} command, the \texttt{\_\_unique\_id} variable is refreshed with a new, unique value. \end{itemize} Even though these variables exist upon \sollya startup with predefined values, they behave like any other variable: the predefined value can be overwritten by assigning any new value to the variables, the variables can be shadowed by declared, local variables of the same name and so on. \section{Data types}\label{sec:data_types} \sollya has a (very) basic system of types. If you try to perform an illicit operation (such as adding a number and a string, for instance), you will get a typing error. Let us see the available data types. \subsection{Booleans} There are two special values \key{true} and \key{false}. Boolean expressions can be constructed using the boolean connectors \key{\&\&} (and), \key{||} (or), \key{!} (not), and comparisons. The comparison operators \key{<}, \key{<=}, \key{>} and \key{>=} can only be used between two numbers or constant expressions. The comparison operators \key{==} and \key{!=} are polymorphic. You can use them to compare any two objects, like two strings, two intervals, etc. As a matter of fact, polymorphism is allowed on both sides: it is possible to compare objects of different type. Such objects of different type, as they can never be syntactically equal, will always compare unequal (see exception for \key{error}, Section~\ref{laberror}) and never equal. It is important to remember that testing the equality between two functions will return \key{true} if and only if the expression trees representing the two functions are exactly the same or automatic simplification is activated and both functions are polynomials that are equal. See \ref{laberror} for an exception concerning the special object \key{error}. Example: \input{introExample13} \subsection{Numbers} \label{sec:numbers} \sollya represents numbers as binary multi-precision floating-point values. For integer values and values in dyadic, binary, hexadecimal or memory dump notation, it automatically uses a precision needed for representing the value exactly (unless this behaviour is overridden using the syntax given below). Additionally, automatic precision adaption takes place for all integer values (even in decimal notation) written without the exponent sign \texttt{e} or with the exponent sign \texttt{e} and an exponent sufficiently small that they are less than $10^{999}$. Otherwise the values are represented with the current precision \com{prec}. When a number must be rounded, it is rounded to the precision \com{prec} before the expression get evaluated: \input{introExample14} As a matter of fact, each variable has its own precision that corresponds to its intrinsic precision or, if it cannot be represented, to the value of \com{prec} when the variable was set. Thus you can work with variables having a precision higher than the current precision. The same way, if you define a function that refers to some constant, this constant is stored in the function with the current precision and will keep this value in the future, even if \com{prec} becomes smaller. If you define a function that refers to some variable, the precision of the variable is kept, independently of the current precision: \input{introExample15} In some rare cases, it is necessary to read in decimal constants with a particular precision being used in the conversion to the binary floating-point format, which \sollya uses. Setting \key{prec} to that precision may prove to be an insufficient means for doing so, for example when several different precisions have to be used in one expression. For these rare cases, \sollya provides the following syntax: decimal constants may be written {\tt \%}\emph{precision}{\tt\%}\emph{constant}, where \emph{precision} is a constant integer, written in decimal, and \emph{constant} is the decimal constant. \sollya will convert the constant \emph{constant} with precision \emph{precision}, regardless of the global variable \key{prec} and regardless if \emph{constant} is an integer or would otherwise be representable. \input{introExample44} \sollya is an environment that uses floating-point arithmetic. The IEEE 754-2008 standard on floating-point arithmetic does not only define floating-point numbers that represent real numbers but also floating-point data representing infinities and Not-a-Numbers (NaNs). \sollya also supports infinities and NaNs in the spirit of the IEEE 754-2008 standard without taking the standard's choices literally. \begin{itemize} \item Signed infinities are available through the \sollya objects \texttt{infty, -infty, @Inf@} and \texttt{-@Inf@}. \item Not-a-Numbers are supported through the \sollya objects \texttt{NaN} and \texttt{@NaN@}. \sollya does not have support for NaN payloads, signaling or quiet NaNs or signs of NaNs. Signaling NaNs are supported on input for single and double precision memory notation (see Section~\ref{sec:general_principles}). However, they immediately get converted to plain \sollya NaNs. \end{itemize} The evaluation of an expression involving a NaN or the evaluation of a function at a point being NaN always results in a NaN. Infinities are considered to be the limits of expressions tending to infinity. They are supported as bounds of intervals in some cases. However, particular commands might prohibit their use even though there might be a mathematical meaning attached to such expressions. For example, while \sollya will evaluate expressions such as $\lim\limits_{x \rightarrow -\infty} e^x$, expressed \emph{e.g.}, through \texttt{evaluate(exp(x),[-infty;0])}, it will not accept to compute the (finite) value of $$\int\limits_{-\infty}^0 e^x \,\mbox{d}x.$$ The following examples give an idea of what can be done with \sollya infinities and NaNs. Here is what can be done with infinities: \input{introExample32} And the following example illustrates NaN behavior. \input{introExample33} \subsection{Rational numbers and rational arithmetic}\label{sec:rationalmode} The \sollya tool is mainly based on floating-point arithmetic: wherever possible, floating-point algorithms, including algorithms using interval arithmetic, are used to produce approximate but safe results. For some particular cases, floating-point arithmetic is not sufficient: some algorithms just require natural and rational numbers to be handled exactly. More importantly, for these applications, it is required that rational numbers be displayed as such. \sollya implements a particular mode that offers a lightweight support for rational arithmetic. When needed, it can be enabled by assigning \com{on} to the global variable \com{rationalmode}. It is disabled by assigning \com{off}; the default is \com{off}. When the mode for rational arithmetic is enabled, \sollya's behavior will change as follows: \begin{itemize} \item When a constant expression is given at the \sollya prompt, \sollya will first try to simplify the expression to a rational number. If such an evaluation to a rational number is possible, \sollya will display that number as an integer or a fraction of two integers. Only if \sollya is not able to simplify the constant expression to a rational number, it will launch the default behavior of evaluating constant expressions to floating-point numbers that are generally faithful roundings of the expressions. \item When the global mode \com{autosimplify} is \com{on}, which is the default, \sollya will additionally use rational arithmetic while trying to simplify expressions given in argument of commands. \end{itemize} Even when \com{rationalmode} is \com{on}, \sollya will not be able to exhibit integer ratios between transcendental quantities. For example, \sollya will not display $\frac{1}{6}$ for $\arcsin\left( \frac{1}{2} \right) / \pi$ but $0.16666\dots$. \sollya's evaluator for rational arithmetic is only able to simplify rational expressions based on addition, subtraction, multiplication, division, negation, perfect squares (for square root) and integer powers. The following example illustrates what can and what cannot be done with \sollya's mode for rational arithmetic: \input{introExample34} \subsection{Intervals and interval arithmetic} \sollya can manipulate intervals that are closed subsets of the real numbers. Several ways of defining intervals exist in \sollya. There is the most common way where intervals are composed of two numbers or constant expressions representing the lower and the upper bound. These values are separated either by commas or semi-colons. Interval bound evaluation is performed in a way that ensures the inclusion property: all points in the original, unevaluated interval will be contained in the interval with its bounds evaluated to floating-point numbers. \input{introExample16} \sollya has a mode for printing intervals that are that thin that their bounds have a number of decimal digits in common when printed. That mode is called \com{midpointmode}; see below for an introduction and Section~\ref{labmidpointmode} for details. As \sollya must be able to parse back its own output, a syntax is provided to input intervals in midpoint~mode. However, please pay attention to the fact that the notation used in midpoint~mode generally increases the width of intervals: hence when an interval is displayed in midpoint~mode and read again, the resulting interval may be wider than the original interval. \input{introExample41} In some cases, intervals become infinitely thin in theory, in which case one tends to think of point intervals even if their floating-point representation is not infinitely thin. \sollya provides a very covenient way for input of such point intervals. Instead of writing \texttt{[a;a]}, it is possible to just write \texttt{[a]}. \sollya will expand the notation while making sure that the inclusion property is satisfied: \input{introExample38} When the mode \com{midpointmode} is set to \com{on} (see \ref{labmidpointmode}), \sollya will display intervals that are provably reduced to one point in this extended interval syntax. It will use \com{midpointmode} syntax for intervals that are sufficiently thin but not reduced to one point (see Section~\ref{labmidpointmode} for details): \input{introExample40} \sollya intervals are internally represented with floating-point numbers as bounds; rational numbers are not supported here. If bounds are defined by constant expressions, these are evaluated to floating-point numbers using the current precision. Numbers or variables containing numbers keep their precision for the interval bounds. Constant expressions get evaluated to floating-point values immediately; this includes $\pi$ and rational numbers, even when \com{rationalmode} is \com{on} (see Section~\ref{sec:rationalmode} for this mode). \input{introExample17} You can get the upper-bound (respectively the lower-bound) of an interval with the command \com{sup} (respectively \com{inf}). The middle of the interval can be computed with the command \com{mid}. Let us also mention that these commands can also be used on numbers (in that case, the number is interpreted as an interval containing only one single point. In that case the commands \com{inf}, \com{mid} and \com{sup} are just the identity): \input{introExample18} Let us mention that the \com{mid} operator never provokes a rounding. It is rewritten as an unevaluated expression in terms of \com{inf} and \com{sup}. \sollya permits intervals to also have non-real bounds, such as infinities or NaNs. When evaluating certain expressions, in particular given as interval bounds, \sollya will itself generate intervals containing infinities or NaNs. When evaluation yields an interval with a NaN bound, the given expression is most likely undefined or numerically unstable. Such results should not be trusted; a warning is displayed. While computations on intervals with bounds being NaN will always fail, \sollya will try to interpret infinities in the common way as limits. However, this is not guaranteed to work, even if it is guaranteed that no unsafe results will be produced. See also section \ref{sec:numbers} for more detail on infinities in \sollya. The behavior of interval arithmetic on intervals containing infinities or NaNs is subject to debate; moreover, there is no complete consensus on what should be the result of the evaluation of a function $f$ over an interval $I$ containing points where $f$ is not defined. \sollya has its own philosophy regarding these questions. This philosophy is explained in Appendix~\ref{IntervalArithmeticPhilopshy} at the end of this document. \input{introExample39} \sollya internally uses interval arithmetic extensively to provide safe answers. In order to provide for algorithms written in the \sollya language being able to use interval arithmetic, \sollya offers native support of interval arithmetic. Intervals can be added, subtracted, multiplied, divided, raised to powers, for short, given in argument to any \sollya function. The tool will apply the rules of interval arithmetic in order to compute output intervals that safely encompass the hull of the image of the function on the given interval: \input{introExample42} When such expressions involving intervals are given, \sollya will follow the rules of interval arithmetic in precision \com{prec} for immediately evaluating them to interval enclosures. While \sollya's evaluator always guarantees the inclusion property, it also applies some optimisations in some cases in order to make the image interval as thin as possible. For example, \sollya will use a Taylor expansion based evaluation if a composed function, call it $f$, is applied to an interval. In other words, in this case \sollya will behave as if the \com{evaluate} command (see Section~\ref{labevaluate}) were implicitly used. In most cases, the result will be different from the one obtained by replacing all occurences of the free variable of a function by the interval the function is to be evaluated on: \input{introExample43} \subsection{Functions} \sollya knows only about functions with one single variable. The first time in a session that an unbound name is used (without being assigned) it determines the name used to refer to the free variable. The basic functions available in \sollya are the following: \begin{itemize} \item \com{+}, \com{-}, \com{*}, \com{/}, \com{\^{}} \item \com{sqrt} \item \com{abs} \item \com{sin}, \com{cos}, \com{tan}, \com{sinh}, \com{cosh}, \com{tanh} \item \com{asin}, \com{acos}, \com{atan}, \com{asinh}, \com{acosh}, \com{atanh} \item \com{exp}, \com{expm1} (defined as $\mathrm{expm1}(x) = \exp(x)-1$) \item \com{log} (natural logarithm), \com{log2} (binary logarithm), \com{log10} (decimal logarithm), \com{log1p} (defined as $\mathrm{log1p}(x) = \log(1+x)$) \item \com{erf}, \com{erfc} \item \com{halfprecision}, \com{single}, \com{double}, \com{doubleextended}, \com{doubledouble}, \com{quad}, \com{tripledouble} (see sections \ref{labhalfprecision}, \ref{labsingle}, \ref{labdouble}, \ref{labdoubleextended}, \ref{labdoubledouble}, \ref{labquad} and \ref{labtripledouble}) \item \com{HP}, \com{SG}, \com{D}, \com{DE}, \com{DD}, \com{QD}, \com{TD} (see sections \ref{labhalfprecision}, \ref{labsingle}, \ref{labdouble}, \ref{labdoubleextended}, \ref{labdoubledouble}, \ref{labquad} and \ref{labtripledouble}) \item \com{floor}, \com{ceil}, \com{nearestint}. \end{itemize} The constant $\pi$ is available through the keyword \key{pi} as a $0$-ary function: \input{introExample19} The reader may wish to see Sections \ref{lablibrary} and \ref{labfunction} for ways of dynamically adding other base functions to \sollya. \subsection{Strings} Anything written between quotes is interpreted as a string. The infix operator \com{@} concatenates two strings. To get the length of a string, use the \com{length} function. You can access the $i$-th character of a string using brackets (see the example below). There is no character type in \sollya: the $i$-th character of a string is returned as a string itself. \input{introExample20} Strings may contain the following escape sequences: \texttt{$\backslash\backslash$}, \texttt{$\backslash$\"}, \texttt{$\backslash$?}, \texttt{$\backslash$\'}, \texttt{$\backslash$n}, \texttt{$\backslash$t}, \texttt{$\backslash$a}, \texttt{$\backslash$b}, \texttt{$\backslash$f}, \texttt{$\backslash$r}, \texttt{$\backslash$v}, \texttt{$\backslash$x}[hexadecimal number] and \texttt{$\backslash$}[octal number]. Refer to the C99 standard for their meaning. \subsection{Particular values} \sollya knows about some particular values. These values do not really have a type. They can be stored in variables and in lists. A (possibly not exhaustive) list of such values is the following one: \begin{itemize} \item \com{on}, \com{off} (see sections \ref{labon} and \ref{laboff}) \item \com{dyadic}, \com{powers}, \com{binary}, \com{decimal}, \com{hexadecimal} (see sections \ref{labdyadic}, \ref{labpowers}, \ref{labbinary}, \ref{labdecimal} and \ref{labhexadecimal}) \item \com{file}, \com{postscript}, \com{postscriptfile} (see sections \ref{labfile}, \ref{labpostscript} and \ref{labpostscriptfile}) \item \com{RU}, \com{RD}, \com{RN}, \com{RZ} (see sections \ref{labru}, \ref{labrd}, \ref{labrn} and \ref{labrz}) \item \com{absolute}, \com{relative} (see sections \ref{lababsolute} and \ref{labrelative}) \item \com{floating}, \com{fixed} (see sections \ref{labfloating} and \ref{labfixed}) \item \com{halfprecision}, \com{single}, \com{double}, \com{doubleextended}, \com{doubledouble}, \com{quad}, \com{tripledouble} (see sections \ref{labhalfprecision}, \ref{labsingle}, \ref{labdouble}, \ref{labdoubleextended}, \ref{labdoubledouble}, \ref{labquad} and \ref{labtripledouble}) \item \com{HP}, \com{SG}, \com{D}, \com{DE}, \com{DD}, \com{QD}, \com{TD} (see sections \ref{labhalfprecision}, \ref{labsingle}, \ref{labdouble}, \ref{labdoubleextended}, \ref{labdoubledouble}, \ref{labquad} and \ref{labtripledouble}) \item \com{perturb} (see Section~\ref{labperturb}) \item \com{honorcoeffprec} (see Section~\ref{labhonorcoeffprec}) \item \com{default} (see Section~\ref{labdefault}) \item \com{error} (see Section~\ref{laberror}) \item \com{void} (see Section~\ref{labvoid}) \end{itemize} \subsection{Lists} Objects can be grouped into lists. A list can contain elements with different types. As for strings, you can concatenate two lists with \com{@}. The function \com{length} also gives the length of a list. You can prepend an element to a list using \com{.:} and you can append an element to a list using \com{:.}\\ The following example illustrates some features: \input{introExample21} Lists can be considered arrays and elements of lists can be referenced using brackets. Possible indices start at $0$. The following example illustrates this point: \input{introExample22} Lists may contain ellipses indicated by \texttt{,...,} between elements that are constant and evaluate to integers that are incrementally ordered. \sollya translates such ellipses to the full list upon evaluation. The use of ellipses between elements that are not constants is not allowed. This feature is provided for ease of programming; remark that the complexity for expanding such lists is high. For illustration, see the following example: \input{introExample23} Lists may be continued to infinity by means of the \texttt{...} indicator after the last element given. At least one element must explicitly be given. If the last element given is a constant expression that evaluates to an integer, the list is considered as continued to infinity by all integers greater than that last element. If the last element is another object, the list is considered as continued to infinity by re-duplicating this last element. Let us remark that bracket notation is supported for such end-elliptic lists even for implicitly given elements. However, evaluation complexity is high. Combinations of ellipses inside a list and in its end are possible. The usage of lists described here is best illustrated by the following examples: \input{introExample24} \subsection{Structures} In a similar way as in lists, \sollya allows data to be grouped in -- untyped -- structures. A structure forms an object to which other objects can be added as elements and identified by their names. The elements of a structure can be retrieved under their name and used as usual. The following sequence shows that point: \input{introExample46} Structures can also be defined literally using the syntax illustrated in the next example. They will also be printed in that syntax. \input{introExample47} If the variable \texttt{a} is bound to an existing structure, it is possible to use the ``dot notation'' \texttt{a.b} to assign the value of the field \texttt{b} of the structure \texttt{a}. This works even if \texttt{b} is not yet a field of \texttt{a}: in this case a new field is created inside the structure \texttt{a}. Besides, the dot notation can be used even when \texttt{a} is unassigned. In this case a new structure is created with a field \texttt{b}, and this structure is bound to \texttt{a}. However, the dot notation cannot be used if \texttt{a} is already bound to something that is not a structure. These principles apply recursively: for instance, if \texttt{a} is a structure that contains only one field \texttt{d}, the command \texttt{a.b.c = 3} creates a new field named \texttt{b} inside the structure \texttt{a}; this field itself is a structure containing the field \texttt{c}. The command \texttt{a.d.c = 3} is allowed if \texttt{a.d} is already a structure, but forbidden otherwise (\emph{e.g.}, if \texttt{a.d} was equal to \texttt{sin(x)}). This is summed up in the following example. \input{introExample48} When printed, the elements of a structure are not sorted in any manner. They get printed in an arbitrary order that just maintains the order given in the definition of literate structures. That said, when compared, two structures compare equal iff they contain the same number of identifiers, with the same names and iff the elements of corresponding names all compare equal. This means the order does not matter in comparisons and otherwise does only for printing. The following example illustrates this matter: \input{introExample49} \section{Iterative language elements: assignments, conditional statements and loops} \subsection{Blocks} Statements in \sollya can be grouped in blocks, so-called begin-end-blocks. This can be done using the key tokens \key{$\lbrace$} and \key{$\rbrace$}. Blocks declared this way are considered to be one single statement. As already explained in Section~\ref{variables}, using begin-end-blocks also opens the possibility of declaring variables through the keyword \key{var}. \subsection{Assignments} \sollya has two different assignment operators, \texttt{=} and \texttt{:=}. The assignment operator \texttt{=} assigns its right-hand-object ``as is'', \emph{i.e.}, without evaluating functional expressions. For instance, \texttt{i = i + 1;} will dereferentiate the identifier \texttt{i} with some content, notate it $y$, build up the expression (function) $y + 1$ and assign this expression back to \texttt{i}. In the example, if \texttt{i} stood for the value $1000$, the statement \texttt{i = i + 1;} would assign ``$1000 + 1$'' -- and not ``$1001$'' -- to \texttt{i}. The assignment operator \texttt{:=} evaluates constant functional expressions before assigning them. On other expressions it behaves like \texttt{=}. Still in the example, the statement \texttt{i := i + 1;} really assigns $1001$ to \texttt{i}. Both \sollya assignment operators support indexing of lists or strings elements using brackets on the left-hand-side of the assignment operator. The indexed element of the list or string gets replaced by the right-hand-side of the assignment operator. When indexing strings this way, that right-hand side must evaluate to a string of length $1$. End-elliptic lists are supported with their usual semantic for this kind of assignment. When referencing and assigning a value in the implicit part of the end-elliptic list, the list gets expanded to the corresponding length. The following examples well illustrate the behavior of assignment statements: \input{introExample25} The indexing of lists on left-hand sides of assignments is reduced to the first order. Multiple indexing of lists of lists on assignment is not supported for complexity reasons. Multiple indexing is possible in right-hand sides. \input{introExample45} \subsection{Conditional statements} \sollya supports conditional statements expressed with the keywords \key{if}, \key{then} and optionally \key{else}. Let us mention that only conditional statements are supported and not conditional expressions. The following examples illustrate both syntax and semantic of conditional statements in \sollya. Concerning syntax, be aware that there must not be any semicolon before the \key{else} keyword. \input{introExample26} \subsection{Loops} \sollya supports three kinds of loops. General \emph{while-condition} loops can be expressed using the keywords \key{while} and \key{do}. One has to be aware of the fact that the condition test is executed always before the loop, there is no \emph{do-until-condition} loop. Consider the following examples for both syntax and semantic: \input{introExample27} The second kind of loops are loops on a variable ranging from a numerical start value and a end value. These kind of loops can be expressed using the keywords \key{for}, \key{from}, \key{to}, \key{do} and optionally \key{by}. The \key{by} statement indicates the width of the steps on the variable from the start value to the end value. Once again, syntax and semantic are best explained with an example: \input{introExample28} The third kind of loops are loops on a variable ranging on values contained in a list. In order to ensure the termination of the loop, that list must not be end-elliptic. The loop is expressed using the keywords \key{for}, \key{in} and \key{do} as in the following examples: \input{introExample29} For both types of \key{for} loops, assigning the loop variable is allowed and possible. When the loop terminates, the loop variable will contain the value that made the loop condition fail. Consider the following examples: \input{introExample30} \section{Functional language elements: procedures and pattern matching} \subsection{Procedures} \label{procedures} \sollya has some elements of functional languages. In order to avoid confusion with mathematical functions, the associated programming objects are called \emph{procedures} in \sollya. \sollya procedures are common objects that can be, for example, assigned to variables or stored in lists. Procedures are declared by the \key{proc} keyword; see Section~\ref{labproc} for details. The returned procedure object must then be assigned to a variable. It can hence be applied to arguments with common application syntax. The \key{procedure} keyword provides an abbreviation for declaring and assigning a procedure; see Section~\ref{labprocedure} for details. \sollya procedures can return objects using the \key{return} keyword at the end of the begin-end-block of the procedure. Section \ref{labreturn} gives details on the usage of \key{return}. Procedures further can take any type of object in argument, in particular also other procedures that are then applied to arguments. Procedures can be declared inside other procedures. Common \sollya procedures are declared with a certain number of formal parameters. When the procedure is applied to actual parameters, a check is performed if the right number of actual parameters is given. Then the actual parameters are applied to the formal parameters. In some cases, it is required that the number of parameters of a procedure be variable. \sollya provides support for the case with procedures with an arbitrary number of actual arguments. When the procedure is called, those actual arguments are gathered in a list which is applied to the only formal list parameter of a procedure with an arbitrary number of arguments. See Section~\ref{labprocedure} for the exact syntax and details; an example is given just below. Let us remark that declaring a procedure does not involve any evaluation or other interpretation of the procedure body. In particular, this means that constants are evaluated to floating-point values inside \sollya when the procedure is applied to actual parameters and the global precision valid at this moment. \sollya procedures are well illustrated with the following examples: \input{introExample31} \input{introExample35} \input{introExample36} \input{introExample37} Let us note that, when writing a procedure, one does not know what will be the name of the free variable at run-time. This is typically the context when one should use the special keyword \verb|_x_|: \input{introExample37bis} \sollya also supports external procedures, \emph{i.e.}, procedures written in \texttt{C} (or some other language) and dynamically bound to \sollya identifiers. See \ref{labexternalproc} for details. \subsection{Pattern matching} Starting with version 3.0, \sollya supports matching expressions with expression patterns. This feature is important for an extended functional programming style. Further, and most importantly, it allows expression trees to be recursively decomposed using native constructs of the \sollya language. This means no help from external procedures or other compiled-language mechanisms is needed here anymore. Basically, pattern matching supports relies on one \sollya construct: \begin{center} \begin{minipage}{0.8\textwidth} \key{match {\it expr} with \\ {\it pattern1} : ({\it return-expr1}) \\ {\it pattern2} : ({\it return-expr2}) \\ \dots \\ {\it patternN} : ({\it return-exprN}) } \end{minipage} \end{center} That construct has the following semantic: try to match the expression {\it expr} with the patterns {\it pattern1} through {\it patternN}, proceeding in natural order. If a pattern {\it patternI} is found that matches, evaluate the whole \key{match \dots~with} construct to the return expression {\it return-exprI} associated with the matching pattern {\it patternI}. If no matching pattern is found, display an error warning and return \key{error}. Note that the parentheses around the expressions {\it return-exprI} are mandatory. Matching a pattern means the following: \begin{itemize} \item If a pattern does not contain any programming-language-level variables (different from the free mathematical variable), it matches expressions that are syntactically equal to itself. For instance, the pattern \key{exp(sin(3 * x))} will match the expression \key{exp(sin(3 * x))}, but it does not match \key{exp(sin(x * 3))} because the expressions are not syntactically equal. \item If a pattern does contain variables, it matches an expression {\it expr} if these variables can be bound to subexpressions of {\it expr} such that once the pattern is evaluated with that variable binding, it becomes syntactically equal to the expression {\it expr}. For instance, the pattern \key{exp(sin(a * x))} will match the expression \key{exp(sin(3 * x))} as it is possible to bind \key{a} to \key{3} such that \key{exp(sin(a~*~x))} evaluates to \key{exp(sin(3~*~x))}. \end{itemize} If a pattern {\it patternI} with variables is matched in a \key{match \dots~with} construct, the variables in the pattern stay bound during the evaluation of the corresponding return expression {\it return-exprI}. This allows subexpressions to be extracted from expressions and/or recursively handled as needed. The following examples illustrate the basic principles of pattern matching in \sollya. One can remark that it is useful to use the keyword \verb|_x_| when one wants to be sure to refer to the free variable in a pattern matching: \input{introExample50} As \sollya is not a purely functional language, the \key{match \dots~with} construct can also be used in a more imperative style, which makes it become closer to constructs like \key{switch} in {\tt C} or {\tt Perl}. In lieu of a simple return expression, a whole block of imperative statements can be given. The expression to be returned by that block is indicated in the end of the block, using the \key{return} keyword. That syntax is illustrated in the next example: \input{introExample51} In the case when no return statement is indicated for a statement-block in a \key{match \dots~with} construct, the construct evaluates to the special value \key{void} if that pattern matches. In order to well understand pattern matching in \sollya, it is important to realize the meaning of variables in patterns. This meaning is different from the one usually found for variables. In a pattern, variables are never evaluated to whatever they might have set before the pattern is executed. In contrast, all variables in patterns are new, free variables that will freshly be bound to subexpressions of the matching expression. If a variable of the same name already exists, it will be shadowed during the evaluation of the statement block and the return expression corresponding to the matching expression. This type of semantic implies that patterns can never be computed at run-time, they must always be hard-coded beforehand. However this is necessary to make pattern matching context-free. As a matter of course, all variables figuring in the expression {\it expr} to be matched are evaluated before pattern matching is attempted. In fact, {\it expr} is a usual \sollya expression, not a pattern. In \sollya, the use of variables in patterns does not need to be linear. This means the same variable might appear twice or more in a pattern. Such a pattern will only match an expression if it contains the same subexpression, associated with the variable, in all places indicated by the variable in the pattern. The following examples illustrate the use of variables in patterns in detail: \input{introExample52} \input{introExample53} Pattern matching is meant to be a means to decompose expressions structurally. For this reason and in an analogous way to variables, no evaluation is performed at all on (sub-)expressions that form constant functions. As a consequence, patterns match constant expressions only if they are structurally identical. For example $5 + 1$ only matches $5 + 1$ and not $1 + 5$, $3 + 3$ nor $6$. This general rule on constant expressions admits one exception. Intervals in \sollya can be defined using constant expressions as bounds. These bounds are immediately evaluated to floating-point constants, though. In order to permit pattern matching on intervals, constant expressions given as bounds of intervals that form patterns are evaluated before pattern matching. However, in order not conflict with the rules of no evaluation of variables, these constant expressions as bounds of intervals in patterns must not contain free variables. \input{introExample54} The \sollya keyword \key{default} has a special meaning in patterns. It acts like a wild-card, matching any (sub-)expression, as long as the whole expression stays correctly typed. Upon matching with \key{default}, no variable gets bound. This feature is illustrated in the next example: \input{introExample55} In \sollya, pattern matching is possible on the following \sollya types and operations defined on them: \begin{itemize} \item Expressions that define univariate functions, as explained above, \item Intervals with one, two or no bound defined in the pattern by a variable, \item Character sequences, literate or defined using the \key{@} operator, possibly with a variable on one of the sides of the \key{@} operator, \item Lists, literate, literate with variables or defined using the \key{.:}, \key{:.} and \key{@} operators, possibly with a variable on one of the sides of the \key{@} operator or one or two variables for \key{.:} and \key{:.}, \item Structures, literate or literate with variables, and \item All other \sollya objects, matchable with themselves (\key{DE} matches \key{DE}, \key{on} matches \key{on}, \key{perturb} matches \key{perturb} etc.) \end{itemize} \input{introExample56} Concerning intervals, please pay attention to the fact that expressions involving intervals are immediately evaluated and that structural pattern matching on functions on intervals is not possible. This point is illustrated in the next example: \input{introExample57} With respect to pattern matching on lists or character sequences defined using the \key{@} operator, the following is to be mentionned: \begin{itemize} \item Patterns like \key{a @ b} are not allowed as they would need to perform an ambiguous cut of the list or character sequence to be matched. This restriction is maintained even if the variables (here \key{a} and \key{b}) are constrained by other occurrences in the pattern (for example in a list) which would make the cut unambiguous. \item Recursive use of the \key{@} operator (even mixed with the operators \key{.:} and \key{:.}) is possible under the condition that there must not exist any other parenthezation of the term in concatenations (\key{@}) such that the rule of one single variable for \key{@} above gets violated. For instance, \key{( [| 1 |] @ a) @ (b @ [| 4 |])} is not possible as it can be re-parenthesized \key{ [| 1 |] @ (a @ b) @ [| 4 |]}, which exhibits the ambiguous case. \end{itemize} These points are illustrated in this example: \input{introExample58} As mentionned above, pattern matching on \sollya structures is possible. Patterns for such a match are given in a literately, \emph{i.e.}, using the syntax \key{ \{ .a = {\it exprA}, .b = {\it exprB}, {\it \dots}~\}}. A structure pattern {\it sp} will be matched by a structure {\it s} iff that structure {\it s} contains at least all the elements (like \key{.a}, \key{.b} etc.) of the structure pattern {\it sp} and iff each of the elements of the structure {\it s} matches the pattern in the corresponding element of the structure pattern {\it sp}. The user should be aware of the fact that the structure to be matched is only supposed to have at least the elements of the pattern but that it may contain more elements is a particular \sollya feature. For instance with pattern matching, it is hence possible to ensure that access to particular elements will be possible in a particular code segment. The following example is meant to clarify this point: \input{introExample59} \section{Commands and functions} \label{commandsAndFunctions} \input{CommandsAndFunctions} \newpage \section{Appendix: interval arithmetic philosophy in \sollya} \label{IntervalArithmeticPhilopshy} Although it is currently based on the MPFI library, \sollya has its own way of interpreting interval arithmetic when infinities or NaN occur, or when a function is evaluated on an interval containing points out of its domain, etc. This philosophy may differ from the one applied in MPFI. It is also possible that the behavior of \sollya does not correspond to the behavior that one would expect, \emph{e.g.}, as a natural consequence of the IEEE-754 standard. The topology that we consider is always the usual topology of $\overline{\mathbb{R}} = \mathbb{R} \cup \{-\infty,\,+\infty\}$. For any function, if one of its arguments is empty (respectively NaN), we return empty (respectively NaN). \subsection{Univariate functions} Let $f$ be a univariate basic function and $I$ an interval. We denote by $J$ the result of the interval evaluation of $f$ over $I$ in \sollya. If $I$ is completely included in the domain of $f$, $J$ will usually be the smallest interval (at the current precision) containing the exact image $f(I)$. However, in some cases, it may happen that $J$ is not as small as possible. It is guaranteed however, that $J$ tends to $f(I)$ when the precision of the tool tends to infinity. When $f$ is not defined at some point $x$ but is defined on a neighborhood of $x$, we consider that the ``value'' of $f$ at $x$ is the convex hull of the limit points of $f$ around $x$. For instance, consider the evaluation of $f= \tan$ on $[0,\, \pi]$. It is not defined at $\pi/2$ (and only at this point). The limit points of $f$ around $\pi/2$ are $-\infty$ and $+\infty$, so, we return $[-\infty,\,\infty]$. Another example: $f=\sin$ on $[+\infty]$. The function has no limit at this point, but all points of $[-1, 1]$ are limit points. So, we return $[-1,\,1]$. Finally, if $I$ contains a subinterval on which $f$ is not defined, we return $[\textrm{NaN},\,\textrm{NaN}]$ (example: $\sqrt{[-1,\,2]}$). \subsection{Bivariate functions} Let $f$ be a bivariate function and $I_1$ and $I_2$ be intervals. If $I_1=[x]$ and $I_2=[y]$ are both point-intervals, we return the convex hull of the limit points of $f$ around $(x,\,y)$ if it exists. In particular, if $f$ is defined at $(x,\,y)$ we return its value (or a small interval around it, if it is not exactly representable). As an example $[1]/[+\infty]$ returns $[0]$. Also, $[1]/[0]$ returns $[-\infty,\,+\infty]$ (note that \sollya does not consider signed zeros). If it is not possible to give a meaning to the expression $f(I_1,\,I_2)$, we return NaN: for instance $[0]/[0]$ or $[0]*[+\infty]$. If one and only one of the intervals is a point-interval (say $I_1 = [x]$), we consider the partial function $g: y \mapsto f(x,y)$ and return the value that would be obtained when evaluating $g$ on $I_2$. For instance, in order to evaluate $[0]/I_2$, we consider the function $g$ defined for every $y \neq 0$ by $g(y)=0/y=0$. Hence, $g(I_2) = [0]$ (even if $I_2$ contains $0$, by the argument of limit-points). In particular, please note that $[0]/[-1,\,1]$ returns $[0]$ even though $[0]/[0]$ returns NaN. This rule even holds when $g$ can only be defined as limit points: for instance, in the case $I_1/[0]$ we consider $g: x \mapsto x/0$. This function cannot be defined \emph{stricto sensu}, but we can give it a meaning by considering $0$ as a limit. Hence $g$ is multivalued and its value is $\{-\infty,\,+\infty\}$ for every $x$. Hence, $I_1/[0]$ returns $[-\infty,\,+\infty]$ when $I_1$ is not a point-interval. Finally, if neither $I_1$ nor $I_2$ are point-intervals, we try to give a meaning to $f(I_1,\,I_2)$ by an argument of limit-points when possible. For instance $[1,\,2] / [0,\,1]$ returns $[1,\,+\infty]$. As a special exception to these rules, $[0]^{[0]}$ returns $[1]$. \newpage \section{Appendix: the \sollya library} \label{Libsollya} \subsection{Introduction} The header file of the \sollya library is \texttt{sollya.h}. Its inclusion may provoke the inclusion of other header files, such as \texttt{gmp.h}, \texttt{mpfr.h} or \texttt{mpfi.h}. The library provides a virtual \sollya session that is perfectly similar to an interactive session: global variables such as \texttt{verbosity}, \texttt{prec}, \texttt{display}, \texttt{midpointmode}, etc. are maintained and affect the behavior of the library, warning messages are displayed when something is not exact, etc. Please notice that the \sollya library currently is \textbf{not} re-entrant and can only be opened once. A process using the library must hence not be multi-threaded and is limited to one single virtual \sollya session. In order to get started with the \sollya library, the first thing to do is hence to initialize this virtual session. This is performed with the \verb|sollya_lib_init| function. Accordingly, one should close the session at the end of the program (which has the effect of releasing all the memory used by \sollya). Please notice that \sollya uses its own allocation functions and registers them to \verb|GMP| using the custom allocation functions provided by \verb|GMP|. Particular precautions should hence be taken when using the \sollya library in a program that also registers its own functions to \verb|GMP|: in that case \verb|sollya_lib_init_with_custom_memory_functions| should be used instead of \verb|sollya_lib_init| for initializing the library. This is discussed in Section~\ref{customMemoryFunctions}. In the usual case when \sollya is used in a program that does not register allocation functions to~\verb|GMP|, a minimal file using the library is hence the following. \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] #include int main(void) { sollya_lib_init(); /* Functions of the library can be called here */ sollya_lib_close(); return 0; } \end{Verbatim} \end{minipage}\end{center} Suppose that this code is saved in a file called \texttt{foo.c}. The compilation is performed as usual without forgetting to link against \texttt{libsollya} (since the libraries \texttt{libgmp}, \texttt{libmpfr} and \texttt{libmpfi} are dependencies of \sollya, it might also be necessary to explicitly link against them): \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] ~/% cc foo.c -c ~/% cc foo.o -o foo -lsollya -lmpfi -lmpfr -lgmp \end{Verbatim} \end{minipage}\end{center} \subsection{Sollya object data-type} The library provides a single data type called \texttt{sollya\_obj\_t} that can contain any \sollya object (a \sollya object is anything that can be stored in a variable within the interactive tool. See Section~\ref{sec:data_types} of the present documentation for details). Please notice that \texttt{sollya\_obj\_t} is in fact a pointer type; this has two consequences: \begin{itemize} \item \texttt{NULL} is a placeholder that can be used as a \texttt{sollya\_obj\_t} in some contexts. This placeholder is particularly useful as an end marker for functions with a variable number of arguments (see Sections~\ref{creating_lists} and~\ref{library_commands_and_functions}). \item An assignment with the ``='' sign does not copy an object but only copies the reference to it. In order to perform a (deep) copy, the \texttt{sollya\_lib\_copy\_obj()} function is available. \end{itemize} Except for a few functions for which the contrary is explicitly specified, the following conventions are used: \begin{itemize} \item A function does not touch its arguments. Hence if \texttt{sollya\_lib\_foo} is a function of the library, a call to \texttt{sollya\_lib\_foo(a)} leaves the object referenced by \texttt{a} unchanged (the notable exceptions to that rule are the functions containing \verb|build| in their name, \emph{e.g.}, \texttt{sollya\_lib\_build\_foo}). \item A function that returns a \texttt{sollya\_obj\_t} creates a new object (this means that memory is dynamically allocated for that object). The memory allocated for that object should manually be cleared when the object is no longer used and all references to it (on the stack) get out of reach, \emph{e.g.}, on a function return: this is performed by the \texttt{sollya\_lib\_clear\_obj()} function. By convenience \verb|sollya_lib_clear_obj(NULL)| is a valid call, which just does nothing. \end{itemize} In general, except if the user perfectly knows what they are doing, the following rules should be applied (here \texttt{a} and \texttt{b} are C variables of type \texttt{sollya\_obj\_t}, and \texttt{sollya\_lib\_foo} and \texttt{sollya\_lib\_bar} are functions of the library): \begin{itemize} \item One should never write \texttt{a = b}. Instead, use \texttt{a = sollya\_lib\_copy\_obj(b)}. \item One should never write \texttt{a = sollya\_lib\_foo(a)} because one loses the reference to the object initially referenced by the variable \texttt{a} (which is hence not cleared). \item One should never chain function calls such as, \emph{e.g.}, \texttt{a = sollya\_lib\_foo(sollya\_lib\_bar(b))} (the reference to the object created by \texttt{sollya\_lib\_bar(b)} would be lost and hence not cleared). \item A variable \texttt{a} should never be used twice at the left-hand side of the ``='' sign (or as an lvalue in general) without performing \texttt{sollya\_lib\_clear\_obj(a)} in-between. \item In an assignment of the form ``\texttt{a = ...}'', the right-hand side should always be a function call (\emph{i.e.}, something like \texttt{a = sollya\_lib\_foo(...);}). \end{itemize} Please notice that \texttt{sollya\_lib\_close()} clears the memory allocated by the virtual \sollya session but not the objects that have been created and stored in C variables. All the \texttt{sollya\_obj\_t} created by function calls should be cleared manually. We can now write a simple Hello World program using the \sollya library: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] #include int main(void) { sollya_obj_t s1, s2, s; sollya_lib_init(); s1 = sollya_lib_string("Hello "); s2 = sollya_lib_string("World!"); s = sollya_lib_concat(s1, s2); sollya_lib_clear_obj(s1); sollya_lib_clear_obj(s2); sollya_lib_printf("%b\n", s); sollya_lib_clear_obj(s); sollya_lib_close(); return 0; } \end{Verbatim} \end{minipage}\end{center} A universal function allows the user to execute any expression, as if it were given at the prompt of the \sollya tool, and to get a \texttt{sollya\_obj\_t} containing the result of the evaluation: this function is \texttt{sollya\_lib\_parse\_string("some expression here")}. This is very convenient, and indeed, any script written in the \sollya language, could easily be converted into a C program by intensively using \texttt{sollya\_lib\_parse\_string}. However, this should not be the preferred way if efficiency is targeted because (as its name suggests) this function uses a parser to decompose its argument, then constructs intermediate data structures to store the abstract interpretation of the expression, etc. Low-level functions are provided for efficiently creating \sollya objects; they are detailed in the next Section. \subsection{Conventions in use in the library} The library follows some conventions that are useful to remember: \begin{itemize} \item When a function is a direct transposition of a command or function available in the interactive tool, it returns a \verb|sollya_obj_t|. This is true, even when it would sound natural to return, \emph{e.g.}, an \verb|int|. For instance \verb|sollya_lib_get_verbosity()| returns a \verb|sollya_obj_t|, whose integer value must then be recovered with \verb|sollya_lib_get_constant_as_int|. This forces the user to declare (and clear afterwards) a temporary \verb|sollya_obj_t| to store the value, but this is the price of homogeneity in the library. \item When a function returns an integer, this integer generally is a boolean in the usual C meaning, \emph{i.e.}, $0$ represents false and any non-zero value represents true. In many cases, the integer returned by the function indicates a status of success or failure: the convention is ``false means failure'' and ``true means success''. In case of failure, the convention is that the function did not touch any of its arguments. \item When a function would need to return several things, or when a function would need to return something together with a status of failure or success, the convention is that pointers are given as the first arguments of the function. These pointers shall point to valid addresses where the function will store the results. This can sometimes give obscure signatures, when the function would in principle returns a pointer and actually takes as argument a pointer to a pointer (this typically happens when the function allocates a segment of memory and should return a pointer to that segment of memory). \end{itemize} \subsection{Displaying \sollya objects and numerical values} Within the interactive tool, the most simple way of displaying the content of a variable or the value of an expression is to write the name of the variable or the expression, followed by the character ``;''. As a result, \sollya evaluates the expression or the variable and displays the result. Alternatively, a set of objects can be displayed the same way, separating the objects with commas. In library mode, the same behavior can be reproduced using the function \verb|void sollya_lib_autoprint(sollya_obj_t, ...)|. Please notice that this function has a variable number of arguments: they are all displayed, until an argument equal to \verb|NULL| is found. The \verb|NULL| argument is mandatory, even if only one object shall be displayed (the function has no other way to know if other arguments follow or not). So, if only one argument should be displayed, the correct function call is \verb|sollya_lib_autoprint(arg, NULL)|. Accordingly, if two arguments should be displayed, the function call is \verb|sollya_lib_autoprint(arg1, arg2, NULL)|, etc. The function \verb|void sollya_lib_v_autoprint(sollya_obj_t, va_list)| is the same, but it takes a \verb|va_list| argument instead of a variable number of arguments. Further, there is another way of printing formatted strings containing \sollya objects, using a {\tt printf}-like syntax. Eight functions are provided, namely: \begin{itemize} \item \verb|sollya_lib_printf|, \verb|sollya_lib_v_printf|, \item \verb|sollya_lib_fprintf|, \verb|sollya_lib_v_fprintf|, \item \verb|sollya_lib_sprintf|, \verb|sollya_lib_v_sprintf|, \item \verb|sollya_lib_snprintf| and \verb|sollya_lib_v_snprintf|. \end{itemize} Each one of these functions overloads the usual function (respectively, \verb|printf|, \verb|vprintf|, \verb|fprintf|, \verb|vfprintf|, \verb|sprintf|, \verb|vsprintf|, \verb|snprintf| and \verb|vsnprintf|). The full syntax of conversions specifiers supported with the usual functions is handled (please note that the style using '\verb|$|' --~as in \verb|%3$| or \verb|%*3$|~-- is not handled though. It is not included in the C99 standard anyway). Additionally, the following conversion specifiers are provided: \begin{itemize} \item \verb|%b|: corresponds to a \verb|sollya_obj_t| argument. There is no precision modifier support. \item \verb|%v|: corresponds to a \verb|mpfr_t| argument. An optional precision modifier can be applied (\emph{e.g.}, \verb|%.5v|). \item \verb|%w|: corresponds to a \verb|mpfi_t| argument. An optional precision modifier can be applied (\emph{e.g.}, \verb|%.5w|). \item \verb|%r|: corresponds to a \verb|mpq_t| argument. There is no precision modifier support. \item \verb|%k|: corresponds to a \verb|mpz_t| argument. There is no precision modifier support. \end{itemize} When one of the above conversion specifiers is used, the corresponding argument is displayed as it would be within the interactive tool: \emph{i.e.}, the way the argument is displayed depends on \sollya environment variables, such as \verb|prec|, \verb|display|, \verb|midpointmode|, etc. When a precision modifier $n$ is used, the argument is first rounded to a binary precision of roughly $\log_2(10)\times n$ bits (\emph{i.e.}, roughly equivalent to $n$ decimal digits) before being displayed. As with traditional \verb|printf|, the precision modifier can be replaced with~\verb|*| which causes the precision to be determined by an additional \verb|int| argument. Flag characters (\emph{e.g.}, `\verb|#|', `\verb|0|', etc.) are allowed but have no effect, except flag character `\verb|-|' that is supported with its usual meaning of left-aligning the converted value. The full syntax for minimum field width is supported: it can be given directly as an integer in the format string (\emph{e.g.}, \verb|%22b|) or it can be replaced with~\verb|*|, which causes the field width to be determined by an additional \verb|int| argument. As usual, a negative field width is taken as a `\verb|-|' flag followed by a positive width. As a special (and sometimes convenient) case, \verb|%b| accepts that its corresponding \verb|sollya_obj_t| argument be \verb|NULL|: in this particular case, the string ``NULL'' is used in the displayed string. Please notice that, except for the particular case of \verb|NULL|, the behavior of \verb|sollya_lib_printf| is completely undefined if the argument of \verb|%b| is not a valid \sollya object. The \verb|sollya_lib_printf| functions return an integer with the same meaning as the traditional \verb|printf| functions. It indicates the number of characters that have been output (excluding the final \verb|\0| character). Similarly, the conversion specifier \verb|%n| can be used, even together with the \sollya conversion specifiers \verb|%b|, \verb|%v|, \verb|%w|, \verb|%r| and \verb|%k|. The functions \verb|sollya_lib_snprintf| and \verb|sollya_lib_v_snprintf| will never write more characters than indicated by their size argument (including the final \verb|\0| character). If the output gets truncated due to this limit, they will return the number of characters (excluding the final \verb|\0| character) that would have been output if there had not been any truncation. In case of error, all \verb|sollya_lib_printf| functions return a negative value. \subsection{Creating \sollya objects} \sollya objects conceptually fall into one of five categories: numerical constants (\emph{e.g.}, $1$ or $1.5$), functional expressions (they might contain numerical constants, \emph{e.g.}, $\sin(\cos(x+1.5))$), other simple objects (intervals, strings, built-in constants such as \texttt{dyadic}, etc.), lists of objects (\emph{e.g.}, \texttt{[|1, "Hello"|]}) and structures (\emph{e.g.}, \verb|{.a = 1; .b = "Hello"}|). \subsubsection{Numerical constants} Table~\ref{creating_numerical_constant} lists the different functions available to construct numerical constants. A \sollya constant is always created without rounding (whatever the value of global variable \texttt{prec} is at the moment of the function call): a sufficient precision is always allocated so that the constant is stored exactly. All these functions return a constant floating-point number except \texttt{sollya\_lib\_constant\_from\_mpq} that may return a constant \emph{expression} if the value of the rational number given as argument is not exactly representable as a floating-point number at some precision. The returned expression is of the form $p/q$ in this case. The objects returned by these functions are newly allocated and copies of the argument. For instance, after the instruction \texttt{a = sollya\_lib\_constant(b)}, the user will eventually have to clear \texttt{a} (with \texttt{sollya\_lib\_clear(a)}) and \texttt{b} (with \texttt{mpfr\_clear(b)}). The function \texttt{sollya\_lib\_constant\_from\_double} (or more conveniently its shortcut \texttt{SOLLYA\_CONST}) is probably the preferred way for constructing numerical constants. As the name indicates it, its argument is a \texttt{double}; however, due to implicit casting in~C, it is perfectly possible to give an \texttt{int} as argument: it will be converted into a \texttt{double} (without rounding if the integer fits on $53$~bits) before being passed to \texttt{SOLLYA\_CONST}. On the contrary, the user should be aware of the fact that if decimal non-integer constants are given, C rules of rounding (to double) are applied, regardless of the setting of the \sollya precision variable \texttt{prec}. \begin{table}[htp] \caption{Creating numerical constants (Creates a fresh \texttt{sollya\_obj\_t}. Conversion is always exact)} \label{creating_numerical_constant} \begin{center} \begin{tabular}{|l|c|l|} \hline \hfil Type of the argument \hfil & \hfil \phantom{\Large{$A^A$}}Name of the function\phantom{\Large{$A^A$}}\hfil & Shortcut macro \\ \hline \verb|double| & \verb|sollya_lib_constant_from_double(x)| & \verb|SOLLYA_CONST(x)| \\ \verb|uint64_t| & \verb|sollya_lib_constant_from_uint64(x)| & \verb|SOLLYA_CONST_UI64(x)| \\ \verb|int64_t| & \verb|sollya_lib_constant_from_int64(x)| & \verb|SOLLYA_CONST_SI64(x)| \\ \verb|int| & \verb|sollya_lib_constant_from_int(x)| & N/A \\ \verb|mpq_t| & \verb|sollya_lib_constant_from_mpq(x)| & N/A \\ \verb|mpz_t| & \verb|sollya_lib_constant_from_mpz(x)| & N/A \\ \verb|mpfr_t| & \verb|sollya_lib_constant(x)| & N/A \\ \hline \end{tabular} \end{center} \end{table} \subsubsection{Functional expressions} Functional expressions are built by composition of basic functions with constants and the free mathematical variable. Since it is convenient to build such expressions by chaining function calls, the library provides functions that ``eat up'' their arguments (actually embedding them in a bigger expression). The convention is that functions that eat up their arguments are prefixed by \texttt{sollya\_lib\_build\_}. For the purpose of building expressions, shortcut macros for the corresponding functions exist. They are all listed in Table~\ref{build_expr}. It is worth mentioning that, although \texttt{SOLLYA\_X\_} and \texttt{SOLLYA\_PI} are used without parentheses (as if they denoted constants), they are in fact function calls that create a new object each time they are used. The absence of parentheses is just more convenient for constructing expressions, such as, \emph{e.g.}, \texttt{SOLLYA\_COS(SOLLYA\_X\_)}. \begin{table}[htp] \caption{Building functional expressions (Eats up arguments, embedding them in the returned object.)} \label{build_expr} \begin{center} \begin{tabular}{|c|l|l|} \hline Name in the interactive tool & \hfil \phantom{\Large{$A^A$}}Function to build it\phantom{\Large{$A^A$}}\hfil & Shortcut macro \\ \hline \verb|_x_| & \verb|sollya_lib_build_function_free_variable()| & \verb|SOLLYA_X_|\\ \verb|pi| & \verb|sollya_lib_build_function_pi()| & \verb|SOLLYA_PI|\\ \verb|e1 + e2| & \verb|sollya_lib_build_function_add(e1, e2)| & \verb|SOLLYA_ADD(e1, e2)|\\ \verb|e1 - e2| & \verb|sollya_lib_build_function_sub(e1, e2)| & \verb|SOLLYA_SUB(e1, e2)|\\ \verb|e1 * e2| & \verb|sollya_lib_build_function_mul(e1, e2)| & \verb|SOLLYA_MUL(e1, e2)|\\ \verb|e1 / e2| & \verb|sollya_lib_build_function_div(e1, e2)| & \verb|SOLLYA_DIV(e1, e2)|\\ \verb|pow(e1, e2)| & \verb|sollya_lib_build_function_pow(e1, e2)| & \verb|SOLLYA_POW(e1, e2)|\\ \verb|-e| & \verb|sollya_lib_build_function_neg(e)| & \verb|SOLLYA_NEG(e)|\\ \verb|sqrt(e)| & \verb|sollya_lib_build_function_sqrt(e)| & \verb|SOLLYA_SQRT(e)|\\ \verb|abs(e)| & \verb|sollya_lib_build_function_abs(e)| & \verb|SOLLYA_ABS(e)|\\ \verb|erf(e)| & \verb|sollya_lib_build_function_erf(e)| & \verb|SOLLYA_ERF(e)|\\ \verb|erfc(e)| & \verb|sollya_lib_build_function_erfc(e)| & \verb|SOLLYA_ERFC(e)|\\ \verb|exp(e)| & \verb|sollya_lib_build_function_exp(e)| & \verb|SOLLYA_EXP(e)|\\ \verb|expm1(e)| & \verb|sollya_lib_build_function_expm1(e)| & \verb|SOLLYA_EXPM1(e)|\\ \verb|log(e)| & \verb|sollya_lib_build_function_log(e)| & \verb|SOLLYA_LOG(e)|\\ \verb|log2(e)| & \verb|sollya_lib_build_function_log2(e)| & \verb|SOLLYA_LOG2(e)|\\ \verb|log10(e)| & \verb|sollya_lib_build_function_log10(e)| & \verb|SOLLYA_LOG10(e)|\\ \verb|log1p(e)| & \verb|sollya_lib_build_function_log1p(e)| & \verb|SOLLYA_LOG1P(e)|\\ \verb|sin(e)| & \verb|sollya_lib_build_function_sin(e)| & \verb|SOLLYA_SIN(e)|\\ \verb|cos(e)| & \verb|sollya_lib_build_function_cos(e)| & \verb|SOLLYA_COS(e)|\\ \verb|tan(e)| & \verb|sollya_lib_build_function_tan(e)| & \verb|SOLLYA_TAN(e)|\\ \verb|asin(e)| & \verb|sollya_lib_build_function_asin(e)| & \verb|SOLLYA_ASIN(e)|\\ \verb|acos(e)| & \verb|sollya_lib_build_function_acos(e)| & \verb|SOLLYA_ACOS(e)|\\ \verb|atan(e)| & \verb|sollya_lib_build_function_atan(e)| & \verb|SOLLYA_ATAN(e)|\\ \verb|sinh(e)| & \verb|sollya_lib_build_function_sinh(e)| & \verb|SOLLYA_SINH(e)|\\ \verb|cosh(e)| & \verb|sollya_lib_build_function_cosh(e)| & \verb|SOLLYA_COSH(e)|\\ \verb|tanh(e)| & \verb|sollya_lib_build_function_tanh(e)| & \verb|SOLLYA_TANH(e)|\\ \verb|asinh(e)| & \verb|sollya_lib_build_function_asinh(e)| & \verb|SOLLYA_ASINH(e)|\\ \verb|acosh(e)| & \verb|sollya_lib_build_function_acosh(e)| & \verb|SOLLYA_ACOSH(e)|\\ \verb|atanh(e)| & \verb|sollya_lib_build_function_atanh(e)| & \verb|SOLLYA_ATANH(e)|\\ \verb|D(e)|, \verb|double(e)| & \verb|sollya_lib_build_function_double(e)| & \verb|SOLLYA_D(e)|\\ \verb|SG(e)|, \verb|single(e)| & \verb|sollya_lib_build_function_single(e)| & \verb|SOLLYA_SG(e)|\\ \verb|QD(e)|, \verb|quad(e)| & \verb|sollya_lib_build_function_quad(e)| & \verb|SOLLYA_QD(e)|\\ \verb|HP(e)|, \verb|halfprecision(e)| & \verb|sollya_lib_build_function_halfprecision(e)| & \verb|SOLLYA_HP(e)|\\ \verb|DD(e)|, \verb|doubledouble(e)| & \verb|sollya_lib_build_function_double_double(e)| & \verb|SOLLYA_DD(e)|\\ \verb|TD(e)|, \verb|tripledouble(e)| & \verb|sollya_lib_build_function_triple_double(e)| & \verb|SOLLYA_TD(e)|\\ \verb|DE(e)|, \verb|doubleextended(e)| & \verb|sollya_lib_build_function_doubleextended(e)| & \verb|SOLLYA_DE(e)|\\ \verb|ceil(e)| & \verb|sollya_lib_build_function_ceil(e)| & \verb|SOLLYA_CEIL(e)|\\ \verb|floor(e)| & \verb|sollya_lib_build_function_floor(e)| & \verb|SOLLYA_FLOOR(e)|\\ \verb|nearestint(e)| & \verb|sollya_lib_build_function_nearestint(e)| & \verb|SOLLYA_NEARESTINT(e)|\\ \hline \end{tabular} \end{center} \end{table} For each function of the form \verb|sollya_lib_build_function_foo|, there exists a function called \verb|sollya_lib_foo|. There are two differences between them: \begin{itemize} \item First, \verb|sollya_lib_foo| does not ``eat up'' its argument. This can sometimes be useful, \emph{e.g.}, if one has an expression stored in a variable \texttt{a} and one wants to build the expression \texttt{exp(a)} without loosing the reference to the expression represented by \texttt{a}. \item Second, while \verb|sollya_lib_build_function_foo| mechanically constructs an expression, function \verb|sollya_lib_foo| also evaluates it, as far as this is possible without rounding.\\ For instance, after the instructions \verb|a = SOLLYA_CONST(0); b = sollya_lib_exp(a);| the variable \texttt{b} contains the number $1$, whereas it would have contained the expression "\texttt{exp(0)}" if it had been created by \verb|b = sollya_lib_build_function_exp(a)|. \end{itemize} Actually, \verb|sollya_lib_foo| has exactly the same behavior as writing an expression at the prompt within the interactive tool. In particular, it is possible to give a range as an argument to \verb|sollya_lib_foo|: the returned object will be the result of the evaluation of function \verb|foo| on that range by interval arithmetic. In contrast, trying to use \verb|sollya_lib_build_function_foo| on a range would result in a typing error. Alternatively, one may create functional expressions with the functions\\ \verb|int sollya_lib_construct_function(sollya_obj_t *res, sollya_base_function_t type, ...)|\\ \verb|int sollya_lib_v_construct_function(sollya_obj_t *, sollya_base_function_t, va_list)|.\\ The advantage of these functions with respect to the others presented above lies in the fact that they offer a way to create any functional expression, the basic function that one wants to construct being provided with the argument \verb|type|. Since these functions are indeed doing the exact contrary of \verb|sollya_lib_decompose_function|, they are described in details in the corresponding Section~\ref{decomposing_a_functional_expression}. \subsubsection{Other simple objects} Other simple objects are created with functions listed in Table~\ref{creating_sollya_obj_t}. The functions with a name of the form \texttt{sollya\_lib\_something} follow the same convention as \texttt{sollya\_lib\_constant}: they build a new object from a copy of their argument, and the conversion is always exact, whatever the value of \texttt{prec} is. Please note that in the interactive tool, \texttt{D} either denotes the discrete mathematical function that maps a real number to its closest \texttt{double} number, or is used as a symbolic constant to indicate that the \texttt{double} format must be used (as an argument of \texttt{round} for instance). In the library, they are completely distinct objects, the mathematical function being obtained with \texttt{sollya\_lib\_build\_function\_double} and the symbolic constant with \texttt{sollya\_lib\_double\_obj}. The same holds for other formats (\texttt{DD}, \texttt{SG}, etc.) \begin{table}[htp] \caption{Creating \sollya objects from scratch (Returns a new \texttt{sollya\_obj\_t})} \label{creating_sollya_obj_t} \renewcommand{\footnoterule}{} % suppress the separation line between main text and footnotes. \begin{minipage}{\textwidth} ~ \begin{center} \begin{tabular}{|c|l|} \hline Name in the interactive tool & \hfil \phantom{\Large{$A^A$}}Function to create it\phantom{\Large{$A^A$}}\hfil \\ \hline \verb|on| & \verb|sollya_lib_on();| \\ \verb|off| & \verb|sollya_lib_off();| \\ \verb|dyadic| & \verb|sollya_lib_dyadic();| \\ \verb|powers| & \verb|sollya_lib_powers();| \\ \verb|binary| & \verb|sollya_lib_binary();| \\ \verb|hexadecimal| & \verb|sollya_lib_hexadecimal();| \\ \verb|file| & \verb|sollya_lib_file();| \\ \verb|postscript| & \verb|sollya_lib_postscript();| \\ \verb|postscriptfile| & \verb|sollya_lib_postscriptfile();| \\ \verb|perturb| & \verb|sollya_lib_perturb();| \\ \verb|RD| & \verb|sollya_lib_round_down();| \\ \verb|RU| & \verb|sollya_lib_round_up();| \\ \verb|RZ| & \verb|sollya_lib_round_towards_zero();| \\ \verb|RN| & \verb|sollya_lib_round_to_nearest();| \\ \verb|honorcoeffprec| & \verb|sollya_lib_honorcoeffprec();| \\ \verb|true| & \verb|sollya_lib_true();| \\ \verb|false| & \verb|sollya_lib_false();| \\ \verb|void| & \verb|sollya_lib_void();| \\ \verb|default| & \verb|sollya_lib_default();| \\ \verb|decimal| & \verb|sollya_lib_decimal();| \\ \verb|absolute| & \verb|sollya_lib_absolute();| \\ \verb|relative| & \verb|sollya_lib_relative();| \\ \verb|fixed| & \verb|sollya_lib_fixed();| \\ \verb|floating| & \verb|sollya_lib_floating();| \\ \verb|error| & \verb|sollya_lib_error();| \\ \verb|D, double| & \verb|sollya_lib_double_obj();| \\ \verb|SG, single| & \verb|sollya_lib_single_obj();| \\ \verb|QD, quad| & \verb|sollya_lib_quad_obj();| \\ \verb|HP, halfprecision| & \verb|sollya_lib_halfprecision_obj();| \\ \verb|DE, doubleextended| & \verb|sollya_lib_doubleextended_obj();| \\ \verb|DD, doubledouble| & \verb|sollya_lib_double_double_obj();| \\ \verb|TD, tripledouble| & \verb|sollya_lib_triple_double_obj();| \\ \verb|"Hello"| & \verb|sollya_lib_string("Hello")| \\ \verb|[1, 3.5]| & \verb|sollya_lib_range_from_interval(a);|\footnote{\texttt{a} is a \texttt{mpfi\_t} containing the interval $[1, 3.5]$. Conversion is always exact.} \\ \verb|[1, 3.5]| & \verb|sollya_lib_range_from_bounds(b, c);|\footnote[2]{\texttt{b} and \texttt{c} are \texttt{mpfr\_t} respectively containing the numbers $1$ and $3.5$. Conversion is always exact.} \\ \verb|[1, 3.5]| & \verb|sollya_lib_range(d, e);|\footnote[3]{\texttt{d} and \texttt{e} are \texttt{sollya\_obj\_t} respectively containing the numbers $1$ and $3.5$. Conversion is always exact.} \\ \hline \end{tabular} \end{center} \end{minipage} \end{table} \subsubsection{Lists} \label{creating_lists} There are actually two kinds of lists: regular lists (such as, \emph{e.g.}, \verb#[|1, 2, 3|]#) and semi-infinite lists (such as, \emph{e.g.}, \verb#[|1, 2...|]#). Withing the interactive tool, the ellipsis ``\texttt{...}'' can sometimes be used as a shortcut to define regular lists, \emph{e.g.}, \verb#[|1, 2, ..., 10|]#. In the library, there is no symbol for the ellipsis, and there are two distinct types: one for regular lists and one for semi-infinite lists (called end-elliptic). Defining a regular list with an ellipsis is not possible in the library (except of course with \texttt{sollya\_lib\_parse\_string}). Constructing regular lists is achieved through three functions: \begin{itemize} \item \verb|sollya_obj_t sollya_lib_list(sollya_obj_t[] L, int n)|: this function returns a new object that is a list the elements of which are copies of \verb|L[0]|, \dots, \verb|L[n-1]|. \item \verb|sollya_obj_t sollya_lib_build_list(sollya_obj_t obj1, ...)|: this function accepts a variable number of arguments. The last one \textbf{must} be \texttt{NULL}. It ``eats up'' its arguments and returns a list containing the objects given as arguments. Since arguments are eaten up, they may be directly produced by function calls, without being stored in variables. A typical use could be \begin{center} \verb|sollya_lib_build_list(SOLLYA_CONST(1), SOLLYA_CONST(2), SOLLYA_CONST(3), NULL);| \end{center} \item \verb|sollya_obj_t sollya_lib_v_build_list(va_list)|: the same as the previous functions, but with a \texttt{va\_list}. \end{itemize} Following the same conventions, end-elliptic lists can be constructed with the following functions: \begin{itemize} \item \verb|sollya_obj_t sollya_lib_end_elliptic_list(sollya_obj_t[] L, int n)|. \item \verb|sollya_obj_t sollya_lib_build_end_elliptic_list(sollya_obj_t obj1, ...)|. \item \verb|sollya_obj_t sollya_lib_v_build_end_elliptic_list(va_list)|. \end{itemize} \subsubsection{Structures} \label{creating_structures} \sollya structures are also available in library mode as any other \sollya object. The support for \sollya structures is however minimal and creating them might seem cumbersome\footnote{Users are encouraged to make well-founded feature requests if they feel the need for better support of structures.}. The only function available to create structures is \begin{center} \verb|int sollya_lib_create_structure(sollya_obj_t *res, sollya_obj_t s, char *name,|\\ \verb| sollya_obj_t val). | \end{center} This function returns a boolean integer: false means failure, and true means success. Three cases of success are possible. In all cases, the function creates a new object and stores it at the address referred to by \texttt{res}. \begin{itemize} \item If \texttt{s} is \texttt{NULL}: \texttt{*res} is filled with a structure with only one field. This field is named after the string \texttt{name} and contains a copy of the object \texttt{val}. \item If \texttt{s} is an already existing structure that has a field named after the string \texttt{name}: \texttt{*res} is filled with a newly created structure. This structure is the same as \texttt{s} except that the field corresponding to \texttt{name} contains a copy of \texttt{val}. \item If \texttt{s} is an already existing structure that does \textbf{not} have a field named after the string \texttt{name}: \texttt{*res} is filled with a newly created structure. This structure is the same as \texttt{s} except that it has been augmented with a field corresponding to \texttt{name} and that contains a copy of \texttt{val}. \end{itemize} Please notice that \texttt{s} is not changed by this function: the structure stored in \texttt{*res} is a new one that does not refer to any of the components of \texttt{s}. As a consequence, one should not forget to explicitly clear \texttt{s} as well as \texttt{*res} when they become useless. \subsubsection{Library functions, library constants and procedure functions} \label{library_functions} In addition to the mathematical base functions and constants provided by \sollya and listed in the Section above, the user may bind other mathematical functions and constants to \sollya objects under the condition that they can provide code to evaluate these functions or constants. The mechanism behind is similar to the one available in interactive \sollya through the {\tt library}, {\tt libraryconstant} and {\tt function} commands (see Sections \ref{lablibrary}, \ref{lablibraryconstant} and \ref{labfunction}). With the \sollya library, this binding is done through one of the following functions: \begin{itemize} \item Binding of a (non-constant) mathematical function for which evaluation code is available through a {\tt C} pointer to a function: \\ \verb|sollya_obj_t sollya_lib_libraryfunction(sollya_obj_t e, | \\ \verb| char *name, | \\ \verb| int (*f)(mpfi_t, mpfi_t, int));| \\ \verb|sollya_obj_t sollya_lib_build_function_libraryfunction(sollya_obj_t e, | \\ \verb| char *name, | \\ \verb| int (*f)(mpfi_t, mpfi_t, int));| \\ \verb|sollya_obj_t sollya_lib_libraryfunction_with_data(|\\ \verb| sollya_obj_t e, | \\ \verb| char *name, | \\ \verb| int (*f)(mpfi_t, mpfi_t, int, void *),|\\ \verb| void *data,|\\ \verb| void (*dealloc_func)(void *));| \\ \verb|sollya_obj_t sollya_lib_build_function_libraryfunction_with_data(|\\ \verb| sollya_obj_t e, | \\ \verb| char *name, | \\ \verb| int (*f)(mpfi_t, mpfi_t, int, void *),|\\ \verb| void *data,|\\ \verb| void (*dealloc_func)(void *));| These four functions construct a \sollya object representing $f(e)$ where $e$ is given as the \sollya object {\tt e} and $f$ is given as the pointer to a function \verb|f(mpfi_t y, mpfi_t x, int n)| (resp. \verb|f(mpfi_t y, mpfi_t x, int n, void *data)|). This code must evaluate the $n$-th derivative of $f$ over the interval $x$, yielding $y$. As usual, the functions whose name contains \verb|_build_function_| ``eat up'' the object {\tt e}, while the corresponding functions (without \verb|_build_function_| in their name) do not. The \verb|name| argument of the function is taken as a suggestion to the name the \sollya object representing the function should be printed as when displayed. The user may choose to provide \verb|NULL| instead. In any case, upon the binding, the \sollya library will determine a unique displaying name for the function. If it is not yet taken as a name (for some other \sollya object or \sollya keyword), the suggested name will be used. If no suggested name is provided, the name of the dynamic object behind the pointer to the function will be used if it can be determined. Otherwise, a more-or-less random name is used. If the (suggested) base name is already taken, the name is unified appending an underscore and a unique number to it. The \verb|name| argument is never ``eaten up'', \emph{i.e.}, it is up to the user to free any memory allocated to that pointer. The functions whose name contains \verb|_with_data| allow for the same binding of an external function to a \sollya object as the corresponding functions (without \verb|_with_data| in their name), but additionnally permit an opaque data pointer \verb|data| to be registered together with the function pointer~\verb|f|. The data pointer \verb|data| will be represented to the function \verb|f| on each call, in an additional (last) argument of type \verb|void *| that the function \verb|f| is supposed to take. Such opaque data pointers may be used, \emph{e.g.}, to distinguish between several different external procedure objects when only unique function pointer is available and the actual procedural code is contained in a closure represented thru the data pointer. As the data field the \verb|data| pointer points to may require deallocation once the \sollya object built thru invokation of the functions described inhere and all of its copies eventually get deallocated, a data-field-deallocation function \verb|dealloc_func| may be registered together with the data field. That function will be called with the \verb|data| pointer in argument when the \sollya object is deallocated. When the user does not need such a deallocation function, they may provide \verb|NULL| as the \verb|dealloc_func| argument to the \verb|sollya_lib_libraryfunction_with_data| function or \verb|sollya_lib_build_function_libraryfunction_with_data| function, in which case the argument is ignored and no deallocation function gets called for the \sollya object built. \item Binding of a mathematical constant for which evaluation code is available through a {\tt C} pointer to a function: \\ \verb|sollya_obj_t sollya_lib_libraryconstant(char *name, | \\ \verb| void (*c)(mpfr_t, mp_prec_t));| \\ \verb|sollya_obj_t sollya_lib_build_function_libraryconstant(char *name, | \\ \verb| void (*c)(mpfr_t, mp_prec_t));| \\ \verb|sollya_obj_t sollya_lib_libraryconstant_with_data(|\\ \verb| char *name, | \\ \verb| void (*c)(mpfr_t, mp_prec_t, void *),|\\ \verb| void *data,|\\ \verb| void (*dealloc_func)(void *));| \\ \verb|sollya_obj_t sollya_lib_build_function_libraryconstant_with_data(|\\ \verb| char *name, | \\ \verb| void (*c)(mpfr_t, mp_prec_t, void *),|\\ \verb| void *data,|\\ \verb| void (*dealloc_func)(void *));| These four functions construct a \sollya object representing the mathematical constant $c$ for which a pointer to a function \verb|c(mpfr_t rop, mp_prec_t prec)| (resp. \\ \verb|c(mpfr_t rop, mp_prec_t prec, void *data)|) is provided. This code must evaluate the constant to precision \verb|prec| and affect the result to \verb|rop|. See Section~\ref{lablibraryconstant} for details with respect to~\verb|prec|. The same remark as above concerning the suggested displaying name of the \sollya object applies for the \verb|name| argument. In the same manner, the same remarks as above concerning the functions taking a data field pointer \verb|data| apply. \item Binding of a mathematical function for which evaluation code is available through a \sollya object representing a \sollya procedure: \\ \verb|sollya_obj_t sollya_lib_procedurefunction(sollya_obj_t e, sollya_obj_t f);| \\ \verb|sollya_obj_t sollya_lib_build_function_procedurefunction(sollya_obj_t e, | \\ \verb| sollya_obj_t f);| These two functions construct a \sollya library object representing $f(e)$ where $e$ corresponds to the mathematical function (or constant) given with argument \verb|e| and where $f$ is given as a \sollya procedure \verb|f(x, n, p)| evaluating the $n$-th derivative of $f$ over the interval $x$ with precision $p$. See Section~\ref{labfunction} concerning details of the arguments of that \sollya procedure. As usual, \verb|sollya_lib_build_function_procedurefunction| ``eats up'' its arguments \verb|e| and \verb|f| while \verb|sollya_obj_t sollya_lib_procedurefunction| does not. Currently, the only way of constructing a \sollya library object representing a \sollya procedure is to use \verb|sollya_lib_parse_string|. \end{itemize} \subsubsection{External procedures} Similarly to library functions or library constants, the binding of which is discussed in Section~\ref{library_functions}, \sollya allows external procedural code to be bound and then used inside \sollya in a procedure-like manner. This is provided in the interactive tool with the \com{externalproc} command, described in Section~\ref{labexternalproc}. The same mechanism is available in the \sollya library thanks to the following functions: \begin{itemize} \item To bind a function pointer \verb|p| as a procedure named \verb|name|, having arity \verb|arity|, returning a result of type \verb|res_type| and accepting arguments of types \verb|arg_types[0]| thru \verb|arg_types[arity - 1]|, the function \\ \verb|sollya_obj_t|\\ \verb| sollya_lib_externalprocedure(sollya_externalprocedure_type_t res_type,|\\ \verb| sollya_externalprocedure_type_t *arg_types,|\\ \verb| int arity,|\\ \verb| char *name,|\\ \verb| void *p);|\\ may be used. The \verb|name| argument of the function is only taken as a suggestion to the name the \sollya object representing the function should be printed as when displayed. The user may choose to provide \verb|NULL| instead. In any case, upon the binding, the \sollya library will determine a unique displaying name for the procedure. If it is not yet taken as a name (for some other \sollya object or \sollya keyword), the suggested name will be used. If no suggested name is provided, the name of the dynamic object behind the pointer to the function will be used if it can be determined. Otherwise, a more-or-less random name is used. If the (suggested) base name is already taken, the name is unified appending an underscore and a unique number to it. The \verb|name| argument is never ``eaten up'', \emph{i.e.}, it is up to the user to free any memory allocated for that pointer. The result type \verb|res_type| as well as the argument types \verb|arg_types| take one of the values defined by the enumeration type \verb|sollya_externalprocedure_type_t|, detailed in Table~\ref{type_external_proc}. The array (resp. pointer) to the argument types \verb|arg_types| provided to the \verb|sollya_lib_externalprocedure| function is not ``eaten up'' by the function, \emph{i.e.}, it is up to the user to free any memory allocated for that pointer (where applicable). When the external procedure does not take any argument, its arity is to be set to zero. In this case, the argument type pointer \verb|arg_types| is ignored by the \verb|sollya_lib_externalprocedure| function; it hence may be invalid or \verb|NULL| in this case. The actual {\tt C} function to be bound is supposed to have a function type corresponding to the result and argument types indicated. It is supposed to be provided to the \verb|sollya_lib_externalprocedure| function as a \verb|void *| function pointer, though, for the sake of unification of the \sollya library interface. A detailed description of the actual type of the {\tt C} function is given in Section~\ref{labexternalproc}. \item In addition to the basic binding function described above, the \\ \verb|sollya_obj_t|\\ \verb| sollya_lib_externalprocedure_with_data(|\\ \verb| sollya_externalprocedure_type_t res_type,|\\ \verb| sollya_externalprocedure_type_t *arg_types,|\\ \verb| int arity,|\\ \verb| char *name,|\\ \verb| void *p,|\\ \verb| void *data,|\\ \verb| void (*dealloc_func)(void *));|\\ function allows for the same binding of an external procedure to a \sollya object but additionnally permits an opaque data pointer \verb|data| to be registered together with the function pointer \verb|p|. The data pointer \verb|data| will be represented to the function \verb|p| on each call, in an additional (last) argument of type \verb|void *| that the function \verb|p| is supposed to take. Such opaque data pointers may be used, \emph{e.g.}, to distinguish between several different external procedure objects when only unique function pointer is available and the actual procedural code is contained in a closure represented thru the data pointer. As the data field the \verb|data| pointer points to may require deallocation once the \sollya object built thru invokation of the \verb|sollya_lib_externalprocedure_with_data| and all of its copies eventually get deallocated, a data-field-deallocation function \verb|dealloc_func| may be registered together with the data field. That function will be called with the \verb|data| pointer in argument when the \sollya object is deallocated. When the user does not need such a deallocation function, they may provide \verb|NULL| as the \verb|dealloc_func| argument to the \verb|sollya_lib_externalprocedure_with_data| function, in which case the argument is ignored and no deallocation function gets called for the \sollya object built. \end{itemize} \begin{table}[htp] \caption{Possible return and argument types for external procedures} \label{type_external_proc} \begin{center} \begin{tabular}{|l|} \hline \verb|SOLLYA_EXTERNALPROC_TYPE_VOID|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_CONSTANT|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_FUNCTION|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_RANGE|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_INTEGER|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_STRING|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_BOOLEAN|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_OBJECT|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_CONSTANT_LIST|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_FUNCTION_LIST|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_RANGE_LIST|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_INTEGER_LIST|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_STRING_LIST|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_BOOLEAN_LIST|\\ \verb|SOLLYA_EXTERNALPROC_TYPE_OBJECT_LIST|\\ \hline \end{tabular} \end{center} \end{table} \subsection{Getting the type of an object} Functions are provided that allow the user to test the type of a \sollya object. They are listed in Table~\ref{type_of_an_object}. They all return an \verb|int| interpreted as the boolean result of the test. Please note that from a typing point of view, a mathematical constant and a non-constant functional expression are both functions. \begin{table}[htp] \caption{Testing the type of a \sollya object (Returns non-zero if true, 0 otherwise)} \label{type_of_an_object} \begin{center} \begin{tabular}{|l|} \hline \verb|sollya_lib_obj_is_function(obj)| \\ \verb|sollya_lib_obj_is_range(obj)| \\ \verb|sollya_lib_obj_is_string(obj)| \\ \verb|sollya_lib_obj_is_list(obj)| \\ \verb|sollya_lib_obj_is_end_elliptic_list(obj)| \\ \verb|sollya_lib_obj_is_structure(obj)| \\ \verb|sollya_lib_obj_is_procedure(obj)| \\ \verb|sollya_lib_obj_is_externalprocedure(obj)| \\ \verb|sollya_lib_obj_is_error(obj)|\\[0.1cm] \hline \verb|sollya_lib_is_on(obj)|\phantom{\Large{$A^A$}} \\ \verb|sollya_lib_is_off(obj)| \\ \verb|sollya_lib_is_dyadic(obj)| \\ \verb|sollya_lib_is_powers(obj)| \\ \verb|sollya_lib_is_binary(obj)| \\ \verb|sollya_lib_is_hexadecimal(obj)| \\ \verb|sollya_lib_is_file(obj)| \\ \verb|sollya_lib_is_postscript(obj)| \\ \verb|sollya_lib_is_postscriptfile(obj)| \\ \verb|sollya_lib_is_perturb(obj)| \\ \verb|sollya_lib_is_round_down(obj)| \\ \verb|sollya_lib_is_round_up(obj)| \\ \verb|sollya_lib_is_round_towards_zero(obj)| \\ \verb|sollya_lib_is_round_to_nearest(obj)| \\ \verb|sollya_lib_is_honorcoeffprec(obj)| \\ \verb|sollya_lib_is_true(obj)| \\ \verb|sollya_lib_is_false(obj)| \\ \verb|sollya_lib_is_void(obj)| \\ \verb|sollya_lib_is_default(obj)| \\ \verb|sollya_lib_is_decimal(obj)| \\ \verb|sollya_lib_is_absolute(obj)| \\ \verb|sollya_lib_is_relative(obj)| \\ \verb|sollya_lib_is_fixed(obj)| \\ \verb|sollya_lib_is_floating(obj)| \\ \verb|sollya_lib_is_double_obj(obj)| \\ \verb|sollya_lib_is_single_obj(obj)| \\ \verb|sollya_lib_is_quad_obj(obj)| \\ \verb|sollya_lib_is_halfprecision_obj(obj)| \\ \verb|sollya_lib_is_doubleextended_obj(obj)| \\ \verb|sollya_lib_is_double_double_obj(obj)| \\ \verb|sollya_lib_is_triple_double_obj(obj)| \\ \verb|sollya_lib_is_pi(obj)| \\ \hline \end{tabular} \end{center} \end{table} \subsection{Recovering the value of a range} If a \verb|sollya_obj_t| is a range, it is possible to recover the values corresponding to the bounds of the range. The range can be recovered either as a \verb|mpfi_t| or as two \verb|mpfr_t| (one per bound). This is achieved with the following conversion functions: \begin{itemize} \item \verb|int sollya_lib_get_interval_from_range(mpfi_t res, sollya_obj_t arg)|, \item \verb|int sollya_lib_get_bounds_from_range(mpfr_t res_left, mpfr_t res_right,|\\ \verb| sollya_obj_t arg)|. \end{itemize} They return a boolean integer: false means failure (\emph{i.e.}, if the \verb|sollya_obj_t| is not a range) and true means success. These functions follow the same conventions as those of the \verb|MPFR| and \verb|MPFI| libraries: the variables \verb|res|, \verb|res_left| and \verb|res_right| must be initialized beforehand, and are used to store the result of the conversion. Also, the functions \verb|sollya_lib_get_something_from_range| \textbf{do not change the internal precision} of \verb|res|, \verb|res_left| and \verb|res_right|. If the internal precision is sufficient to perform the conversion without rounding, then it is guaranteed to be exact. If, on the contrary, the internal precision is not sufficient, the actual bounds of the range stored in \verb|arg| will be rounded at the target precision using a rounding mode that ensures that the inclusion property remains valid, \emph{i.e.}, $\mathtt{arg} \subseteq \mathtt{res}$ (resp. $\mathtt{arg} \subseteq [\mathtt{res\_left}, \mathtt{res\_right}]$). Function \verb|int sollya_lib_get_prec_of_range(mp_prec_t *prec, sollya_obj_t arg)| stores at \verb|*prec| a precision that is guaranteed to be sufficient to represent the range stored in \verb|arg| without rounding. The returned value of this function is a boolean that follows the same convention as above. In conclusion, this is an example of a completely safe conversion: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] ... mp_prec_t prec; mpfr_t a, b; if (!sollya_lib_get_prec_of_range(&prec, arg)) { sollya_lib_printf("Unexpected error: %b is not a range\n", arg); } else { mpfr_init2(a, prec); mpfr_init2(b, prec); sollya_lib_get_bounds_from_range(a, b, arg); /* Now [a, b] = arg exactly */ } ... \end{Verbatim} \end{minipage}\end{center} \subsection{Recovering the value of a numerical constant or a constant expression} From a conceptual point of view, a numerical constant is nothing but a very simple constant functional expression. Hence there is no difference in \sollya between the way constants and constant expressions are handled. The functions presented in this section allow one to recover the value of such constants or constant expressions into usual C data types. A constant expression being given, three cases are possible: \begin{itemize} \item When naively evaluated at the current global precision, the expression always leads to provably exact computations (\emph{i.e.}, at each step of the evaluation, no rounding happens). For instance numerical constants or simple expressions such as $(\exp(0)+5)/16$ fall in this category. \item The constant expressions would be exactly representable at some precision but this is not straightforward from a naive evaluation at the current global precision. An example would be $\sin(\pi/3)/\sqrt{3}$ or even $1 + 2^{-\textrm{prec}-10}$. \item Finally, a third possibility is that the value of the expression is not exactly representable at any precision on a binary floating-point number. Possible examples are $\pi$ or $1/10$. \end{itemize} From now on, we suppose that \verb|arg| is a \verb|sollya_obj_t| that contains a constant expression (or, as a particular case, a numerical constant). The general scheme followed by the conversion functions is the following: \sollya chooses an initial working precision greater than the target precision. If the value of \verb|arg| is easily proved to be exactly representable at that precision, \sollya first computes this exact value and then rounds it to the nearest number of the target format (ties-to-even). Otherwise, \sollya tries to adapt the working precision automatically in order to ensure that the result of the conversion is one of both numbers in the target format that are closest to the exact value (a faithful rounding). A warning message indicates that the conversion is not exact and that a faithful rounding has been performed. In some cases really hard to evaluate, the algorithm can even fail to find a faithful rounding. In that case, too, a warning message is emitted indicating that the result of the conversion should not be trusted. Let us remark that these messages can be caught instead of being displayed and adapted handling can be provided by the user of the library at each emission of a warning (see Section~\ref{callbacks}). The conversion functions are the following. They return a boolean integer: false means failure (\emph{i.e.}, \verb|arg| is not a constant expression) and true means success. \begin{itemize} \item \verb|int sollya_lib_get_constant_as_double(double *res, sollya_obj_t arg)| \item \verb|int sollya_lib_get_constant_as_int(int *res, sollya_obj_t arg)|: any value too big to be represented (this includes $\pm$\verb|Inf|) is converted to \verb|INT_MIN| or \verb|INT_MAX| and a warning is emitted. \verb|NaN| is converted to $0$ with a specific warning. \item \verb|int sollya_lib_get_constant_as_int64(int64_t *res, sollya_obj_t arg)|: any value too big to be represented (this includes $\pm$\verb|Inf|) is converted to \verb|INT64_MIN| or \verb|INT64_MAX| and a warning is emitted. \verb|NaN| is converted to $0$ with a specific warning. \item \verb|int sollya_lib_get_constant_as_uint64(uint64_t *res, sollya_obj_t arg)|: negative values are converted to $0$ with a warning. Any value too big to be represented (this includes \verb|Inf|) is converted to \verb|UINT64_MAX| and a warning is emitted. \verb|NaN| is converted to $0$ with a specific warning. \item \verb|int sollya_lib_get_constant_as_mpz(mpz_t res, sollya_obj_t arg)|: the result of the conversion is stored in \verb|res|. Please note that \verb|res| must be initialized beforehand. Infinities and \verb|NaN| are converted to $0$ with specific warnings. \item \verb|int sollya_lib_get_constant_as_mpq(mpq_t res, sollya_obj_t arg)|: the result of the conversion is stored in \verb|res|. Please note that \verb|res| must be initialized beforehand. If \verb|arg| cannot be proved to be exactly a floating-point number or the ratio of two floating-point numbers at some precision, the function returns false and \verb|res| is left unchanged. \item \verb|int sollya_lib_get_constant(mpfr_t res, sollya_obj_t arg)|: the result of the conversion is stored in \verb|res|. Please note that \verb|res| must be initialized beforehand and that its internal precision is not modified by the algorithm. \end{itemize} Function \verb|int sollya_lib_get_prec_of_constant(mp_prec_t *prec, sollya_obj_t arg)| tries to find a precision that would be sufficient to exactly represent the value of \verb|arg| without rounding. If it manages to find such a precision, it stores it at \verb|*prec| and returns true. If it does not manage to find such a precision, or if \verb|arg| is not a constant expression, it returns false and \verb|*prec| is left unchanged. In conclusion, here is an example of use for converting a constant expression to a \verb|mpfr_t|: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] ... mp_prec_t prec; mpfr_t a; int test = 0; test = sollya_lib_get_prec_of_constant(&prec, arg); if (test) { mpfr_init2(a, prec); sollya_lib_get_constant(a, arg); /* Exact conversion */ } else { mpfr_init2(a, 165); /* Initialization at some default precision */ test = sollya_lib_get_constant(a, arg); if (!test) { sollya_lib_printf("Error: %b is not a constant expression\n", arg); } } ... \end{Verbatim} \end{minipage}\end{center} \subsection{Converting a string from \sollya to C} If \verb|arg| is a \verb|sollya_obj_t| that contains a string, that string can be recovered using \begin{center} \verb|int sollya_lib_get_string(char **res, sollya_obj_t arg)|. \end{center} If \verb|arg| really is a string, this function allocates enough memory on the heap to store the corresponding string, it copies the string at that newly allocated place, and sets \verb|*res| so that it points to it. The function returns a boolean integer: false means failure (\emph{i.e.}, \verb|arg| is not a string) and true means success. Since this function allocates memory on the heap, this memory should manually be cleared by the user with \verb|sollya_lib_free| once it becomes useless. \subsection{Recovering the contents of a \sollya list} It is possible to recover the $i$-th element of a list \verb|arg| (as one would do using \verb|arg[i]| withing \sollya) with the following function:\\ \begin{center} \verb|int sollya_lib_get_element_in_list(sollya_obj_t *res, sollya_obj_t arg, int i)|. \end{center} It returns a boolean integer: false means failure (\emph{i.e.}, \verb|arg| is not a list or the index is out of range) and true means success. In case of success, a copy of the $i$-th element of \verb|arg| is stored at the address referred to by \verb|res|. Since it is a copy, it should be cleared with \verb|sollya_lib_clear_obj| when it becomes useless. Please notice that this function works with regular lists as well as with end-elliptic lists, just as within the interactive tool. Another function allows user to recover all elements of a list in a single call. This function returns a C array of \verb|sollya_obj_t| objects and has the following signature:\\ \begin{center} \verb|int sollya_lib_get_list_elements(sollya_obj_t **L, int *n, int *end_ell,|\\ \verb| sollya_obj_t arg). | \end{center} Three cases are possible: \begin{itemize} \item If \verb|arg| is a regular list of length $N$, the function allocates memory on the heap for $N$ \verb|sollya_obj_t|, sets \verb|*L| so that it points to that memory segment, and copies each of the elements $N$ of \verb|arg| to \verb|(*L)[0]|, \dots, \verb|(*L)[N-1]|. Finally, it sets \verb|*n| to $N$, \verb|*end_ell| to zero and returns true. A particular case is when \verb|arg| is the empty list: everything is the same except that no memory is allocated and \verb|*L| is left unchanged. \item If \verb|arg| is an end-elliptic list containing $N$ elements plus the ellipsis. The function allocates memory on the heap for $N$ \verb|sollya_obj_t|, sets \verb|*L| so that it points to that memory segment, and copies each of the elements $N$ of \verb|arg| at \verb|(*L)[0]|, \dots, \verb|(*L)[N-1]|. Finally, it sets \verb|*n| to $N$, \verb|*end_ell| to a non-zero value and returns true. The only difference between a regular list and an end-elliptic list containing the same elements is hence that \verb|*end_ell| is set to a non-zero value in the latter. \item If \verb|arg| is neither a regular nor an end-elliptic list, \verb|*L|, \verb|*n| and \verb|*end_ell| are left unchanged and the function returns false. \end{itemize} In case of success, please notice that \verb|(*L)[0]|, \dots, \verb|(*L)[N-1]| should manually be cleared with \verb|sollya_lib_clear_obj| when they become useless. Also, the pointer \verb|*L| itself should be cleared with \verb|sollya_lib_free| since it points to a segment of memory allocated on the heap by \sollya. \subsection{Recovering the contents of a \sollya structure} If \verb|arg| is a \verb|sollya_obj_t| that contains a structure, the contents of a given field can be recovered using \begin{center} \verb|int sollya_lib_get_element_in_structure(sollya_obj_t *res, char *name,|\\ \verb| sollya_obj_t arg). | \end{center} If \verb|arg| really is a structure and if that structure has a field named after the string \verb|name|, this function copies the contents of that field into the \sollya object \verb|*res|. The function returns a boolean integer: false means failure (\emph{i.e.}, if \verb|arg| is not a structure or if it does not have a field named after \verb|name|) and true means success. It is also possible to get all the field names and their contents. This is achieved through the function \begin{center} \verb|int sollya_lib_get_structure_elements(char ***names, sollya_obj_t **objs, int *n,|\\ \verb| sollya_obj_t arg). | \end{center} If \verb|arg| really is a structure, say with $N$ fields called ``fieldA'', \dots, ``fieldZ'', this functions sets \verb|*n| to~$N$, allocates and fills an array of $N$ strings and sets \verb|*names| so that it points to that segment of memory (hence \verb|(*names)[0]| is the string ``fieldA'', \dots, \verb|(*names)[N-1]| is the string ``fieldZ''). Moreover, it allocates memory for $N$ \verb|sollya_obj_t|, sets \verb|*objs| so that it points on that memory segment, and copies the contents of each of the $N$ fields at \verb|(*objs)[0]|, \dots, \verb|(*objs)[N-1]|. Finally it returns true. If \verb|arg| is not a structure, the function simply returns false without doing anything. Please note that since \verb|*names| and \verb|*objs| point to memory segments that have been dynamically allocated, they should manually be cleared by the user with \verb|sollya_lib_free| once they become useless. \subsection{Decomposing a functional expression} \label{decomposing_a_functional_expression} If a \texttt{sollya\_obj\_t} contains a functional expression, one can decompose the expression tree using the following functions. These functions all return a boolean integer: true in case of success (\emph{i.e.}, if the \texttt{sollya\_obj\_t} argument really contains a functional expression) and false otherwise. \begin{table}[htp] \caption{List of values defined in type \texttt{sollya\_base\_function\_t}} \label{list_of_sollya_base_function_t} \begin{center} \begin{tabular}{|c|c|c|} \hline \phantom{\Large{$A^A$}} \verb|SOLLYA_BASE_FUNC_COS|\phantom{\Large{$A^A$}} & \verb|SOLLYA_BASE_FUNC_DOUBLE| & \verb|SOLLYA_BASE_FUNC_LOG| \\ \verb|SOLLYA_BASE_FUNC_ACOS| & \verb|SOLLYA_BASE_FUNC_DOUBLEDOUBLE| & \verb|SOLLYA_BASE_FUNC_LOG_2| \\ \verb|SOLLYA_BASE_FUNC_ACOSH| & \verb|SOLLYA_BASE_FUNC_DOUBLEEXTENDED| & \verb|SOLLYA_BASE_FUNC_LOG_10|\\ \verb|SOLLYA_BASE_FUNC_COSH| & \verb|SOLLYA_BASE_FUNC_TRIPLEDOUBLE| & \verb|SOLLYA_BASE_FUNC_LOG_1P| \\ \verb|SOLLYA_BASE_FUNC_SIN| & \verb|SOLLYA_BASE_FUNC_HALFPRECISION| & \verb|SOLLYA_BASE_FUNC_EXP| \\ \verb|SOLLYA_BASE_FUNC_ASIN| & \verb|SOLLYA_BASE_FUNC_SINGLE| & \verb|SOLLYA_BASE_FUNC_EXP_M1| \\ \verb|SOLLYA_BASE_FUNC_ASINH| & \verb|SOLLYA_BASE_FUNC_QUAD| & \verb|SOLLYA_BASE_FUNC_NEG| \\ \verb|SOLLYA_BASE_FUNC_SINH| & \verb|SOLLYA_BASE_FUNC_FLOOR| & \verb|SOLLYA_BASE_FUNC_SUB| \\ \verb|SOLLYA_BASE_FUNC_TAN| & \verb|SOLLYA_BASE_FUNC_CEIL| & \verb|SOLLYA_BASE_FUNC_ADD| \\ \verb|SOLLYA_BASE_FUNC_ATAN| & \verb|SOLLYA_BASE_FUNC_NEARESTINT| & \verb|SOLLYA_BASE_FUNC_MUL| \\ \verb|SOLLYA_BASE_FUNC_ATANH| & \verb|SOLLYA_BASE_FUNC_LIBRARYCONSTANT| & \verb|SOLLYA_BASE_FUNC_DIV| \\ \verb|SOLLYA_BASE_FUNC_TANH| & \verb|SOLLYA_BASE_FUNC_LIBRARYFUNCTION| & \verb|SOLLYA_BASE_FUNC_POW|\\ \verb|SOLLYA_BASE_FUNC_ERF| & \verb|SOLLYA_BASE_FUNC_PROCEDUREFUNCTION| & \verb|SOLLYA_BASE_FUNC_SQRT| \\ \verb|SOLLYA_BASE_FUNC_ERFC| & \verb|SOLLYA_BASE_FUNC_FREE_VARIABLE| & \verb|SOLLYA_BASE_FUNC_PI| \\ \verb|SOLLYA_BASE_FUNC_ABS| & \verb|SOLLYA_BASE_FUNC_CONSTANT| & \\ \hline \end{tabular} \end{center} \end{table} \begin{itemize} \item \verb|int sollya_lib_get_function_arity(int *n, sollya_obj_t f)|: it stores the arity of the head function in \texttt{f} at the address referred to by \texttt{n}. Currently, the mathematical functions handled in \sollya are at most dyadic. Mathematical constants are considered as 0-adic functions. The free variable is regarded as the identity function applied to the free variable: its arity is hence $1$. \item \verb|int sollya_lib_get_head_function(sollya_base_function_t *type, sollya_obj_t f)|:\\ it stores the type of \texttt{f} at the address referred to by \texttt{type}. The \texttt{sollya\_base\_function\_t} is an enum type listing all possible cases (see Table~\ref{list_of_sollya_base_function_t}). \item \verb|int sollya_lib_get_subfunctions(sollya_obj_t f, int *n, ...)|: let us denote by \texttt{g\_1}, \dots, \texttt{g\_k} the arguments following the argument \texttt{n}. They must be of type \verb|sollya_obj_t *|. The function stores the arity of \texttt{f} at the address referred to by \texttt{n} (except if \texttt{n} is \verb|NULL|, in which case, \verb|sollya_lib_get_subfunctions| simply ignores it and goes on). Suppose that \texttt{f} contains an expression of the form $f_0(f_1,\dots,f_s)$ (as a particular case, if \texttt{f} is just the free variable, it is regarded in this context as the identity function applied to the free variable, so both $f_0$ and $f_1$ are the free variable). For each $i$ from $1$ to $s$, the expression corresponding to $f_i$ is stored at the address referred to by \texttt{g\_i}, unless one of the \texttt{g\_i} is \texttt{NULL} in which case the function returns when encountering it. In practice, it means that the user should always put \texttt{NULL} as last argument, in order to prevent the case when they would not provide enough variables \texttt{g\_i}. They can check afterwards that they provided enough variables by checking the value contained at the address referred to by \texttt{n}. If the user does not put \texttt{NULL} as last argument and do not provide enough variables \texttt{g\_i}, the algorithm will continue storing arguments at random places in the memory (on the contrary, providing more arguments than necessary does not harm: useless arguments are simply ignored and left unchanged). In the case when $f_0$ is a library function, a constant (\emph{i.e.}, represented by the \verb|sollya_base_function_t| \verb|SOLLYA_BASE_FUNC_CONSTANT|), a library constant, the constant $\pi$ (\emph{i.e.}, represented by the \verb|sollya_base_function_t| \verb|SOLLYA_BASE_FUNC_PI|) or a procedure function, and if the user provides a non-\texttt{NULL} argument \texttt{g\_t} after \texttt{g\_s}, additionnal information is returned in the remaining argument: \begin{itemize} \item If $f_0$ is a library function, a \sollya object corresponding to the expression $f_0(x)$ is stored at the address referred to by \texttt{g\_t}. This allows the user to get a \sollya object corresponding to function $f_0$. This object can further be used to evaluate $f_0$ at points or to build new expressions involving $f_0$. Please notice that a library function object is not necessarily the result of a call to the \verb|library| command: it can also be, \emph{e.g.}, the derivative of a function created by a call to \verb|library|. \item If $f_0$ is a procedure function, a \sollya object corresponding to the expression $f_0(x)$ is stored at the address referred to by \texttt{g\_t}. The same remarks as above apply. \item If $f_0$ is a constant, the constant $\pi$, or a library constant, $f_0$ itself is stored at the address referred to by \texttt{g\_t}. In this particular case, $t=1$ and the object referred to by \texttt{g\_t} simply gets a copy of \texttt{f}. This (somehow useless) mechanism is made only to handle the cases of library functions, procedure functions, constants and library constants in a unified way. \end{itemize} Please note that the objects that have been stored in variables \texttt{g\_i} must manually be cleared once they become useless. \item \verb|int sollya_lib_v_get_subfunctions(sollya_obj_t f, int *n, va_list va)|: the same as the previous function, but with a \texttt{va\_list} argument. \item \verb|int sollya_lib_get_nth_subfunction(sollya_obj_t *res, sollya_obj_t f, int m)|: while \verb|sollya_lib_get_subfunctions| allows the user to retrieve all the subtrees of a functional expression (including an extra subtree in the case of a constant, the constant $\pi$, a library constant, a library function or a procedure function), this function allows the user to retrieve only one of them. More precisely (using the same notations as in the documentation of \verb|sollya_lib_get_subfunctions| above) if \verb|sollya_lib_get_subfunctions| would put something at the address referred to by variable \verb|g_m|, then \verb|sollya_lib_get_nth_subfunction(res, f, m)| would put the same thing at the address referred to by \verb|res| and return a boolean integer representing true. In any other case, it would let \verb|res| unchanged and return a boolean integer representing false. Notice that the subfunctions are numbered starting from~$1$ (as opposed to, \emph{e.g.}, arrays in~C), hence in the expression $f = e_1 + e_2$, the subexpression $e_1$ corresponds to $m=1$ and the subexpression $e_2$ corresponds to $m=2$. Accordingly, in an expression like $f = \sin(e)$, the subexpression $e$ corresponds to $m=1$. \item \verb|int sollya_lib_decompose_function(sollya_obj_t f, sollya_base_function_t *type,|\\ \verb| int *n, ...)|:\\ this function is a all-in-one function equivalent to using \verb|sollya_lib_get_head_function| and \verb|sollya_lib_get_subfunctions| in only one function call. \item \verb|int sollya_lib_v_decompose_function(sollya_obj_t f, sollya_base_function_t *type,|\\ \verb| int *n, va_list va)|:\\ the same as the previous function, but with a \texttt{va\_list}. \end{itemize} To construct a functional expression, functions are provided that precisely undo what\\ \verb|sollya_lib_decompose_function| does. These functions are the following: \begin{itemize} \item \verb|int sollya_lib_construct_function(sollya_obj_t *res, sollya_base_function_t type, ...)|: let us denote by \verb|g_1|, ..., \verb|g_k| the arguments following the argument \verb|type|. They must be of type \verb|sollya_obj_t|. The function creates a functional expression whose head function corresponds to the basic function represented by variable \verb|type| and whose arguments are \verb|g_1|, ..., \verb|g_s| where $s$ denotes the arity of the considered basic function. It is the responsibility of the user to provide enough arguments with respect to the required arity. As a particular case, when the desired type corresponds to a library function, a constant, the constant $\pi$, a library constant or a procedure function, the user \textbf{must} provide an extra argument \verb|g_t| after \verb|g_s| corresponding to what \verb|sollya_lib_decompose_function| would store in this extra argument on such a case (namely, a \sollya object corresponding to the expression $f_0(x)$ in the case of a library function or procedure function, and $f_0$ itself in the case of a constant, the constant~$\pi$ or a library constant). As a particular case, and to make it more useful in practice, the argument \verb|g_t| is allowed to be equal to \verb|NULL| whenever \verb|type| is equal to \verb|SOLLYA_BASE_FUNC_PI|, in which case the function will succeed, even though \verb|g_t| does not contain the constant~$\pi$ as it theoretically should. Notice however that any other value than \verb|NULL| leads to a failure if it does not contain the constant~$\pi$ itself. If everything goes well the functional expression is created and stored at the address referred to by \verb|res| and a boolean integer representing true is returned. Notice that the arguments \verb|g_1|, \dots, \verb|g_k| are not eaten up by this function and the user must subsequently manually clear these objects. If something goes wrong (bad number of arguments, arguments not having the proper type, etc.) \verb|res| is left unchanged and a boolean integer representing false is returned. \item \verb|int sollya_lib_v_construct_function(sollya_obj_t *res, sollya_base_function_t type,|\\ \verb| va_list varlist)|:\\ the same as the previous function, but with a \verb|va_list|. \end{itemize} As an example of use of the functions described in the present section, the following code returns $1$ if \texttt{f} denotes a functional expression made only of constants (\emph{i.e.}, without the free variable), and returns~$0$ otherwise: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] #include /* Note: we suppose that the library has already been initialized */ int is_made_of_constants(sollya_obj_t f) { sollya_obj_t tmp1 = NULL; sollya_obj_t tmp2 = NULL; int n, r, res; sollya_base_function_t type; r = sollya_lib_decompose_function(f, &type, &n, &tmp1, &tmp2, NULL); if (!r) { sollya_lib_printf("Not a mathematical function\n"); res = 0; } else if (n >= 3) { sollya_lib_printf("Unexpected error: %b has more than two arguments.\n", f); res = 0; } else { switch (type) { case SOLLYA_BASE_FUNC_FREE_VARIABLE: res = 0; break; case SOLLYA_BASE_FUNC_PI: res = 1; break; case SOLLYA_BASE_FUNC_CONSTANT: res = 1; break; case SOLLYA_BASE_FUNC_LIBRARYCONSTANT: res = 1; break; default: res = is_made_of_constants(tmp1); if ((res) && (n==2)) res = is_made_of_constants(tmp2); } } if (tmp1) sollya_lib_clear_obj(tmp1); if (tmp2) sollya_lib_clear_obj(tmp2); return res; } \end{Verbatim} \end{minipage}\end{center} Functions are provided to allow the user to retrieve further information from library function, library constant, procedure function and external procedure objects: \begin{itemize} \item \verb|int sollya_lib_decompose_libraryfunction(int (**f)(mpfi_t, mpfi_t, int),|\\ \phantom{\texttt{int sollya\_lib\_decompose\_libraryfunction( }}\verb|int *deriv, sollya_obj_t *e,|\\ \phantom{\texttt{int sollya\_lib\_decompose\_libraryfunction( }}\verb|sollya_obj_t g)|:\\ assume that \verb|g| represents an expression $f_0(f_1)$ where $f_0$ is a library function. Then, $f_0$ is the $n$-th derivative (for some $n$) of a function provided within \sollya via an external C function \verb|int func(mpfi_t, mpfi_t, int)|.\\ As a result of a call to \verb|sollya_lib_decompose_libraryfunction|, the value $n$ is stored at the address referred to by \verb|deriv|, a pointer to \verb|func| is stored at the address referred to by \verb|f| and a \sollya object representing $f_1$ is stored at the address referred to by \verb|e|. Please notice that the object stored in \verb|e| must manually be cleared once it becomes useless. Upon success, a boolean integer representing true is returned. If \verb|g| is not a library function object, nothing happens and false is returned. \item \verb|int sollya_lib_decompose_libraryfunction_with_data(|\\ \phantom{\texttt{mmmmmmmmmmmmmmmmmmmmmm}}\verb|int (**f)(mpfi_t, mpfi_t, int, void *),|\\ \phantom{\texttt{mmmmmmmmmmmmmmmmmmmmmm}}\verb|int *deriv, sollya_obj_t *e,|\\ \phantom{\texttt{mmmmmmmmmmmmmmmmmmmmmm}}\verb|void **data, void (**dealloc)(void *),|\\ \phantom{\texttt{mmmmmmmmmmmmmmmmmmmmmm}}\verb|sollya_obj_t g)|:\\ works exactly as the previous function but additionnally returns a pointer to the \verb|void *| data field and to the pointer to the deallocation function that had been provided when the library function was created. Notice that, in the case when \verb|g| represents an expression $f_0(f_1)$ where $f_0$ is indeed a library function, but has been constructed with \verb|sollya_lib_libraryfunction| or \verb|sollya_lib_build_function_libraryfunction| and not with one of the \verb|_with_data| variants, this function will fail and return false without touching any of its argument. \item \verb|int sollya_lib_decompose_procedurefunction(sollya_obj_t *f, int *deriv,|\\ \phantom{\texttt{int sollya\_lib\_decompose\_procedurefunction( }}\verb|sollya_obj_t *e, sollya_obj_t g)|:\\ assume that \verb|g| represents an expression $f_0(f_1)$ where $f_0$ is a procedure function. Then, $f_0$ is the $n$-th derivative (for some $n$) of a function provided within \sollya via a procedure \verb|proc(X, n, p) {...}|.\\ As a result of a call to \verb|sollya_lib_decompose_procedurefunction|, the value $n$ is stored at the address referred to by \verb|deriv|, a \sollya object representing the procedure is stored at the address referred to by \verb|f|, a \sollya object representing $f_1$ is stored at the address referred to by \verb|e|. Please notice that the objects stored in \verb|f| and \verb|e| must manually be cleared once they become useless. Upon success, a boolean integer representing true is returned. If \verb|g| is not a procedure function object, nothing happens and false is returned. \item \verb|int sollya_lib_decompose_libraryconstant(void (**f)(mpfr_t, mp_prec_t),|\\ \phantom{\texttt{int sollya\_lib\_decompose\_libraryconstant( }}\verb|sollya_obj_t c)|:\\ assume that \verb|c| is a constant provided via an external C function \verb|void func(mpfr_t, mp_prec_t)|. As a result of a call to \verb|sollya_lib_decompose_libraryconstant|, a pointer to \verb|func| is stored at the address referred to by \verb|f| and a boolean integer representing true is returned. Otherwise, nothing happens and false is returned. \item \verb|int sollya_lib_decompose_libraryconstant_with_data(|\\ \phantom{\texttt{mmmmmmmmmmmmmmmmmmmmmm}}\verb|void (**f)(mpfr_t, mp_prec_t, void *),|\\ \phantom{\texttt{mmmmmmmmmmmmmmmmmmmmmm}}\verb|void **data, void (**dealloc)(void *),|\\ \phantom{\texttt{mmmmmmmmmmmmmmmmmmmmmm}}\verb|sollya_obj_t c)|:\\ works exactly as the previous function but additionnally returns a pointer to the \verb|void *| data field and the pointer to the deallocation function that had been provided when the library constant was created. Similarly to \verb|sollya_lib_decompose_libraryfunction_with_data|, this function fails on library constants that have been created with \verb|sollya_lib_libraryconstant| or \verb|sollya_lib_build_function_libraryconstant| instead of using the \verb|_with_data| variant of these constructors. \item \verb|int sollya_lib_decompose_externalprocedure(sollya_externalprocedure_type_t *res,|\\ \phantom{\texttt{int sollya\_lib\_decompose\_externalprocedure( }}\verb|sollya_externalprocedure_type_t **args,|\\ \phantom{\texttt{int sollya\_lib\_decompose\_externalprocedure( }}\verb|int *arity, void **f,|\\ \phantom{\texttt{int sollya\_lib\_decompose\_externalprocedure( }}\verb|sollya_obj_t p)|:\\ assume that \verb|p| is an external procedure provided via an external C function \verb|func| (of appropriate type) bound to \sollya by one of the means provided for that purpose. As a result of a call to \verb|sollya_lib_decompose_externalprocedure|, a pointer to \verb|func| is stored at the address pointed to by \verb|f|, the result type of the external procedure is stored at \verb|res|, an array of its argument types is allocated, filled and stored at the address pointed to by \verb|args| (unless the procedure function takes no argument in which case the \verb|args| argument is ignored), the arity of the external procedure (and hence number of elements of the array allocated and stored at \verb|args|) is stored at the integer pointed by \verb|arity| and true is returned. If \verb|p| is no external procedure object, nothing happens and false is returned. \item \verb|int sollya_lib_decompose_externalprocedure_with_data(|\\ \phantom{\texttt{mmmmmmmmmmmmmmmmmmmmmm}}\verb|sollya_externalprocedure_type_t *res,|\\ \phantom{\texttt{mmmmmmmmmmmmmmmmmmmmmm}}\verb|sollya_externalprocedure_type_t **args,|\\ \phantom{\texttt{mmmmmmmmmmmmmmmmmmmmmm}}\verb|int *arity, void **f,|\\ \phantom{\texttt{mmmmmmmmmmmmmmmmmmmmmm}}\verb|void **data, void (**dealloc)(void *),|\\ \phantom{\texttt{mmmmmmmmmmmmmmmmmmmmmm}}\verb|sollya_obj_t p)|:\\ works exactly as the previous function but additionnally returns a pointer to the \verb|void *| data field and the pointer to the deallocation function that had been provided when the external procedure was created. The same remark as with \verb|sollya_lib_decompose_libraryfunction_with_data| and \verb|sollya_lib_decompose_libraryconstant_with_data| also applies: this function fails when used on an external procedure that has been constructed without the \verb|_with_data| variant of the constructor. \end{itemize} \subsection{Faithfully evaluate a functional expression} Let us suppose that \verb|f| is a functional expression and \verb|a| is a numerical value or a constant expression. One of the very convenient features of the interactive tool is that the user can simply write \verb|f(a)| at the prompt: the tool automatically adapts its internal precision in order to compute a value that is a faithful rounding (at the current tool precision) of the true value $f(a)$. Sometimes it does not achieve to find a faithful rounding, but in any case, if the result is not proved to be exact, a warning is displayed explaining how confident one should be with respect to the returned value. The object \verb|a| can also be an interval, in which case \sollya automatically performs the evaluation using an enhanced interval arithmetic, \emph{e.g.}, using L'Hopital's rule to produce finite (yet valid of course) enclosures even in cases when $f$ exhibits removable singularities (for instance $\sin(x)/x$ over an interval containing $0$). This behavior is reproduced in the library with the \verb|sollya_lib_apply| function (this function is in fact to be used to reproduce any construction of the form \verb|obj1(obj2, obj3, ...)| within the library; for instance \verb|obj1| might also be a procedure. See Section~\ref{library_commands_and_functions} for a more detailed description of this function). More precisely if \verb|f| and \verb|a| are two \verb|sollya_obj_t| representing respectively a univariate function and a constant or an interval, the following call returns a new \verb|sollya_obj_t| representing the object that would be produced as a result of typing \verb|f(a);| at the interactive prompt: \begin{center} \verb|b = sollya_lib_apply(f, a, NULL);| \end{center} However, when using the library, it might be interesting to have access to this feature when the argument \verb|a| is not a \sollya object but rather directly a multiprecision constant of type \verb|mpfr_t| or \verb|mpfi_t|. Also, in this case, one may want to have a finer-grain access to the evaluation algorithm, \emph{e.g.}, to correctly react to cases where a faithful rounding has not been achieved without having to catch warning messages emitted by \sollya. This is the reason why the library proposes the following functions. To evaluate a unary function at a constant expression or constant value, the library provides the two following functions: \begin{itemize} \item \verb|sollya_fp_result_t|\\ \verb| sollya_lib_evaluate_function_at_constant_expression(mpfr_t res, sollya_obj_t f,|\\ \verb| sollya_obj_t a,|\\ \verb| mpfr_t *cutoff)|, \item \verb|sollya_fp_result_t|\\ \verb| sollya_lib_evaluate_function_at_point(mpfr_t res, sollya_obj_t f,|\\ \verb| mpfr_t a, mpfr_t *cutoff)|. \end{itemize} In the former, the argument \verb|a| is any \verb|sollya_obj_t| containing a numerical constant or a constant expression, while in the latter \verb|a| is a constant already stored in a \verb|mpfr_t|. These functions store the result in \verb|res| and return a \verb|sollya_fp_result_t| which is an enum type described in Table~\ref{list_of_sollya_fp_result_t}. In order to understand the role of the \verb|cutoff| parameter and the value returned by the function, it is necessary to describe the algorithm in a nutshell:\\~\\ \rule{\textwidth}{0.5px} \begin{enumerate} \item[~]\textbf {Input:} a functional expression \verb|f|, a constant expression \verb|a|, a target precision $q$, a parameter $\varepsilon$. \item Choose an initial working precision $p$. \item Evaluate \verb|a| with interval arithmetic, performing the computations at precision $p$. \item Replace the occurrences of the free variable in \verb|f| by the interval obtained at step 2. Evaluate the resulting expression with interval arithmetic, performing the computations at precision $p$. This yields an interval $I = [x,y]$. \item Examine the following cases successively ($\mathrm{RN}$ denotes rounding to nearest at precision~$q$): \begin{enumerate} \item If $\mathrm{RN}(x) = \mathrm{RN}(y)$, set \verb|res| to that value and return. \item If $I$ does not contain any floating-point number at precision $q$, set \verb|res| to one of both floating-point numbers enclosing $I$ and return. \item If $I$ contains exactly one floating-point number at precision $q$, set \verb|res| to that number and return. \item If all numbers in $I$ are smaller than $\varepsilon$ in absolute value, then set \verb|res| to $0$ and return. \item If $p$ has already been increased many times, then set \verb|res| to some value in $I$ and return. \item Otherwise, increase $p$ and go back to step 2. \end{enumerate} \end{enumerate} \vspace{-0.2cm} \rule{\textwidth}{0.5px}\\[0.7cm] The target precision $q$ is chosen to be the precision of the \verb|mpfr_t| variable \verb|res|. The parameter $\varepsilon$ corresponds to the parameter \verb|cutoff|. The reason why \verb|cutoff| is a pointer is that, most of the time, the user may not want to provide it, and using a pointer makes it possible to pass \verb|NULL| instead. So, if \verb|NULL| is given, $\varepsilon$ is set to $0$. If \verb|cutoff| is not \verb|NULL|, the absolute value of \verb|*cutoff| is used as value for $\varepsilon$. Using a non-zero value for $\varepsilon$ can be useful when one does not care about the precise value of $f(a)$ whenever its absolute value is below a given threshold. Typically, if one wants to compute the maximum of $|f(a_1)|$, \dots, $|f(a_n)|$, it is not necessary to spend too much effort on the computation of $|f(a_i)|$ if one already knows that it is smaller than $\varepsilon = \max \{|f(a_1)|,\dots,|f(a_{i-1})|\}$. \begin{table}[htp] \caption{List of values defined in type \texttt{sollya\_fp\_result\_t}} \label{list_of_sollya_fp_result_t} \renewcommand{\footnoterule}{} % suppress the separation line between main text and footnotes. \begin{minipage}{\textwidth} \hspace{-1cm} \begin{tabular}{|l|p{7cm}|} \multicolumn{1}{c}{~}\\ \hline \hfil\phantom{\Large{$A^A$}}Value\phantom{\Large{$A^A$}}\hfil & \hfil Meaning\hfil \\ \hline \verb|SOLLYA_FP_OBJ_NO_FUNCTION| & \verb|f| is not a functional expression.\phantom{\Large{$A^A$}}\\[0.3cm] \verb|SOLLYA_FP_EXPRESSION_NOT_CONSTANT| & \verb|a| is not a constant expression.\\[0.3cm] \verb|SOLLYA_FP_FAILURE| & The algorithm ended up at step (e) and $I$ contained NaN. This typically happens when $a$ is not in the definition domain of $f$.\\[0.3cm] \verb|SOLLYA_FP_CUTOFF_IS_NAN| & \verb|cutoff| was not \verb|NULL| and the value of \verb|*cutoff| is NaN.\\[0.3cm] \verb|SOLLYA_FP_INFINITY| & The algorithm ended up at step (a) with $I$ of the form $[+\infty, +\infty]$ or $[-\infty, -\infty]$. Hence $f(a)$ is proved to be an exact infinity.\\[0.3cm] \verb|SOLLYA_FP_PROVEN_EXACT| & The algorithm ended up at step (a) with a finite value and $x = \mathrm{RN}(x) = \mathrm{RN}(y)=y$.\\[0.3cm] \verb|SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT| & The algorithm ended up at step (b) with a finite value and $\mathtt{res} < x \le y$ or $x \le y < \mathtt{res}$.\\[0.3cm] \verb|SOLLYA_FP_CORRECTLY_ROUNDED| & The algorithm ended up at step (a) with a finite value and $x \le \mathtt{res} \le y$.$~^a$\footnotetext[1]{Please notice that this means that the algorithm did not manage to conclude whether the result is exact or not. However, it might have been able to conclude if the working precision had been increased.}\\[0.3cm] \verb|SOLLYA_FP_FAITHFUL_PROVEN_INEXACT| & The algorithm ended up at step (b) with a finite value and $\mathtt{res} < x \le y$ or $x \le y < \mathtt{res}$.\\[0.3cm] \verb|SOLLYA_FP_FAITHFUL| & The algorithm ended up at step (c) with a finite value.$~^a$\\[0.3cm] \verb|SOLLYA_FP_BELOW_CUTOFF| & The algorithm ended up at step (d).\\[0.3cm] \verb|SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD| & The algorithm ended up at step (e) and $I$ was of the form $[-\delta_1,\,\delta_2]$ where $0 < \delta_i \ll 1$ (below some threshold of the algorithm). This typically happens when $f(a)$ exactly equals zero, but the algorithm does not manage to prove this exact equality.\\[0.3cm] \verb|SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_NOT_BELOW_THRESHOLD| & The algorithm ended up at step (e) with an interval $I$ containing $0$ but too large to fall in the above case.$~^b$\footnotetext[2]{In general, this should be considered as a case of failure and the value stored in \texttt{res} might be completely irrelevant.}\\[0.3cm] \verb|SOLLYA_FP_NOT_FAITHFUL_ZERO_NOT_CONTAINED| & The algorithm ended up at step (e) with an interval $I$ that does not contain $0$.$~^b$\\[0.3cm] \verb|SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED| & The algorithm ended up at step (e) and (at least) one of the bounds of $I$ was infinite. This typically happens when the limit of $f(x)$ when $x$ goes to $a$ is infinite.\\[0.3cm] \hline \end{tabular} \end{minipage} \end{table} To evaluate a unary function on an interval, the following function is provided: \begin{center} \verb|int sollya_lib_evaluate_function_over_interval(mpfi_t res, sollya_obj_t f, mpfi_t a).| \end{center} This function returns a boolean integer: false means failure (\emph{i.e.}, \verb|f| is not a functional expression), in which case \verb|res| is left unchanged, and true means success, in which case \verb|res| contains the result of the evaluation. The function might succeed, and yet \verb|res| might contain something useless such as an unbounded interval or even $[\textrm{NaN},\textrm{NaN}]$ (this happens for instance when \verb|a| contains points that lie in the interior of the complement of the definition domain of \verb|f|). It is the user's responsibility to check afterwards whether the computed interval is bounded, unbounded or NaN. \subsection{Comparing objects structurally and computing hashes on \sollya objects} The library provides function \begin{center} \verb|int sollya_lib_cmp_objs_structurally(sollya_obj_t obj1, sollya_obj_t obj2)| \end{center} to allow the user to perform a structural comparison of any two \sollya objects. It returns an integer (interpreted as a boolean) that is true if and only if \verb|obj1| and \verb|obj2| are syntactically the same (as opposed to mathematically). For instance the fractions $2/3$ and $4/6$ are recognized as mathematically equal by \sollya when compared with \key{==} (or \verb|sollya_lib_cmp_equal| with the library) but are syntactically different. Certain language bindings require hashes to be available for any object represented. In order to help with such language bindings, the \sollya library supports a function that computes a $64$ bit unsigned integer as a hash for a given \sollya object: \begin{center} \verb|uint64_t sollya_lib_hash(sollya_obj_t obj).| \end{center} The \sollya library guarantees that any two objects that are syntactically equal (as when compared with \verb|sollya_lib_cmp_objs_structurally|) will have the same hash value. For some particular objects (\emph{e.g.}, polynomials) \sollya can normalize the expression before computing the hash value and in this case two objects that are mathematically equal (even though they are not structurally equal) will have the same hash value. However, except in such particular cases, two objects that are syntactically different are likely to have different hashes (although this is not guaranteed, of course). Computing the hash of an object takes a time proportional to the size of the directed acyclic graph internally used to represent that object. However, \sollya will cache an object's hash value for further use after it has been computed, so the cost of computing the hash of a given object is paid only once. The user should also be aware that the hash value for a given object is currently not guaranteed to be portable between platforms nor over consecutive \sollya versions. \subsection{Executing \sollya procedures} Objects representing procedures written in \sollya language (see also Section~\ref{procedures}) can be created using the \sollya library functions \verb|sollya_lib_parse_string| and \verb|sollya_lib_parse| or through execution of a \sollya script using \verb|sollya_lib_execute|. In order to execute such procedure objects on arguments, available as \sollya objects, too, the functions \begin{itemize} \item \verb|sollya_obj_t sollya_lib_execute_procedure(sollya_obj_t proc, ...)| and \item \verb|sollya_obj_t sollya_lib_v_execute_procedure(sollya_obj_t proc, va_list arglist)| \end{itemize} may be used. These functions apply the given procedure \verb|proc| on the following arguments (or the elements in the argument list \verb|arglist|). If no argument is needed to execute the procedure, the variadic argument list shall immediately be terminated using \verb|NULL|; otherwise the argument list shall be terminated with an extra \verb|NULL| argument. An arity test is performed by \sollya before the procedure is executed: if the arity of the given procedure does not correspond to the actual number of given arguments (and the \sollya procedure is not variadic), an error object is returned instead of the procedure's result. When the functions are used to execute procedures that return a \sollya object, the object is returned by the function. When the procedure does not use the \sollya \verb|return| statement or returns the \sollya \verb|void| object, a \sollya \verb|void| object is returned. The user should not forget to deallocate that \verb|void| object. \subsection{Name of the free variable} The default name for the free variable is the same in the library and in the interactive tool: it is \texttt{\_x\_}. In the interactive tool, this name is automatically changed at the first use of an undefined symbol. Accordingly in library mode, if an object is defined by \texttt{sollya\_lib\_parse\_string} with an expression containing an undefined symbol, that symbol will become the free variable name if it has not already been changed before. But what if one does not use \texttt{sollya\_lib\_parse\_string} (because it is not efficient) but one wants to change the name of the free variable? The name can be changed with \texttt{sollya\_lib\_name\_free\_variable("some\_name")}. It is possible to get the current name of the free variable with \texttt{sollya\_lib\_get\_free\_variable\_name()}. This function returns a \texttt{char *} containing the current name of the free variable. Please note that this \texttt{char *} is dynamically allocated on the heap and should be cleared after its use with \texttt{sollya\_lib\_free()} (see below). \subsection{Commands and functions} \label{library_commands_and_functions} Besides some exceptions, every command and every function available in the \sollya interactive tool has its equivalent (with a very close syntax) in the library. Section~\ref{commandsAndFunctions} of the present documentation gives the library syntax as well as the interactive tool syntax of each commands and functions. The same information is available within the interactive tool by typing \texttt{help some\_command}. So if one knows the name of a command or function in the interactive tool, it is easy to recover its library name and signature. There are some commands and functions available in interactive mode which, for syntactical reasons, have a different function name in the \sollya library: \begin{itemize} \item The \sollya language construction \texttt{(obj1)(obj2, obj3, ...)} which applies the object \texttt{obj1} to the objects \texttt{obj2}, \texttt{obj3}, etc. is expressed in the \sollya library through a call to\\ \texttt{sollya\_obj\_t sollya\_lib\_apply(sollya\_obj\_t obj1, sollya\_obj\_t obj2, ...)}\\ resp. \texttt{sollya\_obj\_t sollya\_lib\_v\_apply(sollya\_obj\_t obj1, sollya\_obj\_t obj2, va\_list)}. \end{itemize} A particular point is worth mentioning: some functions of the tool such as \texttt{remez} for instance have a variable number of arguments. For instance, one might call \texttt{remez(exp(x), 4, [0,1])} or \texttt{remez(1, 4, [0,1], 1/exp(x))}. This feature is rendered in the C library by the use of variadic functions (functions with an arbitrary number of arguments), as they are permitted by the C standard. The notable difference is that there must \textbf{always be an explicit NULL argument} at the end of the function call. Hence one can write \texttt{sollya\_lib\_remez(a, b, c, NULL)} or \texttt{sollya\_lib\_remez(a, b, c, d, NULL)}. It is very easy to forget the \texttt{NULL} argument and to use for instance \texttt{sollya\_lib\_remez(a, b, c)}. This is \textbf{completely wrong} because the memory will be read until a \texttt{NULL} pointer is found. In the best case, this will lead to an error or a result obviously wrong, but it could also lead to subtle, not-easy-to-debug errors. The user is advised to be particularly careful with respect to this point. Each command or function accepting a variable number of arguments comes in a \texttt{sollya\_lib\_v\_} version accepting a \texttt{va\_list} parameter containing the list of optional arguments. For instance, one might write a function that takes as arguments a function $f$, an interval $I$, optionally a weight function $w$, optionally a quality parameter $q$. That function would display the minimax obtained when approximating $f$ over $I$ (possibly with weight $w$ and quality $q$) by polynomials of degree $n=2$ to $20$. So, that function would get a variable number of arguments (\emph{i.e.}, a \texttt{va\_list} in fact) and pass them straight to remez. In that case, one needs to use the \texttt{v\_remez} version, as the following code shows: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] #include #include /* Note: we suppose that the library has already been initialized */ void my_function(sollya_obj_t f, sollya_obj_t I, ...) { sollya_obj_t n, res; int i; va_list va; for(i=2;i<=20;i++) { n = SOLLYA_CONST(i); va_start(va, I); res = sollya_lib_v_remez(f, n, I, va); sollya_lib_printf("Approximation of degree %b is %b\n", n, res); va_end(va); sollya_lib_clear_obj(n); sollya_lib_clear_obj(res); } return; } \end{Verbatim} \end{minipage}\end{center} \subsection{Warning messages in library mode} \label{callbacks} \subsubsection{Catching warning messages} The philosophy of \sollya is ``whenever something is not exact, explicitly warn about that''. This is a nice feature since this ensures that the user always perfectly knows the degree of confidence they can have in a result (is it exact? or only faithful? or even purely numerical, without any warranty?) However, it is sometimes desirable to hide some (or all) of these messages. This is especially true in library mode where messages coming from \sollya are intermingled with the messages of the main program. The library hence provides a specific mechanism to catch all messages emitted by the \sollya core and handle each of them specifically: installation of a callback for messages. Before describing the principle of the message callback, it seems appropriate to recall that several mechanisms are available in the interactive tool to filter the messages emitted by \sollya. These mechanisms are also available in library mode for completeness. When a message is emitted, it has two characteristics: a verbosity level and an id (a number uniquely identifying the message). After it has been emitted, it passes through the following steps where it can be filtered. If it has not been filtered (and only in this case) it is displayed. \begin{enumerate} \item If the verbosity level of the message is greater than the value of the environment variable \verb|verbosity|, it is filtered. \item If the environment variable \verb|roundingwarnings| is set to \verb|off| and if the message informs the user that a rounding occurred, it is filtered. \item If the id of the message has been registered with the \verb|suppressmessage| command, the message is filtered. \item If a message callback has been installed and if the message has not been previously filtered, it is handled by the callback, which decides to filter it or to permit its displaying. \end{enumerate} A message callback is a function of the form \verb|int my_callback(sollya_msg_t msg, void *data)|. It receives as input an object representing the message and a user-defined pointer. It performs whatever treatment seems appropriate and returns an integer interpreted as a boolean. If the returned value is false, the message is not displayed. If, on the contrary, the returned value is true, the message is displayed as usual. By default, no callback is installed and all messages are displayed. To install a callback, use \verb|sollya_lib_install_msg_callback(my_callback, data)|. The \verb|(void *)| pointer \verb|data| is arbitrary (it can be \verb|NULL|) and is simply transmitted as second argument at each call of the callback. It can be used, \emph{e.g.}, to point to a segment of memory where some information should be stored from a call of the callback to another. Please remember that, if a message is filtered because of one of the three other mechanisms, it will never be transmitted to the callback. Hence, in library mode, if one wants to catch every single message through the callback, one should set the value of \verb|verbosity| to \verb|MAX_INT|, set \verb|roundingwarnings| to \verb|on| (this is the default anyway) and one should not use the \verb|suppressmessage| mechanism. It is possible to come back to the default behavior, using \verb|sollya_lib_uninstall_msg_callback()|. Please notice that callbacks do not stack over each other: \emph{i.e.}, if some callback \verb|callback1| is installed, and if one installs another one \verb|callback2|, then the effect of \verb|sollya_lib_uninstall_msg_callback()| is to come back to the default behavior, \textbf{and not} to come back to callback \verb|callback1|. Both \verb|sollya_lib_install_msg_callback| and \verb|sollya_lib_uninstall_msg_callback| return an integer interpreted as a boolean: false means failure and true means success. It is possible to get the current callback using \verb|sollya_lib_get_msg_callback(cb_ptr, data_ptr)|. This stores the current callback at the address referred to by \verb|cb_ptr| (the type of \verb|cb_ptr| is hence \verb|int (**)(sollya_msg_t, void *)|) and stores the current data pointer at the address referred to by \verb|data_ptr| (which has hence \verb|(void **)| type). The arguments \verb|cb_ptr| and \verb|data_ptr| can be \verb|NULL| in which case the corresponding argument is not retrieved (please take care of the difference between \verb|data_ptr| being \verb|NULL| and \verb|data_ptr| pointing to a \verb|(void *)| pointer which value is \verb|NULL|). If no callback is currently installed, the \verb|NULL| value is stored at the addresses referred to by \verb|cb_ptr| and \verb|data_ptr|. The type \verb|sollya_msg_t| is indeed a pointer and its content is only accessible during the callback call: it does not make sense to keep it for further use after the callback call. Currently the type has only two accessors: \begin{itemize} \item \verb|int sollya_lib_get_msg_id(sollya_msg_t msg)| returns an integer that identifies the type of the message. The message types are listed in the file \verb|sollya-messages.h|. Please note that this file not only lists the possible identifiers but also defines meaningful names to each possible message number (\emph{e.g.}, \verb|SOLLYA_MSG_UNDEFINED_ERROR| is an alias for the number $2$ but is more meaningful to understand what the message is about). It is recommended to use these names instead of numerical values. \item \verb|char *sollya_lib_msg_to_text(sollya_msg_t msg)| returns a generic string briefly summarizing the contents of the message. Please note that this \verb|char *| is dynamically allocated on the heap and should manually be cleared with \verb|sollya_lib_free| when it becomes useless. \end{itemize} In the future, other accessors could be added (to get the verbosity level at which the message has been emitted, to get data associated with the message, etc.) The developers of \sollya are open to suggestions and feature requests on this subject. As an illustration let us give a few examples of possible use of callbacks: \paragraph{Example 1:} A callback that filters everything. \begin{center} \begin{minipage}{15cm}\begin{Verbatim}[frame=single] int hide_everything(sollya_msg_t msg, void *data) { return 0; } \end{Verbatim} \end{minipage}\end{center} \paragraph{Example 2:} filter everything but the messages indicating that a comparison is uncertain. \begin{center} \begin{minipage}{15cm}\begin{Verbatim}[frame=single] int keep_comparison_warnings(sollya_msg_t msg, void *data) { switch(sollya_lib_get_msg_id(msg)) { case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT: case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL: return 1; default: return 0; } } \end{Verbatim} \end{minipage}\end{center} \paragraph{Example 3:} ensuring perfect silence for a particular function call (uses the callback defined in Example~1). \begin{center} \begin{minipage}{15cm}\begin{Verbatim}[frame=single] ... int (*old_callback)(sollya_msg_t, void *); void *old_data; sollya_lib_get_msg_callback(&old_callback, &old_data); sollya_lib_install_msg_callback(hide_everything, NULL); /* Here takes place the function call that must be completely silent */ if (old_callback) sollya_lib_install_msg_callback(old_callback, old_data); ... \end{Verbatim} \end{minipage}\end{center} \paragraph{Example 4:} using the \verb|(void *)| data argument to store information from a call to another. \begin{center} \begin{minipage}{15cm}\begin{Verbatim}[frame=single] int set_flag_on_problem(sollya_msg_t msg, void *data) { switch(sollya_lib_get_msg_id(msg)) { case SOLLYA_MSG_DOUBLE_ROUNDING_ON_CONVERSION: *((int *)(data)) = 1; } return 1; } ... int main() { int flag_double_rounding = 0; ... sollya_lib_init(); sollya_lib_install_msg_callback(set_flag_on_problem, &flag_double_rounding); ... } \end{Verbatim} \end{minipage}\end{center} More involved examples are possible: for instance, instead of setting a flag, it is possible to keep in some variable what the last message was. One may even implement a stack mechanism and store the messages in a stack, in order to handle them later. (Please remember however that \verb|sollya_msg_t| is a pointer type and that the \verb|sollya_msg_t| object received as argument of a callback call has no more meaning once the callback call returned. If a stack mechanism is implemented it should store information such as the message ID, or the message text, as given by \verb|sollya_lib_get_msg_id| and \verb|sollya_lib_msg_to_text|, but not the \verb|sollya_msg_t| object itself.) \subsubsection{Emitting warning messages} The \sollya library offers a way to print a message, as if it were produced by the \sollya core. Such a message will go through the entire process described in the previous section, and can eventually provoke a callback call if a callback is installed. The function supporting this feature is \begin{center} \verb|void sollya_lib_printlibrarymessage(int verb, const char *str)|. \end{center} The first argument \verb|verb| is the least verbosity level at which that warning shall be displayed. The second argument \verb|str| is the message to be displayed. When a message is produced with this function, its message~ID (when caught by a callback) is \verb|SOLLYA_MSG_GENERIC_SOLLYA_LIBRARY_MSG|. An important notice is that the character string returned by \verb|sollya_lib_msg_to_text| when such a message is caught by a callback \textbf{is currently not} the argument \verb|str| provided to \verb|sollya_lib_printlibrarymessage|, but is instead a generic message. This behavior might change in the future. \subsection{Using \sollya in a program that has its own allocation functions} \label{customMemoryFunctions} \sollya uses its own allocation functions: as a consequence, pointers that have been allocated by \sollya functions must be freed using \verb|sollya_lib_free| instead of the usual \verb|free| function. Another consequence is that \sollya registers its own allocation functions to the \verb|GMP| library, using the mechanism provided by \verb|GMP|, so that \verb|GMP| also uses \sollya allocation functions behind the scene, when the user performs a call to, \emph{e.g.}, \verb|mpz_init|, \verb|mpfr_init2|, etc. In general, this is completely harmless and the user might even not notice it. However, this is a problem if \sollya is used in a program that also uses its own allocation functions and that has already registered these functions to \verb|GMP|. Actually: \begin{itemize} \item If the main program has already registered allocation functions to \verb|GMP| and if \sollya is naively initialized with \verb|sollya_lib_init()|, \sollya will register its own allocation functions, thus overriding the previously registered functions. \item If the user initializes first \sollya, and then registers its own allocation functions to \verb|GMP|, the exact opposite happens: \sollya allocation functions are overridden by those of the user, and this will likely cause \sollya to crash (or worst, silently behave not reliably). \end{itemize} In order to solve this issue, \sollya provides a chaining mechanism that we are now going to describe. The idea is the following: suppose that the main program should use a function \verb|custom_malloc|. The user should not use \verb|mp_set_memory_functions| as usual, but should instead initialize \sollya with the initializing function described above. This will cause \sollya to register an allocation function \verb|sollya_lib_malloc| to \verb|GMP|. This function overloads \verb|custom_malloc|: when called, it uses \verb|custom_malloc| to perform the actual allocation and does nothing else but some internal accounting and verification for that allocation. To repeat, the actual allocation is done by \verb|custom_malloc|; hence from the point of view of the user, the mechanism is completely transparent and equivalent to directly registering \verb|custom_malloc| to \verb|GMP|. The same holds for all other allocation functions: in particular, this is true for \verb|free| as well: if a function \verb|custom_free| is given at the initialization of \sollya, then the function \verb|sollya_lib_free| eventually uses \verb|custom_free| to free the memory. The initialization function providing this mechanism is: \begin{center} \verb|int sollya_lib_init_with_custom_memory_functions( |\\ \verb| void *(*custom_malloc)(size_t), |\\ \verb| void *(*custom_calloc)(size_t, size_t), |\\ \verb| void *(*custom_realloc)(void *, size_t), |\\ \verb| void (*custom_free)(void *), |\\ \verb| void *(*custom_realloc_with_size)(void *, size_t, size_t),|\\ \verb| void (*custom_free_with_size)(void *, size_t)). | \end{center} None of the arguments is mandatory: if the user does not want to provide an argument, they may use \verb|NULL| as a placeholder for that argument. In that case, the corresponding \sollya default function will be used. Indeed, the default initializing function \verb|sollya_lib_init()| is just an alias to \verb|sollya_lib_init_with_custom_memory_functions(NULL, NULL, NULL, NULL, NULL, NULL)|. Please notice, that if \verb|custom_malloc| is provided, then the function \verb|sollya_lib_malloc| will be defined as an overloaded version of \verb|custom_malloc|. Hence, \verb|custom_malloc| will eventually be used for all the allocations performed by \sollya (including the allocation of memory for its own purpose). This is true also for \verb|custom_calloc|, \verb|custom_realloc| and \verb|custom_free|. However, this is not the case for \verb|custom_realloc_with_size| and \verb|custom_free_with_size|: these functions are only required for the registration to \verb|GMP| and are not used by \sollya itself (except of course when \sollya allocates function through a call to a \verb|GMP|, \verb|MPFR| or \verb|MPFI| function). Thus, to sum up: \begin{itemize} \item If the user only wants to register their own functions to \verb|GMP| through \sollya, they only need to provide \verb|custom_malloc|, \verb|custom_realloc_with_size| and \verb|custom_free_with_size| at the initialization of \sollya (actually an overloaded version will be registered to \verb|GMP| but this is transparent for the user, as explained above). \item If the user also wants \sollya to use their custom allocation functions for all allocations of memory by \sollya, then they also need to provide \verb|custom_calloc|, \verb|custom_realloc| and \verb|custom_free|. \end{itemize} Of course, even if the user registers \verb|custom_malloc|, \verb|custom_free|, etc., at the initialization of \sollya, they stay free to use them for their own allocation needs: only allocations performed by \verb|GMP| (and consequently \verb|MPFR| and \verb|MPFI|) and allocations performed by \sollya have to use the chaining mechanism. However, for the convenience of the user, the library also provides access to the allocation functions of \sollya. They are the following: \begin{itemize} \item \verb|void sollya_lib_free(void *)| \item \verb|void *sollya_lib_malloc(size_t)| \item \verb|void *sollya_lib_calloc(size_t, size_t)| \item \verb|void *sollya_lib_realloc(void *, size_t)|. \end{itemize} No access to the overloaded version of \verb|custom_realloc_with_size| and \verb|custom_free_with_size| is provided, but if the user really wants to retrieve them, they can do it with \verb|mp_get_memory_functions| since they are registered to \verb|GMP|. \end{document} sollya-6.0+ds/doc/sort.tex000066400000000000000000000017131300174114700155420ustar00rootroot00000000000000\subsection{sort} \label{labsort} \noindent Name: \textbf{sort}\\ \phantom{aaa}sorts a list of real numbers.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_sort(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{sort}(\emph{L}) : \textsf{list} $\rightarrow$ \textsf{list}\\ \end{center} Parameters: \begin{itemize} \item \emph{L} is a list. \end{itemize} \noindent Description: \begin{itemize} \item If \emph{L} contains only constant values, \textbf{sort}(\emph{L}) returns the same list, but sorted in increasing order. \item If \emph{L} contains at least one element that is not a constant, the command fails with a type error. \item If \emph{L} is an end-elliptic list, \textbf{sort} will fail with an error. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > sort([| |]); [| |] > sort([|2,3,5,2,1,4|]); [|1, 2, 2, 3, 4, 5|] \end{Verbatim} \end{minipage}\end{center} sollya-6.0+ds/doc/sqrt.tex000066400000000000000000000011001300174114700155320ustar00rootroot00000000000000\subsection{sqrt} \label{labsqrt} \noindent Name: \textbf{sqrt}\\ \phantom{aaa}square root.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_sqrt(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_sqrt(sollya_obj_t)|\\ \verb| #define SOLLYA_SQRT(x) sollya_lib_build_function_sqrt(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{sqrt} is the square root, e.g. the inverse of the function square: $\sqrt{y}$ is the unique positive $x$ such that $x^2=y$. \item It is defined only for $x$ in $[0;+\infty]$. \end{itemize} sollya-6.0+ds/doc/string.tex000066400000000000000000000017661300174114700160710ustar00rootroot00000000000000\subsection{string} \label{labstring} \noindent Name: \textbf{string}\\ \phantom{aaa}keyword representing a \textsf{string} type \\[0.2cm] \noindent Library name:\\ \verb| SOLLYA_EXTERNALPROC_TYPE_STRING|\\[0.2cm] \noindent Usage: \begin{center} \textbf{string} : \textsf{type type}\\ \end{center} \noindent Description: \begin{itemize} \item \textbf{string} represents the \textsf{string} type for declarations of external procedures by means of \textbf{externalproc}. Remark that in contrast to other indicators, type indicators like \textbf{string} cannot be handled outside the \textbf{externalproc} context. In particular, they cannot be assigned to variables. \end{itemize} See also: \textbf{externalproc} (\ref{labexternalproc}), \textbf{boolean} (\ref{labboolean}), \textbf{constant} (\ref{labconstant}), \textbf{function} (\ref{labfunction}), \textbf{integer} (\ref{labinteger}), \textbf{list of} (\ref{lablistof}), \textbf{range} (\ref{labrange}), \textbf{object} (\ref{labobject}) sollya-6.0+ds/doc/subpoly.tex000066400000000000000000000050361300174114700162520ustar00rootroot00000000000000\subsection{subpoly} \label{labsubpoly} \noindent Name: \textbf{subpoly}\\ \phantom{aaa}restricts the monomial basis of a polynomial to a list of monomials\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_subpoly(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{subpoly}(\emph{polynomial}, \emph{list}) : (\textsf{function}, \textsf{list}) $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{polynomial} represents the polynomial the coefficients are taken from \item \emph{list} represents the list of monomials to be taken \end{itemize} \noindent Description: \begin{itemize} \item \textbf{subpoly} extracts the coefficients of a polynomial \emph{polynomial} and builds up a new polynomial out of those coefficients associated to monomial degrees figuring in the list \emph{list}. If \emph{polynomial} represents a function that is not a polynomial, subpoly returns 0. If \emph{list} is a list that is end-elliptic, let be $j$ the last value explicitly specified in the list. All coefficients of the polynomial associated to monomials greater or equal to $j$ are taken. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p = taylor(exp(x),5,0); > s = subpoly(p,[|1,3,5|]); > print(p); 1 + x * (1 + x * (0.5 + x * (1 / 6 + x * (1 / 24 + x / 120)))) > print(s); x * (1 + x^2 * (1 / 6 + x^2 / 120)) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p = remez(atan(x),10,[-1,1]); > subpoly(p,[|1,3,5...|]); x * (0.99986632941452949026018468446163586361700915018232 + x^2 * (-0.3303047850 2455936362667794059988443130926433421739 + x^2 * (0.1801592931781875646289423703 7824735129130095574422 + x * (2.284558411542478828511250156535857664242985696307 2e-9 + x * (-8.5156349064111377895500552996061844977507560037485e-2 + x * (-2.71 7563409627750199168187692393409435243830189218e-9 + x * (2.084511343071147293732 39910549169872454686955895e-2 + x * 1.108898611811290576571996643868266300817934 00489512e-9))))))) \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > subpoly(exp(x),[|1,2,3|]); 0 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{taylor} (\ref{labtaylor}), \textbf{remez} (\ref{labremez}), \textbf{fpminimax} (\ref{labfpminimax}), \textbf{implementpoly} (\ref{labimplementpoly}) sollya-6.0+ds/doc/substitute.tex000066400000000000000000000036411300174114700167700ustar00rootroot00000000000000\subsection{substitute} \label{labsubstitute} \noindent Name: \textbf{substitute}\\ \phantom{aaa}replace the occurrences of the free variable in an expression.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_substitute(sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{substitute}(\emph{f},\emph{g}) : (\textsf{function}, \textsf{function}) $\rightarrow$ \textsf{function}\\ \textbf{substitute}(\emph{f},\emph{t}) : (\textsf{function}, \textsf{constant}) $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is a function. \item \emph{g} is a function. \item \emph{t} is a real number. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{substitute}(\emph{f}, \emph{g}) produces the function $(f \circ g) : x \mapsto f(g(x))$. \item \textbf{substitute}(\emph{f}, \emph{t}) is the constant $f(t)$. Note that the constant is represented by its expression until it has been evaluated (exactly the same way as if you type the expression \emph{f} replacing instances of the free variable by \emph{t}). \item If \emph{f} is stored in a variable \emph{F}, the effect of the commands \textbf{substitute}(\emph{F},\emph{g}) or \textbf{substitute}(\emph{F},\emph{t}) is absolutely equivalent to writing \emph{F(g)} resp. \emph{F(t)}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f=sin(x); > g=cos(x); > substitute(f,g); sin(cos(x)) > f(g); sin(cos(x)) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > a=1; > f=sin(x); > substitute(f,a); 0.84147098480789650665250232163029899962256306079837 > f(a); 0.84147098480789650665250232163029899962256306079837 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{evaluate} (\ref{labevaluate}), \textbf{composepolynomials} (\ref{labcomposepolynomials}) sollya-6.0+ds/doc/sup.tex000066400000000000000000000026041300174114700153620ustar00rootroot00000000000000\subsection{sup} \label{labsup} \noindent Name: \textbf{sup}\\ \phantom{aaa}gives the upper bound of an interval.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_sup(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{sup}(\emph{I}) : \textsf{range} $\rightarrow$ \textsf{constant}\\ \textbf{sup}(\emph{x}) : \textsf{constant} $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{I} is an interval. \item \emph{x} is a real number. \end{itemize} \noindent Description: \begin{itemize} \item Returns the upper bound of the interval \emph{I}. Each bound of an interval has its own precision, so this command is exact, even if the current precision is too small to represent the bound. \item When called on a real number \emph{x}, \textbf{sup} behaves like the identity. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > sup([1;3]); 3 > sup(5); 5 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > display=binary!; > I=[0; 0.111110000011111_2]; > sup(I); 1.11110000011111_2 * 2^(-1) > prec=12!; > sup(I); 1.11110000011111_2 * 2^(-1) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{inf} (\ref{labinf}), \textbf{mid} (\ref{labmid}), \textbf{max} (\ref{labmax}), \textbf{min} (\ref{labmin}) sollya-6.0+ds/doc/supnorm.tex000066400000000000000000000123301300174114700162530ustar00rootroot00000000000000\subsection{supnorm} \label{labsupnorm} \noindent Name: \textbf{supnorm}\\ \phantom{aaa}computes an interval bounding the supremum norm of an approximation error (absolute or relative) between a given polynomial and a function.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_supnorm(sollya_obj_t, sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{supnorm}(\emph{p}, \emph{f}, \emph{I}, \emph{errorType}, \emph{accuracy}) : (\textsf{function}, \textsf{function}, \textsf{range}, \textsf{absolute$|$relative}, \textsf{constant}) $\rightarrow$ \textsf{range}\\ \end{center} Parameters: \begin{itemize} \item \emph{p} is a polynomial. \item \emph{f} is a function. \item \emph{I} is an interval. \item \emph{errorType} is the type of error to be considered: \textbf{absolute} or \textbf{relative} (see details below). \item \emph{accuracy} is a constant that controls the relative tightness of the interval returned. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{supnorm}(\emph{p}, \emph{f}, \emph{I}, \emph{errorType}, \emph{accuracy}) tries to compute an interval bound $r = [\ell,\,u]$ for the supremum norm of the error function $\varepsilon_{\textrm{absolute}}=p-f$ (when \emph{errorType} evaluates to \textbf{absolute}) or $\varepsilon_{\textrm{relative}}=p/f-1$ (when \emph{errorType} evaluates to \textbf{relative}), over the interval $I$, such that $\sup_{x \in I} \{|\varepsilon(x)|\}\subseteq r$ and $0 \le \left \vert\frac{u}{\ell} - 1 \right \vert \le$ \emph{accuracy}. If \textbf{supnorm} succeeds in computing a suitable interval $r$, which it returns, that interval is guaranteed to contain the supremum norm value and to satisfy the required quality. Otherwise, \textbf{supnorm} evaluates to \textbf{error}, displaying a corresponding error message. These failure cases are rare and basically happen only for functions which are too complicated. \item Roughly speaking, \textbf{supnorm} is based on \textbf{taylorform} to obtain a higher degree polynomial approximation for \emph{f}. This process is coupled with an a posteriori validation of a potential supremum norm upper bound. The validation is based on showing a certain polynomial the problem gets reduced to does not vanish. In cases when this process alone does not succeed, for instance because \textbf{taylorform} is unable to compute a sufficiently good approximation to \emph{f}, \textbf{supnorm} falls back to bisecting the working interval until safe supremum norm bounds can be computed with the required accuracy or until the width of the subintervals becomes less than \textbf{diam} times the original interval \emph{I}, in which case \textbf{supnorm} fails. \item The algorithm used for \textbf{supnorm} is quite complex, which makes it impossible to explain it here in further detail. Please find a complete description in the following article:\\ ~\\ Sylvain Chevillard, John Harrison, Mioara Joldes, Christoph Lauter\\ Efficient and accurate computation of upper bounds of approximation errors\\ Journal of Theoretical Computer Science (TCS), 2010\\ LIP Research Report number RR LIP2010-2\\ http://prunel.ccsd.cnrs.fr/ensl-00445343/fr/\\ \item In practical cases, \textbf{supnorm} should be able to automatically handle removable discontinuities that relative errors might have. This means that usually, if \emph{f} vanishes at a point $x_0$ in the interval considered, the approximation polynomial \emph{p} is designed such that it also vanishes at the same point with a multiplicity large enough. Hence, although \emph{f} vanishes, $\varepsilon_{\textrm{relative}}=p/f-1$ may be defined by continuous extension at such points $x_0$, called removable discontinuities (see Example~$3$). \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > p = remez(exp(x), 5, [-1;1]); > midpointmode=on!; > supnorm(p, exp(x), [-1;1], absolute, 2^(-40)); 0.45205513967~0/2~e-4 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > prec=200!; > midpointmode=on!; > d = [1;2]; > f = exp(cos(x)^2 + 1); > p = remez(1,15,d,1/f,1e-40); > theta=1b-60; > prec=default!; > mode=relative; > supnorm(p,f,d,mode,theta); 0.30893006200251428~5/6~e-13 \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > midpointmode=on!; > mode=relative; > theta=1b-135; > d = [-1b-2;1b-2]; > f = expm1(x); > p = x * (1 + x * ( 2097145 * 2^(-22) + x * ( 349527 * 2^(-21) + x * (87609 * 2^(-21) + x * 4369 * 2^(-19))))); > theta=1b-40; > supnorm(p,f,d,mode,theta); 0.98349131972~2/3~e-7 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{dirtyinfnorm} (\ref{labdirtyinfnorm}), \textbf{infnorm} (\ref{labinfnorm}), \textbf{checkinfnorm} (\ref{labcheckinfnorm}), \textbf{absolute} (\ref{lababsolute}), \textbf{relative} (\ref{labrelative}), \textbf{taylorform} (\ref{labtaylorform}), \textbf{autodiff} (\ref{labautodiff}), \textbf{numberroots} (\ref{labnumberroots}), \textbf{diam} (\ref{labdiam}) sollya-6.0+ds/doc/suppressmessage.tex000066400000000000000000000114001300174114700177760ustar00rootroot00000000000000\subsection{suppressmessage} \label{labsuppressmessage} \noindent Name: \textbf{suppressmessage}\\ \phantom{aaa}suppresses the displaying of messages with a certain number\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_suppressmessage(sollya_obj_t, ...);|\\ \verb| void sollya_lib_v_suppressmessage(sollya_obj_t, va_list);|\\[0.2cm] \noindent Usage: \begin{center} \textbf{suppressmessage}(\emph{msg num 1}, ..., \emph{msg num n}) : (\textsf{integer}, ..., \textsf{integer}) $\rightarrow$ \textsf{void}\\ \textbf{suppressmessage}(\emph{msg list}) : \textsf{list} $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{msg num 1} thru \emph{msg num n} represent the numbers of $n$ messages to be suppressed \item \emph{msg list} represents a list with numbers of messages to be suppressed \end{itemize} \noindent Description: \begin{itemize} \item The \textbf{suppressmessage} command allows particular warning and information messages to be suppressed from message output, while maintaining global verbosity levels (see \textbf{verbosity}) high. Every \sollya warning or information message (that is not fatal to the tool's execution) has a message number. When these message numbers \emph{msg num 1} thru \emph{msg num n} are given to \textbf{suppressmessage}, the corresponding message are no longer displayed. The \textbf{unsuppressmessage} command reverts this suppression from output for a particular message. \item Instead of giving \textbf{suppressmessage} several message numbers \emph{msg num 1} thru \emph{msg num n} or calling \textbf{suppressmessage} several times, it is possible to give a whole list \emph{msg list} of message numbers to \textbf{suppressmessage}. \item The user should be aware that \textbf{suppressmessage} presents sticky behavior for the warning and information messages suppressed from output. This means that even if subsequent calls to \textbf{suppressmessage} occur, a message suppressed by a call to \textbf{suppressmessage} stays suppressed until it is unsuppressed using \textbf{unsuppressmessage} or the tool is restarted. This behavior distinguishes message suppression from other global states of the \sollya tool. The user may use \textbf{getsuppressedmessages} to obtain a list of currently suppressed messages. \item When \textbf{suppressmessage} is used on message numbers that do not exist in the current version of the tool, a warning is displayed. The call has no other effect though. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1; The verbosity level has been set to 1. > 0.1; Warning: Rounding occurred when converting the constant "0.1" to floating-point with 165 bits. If safe computation is needed, try to increase the precision. 0.1 > suppressmessage(174); > 0.1; 0.1 > suppressmessage(407); > 0.1; 0.1 > verbosity = 12; The verbosity level has been set to 12. > showmessagenumbers = on; Displaying of message numbers has been activated. > diff(exp(x * 0.1)); Information (196): formally differentiating a function. Information (197): differentiating the expression 'exp(x * 0.1)' Information (207): no Horner simplification will be performed because the given tree is already in Horner form. exp(x * 0.1) * 0.1 > suppressmessage(207, 196); > diff(exp(x * 0.1)); Information (197): differentiating the expression 'exp(x * 0.1)' exp(x * 0.1) * 0.1 > unsuppressmessage(174); > 0.1; Warning (174): Rounding occurred when converting the constant "0.1" to floating- point with 165 bits. If safe computation is needed, try to increase the precision. 0.1 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 12; The verbosity level has been set to 12. > showmessagenumbers = on; Displaying of message numbers has been activated. > diff(exp(x * 0.1)); Warning (174): Rounding occurred when converting the constant "0.1" to floating- point with 165 bits. If safe computation is needed, try to increase the precision. Information (196): formally differentiating a function. Information (197): differentiating the expression 'exp(x * 0.1)' Information (207): no Horner simplification will be performed because the given tree is already in Horner form. exp(x * 0.1) * 0.1 > suppressmessage([| 174, 207, 196 |]); > diff(exp(x * 0.1)); Information (197): differentiating the expression 'exp(x * 0.1)' exp(x * 0.1) * 0.1 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{getsuppressedmessages} (\ref{labgetsuppressedmessages}), \textbf{suppressmessage} (\ref{labsuppressmessage}), \textbf{unsuppressmessage} (\ref{labunsuppressmessage}), \textbf{verbosity} (\ref{labverbosity}), \textbf{roundingwarnings} (\ref{labroundingwarnings}) sollya-6.0+ds/doc/tail.tex000066400000000000000000000016741300174114700155120ustar00rootroot00000000000000\subsection{tail} \label{labtail} \noindent Name: \textbf{tail}\\ \phantom{aaa}gives the tail of a list.\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_tail(sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{tail}(\emph{L}) : \textsf{list} $\rightarrow$ \textsf{list}\\ \end{center} Parameters: \begin{itemize} \item \emph{L} is a list. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{tail}(\emph{L}) returns the list \emph{L} without its first element. \item If \emph{L} is empty, the command will fail with an error. \item \textbf{tail} can also be used with end-elliptic lists. In this case, the result of \textbf{tail} is also an end-elliptic list. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > tail([|1,2,3|]); [|2, 3|] > tail([|1,2...|]); [|2...|] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{head} (\ref{labhead}) sollya-6.0+ds/doc/tan.tex000066400000000000000000000012461300174114700153360ustar00rootroot00000000000000\subsection{tan} \label{labtan} \noindent Name: \textbf{tan}\\ \phantom{aaa}the tangent function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_tan(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_tan(sollya_obj_t)|\\ \verb| #define SOLLYA_TAN(x) sollya_lib_build_function_tan(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{tan} is the tangent function, defined by $\tan(x) = \sin(x)/\cos(x)$. \item It is defined for every real number $x$ that is not of the form $n\pi + \pi/2$ where $n$ is an integer. \end{itemize} See also: \textbf{atan} (\ref{labatan}), \textbf{cos} (\ref{labcos}), \textbf{sin} (\ref{labsin}) sollya-6.0+ds/doc/tanh.tex000066400000000000000000000012161300174114700155030ustar00rootroot00000000000000\subsection{tanh} \label{labtanh} \noindent Name: \textbf{tanh}\\ \phantom{aaa}the hyperbolic tangent function.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_tanh(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_tanh(sollya_obj_t)|\\ \verb| #define SOLLYA_TANH(x) sollya_lib_build_function_tanh(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{tanh} is the hyperbolic tangent function, defined by $\tanh(x) = \sinh(x)/\cosh(x)$. \item It is defined for every real number $x$. \end{itemize} See also: \textbf{atanh} (\ref{labatanh}), \textbf{cosh} (\ref{labcosh}), \textbf{sinh} (\ref{labsinh}) sollya-6.0+ds/doc/taylor.tex000066400000000000000000000044661300174114700160750ustar00rootroot00000000000000\subsection{taylor} \label{labtaylor} \noindent Name: \textbf{taylor}\\ \phantom{aaa}computes a Taylor expansion of a function in a point\\[0.2cm] \noindent Library name:\\ \verb| sollya_obj_t sollya_lib_taylor(sollya_obj_t, sollya_obj_t, sollya_obj_t)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{taylor}(\emph{function}, \emph{degree}, \emph{point}) : (\textsf{function}, \textsf{integer}, \textsf{constant}) $\rightarrow$ \textsf{function}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents the function to be expanded \item \emph{degree} represents the degree of the expansion to be delivered \item \emph{point} represents the point in which the function is to be developed \end{itemize} \noindent Description: \begin{itemize} \item The command \textbf{taylor} returns an expression that is a Taylor expansion of function \emph{function} in point \emph{point} having the degree \emph{degree}. Let $f$ be the function \emph{function}, $t$ be the point \emph{point} and $n$ be the degree \emph{degree}. Then, \textbf{taylor}(\emph{function},\emph{degree},\emph{point}) evaluates to an expression mathematically equal to $$\sum\limits_{i=0}^n \frac{f^{(i)}\left(t\right)}{i!}\,x^i.$$ In other words, if $p(x)$ denotes the polynomial returned by \textbf{taylor}, $p(x-t)$ is the Taylor polynomial of degree $n$ of $f$ developed at point $t$. Remark that \textbf{taylor} evaluates to $0$ if the degree \emph{degree} is negative. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(taylor(exp(x),3,1)); exp(1) + x * (exp(1) + x * (0.5 * exp(1) + x * exp(1) / 6)) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(taylor(asin(x),7,0)); x * (1 + x^2 * (1 / 6 + x^2 * (3 / 40 + x^2 * 5 / 112))) \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(taylor(erf(x),6,0)); x * (1 / sqrt((pi) / 4) + x^2 * ((sqrt((pi) / 4) * 4 / (pi) * (-2)) / 6 + x^2 * (sqrt((pi) / 4) * 4 / (pi) * 12) / 120)) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{remez} (\ref{labremez}), \textbf{fpminimax} (\ref{labfpminimax}), \textbf{taylorform} (\ref{labtaylorform}) sollya-6.0+ds/doc/taylorform.tex000066400000000000000000000227601300174114700167560ustar00rootroot00000000000000\subsection{taylorform} \label{labtaylorform} \noindent Name: \textbf{taylorform}\\ \phantom{aaa}computes a rigorous polynomial approximation (polynomial, interval error bound) for a function, based on Taylor expansions.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_taylorform(sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, ...)|\\ \verb| sollya_obj_t sollya_lib_v_taylorform(sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, va_list)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{taylorform}(\emph{f}, \emph{n}, \emph{$x_0$}, \emph{I}, \emph{errorType}) : (\textsf{function}, \textsf{integer}, \textsf{constant}, \textsf{range}, \textsf{absolute$|$relative}) $\rightarrow$ \textsf{list}\\ \textbf{taylorform}(\emph{f}, \emph{n}, \emph{$x_0$}, \emph{I}, \emph{errorType}) : (\textsf{function}, \textsf{integer}, \textsf{range}, \textsf{range}, \textsf{absolute$|$relative}) $\rightarrow$ \textsf{list}\\ \textbf{taylorform}(\emph{f}, \emph{n}, \emph{$x_0$}, \emph{errorType}) : (\textsf{function}, \textsf{integer}, \textsf{constant}, \textsf{absolute$|$relative}) $\rightarrow$ \textsf{list}\\ \textbf{taylorform}(\emph{f}, \emph{n}, \emph{$x_0$}, \emph{errorType}) : (\textsf{function}, \textsf{integer}, \textsf{range}, \textsf{absolute$|$relative}) $\rightarrow$ \textsf{list}\\ \end{center} Parameters: \begin{itemize} \item \emph{f} is the function to be approximated. \item \emph{n} is the degree of the polynomial that must approximate \emph{f}. \item \emph{$x_0$} is the point (it can be a real number or an interval) where the Taylor exansion of the function is to be considered. \item \emph{I} is the interval over which the function is to be approximated. If this parameter is omitted, the behavior is changed (see detailed description below). \item \emph{errorType} (optional) is the type of error to be considered. See the detailed description below. Default is \textbf{absolute}. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{WARNING:} \textbf{taylorform} is a certified command, not difficult to use but not completely straightforward to use either. In order to be sure to use it correctly, the reader is invited to carefully read this documentation entirely. \item \textbf{taylorform} computes an approximation polynomial and an interval error bound for function $f$. More precisely, it returns a list $L = \left[p, \textrm{coeffErrors},\Delta \right]$ where: \begin{itemize} \item $p$ is an approximation polynomial of degree $n$ such that $p(x-x_0)$ is roughly speaking a numerical Taylor expansion of $f$ at the point $x_0$. \item coeffsErrors is a list of $n+1$ intervals. Each interval coeffsErrors[$i$] contains an enclosure of all the errors accumulated when computing the $i$-th coefficient of $p$. \item $\Delta$ is an interval that provides a bound for the approximation error between $p$ and $f$. Its significance depends on the \emph{errorType} considered. \end{itemize} \item The polynomial $p$ and the bound $\Delta$ are obtained using Taylor Models principles. \item Please note that $x_0$ can be an interval. In general, it is meant to be a small interval approximating a non representable value. If $x_0$ is given as a constant expression, it is first numerically evaluated (leading to a faithful rounding $\tilde{x_0}$ at precision \textbf{prec}), and it is then replaced by the (exactly representable) point-interval $[\tilde{x_0},\,\tilde{x_0}]$. In particular, it is not the same to call \textbf{taylorform} with $x_0 = \textbf{pi}$ and with $x_0 = [\textbf{pi}]$, for instance. In general, if the point around which one desires to compute the polynomial is not exactly representable, one should preferably use a small interval for~$x_0$. \item More formally, the mathematical property ensured by the algorithm may be stated as follows. For all $\csi_0$ in $x_0$, there exist (small) values $\varepsilon_i \in \textrm{coeffsErrors}[i]$ such that: \\ If \emph{errorType} is \textbf{absolute}, $\forall x \in I, \exists \delta \in \Delta,\,$ $f(x)-p(x-\csi_0) = \sum\limits_{i=0}^{n} \varepsilon_i\, (x-\csi_0)^i + \delta$. \\ If \emph{errorType} is \textbf{relative}, $\forall x \in I, \exists \delta \in \Delta,\,$ $f(x)-p(x-\csi_0) = \sum\limits_{i=0}^{n} \varepsilon_i\, (x-\csi_0)^i + \delta\,(x-\csi_0)^{n+1}$. \item It is also possible to use a large interval for $x_0$, though it is not obvious to give an intuitive sense to the result of \textbf{taylorform} in that case. A particular case that might be interesting is when $x_0 = I$ in relative mode. In that case, denoting by $p_i$ the coefficient of $p$ of order $i$, the interval $p_i + \textrm{coeffsError}[i]$ gives an enclosure of $f^{(i)}(I)/i!$. However, the command \textbf{autodiff} is more convenient for computing such enclosures. \item When the interval $I$ is not given, the approximated Taylor polynomial is computed but no remainder is produced. In that case the returned list is $L = \left[p, \textrm{coeffErrors}\right]$. \item The relative case is especially useful when functions with removable singularities are considered. In such a case, this routine is able to compute a finite remainder bound, provided that the expansion point given is the problematic removable singularity point. \item The algorithm does not guarantee that by increasing the degree of the approximation, the remainder bound will become smaller. Moreover, it may even become larger due to the dependency phenomenon present with interval arithmetic. In order to reduce this phenomenon, a possible solution is to split the definition domain $I$ into several smaller intervals. \item The command \textbf{taylor} also computes a Taylor polynomial of a function. However it does not provide a bound on the remainder. Besides, \textbf{taylor} is a somehow symbolic command: each coefficient of the Taylor polynomial is computed exactly and returned as an expression tree exactly equal to theoretical value. It is henceforth much more inefficient than \textbf{taylorform} and \textbf{taylorform} should be preferred if only numercial (yet safe) computations are required. The same difference exists between commands \textbf{diff} and \textbf{autodiff}. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > TL=taylorform(sin(x)/x, 10, 0, [-1,1], relative); > p=TL[0]; > Delta=TL[2]; > errors=TL[1]; > for epsi in errors do epsi; [0;0] [0;0] [0;5.3455294201843912922810729343029637576303937602101e-51] [0;0] [-3.3409558876152445576756705839393523485189961001313e-52;3.34095588761524455767 56705839393523485189961001313e-52] [0;0] [-1.04404871487976392427364705748104760891218628129103e-53;1.0440487148797639242 7364705748104760891218628129103e-53] [0;0] [-1.63132611699963113167757352731413688892529106451724e-55;1.6313261169996311316 7757352731413688892529106451724e-55] [0;0] [-1.91171029335894273243465647732125416670932546623114e-57;1.9117102933589427324 3465647732125416670932546623114e-57] > p; Delta; 1 + x^2 * (-0.16666666666666666666666666666666666666666666666667 + x^2 * (8.3333 333333333333333333333333333333333333333333333e-3 + x^2 * (-1.9841269841269841269 84126984126984126984126984127e-4 + x^2 * (2.755731922398589065255731922398589065 2557319223986e-6 + x^2 * (-2.5052108385441718775052108385441718775052108385442e- 8))))) [-1.6135797443886066084999806203254010793747502812764e-10;1.61357974438860660849 99806203254010793747502812764e-10] \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > TL=taylorform(exp(x), 10, 0, [-1,1], absolute); > p=TL[0]; > Delta=TL[2]; > p; Delta; 1 + x * (1 + x * (0.5 + x * (0.1666666666666666666666666666666666666666666666666 7 + x * (4.1666666666666666666666666666666666666666666666668e-2 + x * (8.3333333 333333333333333333333333333333333333333333e-3 + x * (1.3888888888888888888888888 888888888888888888888889e-3 + x * (1.9841269841269841269841269841269841269841269 84127e-4 + x * (2.4801587301587301587301587301587301587301587301587e-5 + x * (2. 7557319223985890652557319223985890652557319223986e-6 + x * 2.7557319223985890652 557319223985890652557319223986e-7))))))))) [-2.3114271964118761944124253418268474583253955510297e-8;2.731266075564247442020 6278018039434042553645532164e-8] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > TL1 = taylorform(exp(x), 10, log2(10), [-1,1], absolute); > TL2 = taylorform(exp(x), 10, [log2(10)], [-1,1], absolute); > TL1==TL2; false \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > TL1 = taylorform(exp(x), 3, 0, [0,1], relative); > TL2 = taylorform(exp(x), 3, 0, relative); > TL1[0]==TL2[0]; true > TL1[1]==TL2[1]; true > length(TL1); 3 > length(TL2); 2 \end{Verbatim} \end{minipage}\end{center} \noindent Example 5: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = exp(cos(x)); x0 = 0; > TL = taylorform(f, 3, x0); > T1 = TL[0]; > T2 = taylor(f, 3, x0); > print(coeff(T1, 2)); -1.35914091422952261768014373567633124887862354685 > print(coeff(T2, 2)); -(0.5 * exp(1)) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{diff} (\ref{labdiff}), \textbf{autodiff} (\ref{labautodiff}), \textbf{taylor} (\ref{labtaylor}), \textbf{remez} (\ref{labremez}), \textbf{chebyshevform} (\ref{labchebyshevform}) sollya-6.0+ds/doc/taylorrecursions.tex000066400000000000000000000047021300174114700202030ustar00rootroot00000000000000\subsection{taylorrecursions} \label{labtaylorrecursions} \noindent Name: \textbf{taylorrecursions}\\ \phantom{aaa}controls the number of recursion steps when applying Taylor's rule.\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_taylorrecursions_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_taylorrecursions(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_taylorrecursions()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{taylorrecursions} = \emph{n} : \textsf{integer} $\rightarrow$ \textsf{void}\\ \textbf{taylorrecursions} = \emph{n} ! : \textsf{integer} $\rightarrow$ \textsf{void}\\ \textbf{taylorrecursions} : \textsf{integer}\\ \end{center} Parameters: \begin{itemize} \item \emph{n} represents the number of recursions \end{itemize} \noindent Description: \begin{itemize} \item \textbf{taylorrecursions} is a global variable. Its value represents the number of steps of recursion that are used when applying Taylor's rule. This rule is applied by the interval evaluator present in the core of \sollya (and particularly visible in commands like \textbf{infnorm}). \item To improve the quality of an interval evaluation of a function $f$, in particular when there are problems of decorrelation), the evaluator of \sollya uses Taylor's rule: $f([a,b]) \subseteq f(m) + [a-m,\,b-m] \cdot f'([a,\,b])$ where $m=\frac{a+b}{2}$. This rule can be applied recursively. The number of step in this recursion process is controlled by \textbf{taylorrecursions}. \item Setting \textbf{taylorrecursions} to 0 makes \sollya use this rule only once; setting it to 1 makes \sollya use the rule twice, and so on. In particular: the rule is always applied at least once. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f=exp(x); > p=remez(f,3,[0;1]); > taylorrecursions=0; The number of recursions for Taylor evaluation has been set to 0. > evaluate(f-p, [0;1]); [-0.46839364816268368775174657814112460243249079671039;0.46947781754646820647293 019728402934746974652584671] > taylorrecursions=1; The number of recursions for Taylor evaluation has been set to 1. > evaluate(f-p, [0;1]); [-0.138131114954063839905475752120786856031651747712954;0.1392152843378483586266 5937126369160106890747684927] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{hopitalrecursions} (\ref{labhopitalrecursions}), \textbf{evaluate} (\ref{labevaluate}), \textbf{infnorm} (\ref{labinfnorm}) sollya-6.0+ds/doc/td.tex000066400000000000000000000002571300174114700151640ustar00rootroot00000000000000\subsection{TD} \label{labtd} \noindent Name: \textbf{TD}\\ \phantom{aaa}short form for \textbf{tripledouble}\\[0.2cm] See also: \textbf{tripledouble} (\ref{labtripledouble}) sollya-6.0+ds/doc/time.tex000066400000000000000000000062661300174114700155210ustar00rootroot00000000000000\subsection{time} \label{labtime} \noindent Name: \textbf{time}\\ \phantom{aaa}procedure for timing \sollya code.\\[0.2cm] \noindent Usage: \begin{center} \textbf{time}(\emph{code}) : \textsf{code} $\rightarrow$ \textsf{constant}\\ \end{center} Parameters: \begin{itemize} \item \emph{code} is the code to be timed. \end{itemize} \noindent Description: \begin{itemize} \item \textbf{time} permits timing a \sollya instruction, resp. a begin-end block of \sollya instructions. The timing value, measured in seconds, is returned as a \sollya constant (and not merely displayed as for \textbf{timing}). This permits performing computations of the timing measurement value inside \sollya. \item The extended \textbf{nop} command permits executing a defined number of useless instructions. Taking the ratio of the time needed to execute a certain \sollya instruction and the time for executing a \textbf{nop} therefore gives a way to abstract from the speed of a particular machine when evaluating an algorithm's performance. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > t = time(p=remez(sin(x),10,[-1;1])); > write(t,"s were spent computing p = ",p,"\n"); 3.05160009999999999999999999999999999983557553655726e-2s were spent computing p = 9.0486898749977990986908851357759191711354777014602e-17 * x^10 + 2.68762595115 123596299959320959141640012683406736586e-6 * x^9 + -2.42479784925213133490732322 89246205727856268698001e-16 * x^8 + -1.98344863020965929701245606503586461226130 937598776e-4 * x^7 + 2.2748214757753544349162426281857910162575492126267e-16 * x ^6 + 8.3333037186560980567697821420813799547276481409702e-3 * x^5 + -8.574715198 972066974170696130354953131211051121887e-17 * x^4 + -0.1666666613860132370762165 66493953847771564552744173 * x^3 + 1.0569955896986387584149333228209702258049344 9058156e-17 * x^2 + 0.99999999973628365676559825181776417246038944720795 * x + ( -3.1206530956601883024316320853642604562810646600878e-19) \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > write(time({ p=remez(sin(x),10,[-1;1]); write("The error is 2^(", log2(dirtyin fnorm(p-sin(x),[-1;1])), ")\n"); }), " s were spent\n"); The error is 2^(log2(2.39601979446524486606649528289933482070294808074097e-11)) 5.300610899999999999999999999999999999655643425017e-2 s were spent \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > t = time(bashexecute("sleep 10")); > write(~(t-10),"s of execution overhead.\n"); 1.0307540000000000000000000000000012841361312075444e-3s of execution overhead. \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > ratio := time(p=remez(sin(x),10,[-1;1]))/time(nop(10)); > write("This ratio = ", ratio, " should somehow be independent of the type of m achine.\n"); This ratio = 1.4352753375948099305970843816649472572809229468204 should somehow be independent of the type of machine. \end{Verbatim} \end{minipage}\end{center} See also: \textbf{timing} (\ref{labtiming}), \textbf{nop} (\ref{labnop}) sollya-6.0+ds/doc/timing.tex000066400000000000000000000031701300174114700160410ustar00rootroot00000000000000\subsection{timing} \label{labtiming} \noindent Name: \textbf{timing}\\ \phantom{aaa}global variable controlling timing measures in \sollya.\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_timing_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_timing(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_timing()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{timing} = \emph{activation value} : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{timing} = \emph{activation value} ! : \textsf{on$|$off} $\rightarrow$ \textsf{void}\\ \textbf{timing} : \textsf{on$|$off}\\ \end{center} Parameters: \begin{itemize} \item \emph{activation value} controls if timing should be performed or not \end{itemize} \noindent Description: \begin{itemize} \item \textbf{timing} is a global variable. When its value is \textbf{on}, the time spent in each command is measured and displayed (for \textbf{verbosity} levels higher than 1). \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > timing=on; Timing has been activated. > p=remez(sin(x),10,[-1;1]); Information: Remez: computing the quality of approximation spent 3 ms Information: Remez: computing the quality of approximation spent 3 ms Information: Remez: computing the quality of approximation spent 3 ms Information: computing a minimax approximation spent 21 ms Information: assignment spent 25 ms Information: full execution of the last parse chunk spent 29 ms \end{Verbatim} \end{minipage}\end{center} See also: \textbf{on} (\ref{labon}), \textbf{off} (\ref{laboff}), \textbf{time} (\ref{labtime}) sollya-6.0+ds/doc/tripledouble.tex000066400000000000000000000043271300174114700172510ustar00rootroot00000000000000\subsection{tripledouble} \label{labtripledouble} \noindent Names: \textbf{tripledouble}, \textbf{TD}\\ \phantom{aaa}represents a number as the sum of three IEEE doubles.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_triple_double(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_triple_double_obj()|\\ \verb| int sollya_lib_is_triple_double_obj(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_build_function_triple_double(sollya_obj_t)|\\ \verb| #define SOLLYA_TD(x) sollya_lib_build_function_triple_double(x)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{tripledouble} is both a function and a constant. \item As a function, it rounds its argument to the nearest number that can be written as the sum of three double precision numbers. \item The algorithm used to compute \textbf{tripledouble}($x$) is the following: let $x_h$ = \textbf{double}($x$), let $x_m$ = \textbf{double}($x-x_h$) and let $x_l$ = \textbf{double}($x-x_h-x_m$). Return the number $x_h+x_m+x_l$. Note that if the current precision is not sufficient to represent exactly $x_h+x_m+x_l$, a rounding will occur and the result of \textbf{tripledouble}(x) will be useless. \item As a constant, it symbolizes the triple-double precision format. It is used in contexts when a precision format is necessary, e.g. in the commands \textbf{roundcoefficients} and \textbf{implementpoly}. See the corresponding help pages for examples. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > a = 1+ 2^(-55)+2^(-115); > TD(a); 1.00000000000000002775557561562891353466491600711096 > prec=110!; > TD(a); 1.000000000000000027755575615628913534664916007110955975699724 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{halfprecision} (\ref{labhalfprecision}), \textbf{single} (\ref{labsingle}), \textbf{double} (\ref{labdouble}), \textbf{doubleextended} (\ref{labdoubleextended}), \textbf{doubledouble} (\ref{labdoubledouble}), \textbf{quad} (\ref{labquad}), \textbf{roundcoefficients} (\ref{labroundcoefficients}), \textbf{implementpoly} (\ref{labimplementpoly}), \textbf{fpminimax} (\ref{labfpminimax}), \textbf{printexpansion} (\ref{labprintexpansion}) sollya-6.0+ds/doc/true.tex000066400000000000000000000011631300174114700155310ustar00rootroot00000000000000\subsection{true} \label{labtrue} \noindent Name: \textbf{true}\\ \phantom{aaa}the boolean value representing the truth.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_true()|\\ \verb| int sollya_lib_is_true(sollya_obj_t)|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{true} is the usual boolean value. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > true && false; false > 2>1; true \end{Verbatim} \end{minipage}\end{center} See also: \textbf{false} (\ref{labfalse}), \textbf{$\&\&$} (\ref{laband}), \textbf{$||$} (\ref{labor}) sollya-6.0+ds/doc/unsuppressmessage.tex000066400000000000000000000126571300174114700203600ustar00rootroot00000000000000\subsection{unsuppressmessage} \label{labunsuppressmessage} \noindent Name: \textbf{unsuppressmessage}\\ \phantom{aaa}unsuppresses the displaying of messages with a certain number\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_unsuppressmessage(sollya_obj_t, ...);|\\ \verb| void sollya_lib_v_unsuppressmessage(sollya_obj_t, va_list);|\\[0.2cm] \noindent Usage: \begin{center} \textbf{unsuppressmessage}(\emph{msg num 1}, ..., \emph{msg num n}) : (\textsf{integer}, ..., \textsf{integer}) $\rightarrow$ \textsf{void}\\ \textbf{unsuppressmessage}(\emph{msg list}) : \textsf{list} $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{msg num 1} thru \emph{msg num n} represent the numbers of $n$ messages to be suppressed \item \emph{msg list} represents a list with numbers of messages to be suppressed \end{itemize} \noindent Description: \begin{itemize} \item The \textbf{unsuppressmessage} command allows particular warning and information messages that have been suppressed from message output to be unsuppressed, i.e. activated for display again. Every \sollya warning or information message (that is not fatal to the tool's execution) has a message number. When these message numbers \emph{msg num 1} thru \emph{msg num n} are given to \textbf{unsuppressmessage}, the corresponding message are displayed again, as they are by default at according verbosity levels. Actually, the \textbf{unsuppressmessage} command just reverts the effects of the \textbf{suppressmessage} command. \item Instead of giving \textbf{unsuppressmessage} several message numbers \emph{msg num 1} thru \emph{msg num n} or calling \textbf{unsuppressmessage} several times, it is possible to give a whole list \emph{msg list} of message numbers to \textbf{unsuppressmessage}. \item The user should be aware that \textbf{unsuppressmessage} presents sticky behavior for the warning and information messages suppressed from output. In fact, \textbf{unsuppressmessage} just unsuppresses the warning or information messages given in argument. All other suppressed messages stay suppressed until they get unsuppressed by subsequent calls to \textbf{unsuppressmessage} or the \sollya tool is restarted. This behavior distinguishes message suppression from other global states of the \sollya tool. The user may use \textbf{getsuppressedmessages} to obtain a list of currently suppressed messages. In particular, in order to unsuppressed all currently suppressed warning or information messages, the user may feed the output of \textbf{getsuppressedmessages} (a list) into \textbf{unsuppressmessage}. \item The user should also note that unsuppressing warning or information messages with \textbf{unsuppressmessage} just reverts the effects of the \textbf{suppressmessage} command but that other conditions exist that affect the actual displaying of a message, such as global verbosity (see \textbf{verbosity}) and modes like rounding warnings (see \textbf{roundingwarnings}). A message will not just get displayed because it was unsuppressed with \textbf{unsuppressmessage}. \item When \textbf{unsuppressmessage} is used on message numbers that do not exist in the current version of the tool, a warning is displayed. The call has no other effect though. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 1; The verbosity level has been set to 1. > 0.1; Warning: Rounding occurred when converting the constant "0.1" to floating-point with 165 bits. If safe computation is needed, try to increase the precision. 0.1 > suppressmessage(174); > 0.1; 0.1 > suppressmessage(174); > 0.1; 0.1 \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 12; The verbosity level has been set to 12. > showmessagenumbers = on; Displaying of message numbers has been activated. > diff(exp(x * 0.1)); Warning (174): Rounding occurred when converting the constant "0.1" to floating- point with 165 bits. If safe computation is needed, try to increase the precision. Information (196): formally differentiating a function. Information (197): differentiating the expression 'exp(x * 0.1)' Information (207): no Horner simplification will be performed because the given tree is already in Horner form. exp(x * 0.1) * 0.1 > suppressmessage([| 174, 207, 196 |]); > diff(exp(x * 0.1)); Information (197): differentiating the expression 'exp(x * 0.1)' exp(x * 0.1) * 0.1 > unsuppressmessage([| 174, 196 |]); \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity = 12; The verbosity level has been set to 12. > showmessagenumbers = on; Displaying of message numbers has been activated. > suppressmessage(207, 387, 390, 388, 391, 196, 195, 197, 205); > getsuppressedmessages(); [|195, 196, 197, 205, 207, 387, 388, 390, 391|] > evaluate(x/sin(x) - 1, [-1;1]); [0;0.8508157176809256179117532413986501934703966550941] > unsuppressmessage(getsuppressedmessages()); > getsuppressedmessages(); [| |] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{getsuppressedmessages} (\ref{labgetsuppressedmessages}), \textbf{suppressmessage} (\ref{labsuppressmessage}), \textbf{unsuppressmessage} (\ref{labunsuppressmessage}), \textbf{verbosity} (\ref{labverbosity}), \textbf{roundingwarnings} (\ref{labroundingwarnings}) sollya-6.0+ds/doc/var.tex000066400000000000000000000027461300174114700153520ustar00rootroot00000000000000\subsection{var} \label{labvar} \noindent Name: \textbf{var}\\ \phantom{aaa}declaration of a local variable in a scope\\[0.2cm] \noindent Usage: \begin{center} \textbf{var} \emph{identifier1}, \emph{identifier2},... , \emph{identifiern} : \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{identifier1}, \emph{identifier2},... , \emph{identifiern} represent variable identifiers \end{itemize} \noindent Description: \begin{itemize} \item The keyword \textbf{var} allows for the declaration of local variables \emph{identifier1} through \emph{identifiern} in a begin-end-block ($\lbrace \rbrace$-block). Once declared as a local variable, an identifier will shadow identifiers declared in higher scopes and undeclared identifiers available at top-level. Variable declarations using \textbf{var} are only possible in the beginning of a begin-end-block. Several \textbf{var} statements can be given. Once another statement is given in a begin-end-block, no more \textbf{var} statements can be given. Variables declared by \textbf{var} statements are dereferenced as \textbf{error} until they are assigned a value. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > exp(x); exp(x) > a = 3; > {var a, b; a=5; b=3; {var a; var b; b = true; a = 1; a; b;}; a; b; }; 1 true 5 3 > a; 3 \end{Verbatim} \end{minipage}\end{center} See also: \textbf{error} (\ref{laberror}), \textbf{proc} (\ref{labproc}) sollya-6.0+ds/doc/verbosity.tex000066400000000000000000000046311300174114700166030ustar00rootroot00000000000000\subsection{verbosity} \label{labverbosity} \noindent Name: \textbf{verbosity}\\ \phantom{aaa}global variable controlling the amount of information displayed by commands.\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_set_verbosity_and_print(sollya_obj_t)|\\ \verb| void sollya_lib_set_verbosity(sollya_obj_t)|\\ \verb| sollya_obj_t sollya_lib_get_verbosity()|\\[0.2cm] \noindent Usage: \begin{center} \textbf{verbosity} = \emph{n} : \textsf{integer} $\rightarrow$ \textsf{void}\\ \textbf{verbosity} = \emph{n} ! : \textsf{integer} $\rightarrow$ \textsf{void}\\ \textbf{verbosity} : \textsf{integer}\\ \end{center} Parameters: \begin{itemize} \item \emph{n} controls the amount of information to be displayed \end{itemize} \noindent Description: \begin{itemize} \item \textbf{verbosity} accepts any integer value. At level 0, commands do not display anything on standard output. Note that very critical information may however be displayed on standard error. \item Default level is 1. It displays important information such as warnings when roundings happen. \item For higher levels more information is displayed depending on the command. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=0!; > 1.2+"toto"; error > verbosity=1!; > 1.2+"toto"; Warning: Rounding occurred when converting the constant "1.2" to floating-point with 165 bits. If safe computation is needed, try to increase the precision. Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. error > verbosity=2!; > 1.2+"toto"; Warning: Rounding occurred when converting the constant "1.2" to floating-point with 165 bits. If safe computation is needed, try to increase the precision. Warning: at least one of the given expressions or a subexpression is not correct ly typed or its evaluation has failed because of some error on a side-effect. Information: the expression or a partial evaluation of it has been the following : (1.2) + ("toto") error \end{Verbatim} \end{minipage}\end{center} See also: \textbf{roundingwarnings} (\ref{labroundingwarnings}), \textbf{suppressmessage} (\ref{labsuppressmessage}), \textbf{unsuppressmessage} (\ref{labunsuppressmessage}), \textbf{showmessagenumbers} (\ref{labshowmessagenumbers}), \textbf{getsuppressedmessages} (\ref{labgetsuppressedmessages}) sollya-6.0+ds/doc/void.tex000066400000000000000000000064101300174114700155130ustar00rootroot00000000000000\subsection{void} \label{labvoid} \noindent Name: \textbf{void}\\ \phantom{aaa}the functional result of a side-effect or empty argument resp. the corresponding type\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_void()|\\ \verb| int sollya_lib_is_void(sollya_obj_t)|\\ \verb| SOLLYA_EXTERNALPROC_TYPE_VOID|\\[0.2cm] \noindent Usage: \begin{center} \textbf{void} : \textsf{void} $|$ \textsf{type type}\\ \end{center} \noindent Description: \begin{itemize} \item The variable \textbf{void} represents the functional result of a side-effect or an empty argument. It is used only in combination with the applications of procedures or identifiers bound through \textbf{externalproc} to external procedures. The \textbf{void} result produced by a procedure or an external procedure is not printed at the prompt. However, it is possible to print it out in a print statement or in complex data types such as lists. The \textbf{void} argument is implicit when giving no argument to a procedure or an external procedure when applied. It can nevertheless be given explicitly. For example, suppose that foo is a procedure or an external procedure with a void argument. Then foo() and foo(void) are correct calls to foo. Here, a distinction must be made for procedures having an arbitrary number of arguments. In this case, an implicit \textbf{void} as the only parameter to a call of such a procedure gets converted into an empty list of arguments, an explicit \textbf{void} gets passed as-is in the formal list of parameters the procedure receives. \item \textbf{void} is used also as a type identifier for \textbf{externalproc}. Typically, an external procedure taking \textbf{void} as an argument or returning \textbf{void} is bound with a signature \textbf{void} $->$ some type or some type $->$ \textbf{void}. See \textbf{externalproc} for more details. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > print(void); void > void; \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > hey = proc() { print("Hello world."); }; > hey; proc() { print("Hello world."); return void; } > hey(); Hello world. > hey(void); Hello world. > print(hey()); Hello world. void \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > bashexecute("gcc -fPIC -Wall -c externalprocvoidexample.c"); > bashexecute("gcc -fPIC -shared -o externalprocvoidexample externalprocvoidexam ple.o"); > externalproc(foo, "./externalprocvoidexample", void -> void); > foo; foo > foo(); Hello from the external world. > foo(void); Hello from the external world. > print(foo()); Hello from the external world. void \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > procedure blub(L = ...) { print("Argument list:", L); }; > blub(1); Argument list: [|1|] > blub(); Argument list: [| |] > blub(void); Argument list: [|void|] \end{Verbatim} \end{minipage}\end{center} See also: \textbf{error} (\ref{laberror}), \textbf{proc} (\ref{labproc}), \textbf{externalproc} (\ref{labexternalproc}) sollya-6.0+ds/doc/worstcase.tex000066400000000000000000000046241300174114700165710ustar00rootroot00000000000000\subsection{worstcase} \label{labworstcase} \noindent Name: \textbf{worstcase}\\ \phantom{aaa}searches for hard-to-round cases of a function\\[0.2cm] \noindent Library names:\\ \verb| void sollya_lib_worstcase(sollya_obj_t, sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t, ...)|\\ \verb| void sollya_lib_v_worstcase(sollya_obj_t, sollya_obj_t, sollya_obj_t,|\\ \verb| sollya_obj_t, sollya_obj_t, va_list)|\\[0.2cm] \noindent Usage: \begin{center} \textbf{worstcase}(\emph{function}, \emph{preimage precision}, \emph{preimage exponent range}, \emph{image precision}, \emph{error bound}) : (\textsf{function}, \textsf{integer}, \textsf{range}, \textsf{integer}, \textsf{constant}) $\rightarrow$ \textsf{void}\\ \textbf{worstcase}(\emph{function}, \emph{preimage precision}, \emph{preimage exponent range}, \emph{image precision}, \emph{error bound}, \emph{filename}) : (\textsf{function}, \textsf{integer}, \textsf{range}, \textsf{integer}, \textsf{constant}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{function} represents the function to be considered \item \emph{preimage precision} represents the precision of the preimages \item \emph{preimage exponent range} represents the exponents in the preimage format \item \emph{image precision} represents the precision of the format the images are to be rounded to \item \emph{error bound} represents the upper bound for the search w.r.t. the relative rounding error \item \emph{filename} represents a character sequence containing a filename \end{itemize} \noindent Description: \begin{itemize} \item The \textbf{worstcase} command is deprecated. It searches for hard-to-round cases of a function. The command \textbf{searchgal} has a comparable functionality. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > worstcase(exp(x),24,[1,2],24,1b-26); prec = 165 x = 1.99999988079071044921875 f(x) = 7.3890552520751953125 eps = 4 .5998601423446695596184695493764120138001954979037e-9 = 2^(-27.695763) x = 2 f(x) = 7.38905620574951171875 eps = 1.4456360874967301812222 8379395533417878125150587072e-8 = 2^(-26.043720) \end{Verbatim} \end{minipage}\end{center} See also: \textbf{round} (\ref{labround}), \textbf{searchgal} (\ref{labsearchgal}), \textbf{evaluate} (\ref{labevaluate}) sollya-6.0+ds/doc/write.tex000066400000000000000000000074341300174114700157130ustar00rootroot00000000000000\subsection{write} \label{labwrite} \noindent Name: \textbf{write}\\ \phantom{aaa}prints an expression without separators\\[0.2cm] \noindent Usage: \begin{center} \textbf{write}(\emph{expr1},...,\emph{exprn}) : (\textsf{any type},..., \textsf{any type}) $\rightarrow$ \textsf{void}\\ \textbf{write}(\emph{expr1},...,\emph{exprn}) $>$ \emph{filename} : (\textsf{any type},..., \textsf{any type}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \textbf{write}(\emph{expr1},...,\emph{exprn}) $>>$ \emph{filename} : (\textsf{any type},...,\textsf{any type}, \textsf{string}) $\rightarrow$ \textsf{void}\\ \end{center} Parameters: \begin{itemize} \item \emph{expr} represents an expression \item \emph{filename} represents a character sequence indicating a file name \end{itemize} \noindent Description: \begin{itemize} \item \textbf{write}(\emph{expr1},...,\emph{exprn}) prints the expressions \emph{expr1} through \emph{exprn}. The character sequences corresponding to the expressions are concatenated without any separator. No newline is displayed at the end. In contrast to \textbf{print}, \textbf{write} expects the user to give all separators and newlines explicitly. If a second argument \emph{filename} is given after a single "$>$", the displaying is not output on the standard output of \sollya but if in the file \emph{filename} that get newly created or overwritten. If a double "$>>$" is given, the output will be appended to the file \emph{filename}. The global variables \textbf{display}, \textbf{midpointmode} and \textbf{fullparentheses} have some influence on the formatting of the output (see \textbf{display}, \textbf{midpointmode} and \textbf{fullparentheses}). Remark that if one of the expressions \emph{expri} given in argument is of type \textsf{string}, the character sequence \emph{expri} evaluates to is displayed. However, if \emph{expri} is of type \textsf{list} and this list contains a variable of type \textsf{string}, the expression for the list is displayed, i.e. all character sequences get displayed surrounded by quotes ("). Nevertheless, escape sequences used upon defining character sequences are interpreted immediately. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > write(x + 2 + exp(sin(x))); > write("Hello\n"); x + 2 + exp(sin(x))Hello > write("Hello","world\n"); Helloworld > write("Hello","you", 4 + 3, "other persons.\n"); Helloyou7other persons. \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > write("Hello","\n"); Hello > write([|"Hello"|],"\n"); [|"Hello"|] > s = "Hello"; > write(s,[|s|],"\n"); Hello[|"Hello"|] > t = "Hello\tyou"; > write(t,[|t|],"\n"); Hello you[|"Hello\tyou"|] \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > write(x + 2 + exp(sin(x))) > "foo.sol"; > readfile("foo.sol"); x + 2 + exp(sin(x)) \end{Verbatim} \end{minipage}\end{center} \noindent Example 4: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > write(x + 2 + exp(sin(x))) >> "foo.sol"; \end{Verbatim} \end{minipage}\end{center} See also: \textbf{print} (\ref{labprint}), \textbf{printexpansion} (\ref{labprintexpansion}), \textbf{printdouble} (\ref{labprintdouble}), \textbf{printsingle} (\ref{labprintsingle}), \textbf{printxml} (\ref{labprintxml}), \textbf{readfile} (\ref{labreadfile}), \textbf{autosimplify} (\ref{labautosimplify}), \textbf{display} (\ref{labdisplay}), \textbf{midpointmode} (\ref{labmidpointmode}), \textbf{fullparentheses} (\ref{labfullparentheses}), \textbf{evaluate} (\ref{labevaluate}), \textbf{roundingwarnings} (\ref{labroundingwarnings}), \textbf{autosimplify} (\ref{labautosimplify}) sollya-6.0+ds/doc/xfreevariable.tex000066400000000000000000000053021300174114700173700ustar00rootroot00000000000000\subsection{\_x\_} \label{labxfreevariable} \noindent Name: \textbf{\_x\_}\\ \phantom{aaa}universal name for the mathematical free variable.\\[0.2cm] \noindent Library names:\\ \verb| sollya_obj_t sollya_lib_free_variable()|\\ \verb| sollya_obj_t sollya_lib_build_function_free_variable()|\\ \verb| #define SOLLYA_X_ (sollya_lib_build_function_free_variable())|\\[0.2cm] \noindent Description: \begin{itemize} \item \textbf{\_x\_} is an identifier that always denotes the mathematical free variable. It cannot be assigned. \item \sollya manipulates mathematical functions of a single variable. The first time that a variable name is used without having been assigned before, this variable name is automatically considered by \sollya as the name of the free variable. Subsequently, any other unassigned variable name will be considered as the free variable with a warning making this conversion explicit. This is convenient for an every-day use of the interactive tool, but it has the drawback that the free variable name can change from a session to another. There are contexts (\emph{e.g.}, within a procedure, or for doing pattern matching) when one might want to refer to the free variable regardless of its name in the current session. For this purpose \textbf{\_x\_} is a universal identifier, always available and always denoting the free variable, whatever its name is in the current context. \end{itemize} \noindent Example 1: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > sin(a); sin(a) > b; Warning: the identifier "b" is neither assigned to, nor bound to a library funct ion nor external procedure, nor equal to the current free variable. Will interpret "b" as "a". a > _x_; a \end{Verbatim} \end{minipage}\end{center} \noindent Example 2: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > verbosity=1!; > sin(y); sin(y) > f = proc(a) { return sin(a + _x_); }; > rename(y,z); Information: the free variable has been renamed from "y" to "z". > f(1); sin(1 + z) \end{Verbatim} \end{minipage}\end{center} \noindent Example 3: \begin{center}\begin{minipage}{15cm}\begin{Verbatim}[frame=single] > f = sin(y); > match f with sin(a) : { print("sin of a with a =", a); match a with _x_ : { print("a turns out to be the free variable"); } default : { print("a is some expression"); }; } _x_ : { print("Free variable") ; } default: { print("Something else"); }; sin of a with a = y a turns out to be the free variable \end{Verbatim} \end{minipage}\end{center} See also: \textbf{rename} (\ref{labrename}), \textbf{isbound} (\ref{labisbound}), \textbf{proc} (\ref{labproc}) sollya-6.0+ds/double.c000066400000000000000000001573021300174114700147100ustar00rootroot00000000000000/* Copyright 2006-2014 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #define _BSD_SOURCE #define _DEFAULT_SOURCE #include #include #include "mpfi-compat.h" #include /* fprintf, fopen, fclose, */ #include #include #include #include #include #include "expression.h" #include "execute.h" #include "double.h" #include "general.h" #include "infnorm.h" typedef union { int32_t i[2]; double d; } db_number; typedef union { int32_t i; float f; } fl_number; /* Converts a string of the form [:space:]*(+)?(-)?(0x)?[0-9A-Fa-f]* interpreted in hexadecimal into an int32. If the string is not a valid hexadecimal string or if the number it represents does not fit on an int32_t, the behavior of the function is not determined. Note: this function only exists because we cannot use strtoll as it is not BSD compliant. */ int32_t convertHexadecimalStringToInt32(char *str) { char *ptr; int negate; int32_t res; uint32_t t, c; negate = 0; t = 0; for (ptr=str;*ptr!='\0';ptr++) { if (!isspace(*ptr)) break; } if (*ptr=='+') ptr++; if (*ptr=='-') { negate = 1; ptr++; } if ((*ptr=='0') && (*(ptr+1)=='x')) ptr += 2; for (;*ptr!='\0';ptr++) { if (((*ptr>='0') && (*ptr<='9')) || ((*ptr>='A') && (*ptr<='F')) || ((*ptr>='a') && (*ptr<='f'))) { t <<= 4; if ((*ptr>='0') && (*ptr<='9')) { c = *ptr - '0'; } else { if ((*ptr>='A') && (*ptr<='F')) { c = *ptr - 'A' + 0xa; } else { c = *ptr - 'a' + 0xa; } } t += c; } else { t = 0; break; } } res = *((int32_t *) &t); if (negate) res = -res; return res; } int round_to_format(mpfr_t rop, mpfr_t op, int prec, mp_rnd_t mode) { mpfr_t res; int round_dir; mpfr_init2(res,(mp_prec_t)prec); round_dir = mpfr_set(res,op, mode); if (mpfr_set(rop, res, GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_UNDESIRED_ROUNDING_IN_ROUND_TO_FORMAT,"Warning: an undesired rounding occurred on a rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } mpfr_clear(res); return round_dir; } int mpfr_round_to_double(mpfr_t rop, mpfr_t op) { double d; int res; d = sollya_mpfr_get_d(op,GMP_RNDN); if (mpfr_set_d(rop,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE,"Warning: double rounding occurred on invoking the double precision rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } res = mpfr_cmp(rop,op); return res; } int mpfr_round_to_double_mode(mpfr_t rop, mpfr_t op, mp_rnd_t mode) { double d; int res; d = sollya_mpfr_get_d(op,mode); if (mpfr_set_d(rop,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE,"Warning: double rounding occurred on invoking the double precision rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } res = mpfr_cmp(rop,op); return res; } int mpfr_round_to_prec(mpfr_t rop, mpfr_t op, mp_prec_t prec) { mp_prec_t p; mpfr_t temp; int res; if (prec < 6) p = 6; else p = prec; mpfr_init2(temp,p); mpfr_set(temp,op,GMP_RNDN); if (mpfr_set(rop,temp,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_PREC,"Warning: double rounding occurred on invoking the round-to-prec rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } mpfr_clear(temp); res = mpfr_cmp(rop,op); return res; } int mpfr_round_to_doubledouble(mpfr_t rop, mpfr_t op) { double d; mpfr_t accu, temp, rest; mp_prec_t prec; int res; prec = mpfr_get_prec(op); if (prec < 106) { prec = 106; } mpfr_init2(accu, prec); mpfr_init2(temp, prec); mpfr_init2(rest, prec); d = sollya_mpfr_get_d(op,GMP_RNDN); if (mpfr_set_d(accu,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE_DOUBLE,"Warning: double rounding occurred on invoking the double-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on recasting to MPFR. This should not occur.\n"); } } if (mpfr_sub(rest,op,accu,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE_DOUBLE,"Warning: double rounding occurred on invoking the double-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on subtracting in MPFR. This should not occur.\n"); } } d = sollya_mpfr_get_d(rest,GMP_RNDN); if (mpfr_set_d(temp,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE_DOUBLE,"Warning: double rounding occurred on invoking the double-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on recasting to MPFR. This should not occur.\n"); } } if (mpfr_add(accu,accu,temp,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE_DOUBLE,"Warning: double rounding occurred on invoking the double-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on subtracting in MPFR. This should not occur.\n"); } } if (mpfr_set(rop,accu,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE_DOUBLE,"Warning: double rounding occurred on invoking the double-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } res = mpfr_cmp(rop,op); mpfr_clear(accu); mpfr_clear(temp); mpfr_clear(rest); return res; } int mpfr_round_to_doubledouble_mode(mpfr_t rop, mpfr_t op, mp_rnd_t mode) { double d; mpfr_t accu, temp, rest; mp_prec_t prec; int res; prec = mpfr_get_prec(op); if (prec < 106) { prec = 106; } mpfr_init2(accu, prec); mpfr_init2(temp, prec); mpfr_init2(rest, prec); d = sollya_mpfr_get_d(op,GMP_RNDN); if (mpfr_set_d(accu,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE_DOUBLE,"Warning: double rounding occurred on invoking the double-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on recasting to MPFR. This should not occur.\n"); } } if (mpfr_sub(rest,op,accu,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE_DOUBLE,"Warning: double rounding occurred on invoking the double-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on subtracting in MPFR. This should not occur.\n"); } } d = sollya_mpfr_get_d(rest,mode); if (mpfr_set_d(temp,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE_DOUBLE,"Warning: double rounding occurred on invoking the double-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on recasting to MPFR. This should not occur.\n"); } } if (mpfr_add(accu,accu,temp,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE_DOUBLE,"Warning: double rounding occurred on invoking the double-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on subtracting in MPFR. This should not occur.\n"); } } if (mpfr_set(rop,accu,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE_DOUBLE,"Warning: double rounding occurred on invoking the double-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } res = mpfr_cmp(rop,op); mpfr_clear(accu); mpfr_clear(temp); mpfr_clear(rest); return res; } int mpfr_round_to_tripledouble(mpfr_t rop, mpfr_t op) { double d; mpfr_t accu, temp, rest; mp_prec_t prec; int res; prec = mpfr_get_prec(op); if (prec < 159) { prec = 159; } mpfr_init2(accu, prec); mpfr_init2(temp, prec); mpfr_init2(rest, prec); d = sollya_mpfr_get_d(op,GMP_RNDN); if (mpfr_set_d(accu,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on recasting to MPFR. This should not occur.\n"); } } if (mpfr_sub(rest,op,accu,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on subtracting in MPFR. This should not occur.\n"); } } d = sollya_mpfr_get_d(rest,GMP_RNDN); if (mpfr_set_d(temp,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on recasting to MPFR. This should not occur.\n"); } } if (mpfr_add(accu,accu,temp,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on subtracting in MPFR. This should not occur.\n"); } } if (mpfr_sub(rest,op,accu,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on subtracting in MPFR. This should not occur.\n"); } } d = sollya_mpfr_get_d(rest,GMP_RNDN); if (mpfr_set_d(temp,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on recasting to MPFR. This should not occur.\n"); } } if (mpfr_add(accu,accu,temp,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on subtracting in MPFR. This should not occur.\n"); } } if (mpfr_set(rop,accu,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } res = mpfr_cmp(rop,op); mpfr_clear(accu); mpfr_clear(temp); mpfr_clear(rest); return res; } int mpfr_round_to_tripledouble_mode(mpfr_t rop, mpfr_t op, mp_rnd_t mode) { double d; mpfr_t accu, temp, rest; mp_prec_t prec; int res; prec = mpfr_get_prec(op); if (prec < 159) { prec = 159; } mpfr_init2(accu, prec); mpfr_init2(temp, prec); mpfr_init2(rest, prec); d = sollya_mpfr_get_d(op,GMP_RNDN); if (mpfr_set_d(accu,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on recasting to MPFR. This should not occur.\n"); } } if (mpfr_sub(rest,op,accu,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on subtracting in MPFR. This should not occur.\n"); } } d = sollya_mpfr_get_d(rest,GMP_RNDN); if (mpfr_set_d(temp,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on recasting to MPFR. This should not occur.\n"); } } if (mpfr_add(accu,accu,temp,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on subtracting in MPFR. This should not occur.\n"); } } if (mpfr_sub(rest,op,accu,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on subtracting in MPFR. This should not occur.\n"); } } d = sollya_mpfr_get_d(rest,mode); if (mpfr_set_d(temp,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on recasting to MPFR. This should not occur.\n"); } } if (mpfr_add(accu,accu,temp,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The rounding occurred on subtracting in MPFR. This should not occur.\n"); } } if (mpfr_set(rop,accu,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE,"Warning: double rounding occurred on invoking the triple-double rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } res = mpfr_cmp(rop,op); mpfr_clear(accu); mpfr_clear(temp); mpfr_clear(rest); return res; } int printDoubleInHexa(mpfr_t x) { int res; double d; mpfr_t temp; db_number xdb, endiannessdb; mpfr_init2(temp,mpfr_get_prec(x)); d = sollya_mpfr_get_d(x,GMP_RNDN); if (mpfr_set_d(temp,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_CONVERTING_FROM_DOUBLE,"Warning: rounding occurred unexpectedly on reconverting a double value.\n"); } } res = mpfr_cmp(temp,x); if (res) { if (!noRoundingWarnings) { if (res < 0) printMessage(1,SOLLYA_MSG_ROUNDING_DOWN_BEFORE_PRINTING_DOUBLE,"Warning: rounding down occurred before printing a value as a double.\n"); else printMessage(1,SOLLYA_MSG_ROUNDING_UP_BEFORE_PRINTING_DOUBLE,"Warning: rounding up occurred before printing a value as a double.\n"); } } xdb.d = d; endiannessdb.d = 1.0; if ((endiannessdb.i[1] == 0x3ff00000) && (endiannessdb.i[0] == 0)) { sollyaPrintf("0x%08x%08x\n",xdb.i[1],xdb.i[0]); } else { if ((endiannessdb.i[0] == 0x3ff00000) && (endiannessdb.i[1] == 0)) { sollyaPrintf("0x%08x%08x\n",xdb.i[0],xdb.i[1]); } else { printMessage(1,SOLLYA_MSG_COULD_NOT_FIGURE_OUT_ENDIANESS,"Warning: could not figure out the endianness of the system. Will print 1.0 instead of the value.\n"); sollyaPrintf("0x3ff0000000000000\n"); } } mpfr_clear(temp); return res; } int printSimpleInHexa(mpfr_t x) { int res; volatile double d; mpfr_t tempRound; fl_number xfl; volatile float xfloat; if (mpfr_nan_p(x)) { xfl.i = 0x7fc00003; sollyaPrintf("0x%08x\n",xfl.i); return 0; } mpfr_init2(tempRound,24); res = mpfr_round_to_single(tempRound, x); d = sollya_mpfr_get_d(tempRound,GMP_RNDN); xfloat = d; xfl.f = xfloat; if (res) { if (!noRoundingWarnings) { if (res < 0) printMessage(1,SOLLYA_MSG_ROUNDING_DOWN_BEFORE_PRINTING_SINGLE,"Warning: rounding down occurred before printing a value as a single.\n"); else printMessage(1,SOLLYA_MSG_ROUNDING_DOWN_BEFORE_PRINTING_SINGLE,"Warning: rounding up occurred before printing a value as a single.\n"); } } sollyaPrintf("0x%08x\n",xfl.i); mpfr_clear(tempRound); return res; } int readHexaDouble(mpfr_t res, char *c) { int ret, i; int32_t msb, lsb; double x; char msbstr[9], lsbstr[9]; db_number xdb, endiannessdb; x = 1.0; c += 2; /* Skip over "0x" */ for (i=0;i<9;i++) { msbstr[i] = '\0'; lsbstr[i] = '\0'; } for (i=0;i<8;i++) { msbstr[i] = *c; c++; } for (i=0;i<8;i++) { lsbstr[i] = *c; c++; } msb = convertHexadecimalStringToInt32(msbstr); lsb = convertHexadecimalStringToInt32(lsbstr); endiannessdb.d = 1.0; if ((endiannessdb.i[1] == 0x3ff00000) && (endiannessdb.i[0] == 0)) { xdb.i[1] = msb; xdb.i[0] = lsb; } else { if ((endiannessdb.i[0] == 0x3ff00000) && (endiannessdb.i[1] == 0)) { xdb.i[0] = msb; xdb.i[1] = lsb; } else { printMessage(1,SOLLYA_MSG_COULD_NOT_FIGURE_OUT_ENDIANESS,"Warning: could not figure out the endianness of the system. Will read 1.0 instead of the value.\n"); xdb.d = 1.0; } } x = xdb.d; if ((!(x == x)) && ((msb & 0x00080000) == 0)) { printMessage(1,SOLLYA_MSG_SNAN_MIGHT_HAVE_BECOME_QNAN,"Warning: a sNaN might have been converted to a qNaN.\n"); } if (mpfr_set_d(res,x,GMP_RNDN) != 0) ret = 0; else ret = 1; return ret; } int readHexaSimple(mpfr_t res, char *c) { int ret, i; int32_t msb; double x; char msbstr[9]; fl_number xfl; float xfloat; x = 1.0; c += 2; /* Skip over "0x" */ for (i=0;i<9;i++) { msbstr[i] = '\0'; } for (i=0;i<8;i++) { msbstr[i] = *c; c++; } msb = convertHexadecimalStringToInt32(msbstr); xfl.i = msb; xfloat = xfl.f; x = xfloat; if ((!(x == x)) && ((msb & 0x00400000) == 0)) { printMessage(1,SOLLYA_MSG_SNAN_MIGHT_HAVE_BECOME_QNAN,"Warning: a sNaN might have been converted to a qNaN.\n"); } if (mpfr_set_d(res,x,GMP_RNDN) != 0) ret = 0; else ret = 1; return ret; } int readHexa(mpfr_t res, char *c) { if (strlen(c) == 18) return readHexaDouble(res, c); if (strlen(c) == 10) return readHexaSimple(res, c); printMessage(1,SOLLYA_MSG_UNABLE_TO_CONVERT_FROM_HEXADECIMAL_CONSTANT,"Warning: unable to convert the hexadecimal sequence \"%s\" to a constant.\n"); mpfr_set_nan(res); return 0; } node *roundPolynomialCoefficients(node *poly, chain *formats, mp_prec_t prec) { int degree, listLength, i, deg, res, fillUp, k; chain *curr, *monomials; int *formatsArray, *tempArray; node *roundedPoly, *temp; node **coefficients; mpfr_t *fpcoefficients; mpfr_t tempMpfr, dummyX; node *subPolyToRound, *subPolyRest, *tempNode; degree = getDegree(poly); if (degree < 0) { printMessage(1,SOLLYA_MSG_GIVEN_FUNCTION_IS_NO_POLYNOMIAL,"Warning: the given function is not a polynomial.\n"); return copyTree(poly); } listLength = lengthChain(formats); if (*((int *) formats->value) == -1) { fillUp = 1; curr = formats->next; } else { curr = formats; fillUp = 0; if (listLength < (degree + 1)) { printMessage(1,SOLLYA_MSG_NUM_OF_FORMATS_DOES_NOT_CORRESPOND_TO_DEGREE,"Warning: the number of the given formats does not correspond to the degree of the given polynomial.\n"); monomials = makeIntPtrChainFromTo(0, listLength-1); subPolyToRound = getSubpolynomial(poly, monomials, 0, prec); freeChain(monomials, freeIntPtr); monomials = makeIntPtrChainFromTo(listLength, degree); subPolyRest = getSubpolynomial(poly, monomials, 0, prec); freeChain(monomials, freeIntPtr); tempNode = makeAdd(roundPolynomialCoefficients(subPolyToRound, formats, prec), subPolyRest); free_memory(subPolyToRound); temp = horner(tempNode); free_memory(tempNode); return temp; } } tempArray = (int *) safeCalloc(degree + 1,sizeof(int)); i = 0; while ((curr != NULL) && (i <= degree)) { tempArray[i] = *((int *) curr->value); i++; curr = curr->next; } k = i; formatsArray = (int *) safeCalloc(degree + 1,sizeof(int)); if (fillUp) { for (i=k-1;i>=0;i--) { formatsArray[(k-1) - i] = tempArray[i]; } for (i=k;i<=degree;i++) { formatsArray[i] = formatsArray[k-1]; } } else { for (i=degree;i>=0;i--) { formatsArray[degree - i] = tempArray[i]; } } safeFree(tempArray); getCoefficients(°,&coefficients,poly); if (deg != degree) { printMessage(1,SOLLYA_MSG_ERROR_WHILE_EXTRACTING_COEFFICIENTS_OF_POLY,"Warning: an error occurred while extracting the coefficients of the polynomial.\n"); for (i=0;i<=deg;i++) { if (coefficients[i] != NULL) free_memory(coefficients[i]); } safeFree(coefficients); return copyTree(poly); } fpcoefficients = (mpfr_t *) safeCalloc(degree+1,sizeof(mpfr_t)); mpfr_init2(tempMpfr,prec > 160 ? prec : 160); res = 0; for (i=0;i<=degree;i++) { if (coefficients[i] != NULL) { temp = simplifyTreeErrorfree(coefficients[i]); free_memory(coefficients[i]); if (accessThruMemRef(temp)->nodeType != CONSTANT) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ERROR_POLY_COEFF_GETS_ROUNDED,"Warning: the %dth coefficient of the given polynomial does not evaluate to a floating-point constant without any rounding.\n",i); printMessage(1,SOLLYA_MSG_CONTINUATION,"Will evaluate the coefficient in the current precision in floating-point before rounding to the target format.\n"); } mpfr_init2(fpcoefficients[i],prec); mpfr_init2(dummyX, prec); mpfr_set_si(dummyX, 1, GMP_RNDN); if (!evaluateFaithful(fpcoefficients[i], temp, dummyX, prec)) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ERROR_EVALUATION_OF_POLY_COEFF_NOT_FAITHFUL,"Warning: the evaluation of the %dth coefficient is not faithful.\n",i); } evaluateConstantExpression(fpcoefficients[i], temp, 256 * prec); } mpfr_clear(dummyX); res = 1; } else { mpfr_init2(fpcoefficients[i],mpfr_get_prec(*(accessThruMemRef(temp)->value))); mpfr_set(fpcoefficients[i],*(accessThruMemRef(temp)->value),GMP_RNDN); } free_memory(temp); } else { mpfr_init2(fpcoefficients[i],prec); mpfr_set_d(fpcoefficients[i],0.0,GMP_RNDN); } switch (formatsArray[i]) { case 7: if (mpfr_round_to_quad(tempMpfr, fpcoefficients[i]) != 0) res = 1; break; case 6: if (mpfr_round_to_halfprecision(tempMpfr, fpcoefficients[i]) != 0) res = 1; break; case 5: if (mpfr_round_to_single(tempMpfr, fpcoefficients[i]) != 0) res = 1; break; case 4: if (mpfr_round_to_doubleextended(tempMpfr, fpcoefficients[i]) != 0) res = 1; break; case 3: if (mpfr_round_to_tripledouble(tempMpfr, fpcoefficients[i]) != 0) res = 1; break; case 2: if (mpfr_round_to_doubledouble(tempMpfr, fpcoefficients[i]) != 0) res = 1; break; case 1: if (mpfr_round_to_double(tempMpfr, fpcoefficients[i]) != 0) res = 1; break; default: if (formatsArray[i] > 7) { if (mpfr_round_to_prec(tempMpfr, fpcoefficients[i], (mp_prec_t) (formatsArray[i] - 6)) != 0) res = 1; } else { printMessage(1,SOLLYA_MSG_ERROR_UNKNOWN_EXPANSION_FORMAT,"Warning: unknown expansion format found. No rounding will be performed.\n"); mpfr_set(tempMpfr,fpcoefficients[i],GMP_RNDN); } } if (mpfr_set(fpcoefficients[i],tempMpfr,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_ON_HANDLING_POLY_COEFF,"Warning: double rounding occurred on internal handling of a coefficient.\nTry to increase the precision.\n"); } } } safeFree(coefficients); if (res) { if (!noRoundingWarnings) { printMessage(2,SOLLYA_MSG_AT_LEAST_ONE_POLY_COEFF_HAS_BEEN_ROUNDED,"Information: at least one coefficient has been rounded.\n"); } } else { if (!noRoundingWarnings) { printMessage(2,SOLLYA_MSG_NONE_OF_THE_POLY_COEFFS_HAS_BEEN_ROUNDED,"Information: there has not been any rounding of the coefficients.\n"); } } roundedPoly = makePolynomial(fpcoefficients, degree); for (i=0;i<=degree;i++) mpfr_clear(fpcoefficients[i]); safeFree(fpcoefficients); safeFree(formatsArray); mpfr_clear(tempMpfr); return roundedPoly; } int printDoubleExpansion(mpfr_t x) { double d; mpfr_t temp, rest; db_number xdb, endiannessdb; int noBrackets, roundingOccured; mpfr_init2(temp,mpfr_get_prec(x)); mpfr_init2(rest,mpfr_get_prec(x)); mpfr_set(rest,x,GMP_RNDN); roundingOccured = 0; noBrackets = 0; d = sollya_mpfr_get_d(x,GMP_RNDN); if (mpfr_set_d(temp,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_CONVERTING_FROM_DOUBLE,"Warning: rounding occurred unexpectedly on reconverting a double value.\n"); } roundingOccured = 1; } if (!mpfr_number_p(temp)) { printMessage(1,SOLLYA_MSG_NON_REAL_NUMBER_CANNOT_BE_DOUBLE_EXPANSION,"Warning: will not print a number that is not real as a double expansion.\n"); printValue(&temp); mpfr_clear(temp); mpfr_clear(rest); return 1; } if (mpfr_cmp(temp,x) == 0) noBrackets = 1; if (!noBrackets) sollyaPrintf("("); do { d = sollya_mpfr_get_d(rest,GMP_RNDN); if (mpfr_set_d(temp,d,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_CONVERTING_FROM_DOUBLE,"Warning: rounding occurred unexpectedly on reconverting a double value.\n"); } roundingOccured = 1; } xdb.d = d; endiannessdb.d = 1.0; if ((endiannessdb.i[1] == 0x3ff00000) && (endiannessdb.i[0] == 0)) { sollyaPrintf("0x%08x%08x",xdb.i[1],xdb.i[0]); } else { if ((endiannessdb.i[0] == 0x3ff00000) && (endiannessdb.i[1] == 0)) { sollyaPrintf("0x%08x%08x",xdb.i[0],xdb.i[1]); } else { printMessage(1,SOLLYA_MSG_COULD_NOT_FIGURE_OUT_ENDIANESS,"Warning: could not figure out the endianness of the system. Will print 1.0 instead of the value.\n"); sollyaPrintf("0x3ff0000000000000\n"); roundingOccured = 1; } } if (mpfr_sub(rest,rest,temp,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_ON_CONVERSION,"Warning: rounding occurred unexpectedly on subtracting.\n"); } roundingOccured = 1; } if ((d != 0.0) && (!mpfr_zero_p(rest))) { sollyaPrintf(" + "); } } while ((d != 0.0) && (!mpfr_zero_p(rest))); if (!noBrackets) sollyaPrintf(")"); if (!mpfr_zero_p(rest)) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_EXPANSION_INCOMPLETE,"\nWarning: the expansion is not complete because of the limited exponent range of double precision."); } roundingOccured = 1; } mpfr_clear(temp); mpfr_clear(rest); return roundingOccured; } int printPolynomialAsDoubleExpansion(node *poly, mp_prec_t prec) { int degree, roundingOccured, i, k, l; node **coefficients; node *tempNode, *simplifiedTreeSafe, *simplifiedTree, *myTree; mpfr_t tempValue, tempValue2; roundingOccured = 0; tempNode = horner(poly); simplifiedTreeSafe = simplifyTreeErrorfree(tempNode); free_memory(tempNode); simplifiedTree = simplifyTree(simplifiedTreeSafe); if (!isPolynomial(simplifiedTreeSafe)) { if (!isPolynomial(simplifiedTree)) { printMessage(1,SOLLYA_MSG_GIVEN_FUNCTION_IS_NO_POLYNOMIAL,"Warning: the given expression is not a polynomial."); free_memory(simplifiedTree); free_memory(simplifiedTreeSafe); return -1; } else { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_WHILE_SIMPLIFYING_TO_POLYNOMIAL,"Warning: rounding occurred while simplifying to a polynomial form.\n"); } roundingOccured = 1; myTree = simplifiedTree; free_memory(simplifiedTreeSafe); } } else { myTree = simplifiedTreeSafe; free_memory(simplifiedTree); } getCoefficients(°ree, &coefficients, myTree); mpfr_init2(tempValue,prec); mpfr_init2(tempValue2,prec); mpfr_set_d(tempValue2,1.0,GMP_RNDN); k = 0; l = 0; for (i=0;i<=degree;i++) { if (coefficients[i] != NULL) { if (k > 0) { if (k == 1) { sollyaPrintf("%s * ",((variablename == NULL) ? "_x_" : variablename)); } else { sollyaPrintf("%s^%d * ",((variablename == NULL) ? "_x_" : variablename),k); } } if ((i != degree) && (i != 0)) { sollyaPrintf("("); l++; } tempNode = simplifyTreeErrorfree(coefficients[i]); if (accessThruMemRef(tempNode)->nodeType == CONSTANT) { roundingOccured |= printDoubleExpansion(*(accessThruMemRef(tempNode)->value)); } else { if (!isConstant(tempNode)) { printMessage(1,SOLLYA_MSG_POLY_COEFF_IS_NOT_CONSTANT,"Error: a coefficient of a polynomial is not constant.\n"); } if (!evaluateFaithful(tempValue, tempNode, tempValue2, prec)) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_SOME_EVALUATION_IS_NOT_FAITHFUL,"Warning: an evaluation is not faithful.\n"); } evaluate(tempValue, tempNode, tempValue2, 256 * prec); } printDoubleExpansion(tempValue); roundingOccured = 1; } free_memory(tempNode); free_memory(coefficients[i]); k = 1; if (i != degree) { sollyaPrintf(" + "); } } else { k++; } } for (i=0;inodeType == CONSTANT) { *ternaryOkay = 1; *ternary = round_to_format_or_expansion_format(rop, *(accessThruMemRef(func)->value), expansion_format_round, format, prec, mode); return 1; } startPrec = 200; if (!expansion_format_round) { if (prec + 10 > startPrec) startPrec = prec + 10; } sollya_mpfi_init2(y, startPrec); mpfr_init2(ya, startPrec); mpfr_init2(yb, startPrec); mpfr_init2(rya, startPrec); mpfr_init2(ryb, startPrec); sollya_mpfi_init2(x, 12); sollya_mpfi_set_si(x, 1); for (p = startPrec; p <= 512 * startPrec; p <<= 1) { sollya_mpfi_set_prec(y, p); mpfr_set_prec(ya, p); mpfr_set_prec(yb, p); evaluateInterval(y, func, NULL, x); sollya_mpfi_get_left(ya, y); sollya_mpfi_get_right(yb, y); ta = round_to_format_or_expansion_format(rya, ya, expansion_format_round, format, prec, mode); tb = round_to_format_or_expansion_format(ryb, yb, expansion_format_round, format, prec, mode); if ((!mpfr_nan_p(rya)) && (!mpfr_nan_p(ryb)) && mpfr_equal_p(rya, ryb) && (ta == tb)) { writeBackRnd = GMP_RNDN; if (ta < 0) writeBackRnd = GMP_RNDD; if (ta > 0) writeBackRnd = GMP_RNDU; *ternary = ta; *ternaryOkay = 1; if ((ta = mpfr_set(rop, rya, writeBackRnd)) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_UNDESIRED_ROUNDING_IN_ROUND_TO_FORMAT,"Warning: an undesired rounding occurred on a rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } *ternary = ta; } sollya_mpfi_clear(y); mpfr_clear(ya); mpfr_clear(yb); mpfr_clear(rya); mpfr_clear(ryb); sollya_mpfi_clear(x); return 1; } } /* If we are here, we never got a correct rounding or we always got NaNs. We are going to re-evaluate the values in ya and yb. First, we check if either of them is a NaN, in which case we return NaN. */ if (mpfr_nan_p(ya) || mpfr_nan_p(yb)) { *ternaryOkay = 1; if (mpfr_nan_p(ya)) { *ternary = round_to_format_or_expansion_format(rop, ya, expansion_format_round, format, prec, mode); } else { *ternary = round_to_format_or_expansion_format(rop, yb, expansion_format_round, format, prec, mode); } sollya_mpfi_clear(y); mpfr_clear(ya); mpfr_clear(yb); mpfr_clear(rya); mpfr_clear(ryb); sollya_mpfi_clear(x); return 1; } /* Here, ya and yb can be either real numbers bounding func or infinities. We continue by checking if either of them is an infinity. */ if (mpfr_inf_p(ya) || mpfr_inf_p(yb)) { /* At least one of ya and yb is an infinity. Check if both are infinity. */ if (mpfr_inf_p(ya) && mpfr_inf_p(yb)) { /* Here, both numbers are infinity. Check if they are identical */ if ( ((mpfr_sgn(ya) > 0) && (mpfr_sgn(yb) > 0)) || ((mpfr_sgn(ya) < 0) && (mpfr_sgn(yb) < 0)) ) { /* They are equal: return the rounding of infinity. */ *ternaryOkay = 1; *ternary = round_to_format_or_expansion_format(rop, ya, expansion_format_round, format, prec, mode); sollya_mpfi_clear(y); mpfr_clear(ya); mpfr_clear(yb); mpfr_clear(rya); mpfr_clear(ryb); sollya_mpfi_clear(x); return 1; } else { /* They are different infinities. Return NaN */ if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_NO_CORRECT_ROUNDING_FOR_ROUND_OPERATOR,"Warning: no correctly rounded result could be obtained upon evaluation of a rounding operator.\n"); printMessage(2,SOLLYA_MSG_NO_CORRECT_TERNARY_VALUE_FOR_ROUND,"Warning: the actual rounding direction for a round operation could not be determined.\n"); } *ternaryOkay = 0; mpfr_set_nan(ya); *ternary = round_to_format_or_expansion_format(rop, ya, expansion_format_round, format, prec, mode); sollya_mpfi_clear(y); mpfr_clear(ya); mpfr_clear(yb); mpfr_clear(rya); mpfr_clear(ryb); sollya_mpfi_clear(x); return 1; } } /* Here only one of ya or yb is an infinity, the other one is a real number We simply display a warning and return the rounding of the one of ya and yb that is a real number. */ if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_NO_CORRECT_ROUNDING_FOR_ROUND_OPERATOR,"Warning: no correctly rounded result could be obtained upon evaluation of a rounding operator.\n"); printMessage(2,SOLLYA_MSG_NO_CORRECT_TERNARY_VALUE_FOR_ROUND,"Warning: the actual rounding direction for a round operation could not be determined.\n"); } *ternaryOkay = 0; if (mpfr_inf_p(ya)) { *ternary = round_to_format_or_expansion_format(rop, yb, expansion_format_round, format, prec, mode); } else { *ternary = round_to_format_or_expansion_format(rop, ya, expansion_format_round, format, prec, mode); } sollya_mpfi_clear(y); mpfr_clear(ya); mpfr_clear(yb); mpfr_clear(rya); mpfr_clear(ryb); sollya_mpfi_clear(x); return 1; } /* Here both ya and yb are real numbers bounding func. Distinguish two cases: directed rounding and rounding to nearest. For the directed rounding modes, try to compute the value in ROUND-TO-NEAREST first (which yields the rounding boundary). Then round that rounding boundary. For round-to-nearest, a special algorithm is used (see below). */ if (mode != GMP_RNDN) { /* Directed rounding mode */ ta = round_to_format_or_expansion_format(rya, ya, expansion_format_round, format, prec, GMP_RNDN); tb = round_to_format_or_expansion_format(ryb, yb, expansion_format_round, format, prec, GMP_RNDN); if ((!mpfr_nan_p(rya)) && (!mpfr_nan_p(ryb)) && mpfr_equal_p(rya, ryb)) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OF_BOUNDARY_INSTEAD_OF_CORRECT_ROUNDING,"Warning: the returned rounding is the rounding of the rounding boundary because correct rounding has not been possible.\n"); } *ternary = round_to_format_or_expansion_format(rop, rya, expansion_format_round, format, prec, mode); *ternaryOkay = 0; sollya_mpfi_clear(y); mpfr_clear(ya); mpfr_clear(yb); mpfr_clear(rya); mpfr_clear(ryb); sollya_mpfi_clear(x); return 1; } /* Here, we could not even compute the rounding boundary. We return some approximation. */ mpfr_add(ya, ya, yb, GMP_RNDN); /* might round but only need an approximation */ mpfr_div_2ui(ya, ya, 1, GMP_RNDN); if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_NO_CORRECT_ROUNDING_FOR_ROUND_OPERATOR,"Warning: no correctly rounded result could be obtained upon evaluation of a rounding operator.\n"); printMessage(2,SOLLYA_MSG_NO_CORRECT_TERNARY_VALUE_FOR_ROUND,"Warning: the actual rounding direction for a round operation could not be determined.\n"); } *ternary = round_to_format_or_expansion_format(rop, rya, expansion_format_round, format, prec, mode); *ternaryOkay = 0; sollya_mpfi_clear(y); mpfr_clear(ya); mpfr_clear(yb); mpfr_clear(rya); mpfr_clear(ryb); sollya_mpfi_clear(x); return 1; } /* Here, we are in round-to-nearest mode and we know that both ya and yb are real numbers. We first check if rounding to nearest would actually be possible if we forgot about the ternary value. */ if ((!mpfr_nan_p(rya)) && (!mpfr_nan_p(ryb)) && mpfr_equal_p(rya, ryb)) { /* Here, we know the correct rounding rya = ryb but we are unable to produce the ternary value. */ if (!noRoundingWarnings) { printMessage(2,SOLLYA_MSG_NO_CORRECT_TERNARY_VALUE_FOR_ROUND_BUT_CORRECT_ROUNDING,"Warning: correct rounding was possible but the actual rounding direction could not be determined.\n"); } writeBackRnd = GMP_RNDN; if (ta < 0) writeBackRnd = GMP_RNDD; if (ta > 0) writeBackRnd = GMP_RNDU; *ternary = ta; *ternaryOkay = 0; if ((ta = mpfr_set(rop, rya, writeBackRnd)) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_UNDESIRED_ROUNDING_IN_ROUND_TO_FORMAT,"Warning: an undesired rounding occurred on a rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } *ternary = ta; } sollya_mpfi_clear(y); mpfr_clear(ya); mpfr_clear(yb); mpfr_clear(rya); mpfr_clear(ryb); sollya_mpfi_clear(x); return 1; } /* Here, we are in round-to-nearest mode, ya and yb are real numbers but we cannot produce a correct rounding. We suppose that ya and yb are just around the midpoint for the considered format but that [ya;yb] is in the interior of the interval of the two consecutive floating-point numbers of the format around that midpoint. So we round ya down, yb up, take the middle and round it to the target format. We have no means to tell if our assumption was correct, as we can no way perform nextabove or nextbelow operations on double-double or triple-double expansions. So in the worst case, we get some approximation first and a correct rounding of that approximation. In any case, we have to forget about the ternary value. */ round_to_format_or_expansion_format(rya, ya, expansion_format_round, format, prec, GMP_RNDD); round_to_format_or_expansion_format(ryb, yb, expansion_format_round, format, prec, GMP_RNDU); mpfr_init2(tya, mpfr_get_prec(rya) + 10); mpfr_add(tya, rya, ryb, GMP_RNDN); mpfr_div_2ui(tya, tya, 1, GMP_RNDN); if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_NO_CORRECT_ROUNDING_FOR_ROUND_OPERATOR,"Warning: no correctly rounded result could be obtained upon evaluation of a rounding operator.\n"); printMessage(2,SOLLYA_MSG_NO_CORRECT_TERNARY_VALUE_FOR_ROUND,"Warning: the actual rounding direction for a round operation could not be determined.\n"); } *ternaryOkay = 0; *ternary = round_to_format_or_expansion_format(rop, tya, expansion_format_round, format, prec, mode); mpfr_clear(tya); sollya_mpfi_clear(y); mpfr_clear(ya); mpfr_clear(yb); mpfr_clear(rya); mpfr_clear(ryb); sollya_mpfi_clear(x); return 1; } int mpfr_mant_exp(mpfr_t rop, mp_exp_t *expo, mpfr_t op) { mp_exp_t e; mp_prec_t p; mpfr_t temp; int res; if (!mpfr_number_p(op)) { *expo = 0; return mpfr_set(rop,op,GMP_RNDN); } if (mpfr_zero_p(op)) { *expo = 0; return mpfr_set(rop,op,GMP_RNDN); } p = mpfr_get_prec(op); mpfr_init2(temp,p); mpfr_set(temp,op,GMP_RNDN); e = mpfr_get_exp(temp) - p; mpfr_set_exp(temp,p); while (mpfr_integer_p(temp)) { mpfr_div_2ui(temp,temp,1,GMP_RNDN); e++; } mpfr_mul_2ui(temp,temp,1,GMP_RNDN); e--; *expo = e; res = mpfr_set(rop,temp,GMP_RNDN); mpfr_clear(temp); return res; } int roundRangeCorrectly(mpfr_t rop, mpfr_t a, mpfr_t b) { mp_exp_t expoA, expoB; int expoDiff; mp_prec_t prec, p; mpfr_t tempA, tempB; int okay; if (mpfr_sgn(a) != mpfr_sgn(b)) { mpfr_set_nan(rop); return 0; } expoA = mpfr_get_exp(a); expoB = mpfr_get_exp(b); expoDiff = expoA - expoB; if (expoDiff < 0) expoDiff = -expoDiff; if (expoDiff > 1) { mpfr_set_nan(rop); return 0; } prec = mpfr_get_prec(a); p = mpfr_get_prec(b); if (p > prec) prec = p; mpfr_init2(tempA,prec); mpfr_init2(tempB,prec); okay = 0; while (prec >= 3) { mpfr_set(tempA,a,GMP_RNDN); mpfr_set(tempB,b,GMP_RNDN); if (mpfr_cmp(tempA,tempB) == 0) { okay = 1; break; } prec--; mpfr_set_prec(tempA,prec); mpfr_set_prec(tempB,prec); } if (prec < 12) prec = 12; if (okay) { mpfr_set_prec(rop,prec); mpfr_set(rop,tempA,GMP_RNDN); } else{ mpfr_set_nan(rop); } mpfr_clear(tempA); mpfr_clear(tempB); return okay; } void continuedFrac(mpq_t q, sollya_mpfi_t x) { sollya_mpfi_t xprime; mpfr_t a,b; mpfr_t m1,m2; mp_prec_t t; mpq_t res; mpz_t u; t = sollya_mpfi_get_prec(x); if (t<= tools_precision) t=tools_precision; sollya_mpfi_init2(xprime,t); mpfr_init2(a,t); mpfr_init2(b,t); mpfr_init2(m1,t); mpfr_init2(m2,t); mpq_init(res); mpz_init(u); sollya_mpfi_get_left(a,x); sollya_mpfi_get_right(b,x); mpfr_floor(m1,a); /* really a floor because m1 and a have the same precision */ mpfr_floor(m2,b); /* really a floor because m2 and b have the same precision */ if (mpfr_equal_p(m1,m2) && (!mpfr_equal_p(a, m1))) { mpfr_get_z(u,m1,GMP_RNDN); /* exact */ mpfr_sub(a,a,m1,GMP_RNDD); mpfr_sub(b,b,m1,GMP_RNDU); sollya_mpfi_interv_fr(xprime,a,b); sollya_mpfi_inv(xprime,xprime); continuedFrac(res,xprime); mpq_inv(res,res); mpq_set_z(q,u); mpq_add(q,q,res); } else { /* According to http://en.wikipedia.org/wiki/Continued_fraction, section "Best rational within an interval", the best fraction is given by taking the smallest integer in [a,b] */ if (!mpfr_equal_p(a,m1)) mpfr_add_ui(m1, m1,1,GMP_RNDU); mpfr_get_z(u,m1,GMP_RNDN); mpq_set_z(q,u); } sollya_mpfi_clear(xprime); mpfr_clear(a); mpfr_clear(b); mpfr_clear(m1); mpfr_clear(m2); mpq_clear(res); mpz_clear(u); return; } node *rationalApprox(mpfr_t x, int n) { mpq_t q; mpz_t u; sollya_mpfi_t xprime; node *tree; node *num; node *denom; mpfr_t *numerator; mpfr_t *denominator; /* n should be >= 2 */ if (n<2) { printMessage(1, SOLLYA_MSG_RATIONALAPPROX_SECOND_ARG_MUST_BE_GREATER_THAN_ONE, "Error in rationalapprox: the second argument of rationalapprox must be greater or equal to 2.\n"); return makeError(); } if ( (!mpfr_number_p(x)) || mpfr_zero_p(x) ) return makeConstant(x); mpq_init(q); mpz_init(u); sollya_mpfi_init2(xprime,(mp_prec_t)(n+1)); sollya_mpfi_set_fr(xprime,x); /* The bounds of xprime are two consecutive FP numbers at precision n+1. Hence sup(xprime)-inf(xprime) <= 2^(1-(n+1))*inf(abs(xprime)) Hence, for any t in xprime, |x-t| <= 2^(-n)*|x| */ continuedFrac(q,xprime); mpq_get_num(u,q); numerator = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*numerator,mp_bits_per_limb*mpz_size(u)); mpfr_set_z(*numerator,u,GMP_RNDN); mpq_get_den(u,q); denominator = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*denominator,mp_bits_per_limb*mpz_size(u)); mpfr_set_z(*denominator,u,GMP_RNDN); tree = safeMalloc(sizeof(node)); tree->nodeType = DIV; num = safeMalloc(sizeof(node)); denom = safeMalloc(sizeof(node)); num->nodeType = CONSTANT; denom->nodeType = CONSTANT; num->value = numerator; denom->value = denominator; tree->child1 = num; tree->child2 = denom; sollya_mpfi_clear(xprime); mpq_clear(q); mpz_clear(u); return tree; } int mpfr_round_to_ieee_format(mpfr_t rop, mpfr_t op, mp_prec_t prec, unsigned int width, mp_rnd_t mode) { int res; mpfr_t result; unsigned int exponent; mpfr_t largest, smallest, temp; mp_prec_t p; /* In the case when the function is called with a silly width (less than 3 or larger than 30), we exit from the tool. This case should never happen. */ if ((width < 3) || (width > 30)) { sollyaFprintf(stderr,"Error: mpfr_round_to_ieee_format: an exponent width of less than 3 or larger than 30 is not supported\n"); exit(1); } /* We will first produce an internal result and then write back to rop */ mpfr_init2(result,prec); /* Handle the special cases: +/- 0, +/- Inf, NaN */ if (mpfr_zero_p(op) || (!mpfr_number_p(op))) { /* The result is the input */ mpfr_set(result, op, GMP_RNDN); /* exact */ } else { /* Here, the input is not zero, nor Inf nor NaN We start with the first rounding step with unbounded exponent. */ mpfr_set(result, op, mode); /* performs a rounding to the desired precision but with unbounded exponent */ /* Now check if overflow occurs: compare in magnitude with the largest representable number of the format. The largest number is 1 ulp (of precision prec) below 2^(2^(width - 1)). */ exponent = 1 << (width - 1); mpfr_init2(largest, prec); mpfr_set_ui(largest, 1, GMP_RNDN); /* exact: power of 2 */ mpfr_mul_2ui(largest, largest, exponent, GMP_RNDN); /* exact: power of 2 */ mpfr_nextbelow(largest); /* exact by specification */ if (mpfr_cmpabs(result, largest) > 0) { /* Here, we have an overflow Depending on the rounding mode and the sign of the input we get the largest representable number or +/- Inf as a result */ switch (mode) { case GMP_RNDN: /* -Inf, +Inf */ if (mpfr_sgn(op) < 0) { mpfr_set_inf(result, -1); } else { mpfr_set_inf(result, +1); } break; case GMP_RNDD: /* -Inf, +largest */ if (mpfr_sgn(op) < 0) { mpfr_set_inf(result, -1); } else { mpfr_set(result, largest, GMP_RNDN); /* exact: same precision */ } break; case GMP_RNDU: /* -largest, +Inf */ if (mpfr_sgn(op) < 0) { mpfr_neg(result, largest, GMP_RNDN); /* exact: same precision */ } else { mpfr_set_inf(result, +1); } break; case GMP_RNDZ: /* -largest, +largest */ if (mpfr_sgn(op) < 0) { mpfr_neg(result, largest, GMP_RNDN); /* exact: same precision */ } else { mpfr_set(result, largest, GMP_RNDN); /* exact: same precision */ } break; default: sollyaFprintf(stderr,"Error: mpfr_round_to_ieee_format: unknown rounding mode %d\n", (int) mode); exit(1); } } else { /* Here, the result is either a signed 0, denormal or normal We continue by checking if the first rounding is larger than the least normal. For a format of width bits of exponent, the smallest normal is 2^(-2^(width - 1) + 2). */ mpfr_init2(smallest, prec); exponent = 1 << (width - 1); exponent -= 2; mpfr_set_ui(smallest, 1, GMP_RNDN); /* exact: power of 2 */ mpfr_div_2ui(smallest, smallest, exponent, GMP_RNDN); /* exact: power of 2 */ if (mpfr_cmpabs(result, smallest) < 0) { /* Here, we have to emulate denormal rounding Denormal rounding for precision prec and exponent width width is: result = 2^(-prec - 2^(width - 1) + 3) * round_integer((1/(2^(-prec - 2^(width - 1) + 3))) * op, mode) In other words, result = smallest * 2^(1-prec) * round_integer( 2^(prec-1)*op/smallest, mode) ( the interval [0, smallest) is sent to [0, 2^(prec-1) ) where fixed-point computations at precision prec are exactly integer computations, and then we send it back to [0, smallest) ) */ p = mpfr_get_prec(op); mpfr_init2(temp, p); mpfr_set(temp, op, GMP_RNDN); /* exact: precision of temp not less than the one of op */ exponent = 1 << (width - 1); exponent -= 3; exponent += prec; mpfr_mul_2ui(temp, temp, exponent, GMP_RNDN); /* exact: power of 2 and same precision */ mpfr_rint(result, temp, mode); /* Performs round_integer with mode no wrong rounding possible as precision of result is prec and |temp| <= 2^(prec-1) */ mpfr_div_2ui(result, result, exponent, GMP_RNDN); /* exact: power of 2 and same precision */ mpfr_clear(temp); } /* Otherwise the first rounding is already the final result. */ mpfr_clear(smallest); } mpfr_clear(largest); } /* Write back the result, while verifying if we don't get a double rounding there. */ /* Double-rounding may occur if the precision of rop is smaller than the prec. */ if (mpfr_set(rop,result,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_IEEE_754_2008_OPERATOR,"Warning: double rounding occurred on invoking the IEEE 754-2008 general rounding operator.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } mpfr_clear(result); /* Compute the rounding direction that has finally been chosen */ res = mpfr_cmp(rop,op); return res; } int mpfr_round_to_single(mpfr_t rop, mpfr_t x) { return mpfr_round_to_ieee_format(rop, x, 24, 8, GMP_RNDN); } int mpfr_round_to_single_mode(mpfr_t rop, mpfr_t x, mp_rnd_t mode) { return mpfr_round_to_ieee_format(rop, x, 24, 8, mode); } int mpfr_round_to_quad(mpfr_t rop, mpfr_t x) { return mpfr_round_to_ieee_format(rop, x, 113, 15, GMP_RNDN); } int mpfr_round_to_halfprecision(mpfr_t rop, mpfr_t x) { return mpfr_round_to_ieee_format(rop, x, 11, 5, GMP_RNDN); } int mpfr_round_to_quad_mode(mpfr_t rop, mpfr_t x, mp_rnd_t mode) { return mpfr_round_to_ieee_format(rop, x, 113, 15, mode); } int mpfr_round_to_halfprecision_mode(mpfr_t rop, mpfr_t x, mp_rnd_t mode) { return mpfr_round_to_ieee_format(rop, x, 11, 5, mode); } int mpfr_round_to_doubleextended(mpfr_t rop, mpfr_t op) { return mpfr_round_to_ieee_format(rop, op, 64, 15, GMP_RNDN); } int mpfr_round_to_doubleextended_mode(mpfr_t rop, mpfr_t op, mp_rnd_t mode) { return mpfr_round_to_ieee_format(rop, op, 64, 15, mode); } int sollya_mpfr_rint_nearestint(mpfr_t rop, mpfr_t op, mpfr_rnd_t rnd) { mpfr_t temp; int res; mpfr_init2(temp, mpfr_get_prec(op)); mpfr_rint(temp, op, GMP_RNDN); /* No double rounding possible because precision the same */ res = mpfr_set(rop, temp, rnd); mpfr_clear(temp); return res; } sollya-6.0+ds/double.h000066400000000000000000000077571300174114700147250ustar00rootroot00000000000000/* Copyright 2006-2013 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef DOUBLE_H #define DOUBLE_H #include #include "expression.h" #include "chain.h" int round_to_format(mpfr_t rop, mpfr_t op, int prec, mp_rnd_t mode); int round_to_expansion_format(mpfr_t rop, mpfr_t op, int format, mp_rnd_t mode); int round_to_format_or_expansion_format(mpfr_t rop, mpfr_t op, int expansion_format_round, int format, mp_prec_t prec, mp_rnd_t mode); int round_constant_expr_to_format_or_expansion_format(int *ternary, int *ternaryOkay, mpfr_t rop, node *op, int expansion_format_round, int format, mp_prec_t prec, mp_rnd_t mode); int mpfr_round_to_double(mpfr_t rop, mpfr_t op); int mpfr_round_to_single(mpfr_t rop, mpfr_t op); int mpfr_round_to_single_mode(mpfr_t rop, mpfr_t op, mp_rnd_t mode); int mpfr_round_to_quad(mpfr_t rop, mpfr_t x); int mpfr_round_to_halfprecision(mpfr_t rop, mpfr_t x); int mpfr_round_to_quad_mode(mpfr_t rop, mpfr_t x, mp_rnd_t mode); int mpfr_round_to_halfprecision_mode(mpfr_t rop, mpfr_t x, mp_rnd_t mode); int mpfr_round_to_doubledouble(mpfr_t rop, mpfr_t op); int mpfr_round_to_tripledouble(mpfr_t rop, mpfr_t op); int mpfr_round_to_doubleextended(mpfr_t rop, mpfr_t op); int printDoubleInHexa(mpfr_t x); int printSimpleInHexa(mpfr_t x); int readHexa(mpfr_t res, char *c); node *roundPolynomialCoefficients(node *poly, chain *formats, mp_prec_t prec); int printDoubleExpansion(mpfr_t x); int printPolynomialAsDoubleExpansion(node *poly, mp_prec_t prec); void mpfr_round_to_format(mpfr_t rop, mpfr_t op, int format); int mpfr_mant_exp(mpfr_t rop, mp_exp_t *expo, mpfr_t op); int roundRangeCorrectly(mpfr_t rop, mpfr_t a, mpfr_t b); node *rationalApprox(mpfr_t x, int n); int sollya_mpfr_rint_nearestint(mpfr_t rop, mpfr_t op, mpfr_rnd_t rnd); #endif /* ifdef DOUBLE_H*/ sollya-6.0+ds/execute.c000066400000000000000000034557241300174114700151140ustar00rootroot00000000000000/* Copyright 2007-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard, M. Joldes christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org joldes@laas.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include "mpfi-compat.h" #include #include "execute.h" #include #include #include #include #include #include "general.h" #include "expression.h" #include "infnorm.h" #include "assignment.h" #include "autodiff.h" #include "library.h" #include "external.h" #include "plot.h" #include "remez.h" #include "fpminimax.h" #include "integral.h" #include "double.h" #include "worstcase.h" #include "implement.h" #include "implementconst.h" #include "taylor.h" #include "taylorform.h" #include "chebyshevform.h" #include "supnorm.h" #include "xml.h" #include "miniparser.h" #include "match.h" #include "sollya-messaging.h" #include #include "hooks.h" #include "polynomials.h" #include "hash.h" #ifdef HAVE_CONFIG_H #include "config.h" #endif #define READBUFFERSIZE 16000 extern int internyyparse(void *); extern void internyylex_destroy(void *); extern int internyylex_init(void **); extern void internyyset_in(FILE *, void *); extern int miniyylex_init(void **); extern void miniyyset_in(FILE *, void *); extern void miniyylex_destroy(void *); extern void *startMiniparser(void *scanner, char *str); extern void endMiniparser(void *buf, void *scanner); extern void initSignalHandlerCounted(); extern void blockSignalsCounted(); node *makeExternalProcedureUsage(libraryProcedure *); node *copyThing(node *); node *evaluateThingInner(node *); node *evaluateThing(node *); void *copyThingOnVoid(void *); void *evaluateEntryOnVoid(void *ptr); void freeDoNothing(void *ptr) { UNUSED_PARAM(ptr); return; } typedef struct __backtrace_frame_struct_t * backtrace_frame_t; struct __backtrace_frame_struct_t { node *procedure; chain *arguments; int argsAreEndElliptic; }; /* Performs a fast check if a < b or a > b // // Returns 1 on success, 0 on failure // // Sets res to -1 if a < b and to +1 if a > b // */ int checkInequalityFast(int *res, node *a, node *b) { sollya_mpfi_t aI, bI; mpfr_t ahi, alo, bhi, blo; int okay; if (!(isConstant(a) && isConstant(b))) return 0; sollya_mpfi_init2(aI, 12); sollya_mpfi_init2(bI, 12); mpfr_init2(ahi, 12); mpfr_init2(alo, 12); mpfr_init2(bhi, 12); mpfr_init2(blo, 12); okay = 0; evaluateConstantExpressionToInterval(aI, a); evaluateConstantExpressionToInterval(bI, b); if (sollya_mpfi_is_empty(aI) || sollya_mpfi_is_empty(bI)) { mpfr_clear(blo); mpfr_clear(bhi); mpfr_clear(alo); mpfr_clear(ahi); sollya_mpfi_clear(bI); sollya_mpfi_clear(aI); return 0; } sollya_mpfi_get_left(alo, aI); sollya_mpfi_get_right(ahi, aI); sollya_mpfi_get_left(blo, bI); sollya_mpfi_get_right(bhi, bI); if (mpfr_number_p(alo) && mpfr_number_p(ahi) && mpfr_number_p(blo) && mpfr_number_p(bhi)) { if (mpfr_cmp(ahi,blo) < 0) { okay = 1; *res = -1; } else { if (mpfr_cmp(bhi,alo) < 0) { okay = 1; *res = 1; } } } mpfr_clear(blo); mpfr_clear(bhi); mpfr_clear(alo); mpfr_clear(ahi); sollya_mpfi_clear(bI); sollya_mpfi_clear(aI); return okay; } int isElliptic(node *); /* Sets up the random access data-structure on a LIST or FINALELLIPTICLIST object, if it has not yet been set up. The function does nothing if: * The object is NULL * The object is neither a LIST nor a FINALELLIPTICLIST * The object has the random-access already set up * The list contains ellipses that still need to be expanded before we know its length. */ void setupRandomAccessOnLists(node *obj) { chain *curr; int i; if (obj == NULL) return; switch (obj->nodeType) { case MEMREF: setupRandomAccessOnLists(getMemRefChild(obj)); break; case LIST: case FINALELLIPTICLIST: if (obj->argArray != NULL) return; obj->argArraySize = lengthChain(obj->arguments); if (obj->argArraySize < 1) { obj->argArraySize = 0; return; } obj->argArrayAllocSize = ((size_t) (obj->argArraySize)) * sizeof(node *); obj->argArray = (node **) safeMalloc(obj->argArrayAllocSize); for (curr=obj->arguments, i=0; curr != NULL; curr=curr->next, i++) { if (!isElliptic((node *) (curr->value))) { (obj->argArray)[(obj->argArraySize - 1) - i] = (node *) (curr->value); } else { safeFree(obj->argArray); obj->argArray = NULL; obj->argArraySize = 0; obj->argArrayAllocSize = 0; return; } } break; default: return; break; } } int parseStringCheckExcessCharacters(char *str) { char *curr; for (curr=str; *curr != '\0'; curr++) { if (!((*curr == ' ') || (*curr == '\n') || (*curr == '\r') || (*curr == '\t'))) return 0; } return 1; } node *parseStringInternal(char *str) { node *result; node *oldMinitree; int oldMiniparserCharactersRead; int oldMiniparserEofReached; int oldMiniparserSemicolonAtEnd; void *myScanner; void *buffer; char *myStr; blockSignalsCounted(); myStr = (char *) safeCalloc(strlen(str)+1,sizeof(char)); strcpy(myStr,str); oldMinitree = minitree; oldMiniparserCharactersRead = miniparserCharactersRead; oldMiniparserEofReached = miniparserEofReached; oldMiniparserSemicolonAtEnd = miniparserSemicolonAtEnd; miniparserCharactersRead = 0; miniparserEofReached = 0; miniparserSemicolonAtEnd = 0; minitree = NULL; miniyylex_init(&myScanner); miniyyset_in(stdin, myScanner); buffer = startMiniparser(myScanner,myStr); (void) buffer; if (!miniyyparse(myScanner)) { if (minitree != NULL) { if (miniparserEofReached || (miniparserSemicolonAtEnd && ((miniparserCharactersRead <= (int) strlen(myStr)) && parseStringCheckExcessCharacters(myStr+miniparserCharactersRead)))) { result = evaluateThing(minitree); } else { printMessage(1,SOLLYA_MSG_SYNTAX_ERROR_ENCOUNTERED_WHILE_PARSING, "Warning: syntax error parsing \"%s\" because of unexpected excess characters at the end of the input.\n", myStr); result = NULL; } freeThing(minitree); } else { result = NULL; } } else { result = NULL; } miniyylex_destroy(myScanner); minitree = oldMinitree; miniparserCharactersRead = oldMiniparserCharactersRead; miniparserEofReached = oldMiniparserEofReached; miniparserSemicolonAtEnd = oldMiniparserSemicolonAtEnd; safeFree(myStr); initSignalHandlerCounted(); return result; } node *parseString(char *str) { node *res; res = parseStringInternal(str); if (res != NULL) return res; printMessage(1,SOLLYA_MSG_STRING_CANNOT_BE_PARSED_BY_MINIPARSER,"Warning: the string \"%s\" could not be parsed by the miniparser.\n",str); return makeError(); } rangetype guessDegreeWrapper(node *func, node *weight, mpfr_t a, mpfr_t b, mpfr_t eps, int bound) { rangetype result; int oldVerbosity; int oldPoints; oldVerbosity = verbosity; oldPoints = defaultpoints; result = guessDegree(func, weight, a, b, eps, bound); verbosity = oldVerbosity; defaultpoints = oldPoints; return result; } void executeFile(FILE *fd) { node *oldParsedThingIntern; void *myScanner = NULL; int parseAbort; chain *commands, *commands2; node *tempThing; int res; commands = NULL; blockSignalsCounted(); oldParsedThingIntern = parsedThingIntern; internyylex_init(&myScanner); internyyset_in(fd, myScanner); while (1) { parsedThingIntern = NULL; parseAbort = internyyparse(myScanner); if (parsedThingIntern != NULL) { commands = addElement(commands,parsedThingIntern); } if (parseAbort) break; } internyylex_destroy(myScanner); parsedThingIntern = oldParsedThingIntern; initSignalHandlerCounted(); commands2 = copyChain(commands, copyThingOnVoid); freeChain(commands, freeThingOnVoid); commands = commands2; tempThing = makeCommandList(commands); res = executeCommand(tempThing); if (res) { printMessage(1,SOLLYA_MSG_FILE_EXECUTION_ASKED_FOR_QUIT_NOT_QUITTING,"Warning: the execution of a file read by execute demanded stopping the interpretation but it is not stopped.\n"); } freeThing(tempThing); } char *readFileIntoString(FILE *fd) { char *readBuf, *newString, *tempString; size_t readChars, i; readBuf = (char *) safeCalloc(READBUFFERSIZE,sizeof(char)); newString = NULL; while (1) { readChars = sollya_fread(readBuf,sizeof(char),READBUFFERSIZE,fd); for (i=0;i 0) { if (newString == NULL) { newString = (char *) safeCalloc(readChars + 1,sizeof(char)); strncpy(newString,readBuf,readChars * sizeof(char)); } else { i = strlen(newString); tempString = (char *) safeCalloc(i + readChars + 1,sizeof(char)); strcpy(tempString,newString); safeFree(newString); newString = tempString; tempString = newString + i; strncpy(tempString,readBuf,readChars * sizeof(char)); } } if (readChars < READBUFFERSIZE) break; } if (newString == NULL) newString = safeCalloc(1,sizeof(char)); safeFree(readBuf); return newString; } node *copyThingInner(node *); node *copyThing(node *tree) { return addMemRef(copyThingInner(tree)); } uint64_t hashEntryWithThing(entry *e) { uint64_t hash; hash = hashString(e->name); hash = hashCombine(hash, hashThing((node *) (e->value))); return hash; } uint64_t hashEntryWithThingNoPolynomialHandling(entry *e) { uint64_t hash; hash = hashString(e->name); hash = hashCombine(hash, hashThingNoPolynomialHandling((node *) (e->value))); return hash; } uint64_t hashThingInnerst(node *tree) { uint64_t hash; chain *curr; if (tree == NULL) return hashPointer(NULL); hash = hashInt((int) (tree->nodeType)); switch (tree->nodeType) { /* Memory references : trivial recursion */ case MEMREF: hash = hashThing(getMemRefChild(tree)); break; /* "Constants" : no recursion */ case VARIABLE: case PI_CONST: case QUIT: case FALSEQUIT: case FALSERESTART: case RESTART: case NOP: case ON: case OFF: case DYADIC: case POWERS: case BINARY: case HEXADECIMAL: case FILESYM: case POSTSCRIPT: case POSTSCRIPTFILE: case PERTURB: case ROUNDDOWN: case ROUNDUP: case ROUNDTOZERO: case ROUNDTONEAREST: case HONORCOEFF: case TRUE: case UNIT: case FALSE: case DEFAULT: case DECIMAL: case ABSOLUTESYM: case RELATIVESYM: case FIXED: case FLOATING: case ERRORSPECIAL: case DOUBLESYMBOL: case SINGLESYMBOL: case QUADSYMBOL: case HALFPRECISIONSYMBOL: case DOUBLEEXTENDEDSYMBOL: case DOUBLEDOUBLESYMBOL: case TRIPLEDOUBLESYMBOL: case EMPTYLIST: case ELLIPTIC: case GETSUPPRESSEDMESSAGES: case GETBACKTRACE: case PRECDEREF: case POINTSDEREF: case DIAMDEREF: case DISPLAYDEREF: case VERBOSITYDEREF: case CANONICALDEREF: case AUTOSIMPLIFYDEREF: case SHOWMESSAGENUMBERSDEREF: case TAYLORRECURSDEREF: case TIMINGDEREF: case FULLPARENDEREF: case MIDPOINTDEREF: case DIEONERRORMODEDEREF: case RATIONALMODEDEREF: case SUPPRESSWARNINGSDEREF: case HOPITALRECURSDEREF: break; /* Unary "functions" : recursion on child1 */ case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case DOUBLE: case SINGLE: case HALFPRECISION: case QUAD: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case CEIL: case FLOOR: case NEARESTINT: case NOPARG: case PRINTHEXA: case PRINTFLOAT: case PRINTBINARY: case PRINTEXPANSION: case BASHEXECUTE: case PRINTXML: case PRECASSIGN: case POINTSASSIGN: case DIAMASSIGN: case DISPLAYASSIGN: case VERBOSITYASSIGN: case CANONICALASSIGN: case AUTOSIMPLIFYASSIGN: case SHOWMESSAGENUMBERSASSIGN: case TAYLORRECURSASSIGN: case TIMINGASSIGN: case FULLPARENASSIGN: case MIDPOINTASSIGN: case DIEONERRORMODEASSIGN: case RATIONALMODEASSIGN: case SUPPRESSWARNINGSASSIGN: case HOPITALRECURSASSIGN: case PRECSTILLASSIGN: case POINTSSTILLASSIGN: case DIAMSTILLASSIGN: case DISPLAYSTILLASSIGN: case VERBOSITYSTILLASSIGN: case CANONICALSTILLASSIGN: case AUTOSIMPLIFYSTILLASSIGN: case SHOWMESSAGENUMBERSSTILLASSIGN: case TAYLORRECURSSTILLASSIGN: case TIMINGSTILLASSIGN: case FULLPARENSTILLASSIGN: case MIDPOINTSTILLASSIGN: case DIEONERRORMODESTILLASSIGN: case RATIONALMODESTILLASSIGN: case SUPPRESSWARNINGSSTILLASSIGN: case HOPITALRECURSSTILLASSIGN: case NEGATION: case DEBOUNDMAX: case DEBOUNDMIN: case DEBOUNDMID: case EVALCONST: case DIFF: case DIRTYSIMPLIFY: case SIMPLIFYSAFE: case TIME: case HORNER: case CANONICAL: case EXPAND: case DEGREE: case NUMERATOR: case DENOMINATOR: case PARSE: case READXML: case EXECUTE: case HEAD: case ROUNDCORRECTLY: case READFILE: case REVERT: case SORT: case MANTISSA: case EXPONENT: case PRECISION: case TAIL: case LENGTH: case OBJECTNAME: hash = hashCombine(hash, hashThing(tree->child1)); break; /* Binary "functions" : recursion on child1 and child2 */ case ADD: case SUB: case MUL: case DIV: case POW: case WHILE: case IF: case ASCIIPLOT: case PRINTXMLNEWFILE: case PRINTXMLAPPENDFILE: case AND: case OR: case INDEX: case COMPAREEQUAL: case COMPAREIN: case COMPARELESS: case COMPAREGREATER: case COMPARELESSEQUAL: case COMPAREGREATEREQUAL: case COMPARENOTEQUAL: case CONCAT: case ADDTOLIST: case PREPEND: case APPEND: case RANGE: case SUBSTITUTE: case COMPOSEPOLYNOMIALS: case COEFF: case SUBPOLY: case ROUNDCOEFFICIENTS: case RATIONALAPPROX: case EVALUATE: case FINDZEROS: case FPFINDZEROS: case DIRTYINFNORM: case NUMBERROOTS: case INTEGRAL: case DIRTYINTEGRAL: case ZERODENOMINATORS: case ISEVALUABLE: case PROTOASSIGNMENTINSTRUCTURE: case PROTOFLOATASSIGNMENTINSTRUCTURE: case DIRTYFINDZEROS: hash = hashCombine(hash, hashThing(tree->child1)); hash = hashCombine(hash, hashThing(tree->child2)); break; /* "Functions" with more than 2 arguments : recursion the arguments chain */ case COMMANDLIST: case IFELSE: case PRINT: case SUPPRESSMESSAGE: case UNSUPPRESSMESSAGE: case PLOT: case EXTERNALPLOT: case WRITE: case WORSTCASE: case AUTOPRINT: case BASHEVALUATE: case REMEZ: case ANNOTATEFUNCTION: case MIN: case MAX: case FPMINIMAX: case TAYLOR: case TAYLORFORM: case CHEBYSHEVFORM: case AUTODIFF: case ACCURATEINFNORM: case ROUNDTOFORMAT: case INFNORM: case SUPNORM: case IMPLEMENTPOLY: case IMPLEMENTCONST: case CHECKINFNORM: case SEARCHGAL: case GUESSDEGREE: case ASSIGNMENTININDEXING: case FLOATASSIGNMENTININDEXING: for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashThing((node *) (curr->value))); } break; /* "Functions" with more than 2 arguments and one special argument : recursion the arguments chain and on child1 */ case NEWFILEPRINT: case APPENDFILEPRINT: case NEWFILEWRITE: case APPENDFILEWRITE: case APPLY: case MATCH: hash = hashCombine(hash, hashThing(tree->child1)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashThing((node *) (curr->value))); } break; /* "Functions" with more than 2 arguments and 2 special arguments : recursion the arguments chain and on child1 and child2 */ case MATCHELEMENT: hash = hashCombine(hash, hashThing(tree->child1)); hash = hashCombine(hash, hashThing(tree->child2)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashThing((node *) (curr->value))); } break; /* Constants : hashing the MPFR value */ case CONSTANT: hash = hashCombine(hash, hashMpfr(*(tree->value))); break; /* "Strings" : hashing the string */ case STRING: case TABLEACCESS: case ISBOUND: case DECIMALCONSTANT: case MIDPOINTCONSTANT: case DYADICCONSTANT: case HEXCONSTANT: case HEXADECIMALCONSTANT: case BINARYCONSTANT: hash = hashCombine(hash, hashString(tree->string)); break; /* "Strings" + arguments with things */ case FOR: case TABLEACCESSWITHSUBSTITUTE: hash = hashCombine(hash, hashString(tree->string)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashThing((node *) (curr->value))); } break; /* "Strings" + 1 child */ case ASSIGNMENT: case FLOATASSIGNMENT: case LIBRARYBINDING: case LIBRARYCONSTANTBINDING: case STRUCTACCESS: hash = hashCombine(hash, hashThing(tree->child1)); hash = hashCombine(hash, hashString(tree->string)); break; /* "Strings" + 2 childs */ case FORIN: case BIND: hash = hashCombine(hash, hashThing(tree->child1)); hash = hashCombine(hash, hashThing(tree->child2)); hash = hashCombine(hash, hashString(tree->string)); break; /* Argument list contains strings */ case VARIABLEDECLARATION: for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashString((char *) (curr->value))); } break; /* "Strings" + argument list contains strings */ case RENAME: hash = hashCombine(hash, hashString(tree->string)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashString((char *) (curr->value))); } break; /* Argument list contains strings + 1 child */ case ASSIGNMENTINSTRUCTURE: case FLOATASSIGNMENTINSTRUCTURE: hash = hashCombine(hash, hashThing(tree->child1)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashString((char *) (curr->value))); } break; /* Argument list contains strings + 2 childs */ case PROC: case PROCILLIM: hash = hashCombine(hash, hashThing(tree->child1)); hash = hashCombine(hash, hashThing(tree->child2)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashString((char *) (curr->value))); } break; /* Special cases */ case LIBRARYFUNCTION: hash = hashCombine(hash, hashThing(tree->child1)); hash = hashCombine(hash, hashInt(tree->libFunDeriv)); hash = hashCombine(hash, hashPointer(tree->libFun->code)); if (tree->libFun->hasData) { hash = hashCombine(hash, hashPointer(tree->libFun->data)); } break; case LIBRARYCONSTANT: hash = hashCombine(hash, hashPointer(tree->libFun->code)); if (tree->libFun->hasData) { hash = hashCombine(hash, hashPointer(tree->libFun->data)); } break; case EXTERNALPROCEDUREUSAGE: hash = hashCombine(hash, hashPointer(tree->libProc->code)); break; case PROCEDUREFUNCTION: hash = hashCombine(hash, hashThing(tree->child1)); hash = hashCombine(hash, hashThing(tree->child2)); hash = hashCombine(hash, hashInt(tree->libFunDeriv)); break; case EXTERNALPROC: hash = hashCombine(hash, hashThing(tree->child1)); hash = hashCombine(hash, hashString(tree->string)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashInt(*((int *) (curr->value)))); } break; case LIST: case FINALELLIPTICLIST: for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashThing((node *) (curr->value))); } break; case STRUCTURE: for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashEntryWithThing((entry *) (curr->value))); } break; default: sollyaFprintf(stderr,"Error: hashThingInnerst: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return hash; } uint64_t hashThingInner(node *tree) { uint64_t hash; polynomial_t polynomial; if (tree == NULL) return hashPointer(NULL); if (tree->nodeType == MEMREF) { if (tree->hashComputed) { return tree->hash; } if (tree->polynomialRepresentation != NULL) { hash = polynomialHash(tree->polynomialRepresentation); } else { tryRepresentAsPolynomial(tree); if (tree->polynomialRepresentation != NULL) { if (!polynomialReferencesExpression(tree->polynomialRepresentation, tree)) { hash = polynomialHash(tree->polynomialRepresentation); } else { hash = hashThingInnerst(getMemRefChild(tree)); } } else { if (isPureTree(tree)) { if (polynomialFromExpressionOnlyRealCoeffs(&polynomial, tree)) { hash = polynomialHash(polynomial); polynomialFree(polynomial); } else { hash = hashThingInnerst(getMemRefChild(tree)); } } else { hash = hashThingInnerst(getMemRefChild(tree)); } } } tree->hash = hash; tree->hashComputed = 1; return hash; } return hashThingInnerst(tree); } uint64_t hashThing(node *tree) { polynomial_t polynomial; uint64_t hash; if (tree == NULL) return hashPointer(NULL); if (tree->nodeType == MEMREF) { return hashThingInner(tree); } if (isPureTree(tree)) { if (polynomialFromExpressionOnlyRealCoeffs(&polynomial, tree)) { hash = polynomialHash(polynomial); polynomialFree(polynomial); return hash; } } return hashThingInner(tree); } uint64_t hashThingNoPolynomialHandling(node *tree) { uint64_t hash; chain *curr; if (tree == NULL) return hashPointer(NULL); hash = hashInt((int) (tree->nodeType)); switch (tree->nodeType) { /* Memory references : trivial recursion */ case MEMREF: hash = hashThingNoPolynomialHandling(getMemRefChild(tree)); break; /* "Constants" : no recursion */ case VARIABLE: case PI_CONST: case QUIT: case FALSEQUIT: case FALSERESTART: case RESTART: case NOP: case ON: case OFF: case DYADIC: case POWERS: case BINARY: case HEXADECIMAL: case FILESYM: case POSTSCRIPT: case POSTSCRIPTFILE: case PERTURB: case ROUNDDOWN: case ROUNDUP: case ROUNDTOZERO: case ROUNDTONEAREST: case HONORCOEFF: case TRUE: case UNIT: case FALSE: case DEFAULT: case DECIMAL: case ABSOLUTESYM: case RELATIVESYM: case FIXED: case FLOATING: case ERRORSPECIAL: case DOUBLESYMBOL: case SINGLESYMBOL: case QUADSYMBOL: case HALFPRECISIONSYMBOL: case DOUBLEEXTENDEDSYMBOL: case DOUBLEDOUBLESYMBOL: case TRIPLEDOUBLESYMBOL: case EMPTYLIST: case ELLIPTIC: case GETSUPPRESSEDMESSAGES: case GETBACKTRACE: case PRECDEREF: case POINTSDEREF: case DIAMDEREF: case DISPLAYDEREF: case VERBOSITYDEREF: case CANONICALDEREF: case AUTOSIMPLIFYDEREF: case SHOWMESSAGENUMBERSDEREF: case TAYLORRECURSDEREF: case TIMINGDEREF: case FULLPARENDEREF: case MIDPOINTDEREF: case DIEONERRORMODEDEREF: case RATIONALMODEDEREF: case SUPPRESSWARNINGSDEREF: case HOPITALRECURSDEREF: break; /* Unary "functions" : recursion on child1 */ case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case DOUBLE: case SINGLE: case HALFPRECISION: case QUAD: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case CEIL: case FLOOR: case NEARESTINT: case NOPARG: case PRINTHEXA: case PRINTFLOAT: case PRINTBINARY: case PRINTEXPANSION: case BASHEXECUTE: case PRINTXML: case PRECASSIGN: case POINTSASSIGN: case DIAMASSIGN: case DISPLAYASSIGN: case VERBOSITYASSIGN: case CANONICALASSIGN: case AUTOSIMPLIFYASSIGN: case SHOWMESSAGENUMBERSASSIGN: case TAYLORRECURSASSIGN: case TIMINGASSIGN: case FULLPARENASSIGN: case MIDPOINTASSIGN: case DIEONERRORMODEASSIGN: case RATIONALMODEASSIGN: case SUPPRESSWARNINGSASSIGN: case HOPITALRECURSASSIGN: case PRECSTILLASSIGN: case POINTSSTILLASSIGN: case DIAMSTILLASSIGN: case DISPLAYSTILLASSIGN: case VERBOSITYSTILLASSIGN: case CANONICALSTILLASSIGN: case AUTOSIMPLIFYSTILLASSIGN: case SHOWMESSAGENUMBERSSTILLASSIGN: case TAYLORRECURSSTILLASSIGN: case TIMINGSTILLASSIGN: case FULLPARENSTILLASSIGN: case MIDPOINTSTILLASSIGN: case DIEONERRORMODESTILLASSIGN: case RATIONALMODESTILLASSIGN: case SUPPRESSWARNINGSSTILLASSIGN: case HOPITALRECURSSTILLASSIGN: case NEGATION: case DEBOUNDMAX: case DEBOUNDMIN: case DEBOUNDMID: case EVALCONST: case DIFF: case DIRTYSIMPLIFY: case SIMPLIFYSAFE: case TIME: case HORNER: case CANONICAL: case EXPAND: case DEGREE: case NUMERATOR: case DENOMINATOR: case PARSE: case READXML: case EXECUTE: case HEAD: case ROUNDCORRECTLY: case READFILE: case REVERT: case SORT: case MANTISSA: case EXPONENT: case PRECISION: case TAIL: case LENGTH: case OBJECTNAME: hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child1)); break; /* Binary "functions" : recursion on child1 and child2 */ case ADD: case SUB: case MUL: case DIV: case POW: case WHILE: case IF: case ASCIIPLOT: case PRINTXMLNEWFILE: case PRINTXMLAPPENDFILE: case AND: case OR: case INDEX: case COMPAREEQUAL: case COMPAREIN: case COMPARELESS: case COMPAREGREATER: case COMPARELESSEQUAL: case COMPAREGREATEREQUAL: case COMPARENOTEQUAL: case CONCAT: case ADDTOLIST: case PREPEND: case APPEND: case RANGE: case SUBSTITUTE: case COMPOSEPOLYNOMIALS: case COEFF: case SUBPOLY: case ROUNDCOEFFICIENTS: case RATIONALAPPROX: case EVALUATE: case FINDZEROS: case FPFINDZEROS: case DIRTYINFNORM: case NUMBERROOTS: case INTEGRAL: case DIRTYINTEGRAL: case ZERODENOMINATORS: case ISEVALUABLE: case PROTOASSIGNMENTINSTRUCTURE: case PROTOFLOATASSIGNMENTINSTRUCTURE: case DIRTYFINDZEROS: hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child1)); hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child2)); break; /* "Functions" with more than 2 arguments : recursion the arguments chain */ case COMMANDLIST: case IFELSE: case PRINT: case SUPPRESSMESSAGE: case UNSUPPRESSMESSAGE: case PLOT: case EXTERNALPLOT: case WRITE: case WORSTCASE: case AUTOPRINT: case BASHEVALUATE: case REMEZ: case ANNOTATEFUNCTION: case MIN: case MAX: case FPMINIMAX: case TAYLOR: case TAYLORFORM: case CHEBYSHEVFORM: case AUTODIFF: case ACCURATEINFNORM: case ROUNDTOFORMAT: case INFNORM: case SUPNORM: case IMPLEMENTPOLY: case IMPLEMENTCONST: case CHECKINFNORM: case SEARCHGAL: case GUESSDEGREE: case ASSIGNMENTININDEXING: case FLOATASSIGNMENTININDEXING: for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashThingNoPolynomialHandling((node *) (curr->value))); } break; /* "Functions" with more than 2 arguments and one special argument : recursion the arguments chain and on child1 */ case NEWFILEPRINT: case APPENDFILEPRINT: case NEWFILEWRITE: case APPENDFILEWRITE: case APPLY: case MATCH: hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child1)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashThingNoPolynomialHandling((node *) (curr->value))); } break; /* "Functions" with more than 2 arguments and 2 special arguments : recursion the arguments chain and on child1 and child2 */ case MATCHELEMENT: hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child1)); hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child2)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashThingNoPolynomialHandling((node *) (curr->value))); } break; /* Constants : hashing the MPFR value */ case CONSTANT: hash = hashCombine(hash, hashMpfr(*(tree->value))); break; /* "Strings" : hashing the string */ case STRING: case TABLEACCESS: case ISBOUND: case DECIMALCONSTANT: case MIDPOINTCONSTANT: case DYADICCONSTANT: case HEXCONSTANT: case HEXADECIMALCONSTANT: case BINARYCONSTANT: hash = hashCombine(hash, hashString(tree->string)); break; /* "Strings" + arguments with things */ case FOR: case TABLEACCESSWITHSUBSTITUTE: hash = hashCombine(hash, hashString(tree->string)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashThingNoPolynomialHandling((node *) (curr->value))); } break; /* "Strings" + 1 child */ case ASSIGNMENT: case FLOATASSIGNMENT: case LIBRARYBINDING: case LIBRARYCONSTANTBINDING: case STRUCTACCESS: hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child1)); hash = hashCombine(hash, hashString(tree->string)); break; /* "Strings" + 2 childs */ case FORIN: case BIND: hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child1)); hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child2)); hash = hashCombine(hash, hashString(tree->string)); break; /* Argument list contains strings */ case VARIABLEDECLARATION: for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashString((char *) (curr->value))); } break; /* "Strings" + argument list contains strings */ case RENAME: hash = hashCombine(hash, hashString(tree->string)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashString((char *) (curr->value))); } break; /* Argument list contains strings + 1 child */ case ASSIGNMENTINSTRUCTURE: case FLOATASSIGNMENTINSTRUCTURE: hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child1)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashString((char *) (curr->value))); } break; /* Argument list contains strings + 2 childs */ case PROC: case PROCILLIM: hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child1)); hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child2)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashString((char *) (curr->value))); } break; /* Special cases */ case LIBRARYFUNCTION: hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child1)); hash = hashCombine(hash, hashInt(tree->libFunDeriv)); hash = hashCombine(hash, hashPointer(tree->libFun->code)); if (tree->libFun->hasData) { hash = hashCombine(hash, hashPointer(tree->libFun->data)); } break; case LIBRARYCONSTANT: hash = hashCombine(hash, hashPointer(tree->libFun->code)); if (tree->libFun->hasData) { hash = hashCombine(hash, hashPointer(tree->libFun->data)); } break; case EXTERNALPROCEDUREUSAGE: hash = hashCombine(hash, hashPointer(tree->libProc->code)); break; case PROCEDUREFUNCTION: hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child1)); hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child2)); hash = hashCombine(hash, hashInt(tree->libFunDeriv)); break; case EXTERNALPROC: hash = hashCombine(hash, hashThingNoPolynomialHandling(tree->child1)); hash = hashCombine(hash, hashString(tree->string)); for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashInt(*((int *) (curr->value)))); } break; case LIST: case FINALELLIPTICLIST: for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashThingNoPolynomialHandling((node *) (curr->value))); } break; case STRUCTURE: for (curr=tree->arguments;curr!=NULL;curr=curr->next) { hash = hashCombine(hash, hashEntryWithThingNoPolynomialHandling((entry *) (curr->value))); } break; default: sollyaFprintf(stderr,"Error: hashThingNoPolynomialHandling: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return hash; } node *copyThingInner(node *tree) { node *copy; if (tree == NULL) return NULL; if (tree->nodeType == MEMREF) { tree->libFunDeriv++; return tree; } copy = (node *) safeMalloc(sizeof(node)); copy->nodeType = tree->nodeType; switch (tree->nodeType) { case VARIABLE: break; case CONSTANT: copy->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(copy->value),mpfr_get_prec(*(tree->value))); mpfr_set(*(copy->value),*(tree->value),GMP_RNDN); break; case ADD: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case SUB: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case MUL: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case DIV: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case SQRT: copy->child1 = copyThingInner(tree->child1); break; case EXP: copy->child1 = copyThingInner(tree->child1); break; case LOG: copy->child1 = copyThingInner(tree->child1); break; case LOG_2: copy->child1 = copyThingInner(tree->child1); break; case LOG_10: copy->child1 = copyThingInner(tree->child1); break; case SIN: copy->child1 = copyThingInner(tree->child1); break; case COS: copy->child1 = copyThingInner(tree->child1); break; case TAN: copy->child1 = copyThingInner(tree->child1); break; case ASIN: copy->child1 = copyThingInner(tree->child1); break; case ACOS: copy->child1 = copyThingInner(tree->child1); break; case ATAN: copy->child1 = copyThingInner(tree->child1); break; case SINH: copy->child1 = copyThingInner(tree->child1); break; case COSH: copy->child1 = copyThingInner(tree->child1); break; case TANH: copy->child1 = copyThingInner(tree->child1); break; case ASINH: copy->child1 = copyThingInner(tree->child1); break; case ACOSH: copy->child1 = copyThingInner(tree->child1); break; case ATANH: copy->child1 = copyThingInner(tree->child1); break; case POW: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case NEG: copy->child1 = copyThingInner(tree->child1); break; case ABS: copy->child1 = copyThingInner(tree->child1); break; case DOUBLE: copy->child1 = copyThingInner(tree->child1); break; case SINGLE: copy->child1 = copyThingInner(tree->child1); break; case HALFPRECISION: copy->child1 = copyThingInner(tree->child1); break; case QUAD: copy->child1 = copyThingInner(tree->child1); break; case DOUBLEDOUBLE: copy->child1 = copyThingInner(tree->child1); break; case TRIPLEDOUBLE: copy->child1 = copyThingInner(tree->child1); break; case ERF: copy->child1 = copyThingInner(tree->child1); break; case ERFC: copy->child1 = copyThingInner(tree->child1); break; case LOG_1P: copy->child1 = copyThingInner(tree->child1); break; case EXP_M1: copy->child1 = copyThingInner(tree->child1); break; case DOUBLEEXTENDED: copy->child1 = copyThingInner(tree->child1); break; case LIBRARYFUNCTION: copy->libFun = tree->libFun; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = copyThingInner(tree->child1); break; case LIBRARYCONSTANT: copy->libFun = tree->libFun; break; case PROCEDUREFUNCTION: copy->libFunDeriv = tree->libFunDeriv; copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case CEIL: copy->child1 = copyThingInner(tree->child1); break; case FLOOR: copy->child1 = copyThingInner(tree->child1); break; case NEARESTINT: copy->child1 = copyThingInner(tree->child1); break; case PI_CONST: break; case COMMANDLIST: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case WHILE: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case IFELSE: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case IF: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case FOR: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case FORIN: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case QUIT: break; case FALSEQUIT: break; case FALSERESTART: break; case RESTART: break; case PRINT: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case SUPPRESSMESSAGE: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case UNSUPPRESSMESSAGE: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case VARIABLEDECLARATION: copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case NOP: break; case NOPARG: copy->child1 = copyThingInner(tree->child1); break; case NEWFILEPRINT: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); copy->child1 = copyThingInner(tree->child1); break; case APPENDFILEPRINT: copy->child1 = copyThingInner(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case PLOT: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case PRINTHEXA: copy->child1 = copyThingInner(tree->child1); break; case PRINTFLOAT: copy->child1 = copyThingInner(tree->child1); break; case PRINTBINARY: copy->child1 = copyThingInner(tree->child1); break; case PRINTEXPANSION: copy->child1 = copyThingInner(tree->child1); break; case BASHEXECUTE: copy->child1 = copyThingInner(tree->child1); break; case EXTERNALPLOT: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case WRITE: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case NEWFILEWRITE: copy->child1 = copyThingInner(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case APPENDFILEWRITE: copy->child1 = copyThingInner(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case ASCIIPLOT: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case PRINTXML: copy->child1 = copyThingInner(tree->child1); break; case PRINTXMLNEWFILE: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case PRINTXMLAPPENDFILE: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case WORSTCASE: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case RENAME: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case AUTOPRINT: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case EXTERNALPROC: copy->child1 = copyThingInner(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); copy->arguments = copyChainWithoutReversal(tree->arguments, copyIntPtrOnVoid); break; case ASSIGNMENT: copy->child1 = copyThingInner(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case FLOATASSIGNMENT: copy->child1 = copyThingInner(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case LIBRARYBINDING: copy->child1 = copyThingInner(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case LIBRARYCONSTANTBINDING: copy->child1 = copyThingInner(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case PRECASSIGN: copy->child1 = copyThingInner(tree->child1); break; case POINTSASSIGN: copy->child1 = copyThingInner(tree->child1); break; case DIAMASSIGN: copy->child1 = copyThingInner(tree->child1); break; case DISPLAYASSIGN: copy->child1 = copyThingInner(tree->child1); break; case VERBOSITYASSIGN: copy->child1 = copyThingInner(tree->child1); break; case CANONICALASSIGN: copy->child1 = copyThingInner(tree->child1); break; case AUTOSIMPLIFYASSIGN: copy->child1 = copyThingInner(tree->child1); break; case SHOWMESSAGENUMBERSASSIGN: copy->child1 = copyThingInner(tree->child1); break; case TAYLORRECURSASSIGN: copy->child1 = copyThingInner(tree->child1); break; case TIMINGASSIGN: copy->child1 = copyThingInner(tree->child1); break; case FULLPARENASSIGN: copy->child1 = copyThingInner(tree->child1); break; case MIDPOINTASSIGN: copy->child1 = copyThingInner(tree->child1); break; case DIEONERRORMODEASSIGN: copy->child1 = copyThingInner(tree->child1); break; case RATIONALMODEASSIGN: copy->child1 = copyThingInner(tree->child1); break; case SUPPRESSWARNINGSASSIGN: copy->child1 = copyThingInner(tree->child1); break; case HOPITALRECURSASSIGN: copy->child1 = copyThingInner(tree->child1); break; case PRECSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case POINTSSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case DIAMSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case DISPLAYSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case VERBOSITYSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case CANONICALSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case AUTOSIMPLIFYSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case SHOWMESSAGENUMBERSSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case TAYLORRECURSSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case TIMINGSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case FULLPARENSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case MIDPOINTSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case DIEONERRORMODESTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case RATIONALMODESTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case SUPPRESSWARNINGSSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case HOPITALRECURSSTILLASSIGN: copy->child1 = copyThingInner(tree->child1); break; case AND: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case OR: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case NEGATION: copy->child1 = copyThingInner(tree->child1); break; case INDEX: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case COMPAREEQUAL: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case COMPAREIN: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case COMPARELESS: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case COMPAREGREATER: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case COMPARELESSEQUAL: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case COMPAREGREATEREQUAL: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case COMPARENOTEQUAL: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case CONCAT: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case ADDTOLIST: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case PREPEND: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case APPEND: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case ON: break; case OFF: break; case DYADIC: break; case POWERS: break; case BINARY: break; case HEXADECIMAL: break; case FILESYM: break; case POSTSCRIPT: break; case POSTSCRIPTFILE: break; case PERTURB: break; case ROUNDDOWN: break; case ROUNDUP: break; case ROUNDTOZERO: break; case ROUNDTONEAREST: break; case HONORCOEFF: break; case TRUE: break; case UNIT: break; case FALSE: break; case DEFAULT: break; case DECIMAL: break; case ABSOLUTESYM: break; case RELATIVESYM: break; case FIXED: break; case FLOATING: break; case ERRORSPECIAL: break; case DOUBLESYMBOL: break; case SINGLESYMBOL: break; case QUADSYMBOL: break; case HALFPRECISIONSYMBOL: break; case DOUBLEEXTENDEDSYMBOL: break; case DOUBLEDOUBLESYMBOL: break; case TRIPLEDOUBLESYMBOL: break; case STRING: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case TABLEACCESS: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case ISBOUND: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case TABLEACCESSWITHSUBSTITUTE: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case STRUCTACCESS: copy->child1 = copyThingInner(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case APPLY: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); copy->child1 = copyThingInner(tree->child1); break; case DECIMALCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case MIDPOINTCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case DYADICCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case HEXCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case HEXADECIMALCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case BINARYCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case EMPTYLIST: break; case LIST: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; break; case STRUCTURE: copy->arguments = copyChainWithoutReversal(tree->arguments, copyEntryOnVoid); break; case FINALELLIPTICLIST: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; break; case ELLIPTIC: break; case RANGE: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case DEBOUNDMAX: copy->child1 = copyThingInner(tree->child1); break; case DEBOUNDMIN: copy->child1 = copyThingInner(tree->child1); break; case DEBOUNDMID: copy->child1 = copyThingInner(tree->child1); break; case EVALCONST: copy->child1 = copyThingInner(tree->child1); break; case DIFF: copy->child1 = copyThingInner(tree->child1); break; case BASHEVALUATE: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case GETSUPPRESSEDMESSAGES: break; case GETBACKTRACE: break; case DIRTYSIMPLIFY: copy->child1 = copyThingInner(tree->child1); break; case SIMPLIFYSAFE: copy->child1 = copyThingInner(tree->child1); break; case TIME: copy->child1 = copyThingInner(tree->child1); break; case REMEZ: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case ANNOTATEFUNCTION: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case MATCH: copy->child1 = copyThingInner(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case MATCHELEMENT: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case MIN: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case MAX: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case FPMINIMAX: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case HORNER: copy->child1 = copyThingInner(tree->child1); break; case CANONICAL: copy->child1 = copyThingInner(tree->child1); break; case EXPAND: copy->child1 = copyThingInner(tree->child1); break; case TAYLOR: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case TAYLORFORM: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case CHEBYSHEVFORM: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case AUTODIFF: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case DEGREE: copy->child1 = copyThingInner(tree->child1); break; case NUMERATOR: copy->child1 = copyThingInner(tree->child1); break; case DENOMINATOR: copy->child1 = copyThingInner(tree->child1); break; case SUBSTITUTE: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case COMPOSEPOLYNOMIALS: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case COEFF: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case SUBPOLY: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case ROUNDCOEFFICIENTS: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case RATIONALAPPROX: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case ACCURATEINFNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case ROUNDTOFORMAT: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case EVALUATE: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case PARSE: copy->child1 = copyThingInner(tree->child1); break; case READXML: copy->child1 = copyThingInner(tree->child1); break; case EXECUTE: copy->child1 = copyThingInner(tree->child1); break; case INFNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case SUPNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case FINDZEROS: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case FPFINDZEROS: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case DIRTYINFNORM: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case NUMBERROOTS: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case INTEGRAL: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case DIRTYINTEGRAL: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case IMPLEMENTPOLY: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case IMPLEMENTCONST: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case CHECKINFNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case ZERODENOMINATORS: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case ISEVALUABLE: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case SEARCHGAL: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case GUESSDEGREE: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case ASSIGNMENTININDEXING: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case FLOATASSIGNMENTININDEXING: copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case ASSIGNMENTINSTRUCTURE: copy->child1 = copyThingInner(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case FLOATASSIGNMENTINSTRUCTURE: copy->child1 = copyThingInner(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case PROTOASSIGNMENTINSTRUCTURE: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case PROTOFLOATASSIGNMENTINSTRUCTURE: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case DIRTYFINDZEROS: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); break; case HEAD: copy->child1 = copyThingInner(tree->child1); break; case ROUNDCORRECTLY: copy->child1 = copyThingInner(tree->child1); break; case READFILE: copy->child1 = copyThingInner(tree->child1); break; case REVERT: copy->child1 = copyThingInner(tree->child1); break; case SORT: copy->child1 = copyThingInner(tree->child1); break; case MANTISSA: copy->child1 = copyThingInner(tree->child1); break; case EXPONENT: copy->child1 = copyThingInner(tree->child1); break; case PRECISION: copy->child1 = copyThingInner(tree->child1); break; case TAIL: copy->child1 = copyThingInner(tree->child1); break; case LENGTH: copy->child1 = copyThingInner(tree->child1); break; case OBJECTNAME: copy->child1 = copyThingInner(tree->child1); break; case EXTERNALPROCEDUREUSAGE: copy->libProc = tree->libProc; break; case PROC: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case BIND: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case PROCILLIM: copy->child1 = copyThingInner(tree->child1); copy->child2 = copyThingInner(tree->child2); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case PRECDEREF: break; case POINTSDEREF: break; case DIAMDEREF: break; case DISPLAYDEREF: break; case VERBOSITYDEREF: break; case CANONICALDEREF: break; case AUTOSIMPLIFYDEREF: break; case SHOWMESSAGENUMBERSDEREF: break; case TAYLORRECURSDEREF: break; case TIMINGDEREF: break; case FULLPARENDEREF: break; case MIDPOINTDEREF: break; case DIEONERRORMODEDEREF: break; case RATIONALMODEDEREF: break; case SUPPRESSWARNINGSDEREF: break; case HOPITALRECURSDEREF: break; default: sollyaFprintf(stderr,"Error: copyThingInner: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return copy; } void *deepCopyThingOnVoid(void *); void *deepCopyEntryOnVoid(void *); node *deepCopyThing(node *tree) { node *copy; if (tree == NULL) return NULL; if (tree->nodeType == MEMREF) { return deepCopyThing(getMemRefChild(tree)); } copy = (node *) safeMalloc(sizeof(node)); copy->nodeType = tree->nodeType; switch (tree->nodeType) { case VARIABLE: break; case CONSTANT: copy->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(copy->value),mpfr_get_prec(*(tree->value))); mpfr_set(*(copy->value),*(tree->value),GMP_RNDN); break; case ADD: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case SUB: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case MUL: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case DIV: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case SQRT: copy->child1 = deepCopyThing(tree->child1); break; case EXP: copy->child1 = deepCopyThing(tree->child1); break; case LOG: copy->child1 = deepCopyThing(tree->child1); break; case LOG_2: copy->child1 = deepCopyThing(tree->child1); break; case LOG_10: copy->child1 = deepCopyThing(tree->child1); break; case SIN: copy->child1 = deepCopyThing(tree->child1); break; case COS: copy->child1 = deepCopyThing(tree->child1); break; case TAN: copy->child1 = deepCopyThing(tree->child1); break; case ASIN: copy->child1 = deepCopyThing(tree->child1); break; case ACOS: copy->child1 = deepCopyThing(tree->child1); break; case ATAN: copy->child1 = deepCopyThing(tree->child1); break; case SINH: copy->child1 = deepCopyThing(tree->child1); break; case COSH: copy->child1 = deepCopyThing(tree->child1); break; case TANH: copy->child1 = deepCopyThing(tree->child1); break; case ASINH: copy->child1 = deepCopyThing(tree->child1); break; case ACOSH: copy->child1 = deepCopyThing(tree->child1); break; case ATANH: copy->child1 = deepCopyThing(tree->child1); break; case POW: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case NEG: copy->child1 = deepCopyThing(tree->child1); break; case ABS: copy->child1 = deepCopyThing(tree->child1); break; case DOUBLE: copy->child1 = deepCopyThing(tree->child1); break; case SINGLE: copy->child1 = deepCopyThing(tree->child1); break; case HALFPRECISION: copy->child1 = deepCopyThing(tree->child1); break; case QUAD: copy->child1 = deepCopyThing(tree->child1); break; case DOUBLEDOUBLE: copy->child1 = deepCopyThing(tree->child1); break; case TRIPLEDOUBLE: copy->child1 = deepCopyThing(tree->child1); break; case ERF: copy->child1 = deepCopyThing(tree->child1); break; case ERFC: copy->child1 = deepCopyThing(tree->child1); break; case LOG_1P: copy->child1 = deepCopyThing(tree->child1); break; case EXP_M1: copy->child1 = deepCopyThing(tree->child1); break; case DOUBLEEXTENDED: copy->child1 = deepCopyThing(tree->child1); break; case LIBRARYFUNCTION: copy->libFun = tree->libFun; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = deepCopyThing(tree->child1); break; case LIBRARYCONSTANT: copy->libFun = tree->libFun; break; case PROCEDUREFUNCTION: copy->libFunDeriv = tree->libFunDeriv; copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case CEIL: copy->child1 = deepCopyThing(tree->child1); break; case FLOOR: copy->child1 = deepCopyThing(tree->child1); break; case NEARESTINT: copy->child1 = deepCopyThing(tree->child1); break; case PI_CONST: break; case COMMANDLIST: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case WHILE: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case IFELSE: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case IF: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case FOR: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case FORIN: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case QUIT: break; case FALSEQUIT: break; case FALSERESTART: break; case RESTART: break; case PRINT: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case SUPPRESSMESSAGE: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case UNSUPPRESSMESSAGE: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case VARIABLEDECLARATION: copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case NOP: break; case NOPARG: copy->child1 = deepCopyThing(tree->child1); break; case NEWFILEPRINT: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); copy->child1 = deepCopyThing(tree->child1); break; case APPENDFILEPRINT: copy->child1 = deepCopyThing(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case PLOT: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case PRINTHEXA: copy->child1 = deepCopyThing(tree->child1); break; case PRINTFLOAT: copy->child1 = deepCopyThing(tree->child1); break; case PRINTBINARY: copy->child1 = deepCopyThing(tree->child1); break; case PRINTEXPANSION: copy->child1 = deepCopyThing(tree->child1); break; case BASHEXECUTE: copy->child1 = deepCopyThing(tree->child1); break; case EXTERNALPLOT: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case WRITE: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case NEWFILEWRITE: copy->child1 = deepCopyThing(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case APPENDFILEWRITE: copy->child1 = deepCopyThing(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case ASCIIPLOT: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case PRINTXML: copy->child1 = deepCopyThing(tree->child1); break; case PRINTXMLNEWFILE: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case PRINTXMLAPPENDFILE: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case WORSTCASE: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case RENAME: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case AUTOPRINT: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case EXTERNALPROC: copy->child1 = deepCopyThing(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); copy->arguments = copyChainWithoutReversal(tree->arguments, copyIntPtrOnVoid); break; case ASSIGNMENT: copy->child1 = deepCopyThing(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case FLOATASSIGNMENT: copy->child1 = deepCopyThing(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case LIBRARYBINDING: copy->child1 = deepCopyThing(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case LIBRARYCONSTANTBINDING: copy->child1 = deepCopyThing(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case PRECASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case POINTSASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case DIAMASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case DISPLAYASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case VERBOSITYASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case CANONICALASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case AUTOSIMPLIFYASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case SHOWMESSAGENUMBERSASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case TAYLORRECURSASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case TIMINGASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case FULLPARENASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case MIDPOINTASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case DIEONERRORMODEASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case RATIONALMODEASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case SUPPRESSWARNINGSASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case HOPITALRECURSASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case PRECSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case POINTSSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case DIAMSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case DISPLAYSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case VERBOSITYSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case CANONICALSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case AUTOSIMPLIFYSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case SHOWMESSAGENUMBERSSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case TAYLORRECURSSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case TIMINGSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case FULLPARENSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case MIDPOINTSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case DIEONERRORMODESTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case RATIONALMODESTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case SUPPRESSWARNINGSSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case HOPITALRECURSSTILLASSIGN: copy->child1 = deepCopyThing(tree->child1); break; case AND: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case OR: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case NEGATION: copy->child1 = deepCopyThing(tree->child1); break; case INDEX: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case COMPAREEQUAL: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case COMPAREIN: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case COMPARELESS: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case COMPAREGREATER: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case COMPARELESSEQUAL: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case COMPAREGREATEREQUAL: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case COMPARENOTEQUAL: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case CONCAT: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case ADDTOLIST: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case PREPEND: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case APPEND: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case ON: break; case OFF: break; case DYADIC: break; case POWERS: break; case BINARY: break; case HEXADECIMAL: break; case FILESYM: break; case POSTSCRIPT: break; case POSTSCRIPTFILE: break; case PERTURB: break; case ROUNDDOWN: break; case ROUNDUP: break; case ROUNDTOZERO: break; case ROUNDTONEAREST: break; case HONORCOEFF: break; case TRUE: break; case UNIT: break; case FALSE: break; case DEFAULT: break; case DECIMAL: break; case ABSOLUTESYM: break; case RELATIVESYM: break; case FIXED: break; case FLOATING: break; case ERRORSPECIAL: break; case DOUBLESYMBOL: break; case SINGLESYMBOL: break; case QUADSYMBOL: break; case HALFPRECISIONSYMBOL: break; case DOUBLEEXTENDEDSYMBOL: break; case DOUBLEDOUBLESYMBOL: break; case TRIPLEDOUBLESYMBOL: break; case STRING: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case TABLEACCESS: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case ISBOUND: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case TABLEACCESSWITHSUBSTITUTE: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case STRUCTACCESS: copy->child1 = deepCopyThing(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case APPLY: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); copy->child1 = deepCopyThing(tree->child1); break; case DECIMALCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case MIDPOINTCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case DYADICCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case HEXCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case HEXADECIMALCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case BINARYCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case EMPTYLIST: break; case LIST: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; break; case STRUCTURE: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyEntryOnVoid); break; case FINALELLIPTICLIST: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; break; case ELLIPTIC: break; case RANGE: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case DEBOUNDMAX: copy->child1 = deepCopyThing(tree->child1); break; case DEBOUNDMIN: copy->child1 = deepCopyThing(tree->child1); break; case DEBOUNDMID: copy->child1 = deepCopyThing(tree->child1); break; case EVALCONST: copy->child1 = deepCopyThing(tree->child1); break; case DIFF: copy->child1 = deepCopyThing(tree->child1); break; case BASHEVALUATE: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case GETSUPPRESSEDMESSAGES: break; case GETBACKTRACE: break; case DIRTYSIMPLIFY: copy->child1 = deepCopyThing(tree->child1); break; case SIMPLIFYSAFE: copy->child1 = deepCopyThing(tree->child1); break; case TIME: copy->child1 = deepCopyThing(tree->child1); break; case REMEZ: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case ANNOTATEFUNCTION: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case MATCH: copy->child1 = deepCopyThing(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case MATCHELEMENT: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case MIN: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case MAX: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case FPMINIMAX: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case HORNER: copy->child1 = deepCopyThing(tree->child1); break; case CANONICAL: copy->child1 = deepCopyThing(tree->child1); break; case EXPAND: copy->child1 = deepCopyThing(tree->child1); break; case TAYLOR: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case TAYLORFORM: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case CHEBYSHEVFORM: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case AUTODIFF: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case DEGREE: copy->child1 = deepCopyThing(tree->child1); break; case NUMERATOR: copy->child1 = deepCopyThing(tree->child1); break; case DENOMINATOR: copy->child1 = deepCopyThing(tree->child1); break; case SUBSTITUTE: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case COMPOSEPOLYNOMIALS: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case COEFF: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case SUBPOLY: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case ROUNDCOEFFICIENTS: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case RATIONALAPPROX: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case ACCURATEINFNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case ROUNDTOFORMAT: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case EVALUATE: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case PARSE: copy->child1 = deepCopyThing(tree->child1); break; case READXML: copy->child1 = deepCopyThing(tree->child1); break; case EXECUTE: copy->child1 = deepCopyThing(tree->child1); break; case INFNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case SUPNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case FINDZEROS: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case FPFINDZEROS: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case DIRTYINFNORM: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case NUMBERROOTS: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case INTEGRAL: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case DIRTYINTEGRAL: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case IMPLEMENTPOLY: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case IMPLEMENTCONST: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case CHECKINFNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case ZERODENOMINATORS: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case ISEVALUABLE: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case SEARCHGAL: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case GUESSDEGREE: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case ASSIGNMENTININDEXING: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case FLOATASSIGNMENTININDEXING: copy->arguments = copyChainWithoutReversal(tree->arguments, deepCopyThingOnVoid); break; case ASSIGNMENTINSTRUCTURE: copy->child1 = deepCopyThing(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case FLOATASSIGNMENTINSTRUCTURE: copy->child1 = deepCopyThing(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case PROTOASSIGNMENTINSTRUCTURE: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case PROTOFLOATASSIGNMENTINSTRUCTURE: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case DIRTYFINDZEROS: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); break; case HEAD: copy->child1 = deepCopyThing(tree->child1); break; case ROUNDCORRECTLY: copy->child1 = deepCopyThing(tree->child1); break; case READFILE: copy->child1 = deepCopyThing(tree->child1); break; case REVERT: copy->child1 = deepCopyThing(tree->child1); break; case SORT: copy->child1 = deepCopyThing(tree->child1); break; case MANTISSA: copy->child1 = deepCopyThing(tree->child1); break; case EXPONENT: copy->child1 = deepCopyThing(tree->child1); break; case PRECISION: copy->child1 = deepCopyThing(tree->child1); break; case TAIL: copy->child1 = deepCopyThing(tree->child1); break; case LENGTH: copy->child1 = deepCopyThing(tree->child1); break; case OBJECTNAME: copy->child1 = deepCopyThing(tree->child1); break; case EXTERNALPROCEDUREUSAGE: copy->libProc = tree->libProc; break; case PROC: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case BIND: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case PROCILLIM: copy->child1 = deepCopyThing(tree->child1); copy->child2 = deepCopyThing(tree->child2); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case PRECDEREF: break; case POINTSDEREF: break; case DIAMDEREF: break; case DISPLAYDEREF: break; case VERBOSITYDEREF: break; case CANONICALDEREF: break; case AUTOSIMPLIFYDEREF: break; case SHOWMESSAGENUMBERSDEREF: break; case TAYLORRECURSDEREF: break; case TIMINGDEREF: break; case FULLPARENDEREF: break; case MIDPOINTDEREF: break; case DIEONERRORMODEDEREF: break; case RATIONALMODEDEREF: break; case SUPPRESSWARNINGSDEREF: break; case HOPITALRECURSDEREF: break; default: sollyaFprintf(stderr,"Error: deepCopyThing: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return copy; } void *deepCopyThingOnVoid(void *tree) { return (void *) deepCopyThing((node *) tree); } void *copyThingOnVoid(void *tree) { return (void *) copyThing((node *) tree); } void *copyThingAndAddMemRefOnVoid(void *tree) { return (void *) addMemRef(copyThing((node *) tree)); } void *copyEntryOnVoid(void *ptr) { entry *copy; copy = (entry *) safeMalloc(sizeof(entry)); copy->name = (char *) safeCalloc(strlen(((entry *) ptr)->name)+1,sizeof(char)); strcpy(copy->name,((entry *) ptr)->name); copy->value = copyThing((node *) (((entry *) ptr)->value)); return copy; } void *deepCopyEntryOnVoid(void *ptr) { entry *copy; copy = (entry *) safeMalloc(sizeof(entry)); copy->name = (char *) safeCalloc(strlen(((entry *) ptr)->name)+1,sizeof(char)); strcpy(copy->name,((entry *) ptr)->name); copy->value = deepCopyThing((node *) (((entry *) ptr)->value)); return copy; } void *evaluateEntryOnVoid(void *ptr) { entry *copy; copy = (entry *) safeMalloc(sizeof(entry)); copy->name = (char *) safeCalloc(strlen(((entry *) ptr)->name)+1,sizeof(char)); strcpy(copy->name,((entry *) ptr)->name); copy->value = evaluateThing((node *) (((entry *) ptr)->value)); return copy; } void freeEntryOnVoid(void *ptr) { safeFree(((entry *) ptr)->name); freeThing((node *) (((entry *) ptr)->value)); safeFree(ptr); } struct __copyThingWithMemRefReuseInnerStruct { node *reuse; int *didReuse; }; node *copyThingWithMemRefReuseInner(node *tree, node *reuse, int *didReuse); void *copyThingWithMemRefReuseInnerOnVoid(void *ptr1, void *ptr2) { return (void *) copyThingWithMemRefReuseInner((node *) ptr1, ((struct __copyThingWithMemRefReuseInnerStruct *) ptr2)->reuse, ((struct __copyThingWithMemRefReuseInnerStruct *) ptr2)->didReuse); } void *copyEntryWithMemRefReuseInnerOnVoid(void *ptr, void *ptr2) { entry *copy; copy = (entry *) safeMalloc(sizeof(entry)); copy->name = (char *) safeCalloc(strlen(((entry *) ptr)->name)+1,sizeof(char)); strcpy(copy->name,((entry *) ptr)->name); copy->value = (node *) copyThingWithMemRefReuseInnerOnVoid(((entry *) ptr)->value, ptr2); return copy; } node *tryFindMemRefOccurrence(node *subtree, node *tree) { node *rec; chain *curr; if (subtree == NULL) return NULL; if (tree == NULL) return NULL; if ((tree->nodeType == MEMREF) && (isEqualThing(subtree, tree))) { return tree; } switch (tree->nodeType) { case MEMREF: return tryFindMemRefOccurrence(subtree, getMemRefChild(tree)); break; case VARIABLE: case CONSTANT: case LIBRARYCONSTANT: case PI_CONST: case QUIT: case FALSEQUIT: case FALSERESTART: case RESTART: case VARIABLEDECLARATION: case NOP: case RENAME: case ON: case OFF: case DYADIC: case POWERS: case BINARY: case HEXADECIMAL: case FILESYM: case POSTSCRIPT: case POSTSCRIPTFILE: case PERTURB: case ROUNDDOWN: case ROUNDUP: case ROUNDTOZERO: case ROUNDTONEAREST: case HONORCOEFF: case TRUE: case UNIT: case FALSE: case DEFAULT: case DECIMAL: case ABSOLUTESYM: case RELATIVESYM: case FIXED: case FLOATING: case ERRORSPECIAL: case DOUBLESYMBOL: case SINGLESYMBOL: case QUADSYMBOL: case HALFPRECISIONSYMBOL: case DOUBLEEXTENDEDSYMBOL: case DOUBLEDOUBLESYMBOL: case TRIPLEDOUBLESYMBOL: case STRING: case TABLEACCESS: case ISBOUND: case DECIMALCONSTANT: case MIDPOINTCONSTANT: case DYADICCONSTANT: case HEXCONSTANT: case HEXADECIMALCONSTANT: case BINARYCONSTANT: case EMPTYLIST: case ELLIPTIC: case GETSUPPRESSEDMESSAGES: case GETBACKTRACE: case EXTERNALPROCEDUREUSAGE: case PRECDEREF: case POINTSDEREF: case DIAMDEREF: case DISPLAYDEREF: case VERBOSITYDEREF: case CANONICALDEREF: case AUTOSIMPLIFYDEREF: case SHOWMESSAGENUMBERSDEREF: case TAYLORRECURSDEREF: case TIMINGDEREF: case FULLPARENDEREF: case MIDPOINTDEREF: case DIEONERRORMODEDEREF: case RATIONALMODEDEREF: case SUPPRESSWARNINGSDEREF: case HOPITALRECURSDEREF: return NULL; break; case ADD: case SUB: case MUL: case DIV: case POW: case PROCEDUREFUNCTION: case WHILE: case IF: case FORIN: case ASCIIPLOT: case PRINTXMLNEWFILE: case PRINTXMLAPPENDFILE: case AND: case OR: case INDEX: case COMPAREEQUAL: case COMPAREIN: case COMPARELESS: case COMPAREGREATER: case COMPARELESSEQUAL: case COMPAREGREATEREQUAL: case COMPARENOTEQUAL: case CONCAT: case ADDTOLIST: case PREPEND: case APPEND: case RANGE: case SUBSTITUTE: case COMPOSEPOLYNOMIALS: case COEFF: case SUBPOLY: case ROUNDCOEFFICIENTS: case RATIONALAPPROX: case EVALUATE: case FINDZEROS: case FPFINDZEROS: case DIRTYINFNORM: case NUMBERROOTS: case INTEGRAL: case DIRTYINTEGRAL: case ZERODENOMINATORS: case ISEVALUABLE: case PROTOASSIGNMENTINSTRUCTURE: case PROTOFLOATASSIGNMENTINSTRUCTURE: case DIRTYFINDZEROS: case PROC: case BIND: case PROCILLIM: rec = tryFindMemRefOccurrence(subtree, tree->child1); if (rec != NULL) return rec; return tryFindMemRefOccurrence(subtree, tree->child2); break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case DOUBLE: case SINGLE: case HALFPRECISION: case QUAD: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case LIBRARYFUNCTION: case CEIL: case FLOOR: case NEARESTINT: case NOPARG: case PRINTHEXA: case PRINTFLOAT: case PRINTBINARY: case PRINTEXPANSION: case BASHEXECUTE: case PRINTXML: case EXTERNALPROC: case ASSIGNMENT: case FLOATASSIGNMENT: case LIBRARYBINDING: case LIBRARYCONSTANTBINDING: case PRECASSIGN: case POINTSASSIGN: case DIAMASSIGN: case DISPLAYASSIGN: case VERBOSITYASSIGN: case CANONICALASSIGN: case AUTOSIMPLIFYASSIGN: case SHOWMESSAGENUMBERSASSIGN: case TAYLORRECURSASSIGN: case TIMINGASSIGN: case FULLPARENASSIGN: case MIDPOINTASSIGN: case DIEONERRORMODEASSIGN: case RATIONALMODEASSIGN: case SUPPRESSWARNINGSASSIGN: case HOPITALRECURSASSIGN: case PRECSTILLASSIGN: case POINTSSTILLASSIGN: case DIAMSTILLASSIGN: case DISPLAYSTILLASSIGN: case VERBOSITYSTILLASSIGN: case CANONICALSTILLASSIGN: case AUTOSIMPLIFYSTILLASSIGN: case SHOWMESSAGENUMBERSSTILLASSIGN: case TAYLORRECURSSTILLASSIGN: case TIMINGSTILLASSIGN: case FULLPARENSTILLASSIGN: case MIDPOINTSTILLASSIGN: case DIEONERRORMODESTILLASSIGN: case RATIONALMODESTILLASSIGN: case SUPPRESSWARNINGSSTILLASSIGN: case HOPITALRECURSSTILLASSIGN: case NEGATION: case STRUCTACCESS: case DEBOUNDMAX: case DEBOUNDMIN: case DEBOUNDMID: case EVALCONST: case DIFF: case DIRTYSIMPLIFY: case SIMPLIFYSAFE: case TIME: case HORNER: case CANONICAL: case EXPAND: case DEGREE: case NUMERATOR: case DENOMINATOR: case PARSE: case READXML: case EXECUTE: case ASSIGNMENTINSTRUCTURE: case FLOATASSIGNMENTINSTRUCTURE: case HEAD: case ROUNDCORRECTLY: case READFILE: case REVERT: case SORT: case MANTISSA: case EXPONENT: case PRECISION: case TAIL: case LENGTH: case OBJECTNAME: return tryFindMemRefOccurrence(subtree, tree->child1); break; case MATCHELEMENT: rec = tryFindMemRefOccurrence(subtree, tree->child2); if (rec != NULL) return rec; /* CAUTION: this fall-through *is* intended */ case NEWFILEPRINT: case APPENDFILEPRINT: case NEWFILEWRITE: case APPENDFILEWRITE: case APPLY: case MATCH: rec = tryFindMemRefOccurrence(subtree, tree->child1); if (rec != NULL) return rec; /* CAUTION: this fall-through *is* intended */ case COMMANDLIST: case IFELSE: case FOR: case PRINT: case SUPPRESSMESSAGE: case UNSUPPRESSMESSAGE: case PLOT: case EXTERNALPLOT: case WRITE: case WORSTCASE: case AUTOPRINT: case TABLEACCESSWITHSUBSTITUTE: case LIST: case FINALELLIPTICLIST: case BASHEVALUATE: case REMEZ: case ANNOTATEFUNCTION: case MIN: case MAX: case FPMINIMAX: case TAYLOR: case TAYLORFORM: case CHEBYSHEVFORM: case AUTODIFF: case ACCURATEINFNORM: case ROUNDTOFORMAT: case INFNORM: case SUPNORM: case IMPLEMENTPOLY: case IMPLEMENTCONST: case CHECKINFNORM: case SEARCHGAL: case GUESSDEGREE: case ASSIGNMENTININDEXING: case FLOATASSIGNMENTININDEXING: for (curr=tree->arguments;curr!=NULL;curr=curr->next) { rec = tryFindMemRefOccurrence(subtree, (node *) (curr->value)); if (rec != NULL) return rec; } return NULL; break; case STRUCTURE: for (curr=tree->arguments;curr!=NULL;curr=curr->next) { rec = tryFindMemRefOccurrence(subtree, (node *) (((entry *) (curr->value))->value)); if (rec != NULL) return rec; } break; default: break; } return NULL; } node *copyThingWithMemRefReuseInner(node *tree, node *reuse, int *didReuse) { node *copy, *reuseRef; struct __copyThingWithMemRefReuseInnerStruct argStruct; int myDidReuse; argStruct.reuse = reuse; argStruct.didReuse = didReuse; if (tree == NULL) return NULL; if (tree == reuse) { return copyThing(tree); } if (tree->nodeType == MEMREF) { if ((tree->evaluationHook != NULL) || (tree->derivCache != NULL) || (tree->simplifyCache != NULL)) { return copyThing(tree); } myDidReuse = 0; copy = addMemRef(copyThingWithMemRefReuseInner(getMemRefChild(tree), reuse, &myDidReuse)); if (copy == NULL) { *didReuse = *didReuse || myDidReuse; return copy; } if (copy->nodeType != MEMREF) { freeThing(copy); return copyThing(tree); } if ((copy->evaluationHook != NULL) || (copy->derivCache != NULL) || (copy->simplifyCache != NULL)) { *didReuse = *didReuse || myDidReuse; return copy; } if (!myDidReuse) { freeThing(copy); return copyThing(tree); } if (tree->libFunDeriv > copy->libFunDeriv) { freeThing(copy); return copyThing(tree); } *didReuse = *didReuse || myDidReuse; return copy; } reuseRef = tryFindMemRefOccurrence(tree, reuse); if (reuseRef != NULL) { *didReuse = 1; return addMemRef(copyThing(reuseRef)); } copy = (node *) safeMalloc(sizeof(node)); copy->nodeType = tree->nodeType; switch (tree->nodeType) { case VARIABLE: break; case CONSTANT: copy->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(copy->value),mpfr_get_prec(*(tree->value))); mpfr_set(*(copy->value),*(tree->value),GMP_RNDN); break; case ADD: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case SUB: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case MUL: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case DIV: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case SQRT: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case EXP: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case LOG: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case LOG_2: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case LOG_10: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case SIN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case COS: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case TAN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case ASIN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case ACOS: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case ATAN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case SINH: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case COSH: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case TANH: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case ASINH: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case ACOSH: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case ATANH: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case POW: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case NEG: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case ABS: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DOUBLE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case SINGLE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case HALFPRECISION: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case QUAD: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DOUBLEDOUBLE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case TRIPLEDOUBLE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case ERF: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case ERFC: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case LOG_1P: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case EXP_M1: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DOUBLEEXTENDED: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case LIBRARYFUNCTION: copy->libFun = tree->libFun; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case LIBRARYCONSTANT: copy->libFun = tree->libFun; break; case PROCEDUREFUNCTION: copy->libFunDeriv = tree->libFunDeriv; copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case CEIL: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case FLOOR: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case NEARESTINT: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case PI_CONST: break; case COMMANDLIST: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case WHILE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case IFELSE: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case IF: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case FOR: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case FORIN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case QUIT: break; case FALSEQUIT: break; case FALSERESTART: break; case RESTART: break; case PRINT: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case SUPPRESSMESSAGE: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case UNSUPPRESSMESSAGE: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case VARIABLEDECLARATION: copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case NOP: break; case NOPARG: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case NEWFILEPRINT: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case APPENDFILEPRINT: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case PLOT: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case PRINTHEXA: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case PRINTFLOAT: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case PRINTBINARY: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case PRINTEXPANSION: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case BASHEXECUTE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case EXTERNALPLOT: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case WRITE: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case NEWFILEWRITE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case APPENDFILEWRITE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case ASCIIPLOT: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case PRINTXML: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case PRINTXMLNEWFILE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case PRINTXMLAPPENDFILE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case WORSTCASE: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case RENAME: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case AUTOPRINT: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case EXTERNALPROC: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); copy->arguments = copyChainWithoutReversal(tree->arguments, copyIntPtrOnVoid); break; case ASSIGNMENT: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case FLOATASSIGNMENT: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case LIBRARYBINDING: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case LIBRARYCONSTANTBINDING: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case PRECASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case POINTSASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DIAMASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DISPLAYASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case VERBOSITYASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case CANONICALASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case AUTOSIMPLIFYASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case SHOWMESSAGENUMBERSASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case TAYLORRECURSASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case TIMINGASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case FULLPARENASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case MIDPOINTASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DIEONERRORMODEASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case RATIONALMODEASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case SUPPRESSWARNINGSASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case HOPITALRECURSASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case PRECSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case POINTSSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DIAMSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DISPLAYSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case VERBOSITYSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case CANONICALSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case AUTOSIMPLIFYSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case SHOWMESSAGENUMBERSSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case TAYLORRECURSSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case TIMINGSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case FULLPARENSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case MIDPOINTSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DIEONERRORMODESTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case RATIONALMODESTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case SUPPRESSWARNINGSSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case HOPITALRECURSSTILLASSIGN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case AND: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case OR: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case NEGATION: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case INDEX: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case COMPAREEQUAL: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case COMPAREIN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case COMPARELESS: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case COMPAREGREATER: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case COMPARELESSEQUAL: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case COMPAREGREATEREQUAL: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case COMPARENOTEQUAL: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case CONCAT: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case ADDTOLIST: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case PREPEND: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case APPEND: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case ON: break; case OFF: break; case DYADIC: break; case POWERS: break; case BINARY: break; case HEXADECIMAL: break; case FILESYM: break; case POSTSCRIPT: break; case POSTSCRIPTFILE: break; case PERTURB: break; case ROUNDDOWN: break; case ROUNDUP: break; case ROUNDTOZERO: break; case ROUNDTONEAREST: break; case HONORCOEFF: break; case TRUE: break; case UNIT: break; case FALSE: break; case DEFAULT: break; case DECIMAL: break; case ABSOLUTESYM: break; case RELATIVESYM: break; case FIXED: break; case FLOATING: break; case ERRORSPECIAL: break; case DOUBLESYMBOL: break; case SINGLESYMBOL: break; case QUADSYMBOL: break; case HALFPRECISIONSYMBOL: break; case DOUBLEEXTENDEDSYMBOL: break; case DOUBLEDOUBLESYMBOL: break; case TRIPLEDOUBLESYMBOL: break; case STRING: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case TABLEACCESS: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case ISBOUND: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case TABLEACCESSWITHSUBSTITUTE: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case STRUCTACCESS: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case APPLY: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DECIMALCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case MIDPOINTCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case DYADICCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case HEXCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case HEXADECIMALCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case BINARYCONSTANT: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case EMPTYLIST: break; case LIST: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; break; case STRUCTURE: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyEntryWithMemRefReuseInnerOnVoid); break; case FINALELLIPTICLIST: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; break; case ELLIPTIC: break; case RANGE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case DEBOUNDMAX: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DEBOUNDMIN: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DEBOUNDMID: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case EVALCONST: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DIFF: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case BASHEVALUATE: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case GETSUPPRESSEDMESSAGES: break; case GETBACKTRACE: break; case DIRTYSIMPLIFY: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case SIMPLIFYSAFE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case TIME: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case REMEZ: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case ANNOTATEFUNCTION: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case MATCH: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case MATCHELEMENT: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case MIN: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case MAX: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case FPMINIMAX: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case HORNER: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case CANONICAL: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case EXPAND: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case TAYLOR: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case TAYLORFORM: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case CHEBYSHEVFORM: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case AUTODIFF: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case DEGREE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case NUMERATOR: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case DENOMINATOR: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case SUBSTITUTE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case COMPOSEPOLYNOMIALS: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case COEFF: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case SUBPOLY: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case ROUNDCOEFFICIENTS: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case RATIONALAPPROX: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case ACCURATEINFNORM: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case ROUNDTOFORMAT: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case EVALUATE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case PARSE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case READXML: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case EXECUTE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case INFNORM: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case SUPNORM: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case FINDZEROS: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case FPFINDZEROS: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case DIRTYINFNORM: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case NUMBERROOTS: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case INTEGRAL: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case DIRTYINTEGRAL: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case IMPLEMENTPOLY: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case IMPLEMENTCONST: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case CHECKINFNORM: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case ZERODENOMINATORS: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case ISEVALUABLE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case SEARCHGAL: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case GUESSDEGREE: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case ASSIGNMENTININDEXING: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case FLOATASSIGNMENTININDEXING: copy->arguments = copyChainAndMap(tree->arguments, &argStruct, copyThingWithMemRefReuseInnerOnVoid); break; case ASSIGNMENTINSTRUCTURE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case FLOATASSIGNMENTINSTRUCTURE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case PROTOASSIGNMENTINSTRUCTURE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case PROTOFLOATASSIGNMENTINSTRUCTURE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case DIRTYFINDZEROS: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); break; case HEAD: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case ROUNDCORRECTLY: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case READFILE: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case REVERT: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case SORT: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case MANTISSA: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case EXPONENT: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case PRECISION: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case TAIL: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case LENGTH: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case OBJECTNAME: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); break; case EXTERNALPROCEDUREUSAGE: copy->libProc = tree->libProc; break; case PROC: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case BIND: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case PROCILLIM: copy->child1 = copyThingWithMemRefReuseInner(tree->child1,reuse, didReuse); copy->child2 = copyThingWithMemRefReuseInner(tree->child2,reuse, didReuse); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case PRECDEREF: break; case POINTSDEREF: break; case DIAMDEREF: break; case DISPLAYDEREF: break; case VERBOSITYDEREF: break; case CANONICALDEREF: break; case AUTOSIMPLIFYDEREF: break; case SHOWMESSAGENUMBERSDEREF: break; case TAYLORRECURSDEREF: break; case TIMINGDEREF: break; case FULLPARENDEREF: break; case MIDPOINTDEREF: break; case DIEONERRORMODEDEREF: break; case RATIONALMODEDEREF: break; case SUPPRESSWARNINGSDEREF: break; case HOPITALRECURSDEREF: break; default: sollyaFprintf(stderr,"Error: copyThingWithMemRefReuseInner: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return addMemRef(copy); } node *copyThingWithMemRefReuse(node *tree, node *reuse) { node *res; int didReuse; didReuse = 0; res = copyThingWithMemRefReuseInner(tree, reuse, &didReuse); return res; } /* Eats up its first argument, does not change (nor eat up) its second argument */ node *rewriteThingWithMemRefReuse(node *tree, node *reuse) { node *copy; int didReuse; if (tree == NULL) return NULL; if (reuse == NULL) return tree; didReuse = 0; copy = copyThingWithMemRefReuseInner(tree, reuse, &didReuse); if (didReuse) { freeThing(tree); return copy; } freeThing(copy); return tree; } char *getTimingStringForThing(node *tree) { char *constString, *newString; if (tree == NULL) return NULL; if (tree->nodeType == MEMREF) { return getTimingStringForThing(getMemRefChild(tree)); } switch (tree->nodeType) { case VARIABLE: constString = NULL; break; case CONSTANT: constString = NULL; break; case ADD: constString = NULL; break; case SUB: constString = NULL; break; case MUL: constString = NULL; break; case DIV: constString = NULL; break; case SQRT: constString = NULL; break; case EXP: constString = NULL; break; case LOG: constString = NULL; break; case LOG_2: constString = NULL; break; case LOG_10: constString = NULL; break; case SIN: constString = NULL; break; case COS: constString = NULL; break; case TAN: constString = NULL; break; case ASIN: constString = NULL; break; case ACOS: constString = NULL; break; case ATAN: constString = NULL; break; case SINH: constString = NULL; break; case COSH: constString = NULL; break; case TANH: constString = NULL; break; case ASINH: constString = NULL; break; case ACOSH: constString = NULL; break; case ATANH: constString = NULL; break; case POW: constString = NULL; break; case NEG: constString = NULL; break; case ABS: constString = NULL; break; case DOUBLE: constString = NULL; break; case SINGLE: constString = NULL; break; case QUAD: constString = NULL; break; case HALFPRECISION: constString = NULL; break; case DOUBLEDOUBLE: constString = NULL; break; case TRIPLEDOUBLE: constString = NULL; break; case ERF: constString = NULL; break; case ERFC: constString = NULL; break; case LOG_1P: constString = NULL; break; case EXP_M1: constString = NULL; break; case DOUBLEEXTENDED: constString = NULL; break; case LIBRARYFUNCTION: constString = NULL; break; case LIBRARYCONSTANT: constString = NULL; break; case PROCEDUREFUNCTION: constString = NULL; break; case CEIL: constString = NULL; break; case FLOOR: constString = NULL; break; case NEARESTINT: constString = NULL; break; case PI_CONST: constString = NULL; break; case COMMANDLIST: constString = "begin-end statement"; break; case WHILE: constString = "while loop"; break; case IFELSE: constString = "if-then-else statement"; break; case IF: constString = "if-then statement"; break; case FOR: constString = "for loop"; break; case FORIN: constString = "for-in loop"; break; case QUIT: constString = NULL; break; case NOP: constString = NULL; break; case NOPARG: constString = "doing nothing"; break; case FALSEQUIT: constString = NULL; break; case FALSERESTART: constString = NULL; break; case RESTART: constString = NULL; break; case PRINT: constString = "print statement"; break; case SUPPRESSMESSAGE: constString = "suppressing a message"; break; case UNSUPPRESSMESSAGE: constString = "unsuppressing a message"; break; case VARIABLEDECLARATION: constString = NULL; break; case NEWFILEPRINT: constString = "print-into-new-file statement"; break; case APPENDFILEPRINT: constString = "print-into-file statement"; break; case PLOT: constString = "plot statement"; break; case PRINTHEXA: constString = "printdouble statement"; break; case PRINTFLOAT: constString = "printsingle statement"; break; case PRINTBINARY: constString = "printbinary statement"; break; case PRINTEXPANSION: constString = "printexpansion statement"; break; case BASHEXECUTE: constString = "bashexecute statement"; break; case EXTERNALPLOT: constString = "externalplot statement"; break; case WRITE: constString = "write statement"; break; case NEWFILEWRITE: constString = "write-into-new-file statement"; break; case APPENDFILEWRITE: constString = "write-into-file statement"; break; case ASCIIPLOT: constString = "asciiplot statement"; break; case PRINTXML: constString = "printing in xml mode"; break; case PRINTXMLNEWFILE: constString = "printing in xml mode into a new file"; break; case PRINTXMLAPPENDFILE: constString = "printing in xml mode into a file"; break; case WORSTCASE: constString = "worstcase statement"; break; case RENAME: constString = "rename statement"; break; case AUTOPRINT: constString = "automatic printing of expressions"; break; case ASSIGNMENT: constString = "assignment"; break; case FLOATASSIGNMENT: constString = "floating-point assignment"; break; case EXTERNALPROC: constString = "binding of an external procedure"; break; case LIBRARYBINDING: constString = "binding of a library function"; break; case LIBRARYCONSTANTBINDING: constString = "binding of a library constant"; break; case PRECASSIGN: constString = "assigning the precision"; break; case POINTSASSIGN: constString = "assigning the point number"; break; case DIAMASSIGN: constString = "assigning the diameter"; break; case DISPLAYASSIGN: constString = "assigning the display mode"; break; case VERBOSITYASSIGN: constString = "assigning the verbosity"; break; case CANONICALASSIGN: constString = "assigning the canonical printing mode"; break; case AUTOSIMPLIFYASSIGN: constString = "assigning the automatic simplification mode"; break; case SHOWMESSAGENUMBERSASSIGN: constString = "assigning the show-message-numbers mode"; break; case TAYLORRECURSASSIGN: constString = "assigning the number of recursions for Taylor"; break; case TIMINGASSIGN: constString = "assigning the timing mode"; break; case FULLPARENASSIGN: constString = "full parenthezation mode"; break; case MIDPOINTASSIGN: constString = "assigning the midpoint printing mode"; break; case DIEONERRORMODEASSIGN: constString = "assigning the die-on-error mode"; break; case RATIONALMODEASSIGN: constString = "assigning the midpoint printing mode"; break; case SUPPRESSWARNINGSASSIGN: constString = "assigning the warning activation"; break; case HOPITALRECURSASSIGN: constString = "assigning the number of recursions for Hopital"; break; case PRECSTILLASSIGN: constString = NULL; break; case POINTSSTILLASSIGN: constString = NULL; break; case DIAMSTILLASSIGN: constString = NULL; break; case DISPLAYSTILLASSIGN: constString = NULL; break; case VERBOSITYSTILLASSIGN: constString = NULL; break; case CANONICALSTILLASSIGN: constString = NULL; break; case AUTOSIMPLIFYSTILLASSIGN: constString = NULL; break; case SHOWMESSAGENUMBERSSTILLASSIGN: constString = NULL; break; case TAYLORRECURSSTILLASSIGN: constString = NULL; break; case TIMINGSTILLASSIGN: constString = NULL; break; case FULLPARENSTILLASSIGN: constString = NULL; break; case MIDPOINTSTILLASSIGN: constString = NULL; break; case DIEONERRORMODESTILLASSIGN: constString = NULL; break; case RATIONALMODESTILLASSIGN: constString = NULL; break; case SUPPRESSWARNINGSSTILLASSIGN: constString = NULL; break; case HOPITALRECURSSTILLASSIGN: constString = NULL; break; case AND: constString = NULL; break; case OR: constString = NULL; break; case NEGATION: constString = NULL; break; case INDEX: constString = "indexing in a string or list"; break; case COMPAREEQUAL: constString = "compare equal"; break; case COMPAREIN: constString = "compare if in interval"; break; case COMPARELESS: constString = "compare less"; break; case COMPAREGREATER: constString = "compare greater"; break; case COMPARELESSEQUAL: constString = "compare less or equal"; break; case COMPAREGREATEREQUAL: constString = "compare greater or equal"; break; case COMPARENOTEQUAL: constString = "compare not equal"; break; case CONCAT: constString = "concatenation of strings or lists"; break; case ADDTOLIST: constString = "adding an element to a list"; break; case APPEND: constString = "appending an element to a list"; break; case PREPEND: constString = "prepending an element to a list"; break; case ON: constString = NULL; break; case OFF: constString = NULL; break; case DYADIC: constString = NULL; break; case POWERS: constString = NULL; break; case BINARY: constString = NULL; break; case HEXADECIMAL: constString = NULL; break; case FILESYM: constString = NULL; break; case POSTSCRIPT: constString = NULL; break; case POSTSCRIPTFILE: constString = NULL; break; case PERTURB: constString = NULL; break; case ROUNDDOWN: constString = NULL; break; case ROUNDUP: constString = NULL; break; case ROUNDTOZERO: constString = NULL; break; case ROUNDTONEAREST: constString = NULL; break; case HONORCOEFF: constString = NULL; break; case TRUE: constString = NULL; break; case UNIT: constString = NULL; break; case FALSE: constString = NULL; break; case DEFAULT: constString = NULL; break; case DECIMAL: constString = NULL; break; case ABSOLUTESYM: constString = NULL; break; case RELATIVESYM: constString = NULL; break; case FIXED: constString = NULL; break; case FLOATING: constString = NULL; break; case ERRORSPECIAL: constString = NULL; break; case DOUBLESYMBOL: constString = NULL; break; case SINGLESYMBOL: constString = NULL; break; case QUADSYMBOL: constString = NULL; break; case HALFPRECISIONSYMBOL: constString = NULL; break; case DOUBLEEXTENDEDSYMBOL: constString = NULL; break; case DOUBLEDOUBLESYMBOL: constString = NULL; break; case TRIPLEDOUBLESYMBOL: constString = NULL; break; case STRING: constString = NULL; break; case TABLEACCESS: constString = "dereferencing an identifier"; break; case ISBOUND: constString = "testing if an identifier is bound"; break; case TABLEACCESSWITHSUBSTITUTE: constString = "dereferencing an identifier and substituting"; break; case STRUCTACCESS: constString = "accessing a member of a structure"; break; case APPLY: constString = "applying something to something"; break; case DECIMALCONSTANT: constString = "reading a decimal constant"; break; case MIDPOINTCONSTANT: constString = "reading a midpoint constant"; break; case DYADICCONSTANT: constString = "reading a dyadic constant"; break; case HEXCONSTANT: constString = "reading a hexadecimal constant"; break; case HEXADECIMALCONSTANT: constString = "reading a hexadecimal constant"; break; case BINARYCONSTANT: constString = "reading a binary constant"; break; case EMPTYLIST: constString = NULL; break; case LIST: constString = "handling a list"; break; case STRUCTURE: constString = "handling a structure"; break; case FINALELLIPTICLIST: constString = "handling a finally elliptic list"; break; case ELLIPTIC: constString = NULL; break; case RANGE: constString = "handling a range"; break; case DEBOUNDMAX: constString = NULL; break; case DEBOUNDMIN: constString = NULL; break; case DEBOUNDMID: constString = NULL; break; case EVALCONST: constString = "floating-point evaluation of a constant expression"; break; case DIFF: constString = "differentiation"; break; case BASHEVALUATE: constString = "evaluating a string as a bash command"; break; case GETSUPPRESSEDMESSAGES: constString = "getting the list of suppressed messages"; break; case GETBACKTRACE: constString = "getting a backtrace of the procedure calling stack"; break; case DIRTYSIMPLIFY: constString = "simplifying with floating-point evaluation"; break; case SIMPLIFYSAFE: constString = "simplifying"; break; case TIME: constString = "timing a command"; break; case REMEZ: constString = "computing a minimax approximation"; break; case ANNOTATEFUNCTION: constString = "annotating a function"; break; case MATCH: constString = "matching an expression"; case MATCHELEMENT: constString = NULL; break; case MIN: constString = "computing a minimum"; break; case MAX: constString = "computing a maximum"; break; case FPMINIMAX: constString = "computing a fpminimax approximation"; break; case HORNER: constString = "conversion to horner notation"; break; case CANONICAL: constString = "conversion to canonical notation"; break; case EXPAND: constString = "expanding an expression"; break; case TAYLOR: constString = "taylor"; break; case TAYLORFORM: constString = "taylorform"; break; case CHEBYSHEVFORM: constString = "chebyshevform"; break; case AUTODIFF: constString = "autodiff"; break; case DEGREE: constString = "getting the degree"; break; case NUMERATOR: constString = "getting the numerator"; break; case DENOMINATOR: constString = "getting the denominator"; break; case SUBSTITUTE: constString = "substituting"; break; case COMPOSEPOLYNOMIALS: constString = "composing two polynomials"; break; case COEFF: constString = "getting a coefficient"; break; case SUBPOLY: constString = "getting a sub-polynomial"; break; case ROUNDCOEFFICIENTS: constString = "rounding coefficients"; break; case RATIONALAPPROX: constString = "computing a rational approximation"; break; case ACCURATEINFNORM: constString = "computing an accurate infinity norm"; break; case ROUNDTOFORMAT: constString = "rounding to a format"; break; case EVALUATE: constString = "evaluating"; break; case PARSE: constString = "parsing a mini-expression"; break; case READXML: constString = "reading a XML-tree"; break; case EXECUTE: constString = "executing a file"; break; case INFNORM: constString = "computing an infinity norm"; break; case SUPNORM: constString = "computing a supremum norm"; break; case FINDZEROS: constString = "bounding zeros"; break; case FPFINDZEROS: constString = "searching zeros"; break; case DIRTYINFNORM: constString = "computing an infinity norm dirtily"; break; case NUMBERROOTS: constString = "computing the number of real roots of a polynomial"; break; case INTEGRAL: constString = "computing an integral"; break; case DIRTYINTEGRAL: constString = "computing an integral dirtily"; break; case IMPLEMENTPOLY: constString = "implementing a polynomial"; break; case IMPLEMENTCONST: constString = "implementing a constant"; break; case CHECKINFNORM: constString = "checking an infinity norm"; break; case ZERODENOMINATORS: constString = "searching zeros of denominators"; break; case ISEVALUABLE: constString = "testing if evaluable"; break; case SEARCHGAL: constString = "searching a Gal value"; break; case GUESSDEGREE: constString = "guessing a degree for Remez"; break; case ASSIGNMENTININDEXING: constString = "assigning to an indexed element of a list"; break; case FLOATASSIGNMENTININDEXING: constString = "assigning a floating-point value to an indexed element of a list"; break; case ASSIGNMENTINSTRUCTURE: constString = "assigning an element to a structure"; break; case FLOATASSIGNMENTINSTRUCTURE: constString = "assigning a floating-point valued element to a structure"; break; case PROTOASSIGNMENTINSTRUCTURE: constString = NULL; break; case PROTOFLOATASSIGNMENTINSTRUCTURE: constString = NULL; break; case DIRTYFINDZEROS: constString = "searching zeros dirtily"; break; case HEAD: constString = NULL; break; case ROUNDCORRECTLY: constString = "rounding a range to a value"; break; case READFILE: constString = "reading a file into a string"; break; case REVERT: constString = "reverting a list"; break; case SORT: constString = "sorting a list"; break; case EXPONENT: constString = "computing the exponent of a value"; break; case MANTISSA: constString = "computing the integer mantissa of a value"; break; case PRECISION: constString = "computing the effective precision of a value"; break; case TAIL: constString = NULL; break; case LENGTH: constString = "computing the length of a list"; break; case OBJECTNAME: constString = "getting the name of an object"; break; case EXTERNALPROCEDUREUSAGE: constString = "executing an external procedure"; break; case PROC: constString = "executing a procedure"; break; case BIND: constString = "binding an argument of a procedure"; break; case PROCILLIM: constString = "executing a procedure"; break; case PRECDEREF: constString = "dereferencing the precision of the tool"; break; case POINTSDEREF: constString = "dereferencing the number of points of the tool"; break; case DIAMDEREF: constString = "dereferencing the diameter of the tool"; break; case DISPLAYDEREF: constString = "dereferencing the display mode"; break; case VERBOSITYDEREF: constString = "dereferencing the verbosity of the tool"; break; case CANONICALDEREF: constString = "dereferencing the canonical mode state of the tool"; break; case AUTOSIMPLIFYDEREF: constString = "dereferencing the automatic simplification mode state of the tool"; break; case SHOWMESSAGENUMBERSDEREF: constString = "dereferencing the show-message-numbers mode state of the tool"; break; case TAYLORRECURSDEREF: constString = "dereferencing the number of recursions for Taylor"; break; case TIMINGDEREF: constString = "dereferencing the timing mode state of the tool"; break; case FULLPARENDEREF: constString = "dereferencing the full parenthezation mode state of the tool"; break; case MIDPOINTDEREF: constString = "dereferencing the midpoint mode state of the tool"; break; case DIEONERRORMODEDEREF: constString = "dereferencing the die-on-error mode state of the tool"; break; case RATIONALMODEDEREF: constString = "dereferencing the rational number mode state of the tool"; break; case SUPPRESSWARNINGSDEREF: constString = "dereferencing the warning activation state of the tool"; break; case HOPITALRECURSDEREF: constString = "dereferencing the numbers of recursions for Hopital"; break; default: sollyaFprintf(stderr,"Error: getTimingStringForThing: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } if (constString == NULL) return NULL; newString = (char *) safeCalloc(strlen(constString) + 1,sizeof(char)); strcpy(newString,constString); return newString; } int isPureTree(node *tree) { switch (tree->nodeType) { case MEMREF: if (tree->polynomialRepresentation != NULL) return 1; return isPureTree(getMemRefChild(tree)); break; case VARIABLE: return 1; break; case CONSTANT: return 1; break; case ADD: return (isPureTree(tree->child1) && isPureTree(tree->child2)); break; case SUB: return (isPureTree(tree->child1) && isPureTree(tree->child2)); break; case MUL: return (isPureTree(tree->child1) && isPureTree(tree->child2)); break; case DIV: return (isPureTree(tree->child1) && isPureTree(tree->child2)); break; case SQRT: return isPureTree(tree->child1); break; case EXP: return isPureTree(tree->child1); break; case LOG: return isPureTree(tree->child1); break; case LOG_2: return isPureTree(tree->child1); break; case LOG_10: return isPureTree(tree->child1); break; case SIN: return isPureTree(tree->child1); break; case COS: return isPureTree(tree->child1); break; case TAN: return isPureTree(tree->child1); break; case ASIN: return isPureTree(tree->child1); break; case ACOS: return isPureTree(tree->child1); break; case ATAN: return isPureTree(tree->child1); break; case SINH: return isPureTree(tree->child1); break; case COSH: return isPureTree(tree->child1); break; case TANH: return isPureTree(tree->child1); break; case ASINH: return isPureTree(tree->child1); break; case ACOSH: return isPureTree(tree->child1); break; case ATANH: return isPureTree(tree->child1); break; case POW: return (isPureTree(tree->child1) && isPureTree(tree->child2)); break; case NEG: return isPureTree(tree->child1); break; case ABS: return isPureTree(tree->child1); break; case DOUBLE: return isPureTree(tree->child1); break; case SINGLE: return isPureTree(tree->child1); break; case QUAD: return isPureTree(tree->child1); break; case HALFPRECISION: return isPureTree(tree->child1); break; case DOUBLEDOUBLE: return isPureTree(tree->child1); break; case TRIPLEDOUBLE: return isPureTree(tree->child1); break; case ERF: return isPureTree(tree->child1); break; case ERFC: return isPureTree(tree->child1); break; case LOG_1P: return isPureTree(tree->child1); break; case EXP_M1: return isPureTree(tree->child1); break; case DOUBLEEXTENDED: return isPureTree(tree->child1); break; case LIBRARYFUNCTION: return isPureTree(tree->child1); break; case LIBRARYCONSTANT: return 1; break; case PROCEDUREFUNCTION: return isPureTree(tree->child1); break; case CEIL: return isPureTree(tree->child1); break; case FLOOR: return isPureTree(tree->child1); break; case NEARESTINT: return isPureTree(tree->child1); break; case PI_CONST: return 1; break; default: return 0; } } int isExtendedPureTree(node *tree) { switch (tree->nodeType) { case MEMREF: if (tree->polynomialRepresentation != NULL) return 1; return isExtendedPureTree(getMemRefChild(tree)); break; case DEFAULT: return 1; break; case VARIABLE: return 1; break; case TABLEACCESS: return 1; break; case TABLEACCESSWITHSUBSTITUTE: if (tree->arguments == NULL) return 0; if (tree->arguments->next != NULL) return 0; return 1; break; case APPLY: if (accessThruMemRef(tree->child1)->nodeType != VARIABLE) { if (variablename == NULL) return 0; if (accessThruMemRef(tree->child1)->nodeType != TABLEACCESS) return 0; if (strcmp(variablename,accessThruMemRef(tree->child1)->string)) return 0; } if (tree->arguments == NULL) return 0; if (tree->arguments->next != NULL) return 0; return 1; break; case CONSTANT: return 1; break; case ADD: return (isExtendedPureTree(tree->child1) && isExtendedPureTree(tree->child2)); break; case SUB: return (isExtendedPureTree(tree->child1) && isExtendedPureTree(tree->child2)); break; case MUL: return (isExtendedPureTree(tree->child1) && isExtendedPureTree(tree->child2)); break; case DIV: return (isExtendedPureTree(tree->child1) && isExtendedPureTree(tree->child2)); break; case SQRT: return isExtendedPureTree(tree->child1); break; case EXP: return isExtendedPureTree(tree->child1); break; case LOG: return isExtendedPureTree(tree->child1); break; case LOG_2: return isExtendedPureTree(tree->child1); break; case LOG_10: return isExtendedPureTree(tree->child1); break; case SIN: return isExtendedPureTree(tree->child1); break; case COS: return isExtendedPureTree(tree->child1); break; case TAN: return isExtendedPureTree(tree->child1); break; case ASIN: return isExtendedPureTree(tree->child1); break; case ACOS: return isExtendedPureTree(tree->child1); break; case ATAN: return isExtendedPureTree(tree->child1); break; case SINH: return isExtendedPureTree(tree->child1); break; case COSH: return isExtendedPureTree(tree->child1); break; case TANH: return isExtendedPureTree(tree->child1); break; case ASINH: return isExtendedPureTree(tree->child1); break; case ACOSH: return isExtendedPureTree(tree->child1); break; case ATANH: return isExtendedPureTree(tree->child1); break; case POW: return (isExtendedPureTree(tree->child1) && isExtendedPureTree(tree->child2)); break; case NEG: return isExtendedPureTree(tree->child1); break; case ABS: return isExtendedPureTree(tree->child1); break; case DOUBLE: return isExtendedPureTree(tree->child1); break; case SINGLE: return isExtendedPureTree(tree->child1); break; case QUAD: return isExtendedPureTree(tree->child1); break; case HALFPRECISION: return isExtendedPureTree(tree->child1); break; case DOUBLEDOUBLE: return isExtendedPureTree(tree->child1); break; case TRIPLEDOUBLE: return isExtendedPureTree(tree->child1); break; case ERF: return isExtendedPureTree(tree->child1); break; case ERFC: return isExtendedPureTree(tree->child1); break; case LOG_1P: return isExtendedPureTree(tree->child1); break; case EXP_M1: return isExtendedPureTree(tree->child1); break; case DOUBLEEXTENDED: return isExtendedPureTree(tree->child1); break; case LIBRARYFUNCTION: return isExtendedPureTree(tree->child1); break; case LIBRARYCONSTANT: return 1; break; case PROCEDUREFUNCTION: return isExtendedPureTree(tree->child1); break; case CEIL: return isExtendedPureTree(tree->child1); break; case FLOOR: return isExtendedPureTree(tree->child1); break; case NEARESTINT: return isExtendedPureTree(tree->child1); break; case PI_CONST: return 1; break; default: return 0; } } int isMatchable(node *); int isMatchableList(node *tree) { chain *curr; if (tree->nodeType == MEMREF) return isMatchableList(getMemRefChild(tree)); if (isEmptyList(tree)) return 1; if (!(isPureList(tree) || isPureFinalEllipticList(tree))) return 0; for (curr=tree->arguments;curr!=NULL;curr=curr->next) { if (!isMatchable((node *) (curr->value))) return 0; } return 1; } int isString(node *); int isMatchableConcat(node *tree) { if (tree->nodeType == MEMREF) return isMatchableConcat(getMemRefChild(tree)); if (tree->nodeType != CONCAT) return 0; if (((accessThruMemRef(tree->child1)->nodeType == TABLEACCESS) || (accessThruMemRef(tree->child1)->nodeType == DEFAULT)) && ((accessThruMemRef(tree->child2)->nodeType == TABLEACCESS) || (accessThruMemRef(tree->child2)->nodeType == DEFAULT))) return 0; if (((isMatchableList(tree->child1) && (!isPureFinalEllipticList(tree->child1))) || (accessThruMemRef(tree->child1)->nodeType == TABLEACCESS) || (accessThruMemRef(tree->child1)->nodeType == DEFAULT) || isString(tree->child1) || isMatchablePrepend(tree->child1) || isMatchableAppend(tree->child1) || isMatchableConcat(tree->child1)) && (isMatchableList(tree->child2) || (accessThruMemRef(tree->child2)->nodeType == TABLEACCESS) || (accessThruMemRef(tree->child2)->nodeType == DEFAULT) || isString(tree->child2) || isMatchablePrepend(tree->child2) || isMatchableAppend(tree->child2) || isMatchableConcat(tree->child2))) { if (isString(tree->child1) && (!((accessThruMemRef(tree->child2)->nodeType == TABLEACCESS) || (accessThruMemRef(tree->child2)->nodeType == DEFAULT) || isString(tree->child2) || isMatchableConcat(tree->child2)))) return 0; if (isString(tree->child2) && (!((accessThruMemRef(tree->child1)->nodeType == TABLEACCESS) || (accessThruMemRef(tree->child1)->nodeType == DEFAULT) || isString(tree->child1) || isMatchableConcat(tree->child1)))) return 0; return 1; } return 0; } int isMatchablePrepend(node *tree) { if (tree->nodeType == MEMREF) return isMatchablePrepend(getMemRefChild(tree)); if (tree->nodeType != PREPEND) return 0; if (isMatchable(tree->child1) && (isMatchableList(tree->child2) || (accessThruMemRef(tree->child2)->nodeType == TABLEACCESS) || isMatchablePrepend(tree->child2) || isMatchableAppend(tree->child2) || isMatchableConcat(tree->child2))) return 1; return 0; } int isMatchableAppend(node *tree) { if (tree->nodeType == MEMREF) return isMatchableAppend(getMemRefChild(tree)); if (tree->nodeType != APPEND) return 0; if (isMatchable(tree->child2) && ((isMatchableList(tree->child1) && (!isPureFinalEllipticList(tree->child1))) || (accessThruMemRef(tree->child1)->nodeType == TABLEACCESS) || isMatchablePrepend(tree->child1) || isMatchableAppend(tree->child1) || isMatchableConcat(tree->child1))) return 1; return 0; } int isMatchableStructure(node *tree) { chain *curr; if (tree->nodeType == MEMREF) return isMatchableStructure(getMemRefChild(tree)); if (tree->nodeType != STRUCTURE) return 0; if (associationContainsDoubleEntries(tree->arguments)) return 0; for (curr=tree->arguments; curr != NULL; curr = curr->next) { if (!isMatchable((node *) (((entry *) (curr->value))->value))) return 0; } return 1; } int isMatchable(node *tree) { if (tree->nodeType == MEMREF) return isMatchable(getMemRefChild(tree)); if (isExtendedPureTree(tree)) return 1; if (isCorrectlyTypedBaseSymbol(tree)) return 1; if ((tree->nodeType == RANGE) && ((accessThruMemRef(tree->child1)->nodeType == CONSTANT) || (accessThruMemRef(tree->child1)->nodeType == TABLEACCESS) || (accessThruMemRef(tree->child1)->nodeType == DEFAULT)) && ((accessThruMemRef(tree->child2)->nodeType == CONSTANT) || (accessThruMemRef(tree->child2)->nodeType == TABLEACCESS) || (accessThruMemRef(tree->child2)->nodeType == DEFAULT))) return 1; if (isMatchableList(tree)) return 1; if (isMatchableConcat(tree)) return 1; if (isMatchablePrepend(tree)) return 1; if (isMatchableAppend(tree)) return 1; if (isMatchableStructure(tree)) return 1; return 0; } int isDefault(node *tree) { if (tree->nodeType == MEMREF) return isDefault(getMemRefChild(tree)); return (tree->nodeType == DEFAULT); } int isString(node *tree) { if (tree->nodeType == MEMREF) return isString(getMemRefChild(tree)); return (tree->nodeType == STRING); } int isList(node *tree) { if (tree->nodeType == MEMREF) return isList(getMemRefChild(tree)); return (tree->nodeType == LIST); } int isMatchElement(node *tree) { if (tree->nodeType == MEMREF) return isMatchElement(getMemRefChild(tree)); return (tree->nodeType == MATCHELEMENT); } int isStructure(node *tree) { if (tree->nodeType == MEMREF) return isStructure(getMemRefChild(tree)); return (tree->nodeType == STRUCTURE); } int isEmptyList(node *tree) { if (tree->nodeType == MEMREF) return isEmptyList(getMemRefChild(tree)); return (tree->nodeType == EMPTYLIST); } int isElliptic(node *tree) { if (tree->nodeType == MEMREF) return isElliptic(getMemRefChild(tree)); return (tree->nodeType == ELLIPTIC); } int isPureList(node *tree) { chain *curr; if (tree->nodeType == MEMREF) return isPureList(getMemRefChild(tree)); if (!isList(tree)) return 0; if (tree->argArray != NULL) return 1; curr = tree->arguments; while (curr != NULL) { if (isElliptic((node *) (curr->value))) return 0; curr = curr->next; } return 1; } int isFinalEllipticList(node *tree) { if (tree->nodeType == MEMREF) return isFinalEllipticList(getMemRefChild(tree)); return (tree->nodeType == FINALELLIPTICLIST); } int isPureFinalEllipticList(node *tree) { chain *curr; if (tree->nodeType == MEMREF) return isPureFinalEllipticList(getMemRefChild(tree)); if (!isFinalEllipticList(tree)) return 0; if (tree->argArray != NULL) return 1; curr = tree->arguments; while (curr != NULL) { if (isElliptic((node *) (curr->value))) return 0; curr = curr->next; } return 1; } int isRange(node *tree) { if (tree->nodeType == MEMREF) return isRange(getMemRefChild(tree)); if (tree->nodeType != RANGE) return 0; if (accessThruMemRef(tree->child1)->nodeType != CONSTANT) return 0; if (accessThruMemRef(tree->child2)->nodeType != CONSTANT) return 0; return 1; } int isRangeNonEmpty(node *tree) { if (tree->nodeType == MEMREF) return isRangeNonEmpty(getMemRefChild(tree)); if (!isRange(tree)) return 0; if (mpfr_nan_p(*(accessThruMemRef(tree->child1)->value)) || mpfr_nan_p(*(accessThruMemRef(tree->child2)->value))) return 1; if (mpfr_cmp(*(accessThruMemRef(tree->child1)->value),*(accessThruMemRef(tree->child2)->value)) > 0) return 0; return 1; } int isError(node *tree) { if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) return 0; return isError(getMemRefChild(tree)); } if (tree->nodeType == ERRORSPECIAL) return 1; return 0; } int isBoolean(node *tree) { if (tree->nodeType == MEMREF) return isBoolean(getMemRefChild(tree)); if (tree->nodeType == TRUE) return 1; if (tree->nodeType == FALSE) return 1; return 0; } int isUnit(node *tree) { if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) return 0; return isUnit(getMemRefChild(tree)); } if (tree->nodeType == UNIT) return 1; return 0; } int isQuit(node *tree) { if (tree->nodeType == MEMREF) return isQuit(getMemRefChild(tree)); if (tree->nodeType == QUIT) return 1; return 0; } int isRestart(node *tree) { if (tree->nodeType == MEMREF) return isRestart(getMemRefChild(tree)); if (tree->nodeType == RESTART) return 1; return 0; } int isFalseQuit(node *tree) { if (tree->nodeType == MEMREF) return isFalseQuit(getMemRefChild(tree)); if (tree->nodeType == FALSEQUIT) return 1; return 0; } int isFalseRestart(node *tree) { if (tree->nodeType == MEMREF) return isFalseRestart(getMemRefChild(tree)); if (tree->nodeType == FALSERESTART) return 1; return 0; } int isExternalProcedureUsage(node *tree) { if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) return 0; return isExternalProcedureUsage(getMemRefChild(tree)); } if (tree->nodeType == EXTERNALPROCEDUREUSAGE) return 1; return 0; } int isLibraryConstant(node *tree) { if (tree->nodeType == MEMREF) return isLibraryConstant(getMemRefChild(tree)); if (tree->nodeType == LIBRARYCONSTANT) return 1; return 0; } int isProcedure(node *tree) { if (tree->nodeType == MEMREF) return isProcedure(getMemRefChild(tree)); if (tree->nodeType == PROC) return 1; if (tree->nodeType == PROCILLIM) return 1; return 0; } int isProcedureNotIllim(node *tree) { if (tree->nodeType == MEMREF) return isProcedureNotIllim(getMemRefChild(tree)); if (tree->nodeType == PROC) return 1; return 0; } int isHonorcoeffprec(node *tree) { if (tree->nodeType == MEMREF) return isHonorcoeffprec(getMemRefChild(tree)); if (tree->nodeType == HONORCOEFF) return 1; return 0; } int isOnOff(node *tree) { if (tree->nodeType == MEMREF) return isOnOff(getMemRefChild(tree)); if (tree->nodeType == ON) return 1; if (tree->nodeType == OFF) return 1; return 0; } int isDisplayMode(node *tree) { if (tree->nodeType == MEMREF) return isDisplayMode(getMemRefChild(tree)); if (tree->nodeType == DECIMAL) return 1; if (tree->nodeType == DYADIC) return 1; if (tree->nodeType == POWERS) return 1; if (tree->nodeType == BINARY) return 1; if (tree->nodeType == HEXADECIMAL) return 1; return 0; } int isRoundingSymbol(node *tree) { if (tree->nodeType == MEMREF) return isRoundingSymbol(getMemRefChild(tree)); if (tree->nodeType == ROUNDTONEAREST) return 1; if (tree->nodeType == ROUNDDOWN) return 1; if (tree->nodeType == ROUNDUP) return 1; if (tree->nodeType == ROUNDTOZERO) return 1; return 0; } int isExpansionFormat(node *tree) { if (tree->nodeType == MEMREF) return isExpansionFormat(getMemRefChild(tree)); if (tree->nodeType == SINGLESYMBOL) return 1; if (tree->nodeType == HALFPRECISIONSYMBOL) return 1; if (tree->nodeType == QUADSYMBOL) return 1; if (tree->nodeType == DOUBLESYMBOL) return 1; if (tree->nodeType == DOUBLEDOUBLESYMBOL) return 1; if (tree->nodeType == TRIPLEDOUBLESYMBOL) return 1; if (tree->nodeType == DOUBLEEXTENDEDSYMBOL) return 1; return 0; } int isExtendedExpansionFormat(node *tree) { if (tree->nodeType == MEMREF) return isExtendedExpansionFormat(getMemRefChild(tree)); if (tree->nodeType == SINGLESYMBOL) return 1; if (tree->nodeType == HALFPRECISIONSYMBOL) return 1; if (tree->nodeType == QUADSYMBOL) return 1; if (tree->nodeType == DOUBLESYMBOL) return 1; if (tree->nodeType == DOUBLEDOUBLESYMBOL) return 1; if (tree->nodeType == TRIPLEDOUBLESYMBOL) return 1; if (tree->nodeType == DOUBLEEXTENDEDSYMBOL) return 1; if (isPureTree(tree) && isConstant(tree)) return 1; return 0; } int isRestrictedExpansionFormat(node *tree) { if (tree->nodeType == MEMREF) return isRestrictedExpansionFormat(getMemRefChild(tree)); if (tree->nodeType == DOUBLESYMBOL) return 1; if (tree->nodeType == DOUBLEDOUBLESYMBOL) return 1; if (tree->nodeType == TRIPLEDOUBLESYMBOL) return 1; return 0; } int isFilePostscriptFile(node *tree) { if (tree->nodeType == MEMREF) return isFilePostscriptFile(getMemRefChild(tree)); if (tree->nodeType == FILESYM) return 1; if (tree->nodeType == POSTSCRIPT) return 1; if (tree->nodeType == POSTSCRIPTFILE) return 1; return 0; } int isExternalPlotMode(node *tree) { if (tree->nodeType == MEMREF) return isExternalPlotMode(getMemRefChild(tree)); if (tree->nodeType == ABSOLUTESYM) return 1; if (tree->nodeType == RELATIVESYM) return 1; return 0; } int evaluateThingToPureTree(node **result, node *tree) { node *evaluatedResult; evaluatedResult = evaluateThing(tree); if (isPureTree(evaluatedResult)) { *result = evaluatedResult; return 1; } freeThing(evaluatedResult); return 0; } int dirtyIsConstant(node *tree) { mpfr_t tempY, tempX, value, step, pseudozero; int res, i; mpfr_init2(tempY, tools_precision); mpfr_init2(tempX, tools_precision); mpfr_init2(value, tools_precision); mpfr_init2(step, tools_precision); mpfr_init2(pseudozero, tools_precision); mpfr_set_d(step,2.0,GMP_RNDN); mpfr_div_ui(step, step, defaultpoints, GMP_RNDN); mpfr_set_d(tempX, -1.0, GMP_RNDN); mpfr_set_d(pseudozero,1.0,GMP_RNDN); mpfr_div_2ui(pseudozero, pseudozero, tools_precision >> 1, GMP_RNDN); res = 1; evaluate(value, tree, tempX, tools_precision); mpfr_add(tempX, tempX, step, GMP_RNDN); for (i=1; i 0) { res = 0; break; } mpfr_add(tempX, tempX, step, GMP_RNDN); } mpfr_clear(pseudozero); mpfr_clear(step); mpfr_clear(value); mpfr_clear(tempX); mpfr_clear(tempY); return res; } /* Attention: we don't really understand the semantics of the parameter 'silent' any more. So we added an additional parameter superSilent. Probably, this should be unified. In any case, please don't add a parameter 'superSuperSilent' with the same reason. */ int evaluateThingToConstant(mpfr_t result, node *tree, mpfr_t *defaultVal, int silent, int superSilent) { node *evaluatedResult, *simplified, *simplified2; mpfr_t tempMpfr, tempResult; int res, noMessage; int exact, notfaithful; rangetype xrange, yrange; int okaySign, sign; notfaithful = 0; exact = 0; evaluatedResult = evaluateThing(tree); if ((defaultVal != NULL) && (isDefault(evaluatedResult))) { mpfr_set_prec(result,mpfr_get_prec(*defaultVal)); simplifyMpfrPrec(result, *defaultVal); freeThing(evaluatedResult); return 2; } if (isPureTree(evaluatedResult)) { if ((evaluatedResult->nodeType != MEMREF) || (evaluatedResult->child1 != NULL)) { if (accessThruMemRef(evaluatedResult)->nodeType == CONSTANT) { if (mpfr_number_p(*(accessThruMemRef(evaluatedResult)->value))) { if (mpfr_get_prec(*(accessThruMemRef(evaluatedResult)->value)) <= mpfr_get_prec(result)) { simplifyMpfrPrec(result, *(accessThruMemRef(evaluatedResult)->value)); freeThing(evaluatedResult); return 2; } } } } if (treeSize(evaluatedResult) <= MAXHORNERTREESIZE) { simplified2 = horner(evaluatedResult); freeThing(evaluatedResult); evaluatedResult = simplified2; } simplified = simplifyTreeErrorfree(evaluatedResult); free_memory(evaluatedResult); mpfr_init2(tempMpfr,53); mpfr_set_d(tempMpfr,1.0,GMP_RNDN); mpfr_init2(tempResult,mpfr_get_prec(result)); simplified2 = simplifyTree(simplified); if (!isConstant(simplified2)) { if (dirtyIsConstant(simplified2)) { if ((!noRoundingWarnings) && (!superSilent)) { printMessage(1,SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_SEEMS_CONSTANT,"Warning: the given expression should be constant in this context.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The expression actually seems to be constant but no proof could be established.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The resulting syntax error might be unjustified.\n"); } } mpfr_clear(tempResult); mpfr_clear(tempMpfr); freeThing(simplified); freeThing(simplified2); return 0; } freeThing(simplified2); noMessage = 0; if (!isConstant(simplified)) { if ((!noRoundingWarnings) && (!superSilent)) { printMessage(1,SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_IS_CONSTANT_ON_FP,"Warning: the given expression should be constant in this context.\nIt proves constant under floating point evaluation.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"In this evaluation, %s will be set to 1 when evaluating the expression to a constant.\n",((variablename == NULL) ? "_x_" : variablename)); noMessage = 1; } } if (accessThruMemRef(simplified)->nodeType == CONSTANT) { if (mpfr_get_prec(*(accessThruMemRef(simplified)->value)) > mpfr_get_prec(result)) { mpfr_set_prec(tempResult, mpfr_get_prec(*(accessThruMemRef(simplified)->value))); mpfr_set_prec(result, mpfr_get_prec(*(accessThruMemRef(simplified)->value))); } mpfr_set(tempResult,*(accessThruMemRef(simplified)->value),GMP_RNDN); exact = 1; res = 1; } else { res = evaluateFaithful(tempResult, simplified, tempMpfr, defaultprecision); } if (!res) { okaySign = evaluateSign(&sign,simplified); if (okaySign && (sign == 0)) { mpfr_set_ui(tempResult,0,GMP_RNDN); exact = 1; res = 1; } else { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),tools_precision); mpfr_init2(*(xrange.b),tools_precision); mpfr_init2(*(yrange.a),tools_precision * 256); mpfr_init2(*(yrange.b),tools_precision * 256); mpfr_set_ui(*(xrange.a),1.0,GMP_RNDD); mpfr_set_ui(*(xrange.b),1.0,GMP_RNDU); evaluateRangeFunction(yrange, simplified, xrange, tools_precision * 256 + 10); if (mpfr_number_p(*(yrange.a)) && mpfr_number_p(*(yrange.b)) && (mpfr_sgn(*(yrange.a)) * mpfr_sgn(*(yrange.b)) < 0)) { mpfr_set_ui(tempResult,0,GMP_RNDN); if (!noMessage) { if ((!noRoundingWarnings) && (!superSilent)) { printMessage(1,SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_IS_NOT_FAITHFUL,"Warning: the given expression is not a constant but an expression to evaluate\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"and a faithful evaluation is not possible. Will consider the constant to be 0.\n"); } } else { if ((!noRoundingWarnings) && (!superSilent)) { printMessage(1,SOLLYA_MSG_SOME_EVALUATION_IS_NOT_FAITHFUL,"Warning: the expression could not be faithfully evaluated.\n"); } } } else { if (!noMessage) { if ((!noRoundingWarnings) && (!superSilent)) { printMessage(1,SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_NO_FAITHFUL_PLAIN_FP,"Warning: the given expression is not a constant but an expression to evaluate\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"and a faithful evaluation is not possible.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Will use a plain floating-point evaluation, which might yield a completely wrong value.\n"); } } else { if ((!noRoundingWarnings) && (!superSilent)) { printMessage(1,SOLLYA_MSG_SOME_EVALUATION_IS_NOT_FAITHFUL,"Warning: the expression could not be faithfully evaluated.\n"); } } evaluate(tempResult, simplified, tempMpfr, defaultprecision * 256); } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); notfaithful = 1; } } else { if (accessThruMemRef(simplified)->nodeType != CONSTANT) { if (!noMessage) { if ((!noRoundingWarnings) && (!silent) && (!superSilent)) { printMessage(1,SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST,"Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation to %d bits will be used.\n", mpfr_get_prec(tempResult)); } } } } free_memory(simplified); mpfr_set(result,tempResult,GMP_RNDN); simplifyMpfrPrec(result,tempResult); mpfr_clear(tempMpfr); mpfr_clear(tempResult); if (notfaithful) { return 3; } else { if (exact) return 2; else return 1; } } else { freeThing(evaluatedResult); } return 0; } int evaluateThingToInteger(int *result, node *tree, int *defaultVal) { mpfr_t *defaultValMpfr, resultMpfr, resultMpfr2, resInt; int res, tempResult; if (defaultVal != NULL) { defaultValMpfr = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*defaultValMpfr,sizeof(int)*8); mpfr_set_si(*defaultValMpfr,*defaultVal,GMP_RNDN); } else { defaultValMpfr = NULL; } mpfr_init2(resultMpfr,sizeof(int)*16); mpfr_init2(resultMpfr2,sizeof(int)*16); res = evaluateThingToConstant(resultMpfr, tree, defaultValMpfr, 0, 0); if (res) { tempResult = mpfr_get_si(resultMpfr, GMP_RNDN); mpfr_sub_si(resultMpfr2, resultMpfr, tempResult, GMP_RNDN); if (!mpfr_zero_p(resultMpfr2)) { mpfr_init2(resInt,8 * sizeof(int) + 10); mpfr_set_si(resInt,tempResult,GMP_RNDN); if (mpfr_sgn(resInt) != mpfr_sgn(resultMpfr)) { if (mpfr_sgn(resultMpfr) == 0) { tempResult = 0; } else { if (mpfr_sgn(resultMpfr) > 0) { tempResult = INT_MAX; } else { tempResult = INT_MIN; } } } mpfr_clear(resInt); if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_CONSTANT_IS_NOT_MACHINE_INTEGER_WILL_ROUND,"Warning: the given expression does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Will round it to the nearest machine integer.\n"); } } *result = tempResult; } if (defaultValMpfr != NULL) { mpfr_clear(*defaultValMpfr); safeFree(defaultValMpfr); } mpfr_clear(resultMpfr); mpfr_clear(resultMpfr2); return res; } int evaluateThingToString(char **result, node *tree) { node *evaluatedResult; evaluatedResult = evaluateThing(tree); if (isString(evaluatedResult)) { *result = (char *) safeCalloc(strlen(accessThruMemRef(evaluatedResult)->string)+1,sizeof(char)); strcpy(*result,accessThruMemRef(evaluatedResult)->string); freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToStringWithDefault(char **result, node *tree, char *defaultVal) { node *evaluatedResult; evaluatedResult = evaluateThing(tree); if (isString(evaluatedResult)) { *result = (char *) safeCalloc(strlen(accessThruMemRef(evaluatedResult)->string)+1,sizeof(char)); strcpy(*result,accessThruMemRef(evaluatedResult)->string); freeThing(evaluatedResult); return 1; } if (isDefault(evaluatedResult)) { *result = (char *) safeCalloc(strlen(defaultVal)+1,sizeof(char)); strcpy(*result,defaultVal); freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToRange(mpfr_t a, mpfr_t b, node *tree) { node *evaluatedResult; evaluatedResult = evaluateThing(tree); if (isRange(evaluatedResult)) { mpfr_set_prec(a,mpfr_get_prec(*((mpfr_t *) (accessThruMemRef(accessThruMemRef(evaluatedResult)->child1)->value)))); mpfr_set_prec(b,mpfr_get_prec(*((mpfr_t *) (accessThruMemRef(accessThruMemRef(evaluatedResult)->child2)->value)))); mpfr_set(a,*((mpfr_t *) (accessThruMemRef(accessThruMemRef(evaluatedResult)->child1)->value)),GMP_RNDN); mpfr_set(b,*((mpfr_t *) (accessThruMemRef(accessThruMemRef(evaluatedResult)->child2)->value)),GMP_RNDN); freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToBoolean(int *result, node *tree, int *defaultVal) { node *evaluatedResult; evaluatedResult = evaluateThing(tree); if ((defaultVal != NULL) && isDefault(evaluatedResult)) { *result = *defaultVal; freeThing(evaluatedResult); return 1; } if (isBoolean(evaluatedResult)) { if (accessThruMemRef(evaluatedResult)->nodeType == TRUE) *result = 1; else *result = 0; freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToOnOff(int *result, node *tree, int *defaultVal) { node *evaluatedResult; evaluatedResult = evaluateThing(tree); if ((defaultVal != NULL) && isDefault(evaluatedResult)) { *result = *defaultVal; freeThing(evaluatedResult); return 1; } if (isOnOff(evaluatedResult)) { if (accessThruMemRef(evaluatedResult)->nodeType == ON) *result = 1; else *result = 0; freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToExternalPlotMode(int *result, node *tree, int *defaultVal) { node *evaluatedResult; evaluatedResult = evaluateThing(tree); if ((defaultVal != NULL) && isDefault(evaluatedResult)) { *result = *defaultVal; freeThing(evaluatedResult); return 1; } if (isExternalPlotMode(evaluatedResult)) { switch (accessThruMemRef(evaluatedResult)->nodeType) { case ABSOLUTESYM: *result = ABSOLUTE; break; case RELATIVESYM: *result = RELATIVE; break; } freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToDisplayMode(int *result, node *tree, int *defaultVal) { node *evaluatedResult; evaluatedResult = evaluateThing(tree); if ((defaultVal != NULL) && isDefault(evaluatedResult)) { *result = *defaultVal; freeThing(evaluatedResult); return 1; } if (isDisplayMode(evaluatedResult)) { switch (accessThruMemRef(evaluatedResult)->nodeType) { case DECIMAL: *result = 0; break; case DYADIC: *result = 1; break; case POWERS: *result = 2; break; case BINARY: *result = 3; break; case HEXADECIMAL: *result = 4; break; } freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToRoundingSymbol(int *result, node *tree, int *defaultVal) { node *evaluatedResult; evaluatedResult = evaluateThing(tree); if ((defaultVal != NULL) && isDefault(evaluatedResult)) { *result = *defaultVal; freeThing(evaluatedResult); return 1; } if (isRoundingSymbol(evaluatedResult)) { switch (accessThruMemRef(evaluatedResult)->nodeType) { case ROUNDTONEAREST: *result = GMP_RNDN; break; case ROUNDDOWN: *result = GMP_RNDD; break; case ROUNDUP: *result = GMP_RNDU; break; case ROUNDTOZERO: *result = GMP_RNDZ; break; } freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToExpansionFormat(int *result, node *tree) { node *evaluatedResult; evaluatedResult = evaluateThing(tree); if (isExpansionFormat(evaluatedResult)) { switch (accessThruMemRef(evaluatedResult)->nodeType) { case DOUBLESYMBOL: *result = 1; break; case DOUBLEDOUBLESYMBOL: *result = 2; break; case TRIPLEDOUBLESYMBOL: *result = 3; break; case DOUBLEEXTENDEDSYMBOL: *result = 4; break; case SINGLESYMBOL: *result = 5; break; case HALFPRECISIONSYMBOL: *result = 6; break; case QUADSYMBOL: *result = 7; break; } freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToExtendedExpansionFormat(int *result, node *tree) { node *evaluatedResult; int resA; evaluatedResult = evaluateThing(tree); if (isPureTree(evaluatedResult) && isConstant(evaluatedResult)) { if (!evaluateThingToInteger(&resA,evaluatedResult,NULL)) { freeThing(evaluatedResult); return 0; } if (resA < 2) { printMessage(1,SOLLYA_MSG_PRECISION_OF_NUMBERS_MUST_BE_AT_LEAST_TWO_BITS,"Warning: the precision of numbers must be at least 2 bits.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Will change the precision indication to 2 bits.\n"); resA = 2; } *result = resA + 6; /* WHAT THE F**K? Look at line 1002 in double.c to understand. */ freeThing(evaluatedResult); return 1; } if (isExtendedExpansionFormat(evaluatedResult)) { switch (accessThruMemRef(evaluatedResult)->nodeType) { case DOUBLESYMBOL: *result = 1; break; case DOUBLEDOUBLESYMBOL: *result = 2; break; case TRIPLEDOUBLESYMBOL: *result = 3; break; case DOUBLEEXTENDEDSYMBOL: *result = 4; break; case SINGLESYMBOL: *result = 5; break; case HALFPRECISIONSYMBOL: *result = 6; break; case QUADSYMBOL: *result = 7; break; } freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToRestrictedExpansionFormat(int *result, node *tree) { node *evaluatedResult; evaluatedResult = evaluateThing(tree); if (isRestrictedExpansionFormat(evaluatedResult)) { switch (accessThruMemRef(evaluatedResult)->nodeType) { case DOUBLESYMBOL: *result = 1; break; case DOUBLEDOUBLESYMBOL: *result = 2; break; case TRIPLEDOUBLESYMBOL: *result = 3; break; } freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToPureListOfThings(chain **ch, node *tree) { node *evaluatedResult; evaluatedResult = evaluateThing(tree); if (isPureList(evaluatedResult)) { setupRandomAccessOnLists(evaluatedResult); *ch = copyChainWithoutReversal(accessThruMemRef(evaluatedResult)->arguments, copyThingOnVoid); freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToPureListOfPureTrees(chain **ch, node *tree) { node *evaluatedResult; chain *curr; evaluatedResult = evaluateThing(tree); if (isPureList(evaluatedResult)) { setupRandomAccessOnLists(evaluatedResult); *ch = copyChainWithoutReversal(accessThruMemRef(evaluatedResult)->arguments, copyThingOnVoid); freeThing(evaluatedResult); curr = *ch; while (curr != NULL) { if (!isPureTree((node *) (curr->value))) { freeChain(*ch,freeThingOnVoid); return 0; } curr = curr->next; } return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToIntegerList(chain **ch, int *finalelliptic, node *tree) { node *evaluatedResult; chain *curr; int *arrayRes, *resPtr; int i, resA; evaluatedResult = evaluateThing(tree); if (finalelliptic == NULL) { if (isPureList(evaluatedResult)) { setupRandomAccessOnLists(evaluatedResult); curr = accessThruMemRef(evaluatedResult)->arguments; i = 0; while (curr != NULL) { if (!isPureTree((node *) (curr->value))) { freeThing(evaluatedResult); return 0; } i++; curr = curr->next; } arrayRes = (int *) safeCalloc(i,sizeof(int)); curr = accessThruMemRef(evaluatedResult)->arguments; i = 0; while (curr != NULL) { if (!evaluateThingToInteger(&resA,(node *) (curr->value),NULL)) { freeThing(evaluatedResult); safeFree(arrayRes); return 0; } else { arrayRes[i] = resA; } i++; curr = curr->next; } curr = NULL; for (i--;i>=0;i--) { resPtr = (int *) safeMalloc(sizeof(int)); *resPtr = arrayRes[i]; curr = addElement(curr, resPtr); } safeFree(arrayRes); *ch = curr; freeThing(evaluatedResult); return 1; } } else { if (isPureList(evaluatedResult) || isPureFinalEllipticList(evaluatedResult)) { setupRandomAccessOnLists(evaluatedResult); if (isList(evaluatedResult)) *finalelliptic = 0; else *finalelliptic = 1; curr = accessThruMemRef(evaluatedResult)->arguments; i = 0; while (curr != NULL) { if (!isPureTree((node *) (curr->value))) { freeThing(evaluatedResult); return 0; } i++; curr = curr->next; } arrayRes = (int *) safeCalloc(i,sizeof(int)); curr = accessThruMemRef(evaluatedResult)->arguments; i = 0; while (curr != NULL) { if (!evaluateThingToInteger(&resA,(node *) (curr->value),NULL)) { freeThing(evaluatedResult); safeFree(arrayRes); return 0; } else { arrayRes[i] = resA; } i++; curr = curr->next; } curr = NULL; for (i--;i>=0;i--) { resPtr = (int *) safeMalloc(sizeof(int)); *resPtr = arrayRes[i]; curr = addElement(curr, resPtr); } safeFree(arrayRes); freeThing(evaluatedResult); *ch = curr; return 1; } } freeThing(evaluatedResult); return 0; } int evaluateThingToBooleanList(chain **ch, node *tree) { node *evaluatedResult; chain *curr; int *arrayRes, *resPtr; int i, resA; evaluatedResult = evaluateThing(tree); if (isPureList(evaluatedResult)) { setupRandomAccessOnLists(evaluatedResult); curr = accessThruMemRef(evaluatedResult)->arguments; i = 0; while (curr != NULL) { if (!isPureTree((node *) (curr->value))) { freeThing(evaluatedResult); return 0; } i++; curr = curr->next; } arrayRes = (int *) safeCalloc(i,sizeof(int)); curr = accessThruMemRef(evaluatedResult)->arguments; i = 0; while (curr != NULL) { if (!evaluateThingToBoolean(&resA,(node *) (curr->value),NULL)) { freeThing(evaluatedResult); safeFree(arrayRes); return 0; } else { arrayRes[i] = resA; } i++; curr = curr->next; } curr = NULL; for (i--;i>=0;i--) { resPtr = (int *) safeMalloc(sizeof(int)); *resPtr = arrayRes[i]; curr = addElement(curr, resPtr); } safeFree(arrayRes); *ch = curr; freeThing(evaluatedResult); return 1; } freeThing(evaluatedResult); return 0; } int evaluateThingToExpansionFormatList(chain **ch, node *tree) { node *evaluatedResult; chain *curr; int *arrayRes, *resPtr; int i, resA, k; int finalelliptic; evaluatedResult = evaluateThing(tree); if (isPureList(evaluatedResult) || isPureFinalEllipticList(evaluatedResult)) { setupRandomAccessOnLists(evaluatedResult); if (isList(evaluatedResult)) finalelliptic = 0; else finalelliptic = 1; curr = accessThruMemRef(evaluatedResult)->arguments; i = 0; while (curr != NULL) { if (!isExpansionFormat((node *) (curr->value))) { freeThing(evaluatedResult); return 0; } i++; curr = curr->next; } arrayRes = (int *) safeCalloc(i,sizeof(int)); curr = accessThruMemRef(evaluatedResult)->arguments; i = 0; while (curr != NULL) { if (!evaluateThingToExpansionFormat(&resA,(node *) (curr->value))) { freeThing(evaluatedResult); safeFree(arrayRes); return 0; } else { arrayRes[i] = resA; } i++; curr = curr->next; } curr = NULL; for (k=0;karguments; i = 0; while (curr != NULL) { if (!isExtendedExpansionFormat((node *) (curr->value))) { freeThing(evaluatedResult); return 0; } i++; curr = curr->next; } arrayRes = (int *) safeCalloc(i,sizeof(int)); curr = accessThruMemRef(evaluatedResult)->arguments; i = 0; while (curr != NULL) { if (!evaluateThingToExtendedExpansionFormat(&resA,(node *) (curr->value))) { freeThing(evaluatedResult); safeFree(arrayRes); return 0; } else { arrayRes[i] = resA; } i++; curr = curr->next; } curr = NULL; for (k=0;kchild1)->value), *(accessThruMemRef(accessThruMemRef(thing)->child2)->value)); if (temp != NULL) { sollyaPrintf("%s",temp); safeFree(temp); } else { sollyaPrintf("["); printValue(accessThruMemRef(accessThruMemRef(thing)->child1)->value); sollyaPrintf(";"); printValue(accessThruMemRef(accessThruMemRef(thing)->child2)->value); sollyaPrintf("]"); } } else { sollyaPrintf("["); printValue(accessThruMemRef(accessThruMemRef(thing)->child1)->value); sollyaPrintf(";"); printValue(accessThruMemRef(accessThruMemRef(thing)->child2)->value); sollyaPrintf("]"); } } else { if (isList(thing)) { setupRandomAccessOnLists(thing); curr = accessThruMemRef(thing)->arguments; sollyaPrintf("[|"); while (curr != NULL) { printThingWithFullStrings((node *) (curr->value)); if (curr->next != NULL) sollyaPrintf(", "); curr = curr->next; } sollyaPrintf("|]"); } else { if (isFinalEllipticList(thing)) { setupRandomAccessOnLists(thing); curr = accessThruMemRef(thing)->arguments; sollyaPrintf("[|"); while (curr != NULL) { printThingWithFullStrings((node *) (curr->value)); if (curr->next != NULL) sollyaPrintf(", "); curr = curr->next; } sollyaPrintf("...|]"); } else { if (isStructure(thing)) { sollyaPrintf("{ "); curr = accessThruMemRef(thing)->arguments; while (curr != NULL) { sollyaPrintf(".%s = ", ((entry *) (curr->value))->name); printThingWithFullStrings((node *) (((entry *) (curr->value))->value)); if (curr->next != NULL) sollyaPrintf(", "); curr = curr->next; } sollyaPrintf(" }"); } else { rawPrintThing(thing); } } } } } } void printThing(node *thing) { char *temp; chain *curr; if (isPureTree(thing)) { printTree(thing); } else { if (isRange(thing)) { if (midpointMode && (dyadic == 0)) { temp = sprintMidpointMode(*(accessThruMemRef(accessThruMemRef(thing)->child1)->value), *(accessThruMemRef(accessThruMemRef(thing)->child2)->value)); if (temp != NULL) { sollyaPrintf("%s",temp); safeFree(temp); } else { sollyaPrintf("["); printValue(accessThruMemRef(accessThruMemRef(thing)->child1)->value); sollyaPrintf(";"); printValue(accessThruMemRef(accessThruMemRef(thing)->child2)->value); sollyaPrintf("]"); } } else { sollyaPrintf("["); printValue(accessThruMemRef(accessThruMemRef(thing)->child1)->value); sollyaPrintf(";"); printValue(accessThruMemRef(accessThruMemRef(thing)->child2)->value); sollyaPrintf("]"); } } else { if (isList(thing)) { setupRandomAccessOnLists(thing); curr = accessThruMemRef(thing)->arguments; sollyaPrintf("[|"); while (curr != NULL) { printThingWithFullStrings((node *) (curr->value)); if (curr->next != NULL) sollyaPrintf(", "); curr = curr->next; } sollyaPrintf("|]"); } else { if (isFinalEllipticList(thing)) { setupRandomAccessOnLists(thing); curr = accessThruMemRef(thing)->arguments; sollyaPrintf("[|"); while (curr != NULL) { printThingWithFullStrings((node *) (curr->value)); if (curr->next != NULL) sollyaPrintf(", "); curr = curr->next; } sollyaPrintf("...|]"); } else { if (isString(thing)) { sollyaPrintf("%s",accessThruMemRef(thing)->string); } else { if (isStructure(thing)) { sollyaPrintf("{ "); curr = accessThruMemRef(thing)->arguments; while (curr != NULL) { sollyaPrintf(".%s = ", ((entry *) (curr->value))->name); printThingWithFullStrings((node *) (((entry *) (curr->value))->value)); if (curr->next != NULL) sollyaPrintf(", "); curr = curr->next; } sollyaPrintf(" }"); } else { rawPrintThing(thing); } } } } } } } char *newString(char *str) { char *newStr; newStr = (char *) safeCalloc(strlen(str) + 1, sizeof(char)); strcpy(newStr, str); return newStr; } char *concatAndFree(char *str1, char *str2) { char *newStr; newStr = (char *) safeCalloc(strlen(str1) + strlen(str2) + 1, sizeof(char)); sprintf(newStr,"%s%s", str1, str2); safeFree(str1); safeFree(str2); return newStr; } char *sRawPrintThingInner(node *tree, int forceDyadic) { int i; chain *curr; char *res; if (tree == NULL) { res = (char *) safeCalloc(1, sizeof(char)); return res; } if (tree->nodeType == MEMREF) { return sRawPrintThingInner(getMemRefChild(tree), forceDyadic); } switch (tree->nodeType) { case VARIABLE: if (variablename == NULL) { res = newString("_x_"); } else { res = newString(variablename); } break; case CONSTANT: if (forceDyadic) { res = sPrintHexadecimal(*(tree->value)); } else { res = sprintValue(tree->value); } break; case ADD: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") + ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case SUB: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") - ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case MUL: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") * ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case DIV: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") / ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case SQRT: res = concatAndFree(newString("sqrt("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case EXP: res = concatAndFree(newString("exp("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case LOG: res = concatAndFree(newString("log("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case LOG_2: res = concatAndFree(newString("log2("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case LOG_10: res = concatAndFree(newString("log10("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case SIN: res = concatAndFree(newString("sin("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case COS: res = concatAndFree(newString("cos("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case TAN: res = concatAndFree(newString("tan("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case ASIN: res = concatAndFree(newString("asin("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case ACOS: res = concatAndFree(newString("acos("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case ATAN: res = concatAndFree(newString("atan("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case SINH: res = concatAndFree(newString("sinh("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case COSH: res = concatAndFree(newString("cosh("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case TANH: res = concatAndFree(newString("tanh("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case ASINH: res = concatAndFree(newString("asinh("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case ACOSH: res = concatAndFree(newString("acosh("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case ATANH: res = concatAndFree(newString("atanh("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case POW: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") ^ ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case NEG: res = concatAndFree(newString("-("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case ABS: res = concatAndFree(newString("abs("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case DOUBLE: res = concatAndFree(newString("double("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case SINGLE: res = concatAndFree(newString("single("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case HALFPRECISION: res = concatAndFree(newString("halfprecision("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case QUAD: res = concatAndFree(newString("quad("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case DOUBLEDOUBLE: res = concatAndFree(newString("doubledouble("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case TRIPLEDOUBLE: res = concatAndFree(newString("tripledouble("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case ERF: res = concatAndFree(newString("erf("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case ERFC: res = concatAndFree(newString("erfc("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case LOG_1P: res = concatAndFree(newString("log1p("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case EXP_M1: res = concatAndFree(newString("expm1("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case DOUBLEEXTENDED: res = concatAndFree(newString("doubleextended("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case LIBRARYFUNCTION: { if (isPureTree(tree->child1) && (accessThruMemRef(tree->child1)->nodeType == VARIABLE)) { res = newString(""); for (i=1;i<=tree->libFunDeriv;i++) { res = concatAndFree(res,newString("diff(")); } res = concatAndFree(res, newString(tree->libFun->functionName)); for (i=1;i<=tree->libFunDeriv;i++) { res = concatAndFree(res, newString(")")); } } else { if (tree->libFunDeriv == 0) { res = newString(tree->libFun->functionName); res = concatAndFree(res, newString("(")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(")")); } else { res = newString("("); for (i=1;i<=tree->libFunDeriv;i++) { res = concatAndFree(res,newString("diff(")); } res = concatAndFree(res,newString(tree->libFun->functionName)); for (i=1;i<=tree->libFunDeriv;i++) { res = concatAndFree(res, newString(")")); } res = concatAndFree(res, newString(")(")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(")")); } } } break; case PROCEDUREFUNCTION: { if (isPureTree(tree->child1) && (accessThruMemRef(tree->child1)->nodeType == VARIABLE)) { res = newString(""); for (i=1;i<=tree->libFunDeriv;i++) { res = concatAndFree(res,newString("diff(")); } res = concatAndFree(res, newString("function(")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); for (i=1;i<=tree->libFunDeriv;i++) { res = concatAndFree(res, newString(")")); } } else { if (tree->libFunDeriv == 0) { res = newString("(function("); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString("))(")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(")")); } else { res = newString("("); for (i=1;i<=tree->libFunDeriv;i++) { res = concatAndFree(res,newString("diff(")); } res = concatAndFree(res,newString("function(")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res,newString(")")); for (i=1;i<=tree->libFunDeriv;i++) { res = concatAndFree(res, newString(")")); } res = concatAndFree(res, newString(")(")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(")")); } } } break; case LIBRARYCONSTANT: res = newString(tree->libFun->functionName); break; case CEIL: res = concatAndFree(newString("ceil("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case FLOOR: res = concatAndFree(newString("floor("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case NEARESTINT: res = concatAndFree(newString("nearestint("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case PI_CONST: res = newString("pi"); break; case COMMANDLIST: res = newString("{\n"); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); res = concatAndFree(res,newString(";\n")); curr = curr->next; } res = concatAndFree(res,newString("}")); break; case WHILE: res = newString("while "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(" do ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); break; case IFELSE: res = newString("if "); curr = tree->arguments; res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); curr = curr->next; res = concatAndFree(res, newString(" then\n")); res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); res = concatAndFree(res, newString("\nelse\n")); curr = curr->next; res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); break; case IF: res = newString("if "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(" then\n")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); break; case FOR: res = newString("for "); res = concatAndFree(res, newString(tree->string)); res = concatAndFree(res, newString(" from ")); curr = tree->arguments; res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); res = concatAndFree(res, newString(" to ")); curr = curr->next; res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); res = concatAndFree(res, newString(" by ")); curr = curr->next; res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); res = concatAndFree(res, newString(" do\n")); curr = curr->next; res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); break; case FORIN: res = newString("for "); res = concatAndFree(res, newString(tree->string)); res = concatAndFree(res, newString(" in ")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(" do\n")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); break; case QUIT: res = newString("quit"); break; case NOP: res = newString("nop"); break; case NOPARG: res = newString("nop("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(")\n")); break; case FALSEQUIT: res = newString("quit"); break; case FALSERESTART: res = newString("restart"); break; case RESTART: res = newString("restart"); break; case VARIABLEDECLARATION: res = newString("var "); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, newString((char *) (curr->value))); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } break; case PRINT: res = newString("print("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case SUPPRESSMESSAGE: res = newString("suppressmessage("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case UNSUPPRESSMESSAGE: res = newString("unsuppressmessage("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case NEWFILEPRINT: res = newString("print("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(") > ")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case APPENDFILEPRINT: res = newString("print("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(") >> ")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case PLOT: res = newString("plot("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case PRINTHEXA: res = concatAndFree(newString("printdouble("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case PRINTFLOAT: res = concatAndFree(newString("printsingle("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case PRINTBINARY: res = concatAndFree(newString("printbinary("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case PRINTEXPANSION: res = concatAndFree(newString("printexpansion("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case BASHEXECUTE: res = concatAndFree(newString("bashexecute("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case EXTERNALPLOT: res = newString("externalplot("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case WRITE: res = newString("write("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case NEWFILEWRITE: res = newString("write("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(") > ")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case APPENDFILEWRITE: res = newString("write("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(") >> ")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case ASCIIPLOT: res = newString("asciiplot("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(",")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case PRINTXML: res = concatAndFree(newString("printxml("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case PRINTXMLNEWFILE: res = newString("printxml("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(") > ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); break; case PRINTXMLAPPENDFILE: res = newString("printxml("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(") >> ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); break; case WORSTCASE: res = newString("worstcase("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case RENAME: res = newString("rename("); res = concatAndFree(res, newString(tree->string)); res = concatAndFree(res, newString(",")); res = concatAndFree(res, newString((char *) (tree->arguments->value))); res = concatAndFree(res, newString(")")); break; case AUTOPRINT: res = newString(""); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } break; case ASSIGNMENT: res = newString(tree->string); res = concatAndFree(res, newString(" = ")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case FLOATASSIGNMENT: res = newString(tree->string); res = concatAndFree(res, newString(" := ")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case EXTERNALPROC: res = newString("externalproc("); res = concatAndFree(res, newString(tree->string)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); curr = tree->arguments->next; if (*((int *) (curr->value)) == VOID_TYPE) { res = concatAndFree(res, newString("void")); } else { res = concatAndFree(res, newString("(")); while (curr != NULL) { switch (*((int *) (curr->value))) { case VOID_TYPE: res = concatAndFree(res, newString("void")); break; case CONSTANT_TYPE: res = concatAndFree(res, newString("constant")); sollyaPrintf("constant"); break; case FUNCTION_TYPE: res = concatAndFree(res, newString("function")); break; case OBJECT_TYPE: res = concatAndFree(res, newString("object")); break; case RANGE_TYPE: res = concatAndFree(res, newString("range")); break; case INTEGER_TYPE: res = concatAndFree(res, newString("integer")); break; case STRING_TYPE: res = concatAndFree(res, newString("string")); break; case BOOLEAN_TYPE: res = concatAndFree(res, newString("boolean")); break; case CONSTANT_LIST_TYPE: res = concatAndFree(res, newString("list of constant")); break; case FUNCTION_LIST_TYPE: res = concatAndFree(res, newString("list of function")); break; case OBJECT_LIST_TYPE: res = concatAndFree(res, newString("list of object")); break; case RANGE_LIST_TYPE: res = concatAndFree(res, newString("list of range")); break; case INTEGER_LIST_TYPE: res = concatAndFree(res, newString("list of integer")); break; case STRING_LIST_TYPE: res = concatAndFree(res, newString("list of string")); break; case BOOLEAN_LIST_TYPE: res = concatAndFree(res, newString("list of boolean")); break; default: res = concatAndFree(res, newString("unknown type")); } if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); } res = concatAndFree(res, newString(" -> ")); switch (*((int *) (tree->arguments->value))) { case VOID_TYPE: res = concatAndFree(res, newString("void")); break; case CONSTANT_TYPE: res = concatAndFree(res, newString("constant")); break; case FUNCTION_TYPE: res = concatAndFree(res, newString("function")); break; case OBJECT_TYPE: res = concatAndFree(res, newString("object")); break; case RANGE_TYPE: res = concatAndFree(res, newString("range")); break; case INTEGER_TYPE: res = concatAndFree(res, newString("integer")); break; case STRING_TYPE: res = concatAndFree(res, newString("string")); break; case BOOLEAN_TYPE: res = concatAndFree(res, newString("boolean")); break; case CONSTANT_LIST_TYPE: res = concatAndFree(res, newString("list of constant")); break; case FUNCTION_LIST_TYPE: res = concatAndFree(res, newString("list of function")); break; case OBJECT_LIST_TYPE: res = concatAndFree(res, newString("list of object")); break; case RANGE_LIST_TYPE: res = concatAndFree(res, newString("list of range")); break; case INTEGER_LIST_TYPE: res = concatAndFree(res, newString("list of integer")); break; case STRING_LIST_TYPE: res = concatAndFree(res, newString("list of string")); break; case BOOLEAN_LIST_TYPE: res = concatAndFree(res, newString("list of boolean")); break; default: res = concatAndFree(res, newString("unknown type")); } res = concatAndFree(res, newString(")")); break; case LIBRARYBINDING: res = newString(tree->string); res = concatAndFree(res, newString(" = library(")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(")")); break; case LIBRARYCONSTANTBINDING: res = newString(tree->string); res = concatAndFree(res, newString(" = libraryconstant(")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(")")); break; case PRECASSIGN: res = newString("prec = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case POINTSASSIGN: res = newString("points = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case DIAMASSIGN: res = newString("diam = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case DISPLAYASSIGN: res = newString("display = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case VERBOSITYASSIGN: res = newString("verbosity = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case CANONICALASSIGN: res = newString("canonical = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case AUTOSIMPLIFYASSIGN: res = newString("autosimplify = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case SHOWMESSAGENUMBERSASSIGN: res = newString("showmessagenumbers = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case TAYLORRECURSASSIGN: res = newString("taylorrecursions = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case TIMINGASSIGN: res = newString("timing = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case FULLPARENASSIGN: res = newString("fullparentheses = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case MIDPOINTASSIGN: res = newString("midpointmode = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case DIEONERRORMODEASSIGN: res = newString("dieonerrormode = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case RATIONALMODEASSIGN: res = newString("rationalmode = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case SUPPRESSWARNINGSASSIGN: res = newString("roundingwarnings = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case HOPITALRECURSASSIGN: res = newString("hopitalrecursions = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case PRECSTILLASSIGN: res = newString("prec = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case POINTSSTILLASSIGN: res = newString("points = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case DIAMSTILLASSIGN: res = newString("diam = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case DISPLAYSTILLASSIGN: res = newString("display = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case VERBOSITYSTILLASSIGN: res = newString("verbosity = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case CANONICALSTILLASSIGN: res = newString("canonical = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case AUTOSIMPLIFYSTILLASSIGN: res = newString("autosimplify = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case SHOWMESSAGENUMBERSSTILLASSIGN: res = newString("showmessagenumbers = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case TAYLORRECURSSTILLASSIGN: res = newString("taylorrecursions = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case TIMINGSTILLASSIGN: res = newString("timing = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case FULLPARENSTILLASSIGN: res = newString("fullparentheses = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case MIDPOINTSTILLASSIGN: res = newString("midpointmode = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case DIEONERRORMODESTILLASSIGN: res = newString("dieonerrormode = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case RATIONALMODESTILLASSIGN: res = newString("midpointmode = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case SUPPRESSWARNINGSSTILLASSIGN: res = newString("roundingwarnings = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case HOPITALRECURSSTILLASSIGN: res = newString("hopitalrecursions = "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString("!")); break; case AND: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") && ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case OR: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") || ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case NEGATION: res = concatAndFree(newString("!("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case INDEX: res = concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic),newString("[")); res = concatAndFree(res,sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res,newString("]")); break; case COMPAREEQUAL: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") == ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case COMPAREIN: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") in ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case COMPARELESS: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") < ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case COMPAREGREATER: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") > ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case COMPARELESSEQUAL: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") <= ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case COMPAREGREATEREQUAL: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") >= ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case COMPARENOTEQUAL: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") != ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case CONCAT: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") @ ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case ADDTOLIST: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") :: ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case APPEND: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") :. ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case PREPEND: res = concatAndFree(newString("("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), concatAndFree(newString(") .: ("), concatAndFree(sRawPrintThingInner(tree->child2, forceDyadic), newString(")"))))); break; case ON: res = newString("on"); break; case OFF: res = newString("off"); break; case DYADIC: res = newString("dyadic"); break; case POWERS: res = newString("powers"); break; case BINARY: res = newString("binary"); break; case HEXADECIMAL: res = newString("hexadecimal"); break; case FILESYM: res = newString("file"); break; case POSTSCRIPT: res = newString("postscript"); break; case POSTSCRIPTFILE: res = newString("postscriptfile"); break; case PERTURB: res = newString("perturb"); break; case ROUNDDOWN: res = newString("RD"); break; case ROUNDUP: res = newString("RU"); break; case ROUNDTOZERO: res = newString("RZ"); break; case ROUNDTONEAREST: res = newString("RN"); break; case HONORCOEFF: res = newString("honorcoeffprec"); break; case TRUE: res = newString("true"); break; case UNIT: res = newString("void"); break; case FALSE: res = newString("false"); break; case DEFAULT: res = newString("default"); break; case DECIMAL: res = newString("decimal"); break; case ABSOLUTESYM: res = newString("absolute"); break; case RELATIVESYM: res = newString("relative"); break; case FIXED: res = newString("fixed"); break; case FLOATING: res = newString("floating"); break; case ERRORSPECIAL: res = newString("error"); break; case DOUBLESYMBOL: res = newString("double"); break; case SINGLESYMBOL: res = newString("single"); break; case HALFPRECISIONSYMBOL: res = newString("halfprecision"); break; case QUADSYMBOL: res = newString("quad"); break; case DOUBLEEXTENDEDSYMBOL: res = newString("doubleextended"); break; case DOUBLEDOUBLESYMBOL: res = newString("doubledouble"); break; case TRIPLEDOUBLESYMBOL: res = newString("tripledouble"); break; case STRING: res = concatAndFree(newString("\""),concatAndFree(maskString(tree->string),newString("\""))); break; case TABLEACCESS: res = newString(tree->string); break; case ISBOUND: res = concatAndFree(newString("isbound("),concatAndFree(newString(tree->string),newString(")"))); break; case TABLEACCESSWITHSUBSTITUTE: res = concatAndFree(newString(tree->string),newString("(")); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res,sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case STRUCTACCESS: res = concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic),newString(".")); res = concatAndFree(res, newString(tree->string)); break; case APPLY: res = concatAndFree(concatAndFree(concatAndFree(newString("("),sRawPrintThingInner(tree->child1, forceDyadic)), newString(")")),newString("(")); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res,sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case DECIMALCONSTANT: res = newString(tree->string); break; case MIDPOINTCONSTANT: res = newString(tree->string); break; case DYADICCONSTANT: res = newString(tree->string); break; case HEXCONSTANT: res = newString(tree->string); break; case HEXADECIMALCONSTANT: res = newString(tree->string); break; case BINARYCONSTANT: res = concatAndFree(newString(tree->string),newString("_2")); break; case EMPTYLIST: res = newString("[| |]"); break; case LIST: setupRandomAccessOnLists(tree); res = newString("[|"); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res,sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString("|]")); break; case STRUCTURE: res = newString("{ "); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res,concatAndFree(newString("."),newString(((entry *) (curr->value))->name))); res = concatAndFree(res,newString(" = ")); res = concatAndFree(res,sRawPrintThingInner((node *) (((entry *) (curr->value))->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(" }")); break; case FINALELLIPTICLIST: setupRandomAccessOnLists(tree); res = newString("[|"); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res,sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString("...|]")); break; case ELLIPTIC: res = newString("..."); break; case RANGE: res = newString("["); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(";")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString("]")); break; case DEBOUNDMAX: res = concatAndFree(newString("sup("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case DEBOUNDMIN: res = concatAndFree(newString("inf("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case DEBOUNDMID: res = concatAndFree(newString("mid("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case EVALCONST: res = concatAndFree(newString("~"),sRawPrintThingInner(tree->child1, forceDyadic)); break; case DIFF: res = concatAndFree(newString("diff("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case BASHEVALUATE: res = newString("bashevaluate("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case GETSUPPRESSEDMESSAGES: res = newString("getsuppressedmessages()"); break; case GETBACKTRACE: res = newString("getbacktrace()"); break; case DIRTYSIMPLIFY: res = concatAndFree(newString("dirtysimplify("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case SIMPLIFYSAFE: res = concatAndFree(newString("simplify("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case TIME: res = concatAndFree(newString("time("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case REMEZ: res = newString("remez("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case ANNOTATEFUNCTION: res = newString("annotatefunction("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case MATCH: res = newString("match "); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(" with\n")); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); curr = curr->next; } break; case MATCHELEMENT: res = concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic),newString(" : {\n")); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); res = concatAndFree(res, newString(";\n")); curr = curr->next; } res = concatAndFree(res, newString("return ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(";\n}\n")); break; case MIN: res = newString("min("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case MAX: res = newString("max("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case FPMINIMAX: res = newString("fpminimax("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case HORNER: res = concatAndFree(newString("horner("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case CANONICAL: res = concatAndFree(newString("canonical("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case EXPAND: res = concatAndFree(newString("expand("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case TAYLOR: res = newString("taylor("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case TAYLORFORM: res = newString("taylorform("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case CHEBYSHEVFORM: res = newString("chebyshevform("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case AUTODIFF: res = newString("autodiff("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case DEGREE: res = concatAndFree(newString("degree("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case NUMERATOR: res = concatAndFree(newString("numerator("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case DENOMINATOR: res = concatAndFree(newString("denominator("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case SUBSTITUTE: res = newString("substitute("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case COMPOSEPOLYNOMIALS: res = newString("composepolynomials("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case COEFF: res = newString("coeff("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case SUBPOLY: res = newString("subpoly("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case ROUNDCOEFFICIENTS: res = newString("roundcoefficients("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case RATIONALAPPROX: res = newString("rationalapprox("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case ACCURATEINFNORM: res = newString("accurateinfnorm("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case ROUNDTOFORMAT: res = newString("round("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case EVALUATE: res = newString("evaluate("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case PARSE: res = concatAndFree(newString("parse("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case READXML: res = concatAndFree(newString("readxml("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case EXECUTE: res = concatAndFree(newString("execute("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case INFNORM: res = newString("infnorm("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case SUPNORM: res = newString("supnorm("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case FINDZEROS: res = newString("findzeros("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case FPFINDZEROS: res = newString("fpfindzeros("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case DIRTYINFNORM: res = newString("dirtyinfnorm("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case NUMBERROOTS: res = newString("numberroots("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case INTEGRAL: res = newString("integral("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case DIRTYINTEGRAL: res = newString("dirtyintegral("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case IMPLEMENTPOLY: res = newString("implementpoly("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case IMPLEMENTCONST: res = newString("implementconstant("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case CHECKINFNORM: res = newString("checkinfnorm("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case ZERODENOMINATORS: res = newString("zerodenominators("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case ISEVALUABLE: res = newString("isevaluable("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case SEARCHGAL: res = newString("searchgal("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case GUESSDEGREE: res = newString("guessdegree("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")")); break; case ASSIGNMENTININDEXING: curr = tree->arguments; res = concatAndFree(sRawPrintThingInner((node *) (curr->value), forceDyadic), newString("[")); curr = curr->next; res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); res = concatAndFree(res, newString("] = ")); curr = curr->next; res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); break; case FLOATASSIGNMENTININDEXING: curr = tree->arguments; res = concatAndFree(sRawPrintThingInner((node *) (curr->value), forceDyadic), newString("[")); curr = curr->next; res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); res = concatAndFree(res, newString("] := ")); curr = curr->next; res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); break; case ASSIGNMENTINSTRUCTURE: curr = tree->arguments; res = newString((char *) (curr->value)); curr = curr->next; while (curr != NULL) { res = concatAndFree(res, newString(".")); res = concatAndFree(res, newString((char *) (curr->value))); curr = curr->next; } res = concatAndFree(res, newString(" = ")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case FLOATASSIGNMENTINSTRUCTURE: curr = tree->arguments; res = newString((char *) (curr->value)); curr = curr->next; while (curr != NULL) { res = concatAndFree(res, newString(".")); res = concatAndFree(res, newString((char *) (curr->value))); curr = curr->next; } res = concatAndFree(res, newString(" := ")); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); break; case PROTOASSIGNMENTINSTRUCTURE: res = sRawPrintThingInner(tree->child1, forceDyadic); res = concatAndFree(res, newString(" = ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); break; case PROTOFLOATASSIGNMENTINSTRUCTURE: res = sRawPrintThingInner(tree->child1, forceDyadic); res = concatAndFree(res, newString(" := ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); break; case DIRTYFINDZEROS: res = newString("dirtyfindzeros("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case HEAD: res = concatAndFree(newString("head("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case ROUNDCORRECTLY: res = concatAndFree(newString("roundcorrectly("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case READFILE: res = concatAndFree(newString("readfile("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case REVERT: res = concatAndFree(newString("revert("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case SORT: res = concatAndFree(newString("sort("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case MANTISSA: res = concatAndFree(newString("mantissa("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case EXPONENT: res = concatAndFree(newString("exponent("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case PRECISION: res = concatAndFree(newString("precision("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case TAIL: res = concatAndFree(newString("tail("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case LENGTH: res = concatAndFree(newString("length("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case OBJECTNAME: res = concatAndFree(newString("objectname("), concatAndFree(sRawPrintThingInner(tree->child1, forceDyadic), newString(")"))); break; case EXTERNALPROCEDUREUSAGE: res = newString(tree->libProc->procedureName); break; case PROC: res = newString("proc("); curr = tree->arguments; while (curr != NULL) { res = concatAndFree(res, newString((char *) (curr->value))); if (curr->next != NULL) res = concatAndFree(res, newString(", ")); curr = curr->next; } res = concatAndFree(res, newString(")\n{\n")); curr = accessThruMemRef(tree->child1)->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); res = concatAndFree(res, newString(";\n")); curr = curr->next; } res = concatAndFree(res, newString("return ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(";\n}")); break; case BIND: res = newString("bind("); res = concatAndFree(res, sRawPrintThingInner(tree->child1, forceDyadic)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, newString(tree->string)); res = concatAndFree(res, newString(", ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(")")); break; case PROCILLIM: res = newString("proc("); curr = tree->arguments; res = concatAndFree(res, newString((char *) (curr->value))); res = concatAndFree(res, newString(" = ...)\n{\n")); curr = accessThruMemRef(tree->child1)->arguments; while (curr != NULL) { res = concatAndFree(res, sRawPrintThingInner((node *) (curr->value), forceDyadic)); res = concatAndFree(res, newString(";\n")); curr = curr->next; } res = concatAndFree(res, newString("return ")); res = concatAndFree(res, sRawPrintThingInner(tree->child2, forceDyadic)); res = concatAndFree(res, newString(";\n}")); break; case PRECDEREF: res = newString("prec"); break; case POINTSDEREF: res = newString("points"); break; case DIAMDEREF: res = newString("diam"); break; case DISPLAYDEREF: res = newString("display"); break; case VERBOSITYDEREF: res = newString("verbosity"); break; case CANONICALDEREF: res = newString("canonical"); break; case AUTOSIMPLIFYDEREF: res = newString("autosimplify"); break; case SHOWMESSAGENUMBERSDEREF: res = newString("showmessagenumbers"); break; case TAYLORRECURSDEREF: res = newString("taylorrecursions"); break; case TIMINGDEREF: res = newString("timing"); break; case FULLPARENDEREF: res = newString("fullparentheses"); break; case MIDPOINTDEREF: res = newString("midpointmode"); break; case DIEONERRORMODEDEREF: res = newString("dieonerrormode"); break; case RATIONALMODEDEREF: res = newString("rationalmode"); break; case SUPPRESSWARNINGSDEREF: res = newString("roundingwarnings"); break; case HOPITALRECURSDEREF: res = newString("hopitalrecursions"); break; default: sollyaFprintf(stderr,"Error: sRawPrintThingInner: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return res; } char *sRawPrintThing(node *tree) { return sRawPrintThingInner(tree, 0); } char *getReparsableString(node *tree) { return sRawPrintThingInner(tree, 1); } char *sPrintThingWithFullStrings(node *thing) { char *temp; chain *curr; char *temp1, *temp2; if (isPureTree(thing)) { return sprintTree(thing); } else { if (isRange(thing)) { if (midpointMode && (dyadic == 0)) { temp = sprintMidpointMode(*(accessThruMemRef(accessThruMemRef(thing)->child1)->value), *(accessThruMemRef(accessThruMemRef(thing)->child2)->value)); if (temp != NULL) { return temp; } else { temp1 = sprintValue(accessThruMemRef(accessThruMemRef(thing)->child1)->value); temp2 = sprintValue(accessThruMemRef(accessThruMemRef(thing)->child2)->value); temp = (char *) safeCalloc(strlen(temp1) + strlen(temp2) + 3 + 1, sizeof(char)); sprintf(temp, "[%s;%s]",temp1,temp2); safeFree(temp1); safeFree(temp2); return temp; } } else { temp1 = sprintValue(accessThruMemRef(accessThruMemRef(thing)->child1)->value); temp2 = sprintValue(accessThruMemRef(accessThruMemRef(thing)->child2)->value); temp = (char *) safeCalloc(strlen(temp1) + strlen(temp2) + 3 + 1, sizeof(char)); sprintf(temp, "[%s;%s]",temp1,temp2); safeFree(temp1); safeFree(temp2); return temp; } } else { if (isList(thing)) { setupRandomAccessOnLists(thing); curr = accessThruMemRef(thing)->arguments; temp = (char *) safeCalloc(2 + 1, sizeof(char)); sprintf(temp,"[|"); while (curr != NULL) { temp1 = sPrintThingWithFullStrings((node *) (curr->value)); temp2 = (char *) safeCalloc(strlen(temp) + strlen(temp1) + 1, sizeof(char)); sprintf(temp2,"%s%s",temp,temp1); safeFree(temp); safeFree(temp1); temp = temp2; if (curr->next != NULL) { temp2 = (char *) safeCalloc(strlen(temp) + 2 + 1, sizeof(char)); sprintf(temp2,"%s, ",temp); safeFree(temp); temp = temp2; } curr = curr->next; } temp2 = (char *) safeCalloc(strlen(temp) + 2 + 1, sizeof(char)); sprintf(temp2,"%s|]",temp); safeFree(temp); temp = temp2; return temp; } else { if (isFinalEllipticList(thing)) { setupRandomAccessOnLists(thing); curr = accessThruMemRef(thing)->arguments; temp = (char *) safeCalloc(2 + 1, sizeof(char)); sprintf(temp,"[|"); while (curr != NULL) { temp1 = sPrintThingWithFullStrings((node *) (curr->value)); temp2 = (char *) safeCalloc(strlen(temp) + strlen(temp1) + 1, sizeof(char)); sprintf(temp2,"%s%s",temp,temp1); safeFree(temp); safeFree(temp1); temp = temp2; if (curr->next != NULL) { temp2 = (char *) safeCalloc(strlen(temp) + 2 + 1, sizeof(char)); sprintf(temp2,"%s, ",temp); safeFree(temp); temp = temp2; } curr = curr->next; } temp2 = (char *) safeCalloc(strlen(temp) + 5 + 1, sizeof(char)); sprintf(temp2,"%s...|]",temp); safeFree(temp); temp = temp2; return temp; } else { return sRawPrintThing(thing); } } } } } char *sPrintThing(node *thing) { char *temp; chain *curr; char *temp1, *temp2; if (isPureTree(thing)) { return sprintTree(thing); } else { if (isRange(thing)) { if (midpointMode && (dyadic == 0)) { temp = sprintMidpointMode(*(accessThruMemRef(accessThruMemRef(thing)->child1)->value), *(accessThruMemRef(accessThruMemRef(thing)->child2)->value)); if (temp != NULL) { return temp; } else { temp1 = sprintValue(accessThruMemRef(accessThruMemRef(thing)->child1)->value); temp2 = sprintValue(accessThruMemRef(accessThruMemRef(thing)->child2)->value); temp = (char *) safeCalloc(strlen(temp1) + strlen(temp2) + 3 + 1, sizeof(char)); sprintf(temp, "[%s;%s]",temp1,temp2); safeFree(temp1); safeFree(temp2); return temp; } } else { temp1 = sprintValue(accessThruMemRef(accessThruMemRef(thing)->child1)->value); temp2 = sprintValue(accessThruMemRef(accessThruMemRef(thing)->child2)->value); temp = (char *) safeCalloc(strlen(temp1) + strlen(temp2) + 3 + 1, sizeof(char)); sprintf(temp, "[%s;%s]",temp1,temp2); safeFree(temp1); safeFree(temp2); return temp; } } else { if (isList(thing)) { setupRandomAccessOnLists(thing); curr = accessThruMemRef(thing)->arguments; temp = (char *) safeCalloc(2 + 1, sizeof(char)); sprintf(temp,"[|"); while (curr != NULL) { temp1 = sPrintThingWithFullStrings((node *) (curr->value)); temp2 = (char *) safeCalloc(strlen(temp) + strlen(temp1) + 1, sizeof(char)); sprintf(temp2,"%s%s",temp,temp1); safeFree(temp); safeFree(temp1); temp = temp2; if (curr->next != NULL) { temp2 = (char *) safeCalloc(strlen(temp) + 2 + 1, sizeof(char)); sprintf(temp2,"%s, ",temp); safeFree(temp); temp = temp2; } curr = curr->next; } temp2 = (char *) safeCalloc(strlen(temp) + 2 + 1, sizeof(char)); sprintf(temp2,"%s|]",temp); safeFree(temp); temp = temp2; return temp; } else { if (isFinalEllipticList(thing)) { setupRandomAccessOnLists(thing); curr = accessThruMemRef(thing)->arguments; temp = (char *) safeCalloc(2 + 1, sizeof(char)); sprintf(temp,"[|"); while (curr != NULL) { temp1 = sPrintThingWithFullStrings((node *) (curr->value)); temp2 = (char *) safeCalloc(strlen(temp) + strlen(temp1) + 1, sizeof(char)); sprintf(temp2,"%s%s",temp,temp1); safeFree(temp); safeFree(temp1); temp = temp2; if (curr->next != NULL) { temp2 = (char *) safeCalloc(strlen(temp) + 2 + 1, sizeof(char)); sprintf(temp2,"%s, ",temp); safeFree(temp); temp = temp2; } curr = curr->next; } temp2 = (char *) safeCalloc(strlen(temp) + 5 + 1, sizeof(char)); sprintf(temp2,"%s...|]",temp); safeFree(temp); temp = temp2; return temp; } else { if (isString(thing)) { temp = (char *) safeCalloc(strlen(accessThruMemRef(thing)->string) + 1, sizeof(char)); sprintf(temp,"%s",accessThruMemRef(thing)->string); return temp; } else { return sRawPrintThing(thing); } } } } } } void fRawPrintThing(FILE *fd, node *thing); void fPrintThingWithFullStrings(FILE *fd, node *thing) { char *temp; chain *curr; if (isPureTree(thing)) { fprintTreeWithPrintMode(fd,thing); } else { if (isRange(thing)) { if (midpointMode && (dyadic == 0)) { temp = sprintMidpointMode(*(accessThruMemRef(accessThruMemRef(thing)->child1)->value), *(accessThruMemRef(accessThruMemRef(thing)->child2)->value)); if (temp != NULL) { sollyaFprintf(fd,"%s",temp); safeFree(temp); } else { sollyaFprintf(fd,"["); fprintValueWithPrintMode(fd,*(accessThruMemRef(accessThruMemRef(thing)->child1)->value)); sollyaFprintf(fd,";"); fprintValueWithPrintMode(fd,*(accessThruMemRef(accessThruMemRef(thing)->child2)->value)); sollyaFprintf(fd,"]"); } } else { sollyaFprintf(fd,"["); fprintValueWithPrintMode(fd,*(accessThruMemRef(accessThruMemRef(thing)->child1)->value)); sollyaFprintf(fd,";"); fprintValueWithPrintMode(fd,*(accessThruMemRef(accessThruMemRef(thing)->child2)->value)); sollyaFprintf(fd,"]"); } } else { if (isList(thing)) { setupRandomAccessOnLists(thing); curr = accessThruMemRef(thing)->arguments; sollyaFprintf(fd,"[|"); while (curr != NULL) { fPrintThingWithFullStrings(fd,(node *) (curr->value)); if (curr->next != NULL) sollyaFprintf(fd,", "); curr = curr->next; } sollyaFprintf(fd,"|]"); } else { if (isFinalEllipticList(thing)) { setupRandomAccessOnLists(thing); curr = accessThruMemRef(thing)->arguments; sollyaFprintf(fd,"[|"); while (curr != NULL) { fPrintThingWithFullStrings(fd,(node *) (curr->value)); if (curr->next != NULL) sollyaFprintf(fd,", "); curr = curr->next; } sollyaFprintf(fd,"...|]"); } else { if (isStructure(thing)) { sollyaFprintf(fd,"{ "); curr = accessThruMemRef(thing)->arguments; while (curr != NULL) { sollyaFprintf(fd,".%s = ", ((entry *) (curr->value))->name); fPrintThingWithFullStrings(fd,(node *) (((entry *) (curr->value))->value)); if (curr->next != NULL) sollyaFprintf(fd,", "); curr = curr->next; } sollyaFprintf(fd," }"); } else { fRawPrintThing(fd,thing); } } } } } } void fPrintThing(FILE *fd, node *thing) { char *temp; chain *curr; if (isPureTree(thing)) { fprintTreeWithPrintMode(fd,thing); } else { if (isRange(thing)) { if (midpointMode && (dyadic == 0)) { temp = sprintMidpointMode(*(accessThruMemRef(accessThruMemRef(thing)->child1)->value), *(accessThruMemRef(accessThruMemRef(thing)->child2)->value)); if (temp != NULL) { sollyaFprintf(fd,"%s",temp); safeFree(temp); } else { sollyaFprintf(fd,"["); fprintValueWithPrintMode(fd,*(accessThruMemRef(accessThruMemRef(thing)->child1)->value)); sollyaFprintf(fd,";"); fprintValueWithPrintMode(fd,*(accessThruMemRef(accessThruMemRef(thing)->child2)->value)); sollyaFprintf(fd,"]"); } } else { sollyaFprintf(fd,"["); fprintValueWithPrintMode(fd,*(accessThruMemRef(accessThruMemRef(thing)->child1)->value)); sollyaFprintf(fd,";"); fprintValueWithPrintMode(fd,*(accessThruMemRef(accessThruMemRef(thing)->child2)->value)); sollyaFprintf(fd,"]"); } } else { if (isList(thing)) { setupRandomAccessOnLists(thing); curr = accessThruMemRef(thing)->arguments; sollyaFprintf(fd,"[|"); while (curr != NULL) { fPrintThingWithFullStrings(fd,(node *) (curr->value)); if (curr->next != NULL) sollyaFprintf(fd,", "); curr = curr->next; } sollyaFprintf(fd,"|]"); } else { if (isFinalEllipticList(thing)) { setupRandomAccessOnLists(thing); curr = accessThruMemRef(thing)->arguments; sollyaFprintf(fd,"[|"); while (curr != NULL) { fPrintThingWithFullStrings(fd,(node *) (curr->value)); if (curr->next != NULL) sollyaFprintf(fd,", "); curr = curr->next; } sollyaFprintf(fd,"...|]"); } else { if (isString(thing)) { sollyaFprintf(fd,"%s",accessThruMemRef(thing)->string); } else { if (isStructure(thing)) { sollyaFprintf(fd,"{ "); curr = accessThruMemRef(thing)->arguments; while (curr != NULL) { sollyaFprintf(fd,".%s = ", ((entry *) (curr->value))->name); fPrintThingWithFullStrings(fd,(node *) (((entry *) (curr->value))->value)); if (curr->next != NULL) sollyaFprintf(fd,", "); curr = curr->next; } sollyaFprintf(fd," }"); } else { fRawPrintThing(fd,thing); } } } } } } } int assignThingToTable(char *identifier, node *thing) { if (((variablename != NULL) && (strcmp(variablename,identifier) == 0)) || (getFunction(identifier) != NULL) || (getConstantFunction(identifier) != NULL) || (getProcedure(identifier) != NULL)) { printMessage(1,SOLLYA_MSG_IDENTIFIER_ALREADY_BOUND,"Warning: the identifier \"%s\" is already bound to the free variable, to a library function, library constant or to an external procedure.\nThe command will have no effect.\n", identifier); considerDyingOnError(); return 0; } if (containsDeclaredEntry(declaredSymbolTable, identifier)) { declaredSymbolTable = assignDeclaredEntry(declaredSymbolTable, identifier, thing, copyThingAndAddMemRefOnVoid, freeThingOnVoid); return 1; } if (containsEntry(symbolTable, identifier)) { printMessage(3,SOLLYA_MSG_IDENTIFIER_REASSIGNMENT,"Information: the identifier \"%s\" has already been assigned to. This a reassignment.\n",identifier); symbolTable = removeEntry(symbolTable, identifier, freeThingOnVoid); } symbolTable = addEntry(symbolTable, identifier, thing, copyThingAndAddMemRefOnVoid); return 1; } void *returnThingOnVoid(void *ptr) { return ptr; } /* ATTENTION: This function "eats up" its 2nd argument on success */ int performListPrependInTable(char *ident, node *tree) { if (containsDeclaredEntry(declaredSymbolTable, ident)) { return performListPrependOnDeclaredEntry(declaredSymbolTable, ident, tree); } if (containsEntry(symbolTable, ident)) { return performListPrependOnEntry(symbolTable, ident, tree); } return 0; } int performListTailInTable(char *ident) { if (containsDeclaredEntry(declaredSymbolTable, ident)) { return performListTailOnDeclaredEntry(declaredSymbolTable, ident); } if (containsEntry(symbolTable, ident)) { return performListTailOnEntry(symbolTable, ident); } return 0; } node *getThingFromTable(char *identifier, int doCopy, int *didCopy) { libraryFunction *tempLibraryFunction; libraryProcedure *tempLibraryProcedure; node *temp_node; int myDoCopy; myDoCopy = doCopy; if (didCopy == NULL) myDoCopy = 1; if ((variablename != NULL) && (strcmp(variablename,identifier) == 0)) { if (didCopy != NULL) *didCopy = 1; return addMemRef(makeVariable()); } if ((tempLibraryFunction = getFunction(identifier)) != NULL) { temp_node = (node *) safeMalloc(sizeof(node)); temp_node->nodeType = LIBRARYFUNCTION; temp_node->libFun = tempLibraryFunction; temp_node->libFunDeriv = 0; temp_node->child1 = (node *) safeMalloc(sizeof(node)); temp_node->child1->nodeType = VARIABLE; if (didCopy != NULL) *didCopy = 1; return addMemRef(temp_node); } if ((tempLibraryFunction = getConstantFunction(identifier)) != NULL) { temp_node = (node *) safeMalloc(sizeof(node)); temp_node->nodeType = LIBRARYCONSTANT; temp_node->libFun = tempLibraryFunction; if (didCopy != NULL) *didCopy = 1; return addMemRef(temp_node); } if ((tempLibraryProcedure = getProcedure(identifier)) != NULL) { if (didCopy != NULL) *didCopy = 1; return addMemRef(makeExternalProcedureUsage(tempLibraryProcedure)); } if (containsDeclaredEntry(declaredSymbolTable, identifier)) { if (myDoCopy) { if (didCopy != NULL) *didCopy = 1; return addMemRef(getDeclaredEntry(declaredSymbolTable, identifier, copyThingOnVoid)); } if (didCopy != NULL) *didCopy = 0; return getDeclaredEntry(declaredSymbolTable, identifier, returnThingOnVoid); } if (!containsEntry(symbolTable, identifier)) return NULL; if (myDoCopy) { if (didCopy != NULL) *didCopy = 1; return (node *) addMemRef(getEntry(symbolTable, identifier, copyThingOnVoid)); } if (didCopy != NULL) *didCopy = 0; return (node *) getEntry(symbolTable, identifier, returnThingOnVoid); } void printExternalProcedureUsageOldStyle(node *tree) { chain *curr; if (isExternalProcedureUsage(tree)) { sollyaPrintf("%s(",accessThruMemRef(tree)->libProc->procedureName); curr = accessThruMemRef(tree)->libProc->signature->next; while (curr != NULL) { switch (*((int *) (curr->value))) { case VOID_TYPE: sollyaPrintf("void"); break; case CONSTANT_TYPE: sollyaPrintf("constant"); break; case FUNCTION_TYPE: sollyaPrintf("function"); break; case OBJECT_TYPE: sollyaPrintf("object"); break; case RANGE_TYPE: sollyaPrintf("range"); break; case INTEGER_TYPE: sollyaPrintf("integer"); break; case STRING_TYPE: sollyaPrintf("string"); break; case BOOLEAN_TYPE: sollyaPrintf("boolean"); break; case CONSTANT_LIST_TYPE: sollyaPrintf("list of constant"); break; case FUNCTION_LIST_TYPE: sollyaPrintf("list of function"); break; case OBJECT_LIST_TYPE: sollyaPrintf("list of object"); break; case RANGE_LIST_TYPE: sollyaPrintf("list of range"); break; case INTEGER_LIST_TYPE: sollyaPrintf("list of integer"); break; case STRING_LIST_TYPE: sollyaPrintf("list of string"); break; case BOOLEAN_LIST_TYPE: sollyaPrintf("list of boolean"); break; default: sollyaPrintf("unknown type"); } if (curr->next != NULL) sollyaPrintf(", "); curr = curr->next; } sollyaPrintf(") -> "); switch (*((int *) (accessThruMemRef(tree)->libProc->signature->value))) { case VOID_TYPE: sollyaPrintf("void"); break; case CONSTANT_TYPE: sollyaPrintf("constant"); break; case FUNCTION_TYPE: sollyaPrintf("function"); break; case OBJECT_TYPE: sollyaPrintf("object"); break; case RANGE_TYPE: sollyaPrintf("range"); break; case INTEGER_TYPE: sollyaPrintf("integer"); break; case STRING_TYPE: sollyaPrintf("string"); break; case BOOLEAN_TYPE: sollyaPrintf("boolean"); break; case CONSTANT_LIST_TYPE: sollyaPrintf("list of constant"); break; case FUNCTION_LIST_TYPE: sollyaPrintf("list of function"); break; case OBJECT_LIST_TYPE: sollyaPrintf("list of object"); break; case RANGE_LIST_TYPE: sollyaPrintf("list of range"); break; case INTEGER_LIST_TYPE: sollyaPrintf("list of integer"); break; case STRING_LIST_TYPE: sollyaPrintf("list of string"); break; case BOOLEAN_LIST_TYPE: sollyaPrintf("list of boolean"); break; default: sollyaPrintf("unknown type"); } } } void printExternalProcedureUsage(node *tree) { if (isExternalProcedureUsage(tree)) { sollyaPrintf("%s",accessThruMemRef(tree)->libProc->procedureName); } } void autoprint(node *thing, int inList, node *func, node *cst) { mpfr_t a,b; node *temp_node, *tempNode2, *tempNode3, *tempNode4, *tempNode5; chain *curr; int freeThingAfterwards; int okay, shown, shown2, extraMessage; rangetype xrange, yrange; int okaySign, sign; int faithfulAlreadyKnown; node *simplCst; int infinityCase; int deg; int counter; int tern; int faithfulRoundingIsExact; int marker; int resEval; faithfulRoundingIsExact = 0; shown = 0; shown2 = 0; if (isPureTree(thing)) { if (((thing->nodeType == MEMREF) && (thing->polynomialRepresentation != NULL)) || (treeSize(thing) < CHEAPSIMPLIFYSIZE) || rationalMode) { tempNode2 = simplifyTreeErrorfree(thing); freeThingAfterwards = 1; } else { tempNode2 = thing; freeThingAfterwards = 0; } if (isConstant(tempNode2)) { if ((!((tempNode2->nodeType == MEMREF) && (tempNode2->child1 == NULL))) && (accessThruMemRef(tempNode2)->nodeType == CONSTANT)) { if (mpfr_get_prec(*(accessThruMemRef(tempNode2)->value)) < tools_precision * 4) { printValue(accessThruMemRef(tempNode2)->value); } else { mpfr_init2(a,tools_precision); tern = mpfr_set(a, *(accessThruMemRef(tempNode2)->value), GMP_RNDN); if (mpfr_number_p(a) && (!mpfr_zero_p(a))) { if ((tern != 0) && (!noRoundingWarnings)) { printMessage(1,SOLLYA_MSG_DISPLAYED_VALUE_IS_FAITHFULLY_ROUNDED,"Warning: rounding has happened. The value displayed is a faithful rounding to %d bits of the true result.\n", mpfr_get_prec(a)); } printValue(&a); } else { printValue(accessThruMemRef(tempNode2)->value); } mpfr_clear(a); } } else { if (rationalMode && (accessThruMemRef(tempNode2)->nodeType == DIV) && (accessThruMemRef(accessThruMemRef(tempNode2)->child1)->nodeType == CONSTANT) && (accessThruMemRef(accessThruMemRef(tempNode2)->child2)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(accessThruMemRef(tempNode2)->child1)->value)) && mpfr_number_p(*(accessThruMemRef(accessThruMemRef(tempNode2)->child2)->value)) && (!mpfr_zero_p(*(accessThruMemRef(accessThruMemRef(tempNode2)->child2)->value)))) { if (mpfr_cmp_si(*(accessThruMemRef(accessThruMemRef(tempNode2)->child2)->value),1) == 0) { printTree(accessThruMemRef(tempNode2)->child1); } else { printTree(tempNode2); } } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); mpfr_set_d(b,1.0,GMP_RNDN); faithfulAlreadyKnown = 0; if ((func != NULL) && (cst != NULL)) { simplCst = simplifyTreeErrorfree(cst); if ((accessThruMemRef(simplCst)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(simplCst)->value))) { resEval = evaluateFaithful(a,func,*(accessThruMemRef(simplCst)->value),tools_precision); if (resEval) { faithfulAlreadyKnown = 1; if (resEval == 4) { faithfulRoundingIsExact = 1; } } } freeThing(simplCst); } marker = 0; if (faithfulAlreadyKnown || (marker = evaluateFaithful(a,tempNode2,b,tools_precision))) { if (marker && ((accessThruMemRef(tempNode2)->nodeType == CONSTANT) && (mpfr_number_p(*(accessThruMemRef(tempNode2)->value))))) { mpfr_set_prec(a, mpfr_get_prec(*(accessThruMemRef(tempNode2)->value))); faithfulRoundingIsExact = (mpfr_set(a, *(accessThruMemRef(tempNode2)->value), GMP_RNDN) == 0); if (!mpfr_number_p(a)) faithfulRoundingIsExact = 0; } if (mpfr_number_p(a)) { if (!faithfulRoundingIsExact) { if (!noRoundingWarnings) { if (!shown) { if ((!faithfulAlreadyKnown) || (!mpfr_zero_p(a))) { printMessage(1,SOLLYA_MSG_DISPLAYED_VALUE_IS_FAITHFULLY_ROUNDED,"Warning: rounding has happened. The value displayed is a faithful rounding to %d bits of the true result.\n", mpfr_get_prec(a)); } } shown = 1; } } } else { if (mpfr_nan_p(a)) { printMessage(1,SOLLYA_MSG_EXPRESSION_UNDEFINED_OR_UNSTABLE,"Warning: the given expression is undefined or numerically unstable.\n"); } } printValue(&a); } else { tempNode5 = simplifyRationalErrorfree(tempNode2); if (accessThruMemRef(tempNode5)->nodeType == CONSTANT) { mpfr_set_prec(a,mpfr_get_prec(*(accessThruMemRef(tempNode5)->value))); mpfr_set(a,*(accessThruMemRef(tempNode5)->value),GMP_RNDN); } else { okaySign = evaluateSign(&sign,tempNode2); if (okaySign && (sign == 0)) { mpfr_set_ui(a,0,GMP_RNDN); } else { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),tools_precision); mpfr_init2(*(xrange.b),tools_precision); mpfr_init2(*(yrange.a),tools_precision * 256); mpfr_init2(*(yrange.b),tools_precision * 256); mpfr_set_ui(*(xrange.a),1.0,GMP_RNDD); mpfr_set_ui(*(xrange.b),1.0,GMP_RNDU); evaluateRangeFunction(yrange, tempNode5, xrange, tools_precision * 256 + 10); extraMessage = 0; infinityCase = 0; if (mpfr_number_p(*(yrange.a)) && mpfr_number_p(*(yrange.b)) && (mpfr_sgn(*(yrange.a)) * mpfr_sgn(*(yrange.b)) < 0)) { mpfr_set_ui(a,0,GMP_RNDN); if (!noRoundingWarnings) { if (!shown) { printMessage(1,SOLLYA_MSG_ROUNDING_MAY_HAVE_HAPPENED_AND_NOT_FAITHFUL,"Warning: rounding may have happened.\nIf there is rounding, the displayed value is *NOT* guaranteed to be a faithful rounding of the true result.\n"); shown = 1; } } } else { if (mpfr_inf_p(*(yrange.a)) && mpfr_inf_p(*(yrange.b)) && (mpfr_sgn(*(yrange.a)) == mpfr_sgn(*(yrange.b)))) { mpfr_set(a, *(yrange.a), GMP_RNDN); /* Copying an infinity, no rounding */ infinityCase = 1; } else { evaluate(a,tempNode5,b,tools_precision * 256); if (!(mpfr_number_p(*(yrange.a)) && mpfr_number_p(*(yrange.b)))) extraMessage = 1; } } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); if (mpfr_number_p(a)) { if (!noRoundingWarnings) { if (!shown) { printMessage(1,SOLLYA_MSG_ROUNDING_MAY_HAVE_HAPPENED_AND_NOT_FAITHFUL,"Warning: rounding has happened.\nThe displayed value is *NOT* guaranteed to be a faithful rounding of the true result.\n"); if (extraMessage) printMessage(1,SOLLYA_MSG_EVALUATION_WITH_PLAIN_FP_ARITHMETIC,"The displayed value has been computed using plain floating-point arithmetic and might be completely wrong.\n"); shown = 1; } } } else { if (infinityCase) { printMessage(2,SOLLYA_MSG_EXPRESSION_EVALUATES_TO_INFINITY,"Information: the given expression evaluates to infinity.\n"); } else { printMessage(1,SOLLYA_MSG_EXPRESSION_UNDEFINED_OR_UNSTABLE,"Warning: the given expression is undefined or numerically unstable.\n"); if (!isAffine(tempNode5)) { mpfr_set_nan(a); } } } } } printValue(&a); freeThing(tempNode5); } mpfr_clear(a); mpfr_clear(b); } } } else { if (rationalMode) tempNode3 = simplifyAllButDivision(tempNode2); else tempNode3 = simplifyTree(tempNode2); if (!isSyntacticallyEqual(tempNode3,tempNode2)) { if (!noRoundingWarnings) { if (!shown) printMessage(1,SOLLYA_MSG_ROUNDING_MAY_HAVE_HAPPENED_SOMEWHERE,"Warning: rounding may have happened.\n"); shown = 1; } } if (((!((tempNode3->nodeType == MEMREF) && (tempNode3->polynomialRepresentation != NULL))) && (treeSize(tempNode3) > MAXHORNERTREESIZE)) || (isPolynomialExtraSafe(tempNode3) && (((deg = getDegreeSilent(tempNode3)) > MAXHORNERDEGREE) || (deg < 0)))) { if (canonical) printMessage(1,SOLLYA_MSG_EXPRESSION_TOO_BIG_FOR_CANONICAL_FORM,"Warning: the expression is too big for being written in canonical form.\n"); else { if (!(isHorner(tempNode3) || ((tempNode3->nodeType == MEMREF) && (tempNode3->polynomialRepresentation != NULL)) || isPowerOfVariable(tempNode3))) { printMessage(1,SOLLYA_MSG_EXPRESSION_TOO_BIG_FOR_HORNER_FORM,"Warning: the expression is too big for being written in Horner form.\n"); } } temp_node = copyTree(tempNode3); } else { okay = 0; counter = 0; do { if (canonical) temp_node = makeCanonical(tempNode3,tools_precision); else temp_node = horner(tempNode3); if (rationalMode) tempNode4 = simplifyAllButDivision(temp_node); else tempNode4 = simplifyTree(temp_node); if (!isSyntacticallyEqual(tempNode4,temp_node)) { if (!noRoundingWarnings) { if (!shown) printMessage(1,SOLLYA_MSG_ROUNDING_MAY_HAVE_HAPPENED_SOMEWHERE,"Warning: rounding may have happened.\n"); shown = 1; } freeThing(temp_node); if (canonical) { if (isCanonical(tempNode4)) { okay = 1; } } else { if (isHorner(tempNode4)) { okay = 1; } } if (counter > 15) okay = 1; if (!okay) { if (!shown2) printMessage(2,SOLLYA_MSG_DOUBLE_SIMPLIFICATION_NECESSARY,"Information: double simplification necessary\n"); shown2 = 1; freeThing(tempNode3); tempNode3 = copyThing(tempNode4); } else { temp_node = copyThing(tempNode4); } } else okay = 1; freeThing(tempNode4); counter++; } while (!okay); } printTree(temp_node); free_memory(temp_node); free_memory(tempNode3); } if (freeThingAfterwards) free_memory(tempNode2); } else { if (isList(thing)) { setupRandomAccessOnLists(thing); sollyaPrintf("[|"); curr = accessThruMemRef(thing)->arguments; while (curr != NULL) { autoprint((node *) (curr->value),1,NULL,NULL); if (curr->next != NULL) sollyaPrintf(", "); curr = curr->next; } sollyaPrintf("|]"); } else { if (isFinalEllipticList(thing)) { setupRandomAccessOnLists(thing); sollyaPrintf("[|"); curr = accessThruMemRef(thing)->arguments; while (curr != NULL) { autoprint((node *) (curr->value),1,NULL,NULL); if (curr->next != NULL) sollyaPrintf(", "); curr = curr->next; } sollyaPrintf("...|]"); } else { if (isStructure(thing)) { sollyaPrintf("{ "); curr = accessThruMemRef(thing)->arguments; while (curr != NULL) { sollyaPrintf(".%s = ", ((entry *) (curr->value))->name); autoprint((node *) (((entry *) (curr->value))->value),1,NULL,NULL); if (curr->next != NULL) sollyaPrintf(", "); curr = curr->next; } sollyaPrintf(" }"); } else { if (inList) printThingWithFullStrings(thing); else printThing(thing); } } } } } void evaluateThingListToThingArray(int *number, node ***array, chain *things) { chain *curr; int i; *number = lengthChain(things); *array = (node **) safeCalloc(*number,sizeof(node *)); curr = things; i = 0; while (curr != NULL) { (*array)[i] = evaluateThing((node *) (curr->value)); curr = curr->next; i++; } } int evaluateThingArrayToListOfPureTrees(chain **ch, int number, node **array) { chain *curr; int i, err; node *evaluated; err = 0; curr = NULL; for (i=number-1;i>=0;i--) { if (evaluateThingToPureTree(&evaluated, array[i])) { curr = addElement(curr,evaluated); } else { err = 1; break; } } if (err) { freeChain(curr,freeThingOnVoid); return 0; } *ch = curr; return 1; } int evaluateThingToConstantList(chain **ch, node *tree) { node **arrayTrees; chain *newChain; int i, number, k; node *evaluated; mpfr_t **arrayMpfr; evaluated = evaluateThing(tree); if (isPureList(evaluated)) { setupRandomAccessOnLists(evaluated); evaluateThingListToThingArray(&number, &arrayTrees, accessThruMemRef(evaluated)->arguments); arrayMpfr = (mpfr_t **) safeCalloc(number,sizeof(mpfr_t *)); for (i=0;i=0;k--) { newChain = addElement(newChain,arrayMpfr[k]); } safeFree(arrayMpfr); *ch = newChain; for (i=0;iarguments); arrayMpfi = (sollya_mpfi_t **) safeCalloc(number,sizeof(sollya_mpfi_t *)); for (i=0;i=0;k--) { newChain = addElement(newChain,arrayMpfi[k]); } safeFree(arrayMpfi); *ch = newChain; for (i=0;iarguments); arrayString = (char **) safeCalloc(number,sizeof(char *)); for (i=0;i=0;k--) { newChain = addElement(newChain,arrayString[k]); } safeFree(arrayString); *ch = newChain; for (i=0;inodeType == ASSIGNMENT) && (accessThruMemRef(accessThruMemRef(tree)->child1)->nodeType == PREPEND) && (accessThruMemRef(accessThruMemRef(accessThruMemRef(tree)->child1)->child2)->nodeType == TABLEACCESS) && (!strcmp(accessThruMemRef(tree)->string, accessThruMemRef(accessThruMemRef(accessThruMemRef(tree)->child1)->child2)->string))) { didCopy = 0; tempNode = getThingFromTable(accessThruMemRef(tree)->string, 0, &didCopy); if (didCopy) { if (tempNode != NULL) freeThing(tempNode); return 0; } if (tempNode == NULL) return 0; if (isList(tempNode) || isFinalEllipticList(tempNode)) { tempNode2 = evaluateThing(accessThruMemRef(accessThruMemRef(tree)->child1)->child1); if (tempNode2 != NULL) { if (performListPrependInTable(accessThruMemRef(tree)->string, tempNode2)) { *res = 0; return 1; } freeThing(tempNode2); } } } return 0; } int tryTailOptimization(int *res, node *tree) { node *tempNode; int didCopy; if ((accessThruMemRef(tree)->nodeType == ASSIGNMENT) && (accessThruMemRef(accessThruMemRef(tree)->child1)->nodeType == TAIL) && (accessThruMemRef(accessThruMemRef(accessThruMemRef(tree)->child1)->child1)->nodeType == TABLEACCESS) && (!strcmp(accessThruMemRef(tree)->string, accessThruMemRef(accessThruMemRef(accessThruMemRef(tree)->child1)->child1)->string))) { didCopy = 0; tempNode = getThingFromTable(accessThruMemRef(tree)->string, 0, &didCopy); if (didCopy) { if (tempNode != NULL) freeThing(tempNode); return 0; } if (tempNode == NULL) return 0; if ((isList(tempNode) || isFinalEllipticList(tempNode)) && ((accessThruMemRef(tempNode)->arguments != NULL) && (accessThruMemRef(tempNode)->arguments->next != NULL) && (accessThruMemRef(tempNode)->arguments->next->next != NULL))) { if (performListTailInTable(accessThruMemRef(tree)->string)) { *res = 0; return 1; } } } return 0; } int tryOptimizedCommandExecution(int *res, node *tree) { int (*optimizers[])(int *, node *) = { tryPrependOptimization, tryTailOptimization, NULL }; int (*optimizer)(int *, node*); int i, myRes; for (i=0; optimizers[i] != NULL; i++) { optimizer = optimizers[i]; myRes = *res; if (optimizer(&myRes, tree)) { *res = myRes; return 1; } } return 0; } int executeCommandInner(node *tree); int executeCommand(node *tree) { int res = 0; if (tryOptimizedCommandExecution(&res, tree)) return res; res = executeCommandInner(tree); return res; } int timeCommand(mpfr_t time, node *tree) { int res = 0; sollya_time_t *before; sollya_time_t *after; long long int seconds, nanoseconds; unsigned int sec, nsec; mpfr_t tmp; before = safeMalloc(sizeof(sollya_time_t)); after = safeMalloc(sizeof(sollya_time_t)); if(!sollya_gettime(before)) printMessage(1, SOLLYA_MSG_TIMER_UNUSABLE, "Warning: unable to use the timer. Measures may be untrustable\n"); res = executeCommand(tree); if(!sollya_gettime(after)) printMessage(1, SOLLYA_MSG_TIMER_UNUSABLE, "Warning: unable to use the timer. Measures may be untrustable\n"); seconds = (long long int)(after->seconds) - (long long int)(before->seconds); nanoseconds = (long long int)(after->nano_seconds) - (long long int)(before->nano_seconds); safeFree(before); safeFree(after); if (nanoseconds < 0) { nanoseconds += 1000000000l; seconds--; } sec = seconds; nsec = nanoseconds; mpfr_init2(tmp,10 + 20 + 29 + 2 * 8 * sizeof(sec)); mpfr_set_ui(tmp,sec,GMP_RNDN); mpfr_mul_ui(tmp,tmp,1000,GMP_RNDN); mpfr_mul_ui(tmp,tmp,1000,GMP_RNDN); mpfr_mul_ui(tmp,tmp,1000,GMP_RNDN); mpfr_add_ui(tmp,tmp,nsec,GMP_RNDN); mpfr_div_ui(tmp,tmp,1000,GMP_RNDN); mpfr_div_ui(tmp,tmp,1000,GMP_RNDN); mpfr_div_ui(tmp,tmp,1000,GMP_RNDN); mpfr_set(time,tmp,GMP_RNDN); mpfr_clear(tmp); return res; } void doNothing(int n) { mpfr_t x, y; mpfr_t z; volatile unsigned long int t; int i, j; gmp_randstate_t random_state; volatile unsigned long int seed; seed = 17; gmp_randinit_default(random_state); gmp_randseed_ui(random_state, seed); mpfr_init2(x, 10000); mpfr_init2(y, 10000); mpfr_init2(z, 20000 - 20); mpfr_urandomb(x, random_state); mpfr_urandomb(y, random_state); t = 0; for (i=0;inodeType == MEMREF) { return tryToRewriteLeftHandStructAccessInner(idents, getMemRefChild(thing)); } okay = 0; switch (thing->nodeType) { case TABLEACCESS: buf = (char *) safeCalloc(strlen(thing->string)+1,sizeof(char)); strcpy(buf,thing->string); *idents = addElement(NULL,buf); okay = 1; break; case STRUCTACCESS: if (tryToRewriteLeftHandStructAccessInner(&tempChain,thing->child1)) { buf = (char *) safeCalloc(strlen(thing->string)+1,sizeof(char)); strcpy(buf,thing->string); *idents = addElement(tempChain,buf); okay = 1; } else { okay = 0; } break; default: okay = 0; } return okay; } int tryToRewriteLeftHandStructAccess(chain **idents, node *thing) { chain *tempChain, *curr; if (tryToRewriteLeftHandStructAccessInner(&tempChain, thing)) { *idents = NULL; for (curr=tempChain;curr!=NULL;curr=curr->next) { *idents = addElement(*idents,curr->value); } freeChain(tempChain, freeDoNothing); return 1; } return 0; } node *createNestedStructure(node *value, chain *idents) { node *structure; chain *curr; chain *assoclist; entry *structEntry; chain *revertedIdents; revertedIdents = NULL; for (curr=idents;curr!=NULL;curr=curr->next) { revertedIdents = addElement(revertedIdents,curr->value); } curr = revertedIdents; structEntry = (entry *) safeMalloc(sizeof(entry)); structEntry->name = (char *) safeCalloc(strlen((char *) (curr->value))+1,sizeof(char)); strcpy(structEntry->name,(char *) (curr->value)); structEntry->value = copyThing(value); assoclist = addElement(NULL,(void *) structEntry); structure = makeStructure(assoclist); curr = curr->next; while (curr != NULL) { structEntry = (entry *) safeMalloc(sizeof(entry)); structEntry->name = (char *) safeCalloc(strlen((char *) (curr->value))+1,sizeof(char)); strcpy(structEntry->name,(char *) (curr->value)); structEntry->value = structure; assoclist = addElement(NULL,(void *) structEntry); structure = makeStructure(assoclist); curr = curr->next; } freeChain(revertedIdents, freeDoNothing); return structure; } node *recomputeLeftHandSideForAssignmentInStructureInner(node *oldValue, node *newValue, chain *idents) { chain *currentIdent; node *currentStruct; int okay, found; node *res; char *myIdent; chain *currentAssoc; char *otherIdent; node *nextStruct; entry *newEntry; if ((oldValue == NULL) || (isError(oldValue))) return createNestedStructure(newValue, idents); if (!isStructure(oldValue)) { printMessage(1,SOLLYA_MSG_CAN_MODIFY_ONLY_ELEMENTS_OF_STRUCTURES,"Warning: cannot modify an element of something that is not a structure.\n"); return NULL; } okay = 1; res = deepCopyThing(oldValue); currentStruct = res; currentIdent = idents; while (okay && (currentIdent != NULL)) { myIdent = (char *) (currentIdent->value); currentAssoc = currentStruct->arguments; found = 0; while (!found && (currentAssoc != NULL)) { otherIdent = (char *) (((entry *) (currentAssoc->value))->name); if (!strcmp(otherIdent,myIdent)) { found = 1; } else { currentAssoc = currentAssoc->next; } } if (found) { nextStruct = (node *) (((entry *) (currentAssoc->value))->value); if (isError(nextStruct)) { freeThing(nextStruct); if (currentIdent->next == NULL) { ((entry *) (currentAssoc->value))->value = copyThing(newValue); } else { ((entry *) (currentAssoc->value))->value = createNestedStructure(newValue, currentIdent->next); } break; } else { if (isStructure(nextStruct)) { if (currentIdent->next == NULL) { freeThing(nextStruct); ((entry *) (currentAssoc->value))->value = copyThing(newValue); } else { currentStruct = nextStruct; } } else { if (currentIdent->next == NULL) { freeThing(nextStruct); ((entry *) (currentAssoc->value))->value = copyThing(newValue); } else { okay = 0; printMessage(1,SOLLYA_MSG_CAN_MODIFY_ONLY_ELEMENTS_OF_STRUCTURES,"Warning: cannot modify an element of something that is not a structure.\n"); break; } } } } else { newEntry = (entry *) safeMalloc(sizeof(entry)); newEntry->name = (char *) safeCalloc(strlen(myIdent)+1,sizeof(char)); strcpy(newEntry->name,myIdent); if (currentIdent->next == NULL) { newEntry->value = copyThing(newValue); } else { newEntry->value = createNestedStructure(newValue, currentIdent->next); } currentStruct->arguments = addElement(currentStruct->arguments,newEntry); break; } currentIdent = currentIdent->next; } if (!okay) { freeThing(res); res = NULL; } return res; } node *recomputeLeftHandSideForAssignmentInStructure(node *oldValue, node *newValue, chain *idents) { node *res; res = recomputeLeftHandSideForAssignmentInStructureInner(oldValue, newValue, idents); if (res == NULL) return res; return rewriteThingWithMemRefReuse(res, oldValue); } int setMessageSuppressionState(int msgNum, int state) { if ((msgNum < 0) || (msgNum == SOLLYA_MSG_NO_MSG) || (msgNum == SOLLYA_MSG_CONTINUATION) || (!messageNumberExists(msgNum))) { printMessage(1,SOLLYA_MSG_CANNOT_SUPPRESS_OR_UNSUPPRESS_A_MESSAGE, ((state)?"Warning: the message with the number %d cannot be suppressed.\n": "Warning: the message with the number %d cannot be unsuppressed.\n"), msgNum); return 0; } if (suppressedMessages == NULL) { suppressedMessages = initializeBitfield(); } fixBitInBitfield(suppressedMessages, (unsigned int) msgNum, state); return 1; } int symbolNameAlreadyUsed(char *basename) { if ((variablename != NULL) && (strcmp(variablename,basename) == 0)) return 1; if (containsEntry(symbolTable, basename) || containsDeclaredEntry(declaredSymbolTable, basename)) return 1; if (getProcedure(basename) != NULL) return 1; if (getFunction(basename) != NULL) return 1; if (getConstantFunction(basename) != NULL) return 1; return 0; } int executeCommandInner(node *tree) { int result, res, intTemp, resA, resB, resC, resD, resE, resF, resG, defaultVal, i; chain *curr, *tempList, *tempList2, *tempChain, *tempChain2; mpfr_t a, b, c, d, e; node *tempNode, *tempNode2, *tempNode3, *tempNode4, *tempNode5, *tempNode6, *tempNode7; libraryFunction *tempLibraryFunction; libraryProcedure *tempLibraryProcedure; char *tempString, *tempString2, *timingString; FILE *fd; node **array; rangetype tempRange; int autoprintAlreadyDone, floatingPointEvaluationAlreadyDone; int *tempIntPtr; /* Make compiler happy */ fd = NULL; /* End of compiler happiness */ if (tree->nodeType == MEMREF) { return executeCommandInner(getMemRefChild(tree)); } result = 0; timingString = NULL; if (timecounting) { timingString = getTimingStringForThing(tree); if (timingString != NULL) pushTimeCounter(); } switch (tree->nodeType) { case COMMANDLIST: declaredSymbolTable = pushFrame(declaredSymbolTable); curr = tree->arguments; result = 0; while (curr != NULL) { res = executeCommand((node *) (curr->value)); if (res) { result = 1; break; } curr = curr->next; } declaredSymbolTable = popFrame(declaredSymbolTable,freeThingOnVoid); break; case WHILE: result = 0; do { if (!evaluateThingToBoolean(&intTemp, tree->child1, NULL)) { printMessage(1,SOLLYA_MSG_CONTROL_STRUCTURE_NOT_EXECUTABLE_EXPR_NO_BOOLEAN,"Warning: the given expression does not evaluate to a boolean.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The while loop will not be executed.\n"); considerDyingOnError(); break; } if (!intTemp) break; res = executeCommand(tree->child2); if (res) { result = 1; break; } } while (1); break; case IFELSE: result = 0; curr = tree->arguments; if (!evaluateThingToBoolean(&intTemp, (node *) (curr->value), NULL)) { printMessage(1,SOLLYA_MSG_CONTROL_STRUCTURE_NOT_EXECUTABLE_EXPR_NO_BOOLEAN,"Warning: the given expression does not evaluate to a boolean.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Neither the if nor the else statement will be executed.\n"); considerDyingOnError(); } else { if (intTemp) { curr = curr->next; result = executeCommand((node *) (curr->value)); } else { curr = curr->next; curr = curr->next; result = executeCommand((node *) (curr->value)); } } break; case IF: result = 0; if (!evaluateThingToBoolean(&intTemp, tree->child1, NULL)) { printMessage(1,SOLLYA_MSG_CONTROL_STRUCTURE_NOT_EXECUTABLE_EXPR_NO_BOOLEAN,"Warning: the given expression does not evaluate to a boolean.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The if statement will not be executed.\n"); considerDyingOnError(); } else { if (intTemp) { result = executeCommand(tree->child2); } } break; case FOR: result = 0; mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); mpfr_init2(c,tools_precision); curr = tree->arguments; resA = evaluateThingToConstant(a, (node *) (curr->value), NULL, 0, 0); curr = curr->next; resB = evaluateThingToConstant(b, (node *) (curr->value), NULL, 0, 0); curr = curr->next; resC = evaluateThingToConstant(c, (node *) (curr->value), NULL, 0, 0); curr = curr->next; tempNode4 = (node *) (curr->value); if (resA && resB && resC) { tempNode = makeConstant(a); if (assignThingToTable(tree->string, tempNode)) { while (1) { if (mpfr_sgn(c) > 0) { if (mpfr_cmp(a,b) > 0) break; } else { if (mpfr_cmp(a,b) < 0) break; } res = executeCommand(tempNode4); if (res) { result = 1; break; } tempNode2 = getThingFromTable(tree->string, 1, NULL); if (tempNode2 != NULL) { tempNode3 = makeAdd(tempNode2,makeConstant(c)); resA = evaluateThingToConstant(a, tempNode3, NULL, 0, 0); freeThing(tempNode3); if (resA) { tempNode3 = makeConstant(a); if (!assignThingToTable(tree->string,tempNode3)) { printMessage(1,SOLLYA_MSG_AT_END_OF_FOR_CNTRL_VAR_NO_LONGER_ASSIGNABLE,"Warning: at the end of a for loop, the loop variable \"%s\" cannot longer be assigned to.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"The for loop will no longer be executed.\n"); considerDyingOnError(); freeThing(tempNode3); break; } freeThing(tempNode3); } else { printMessage(1,SOLLYA_MSG_AT_END_OF_FOR_CNTRL_VAR_NO_LONGER_CONSTANT,"Warning: at the end of a for loop, the loop variable \"%s\" decreased by the loop step does no longer evaluate to a constant.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"The for loop will no longer be executed.\n"); considerDyingOnError(); break; } } else { printMessage(1,SOLLYA_MSG_TOOL_HAS_BEEN_RESTARTED_INSIDE_LOOP,"Warning: the tool has been restarted inside a for loop.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The for loop will no longer be executed.\n"); considerDyingOnError(); break; } } } else { printMessage(1,SOLLYA_MSG_CNTRL_VAR_OF_LOOP_CANNOT_BE_ASSIGNED,"Warning: the identifier \"%s\" cannot be assigned to.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"The for loop will not be executed.\n"); considerDyingOnError(); } freeThing(tempNode); } else { printMessage(1,SOLLYA_MSG_ARGS_OF_FOR_LOOP_NOT_CONSTANT,"Warning: one of the arguments of the for loop does not evaluate to a constant.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The for loop will not be executed.\n"); considerDyingOnError(); } mpfr_clear(a); mpfr_clear(b); mpfr_clear(c); break; case FORIN: if (evaluateThingToPureListOfThings(&tempList, tree->child1)) { curr = tempList; while (curr != NULL) { if (assignThingToTable(tree->string,(node *) (curr->value))) { res = executeCommand(tree->child2); if (res) { result = 1; break; } } else { printMessage(1,SOLLYA_MSG_AT_END_OF_FOR_CNTRL_VAR_NO_LONGER_ASSIGNABLE,"Warning: the identifier \"%s\" can no longer be assigned to.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"The execution of the for loop will be stopped.\n"); considerDyingOnError(); break; } curr = curr->next; } freeChain(tempList,freeThingOnVoid); } else { if (evaluateThingToEmptyList(tree->child1)) { printMessage(2,SOLLYA_MSG_FOR_IN_LOOP_OVER_EMPTY_LIST,"Information: executing a for in statement on an empty list.\n"); } else { printMessage(1,SOLLYA_MSG_FOR_IN_LOOP_OVER_END_ELLIPTIC_LIST_NOT_ALLOWED,"Warning: the expression given does not evaluate to a non-elliptic list.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The loop will not be executed.\n"); considerDyingOnError(); } } break; case QUIT: result = 1; break; case NOP: result = 0; break; case NOPARG: defaultVal = 1; if (evaluateThingToInteger(&resA, tree->child1, &defaultVal)) { if (resA < 1) { resA = 1; printMessage(1,SOLLYA_MSG_AT_LEAST_ONE_OPERATION_MUST_BE_EXECUTED,"Warning: at least 1 operation must be executed.\n"); } doNothing(resA); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } result = 0; break; case FALSEQUIT: printMessage(1,SOLLYA_MSG_QUIT_IN_FILE_READ_INTO_ANOTHER,"Warning: a quit command has been used in a file read into another.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This quit command will be neglected.\n"); result = 0; break; case FALSERESTART: printMessage(1,SOLLYA_MSG_RESTART_IN_FILE_READ_INTO_ANOTHER,"Warning: a restart command has been used in a file read into another.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This restart command will be neglected.\n"); result = 0; break; case RESTART: restartTool(); outputMode(); sollyaPrintf("The tool has been restarted.\n"); result = 0; break; case VARIABLEDECLARATION: curr = tree->arguments; while (curr != NULL) { if ((variablename != NULL) && (strcmp(variablename, (char *) (curr->value)) == 0)) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_LOCAL_VAR,"Warning: the identifier \"%s\" is already bound to the current free variable.\nIt cannot be declared as a local variable. The declaration of \"%s\" will have no effect.\n", (char *) (curr->value),(char *) (curr->value)); considerDyingOnError(); } else { if (getFunction((char *) (curr->value)) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_LOCAL_VAR,"Warning: the identifier \"%s\" is already bound to a library function.\nIt cannot be declared as a local variable. The declaration of \"%s\" will have no effect.\n", (char *) (curr->value),(char *) (curr->value)); considerDyingOnError(); } else { if (getConstantFunction((char *) (curr->value)) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_LOCAL_VAR,"Warning: the identifier \"%s\" is already bound to a library constant.\nIt cannot be declared as a local variable. The declaration of \"%s\" will have no effect.\n", (char *) (curr->value),(char *) (curr->value)); considerDyingOnError(); } else { if (getProcedure((char *) (curr->value)) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_LOCAL_VAR,"Warning: the identifier \"%s\" is already bound to an external procedure.\nIt cannot be declared as a local variable. The declaration of \"%s\" will have no effect.\n", (char *) (curr->value),(char *) (curr->value)); considerDyingOnError(); } else { if (declaredSymbolTable != NULL) { tempNode = makeError(); declaredSymbolTable = declareNewEntry(declaredSymbolTable, (char *) (curr->value), tempNode, copyThingOnVoid); freeThing(tempNode); } else { printMessage(1,SOLLYA_MSG_FRAME_SYSTEM_CORRUPTED_LOCAL_VAR_NOT_DECLARED,"Warning: previous command interruptions have corrupted the frame system.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Local variable \"%s\" cannot be declared.\n",(char *) (curr->value)); considerDyingOnError(); } } } } } curr = curr->next; } break; case PRINT: curr = tree->arguments; outputMode(); while (curr != NULL) { tempNode = evaluateThing((node *) (curr->value)); printThing(tempNode); freeThing(tempNode); if (curr->next != NULL) sollyaPrintf(" "); curr = curr->next; } sollyaPrintf("\n"); break; case SUPPRESSMESSAGE: evaluateThingListToThingArray(&resA, &array, tree->arguments); tempChain = NULL; for (i=0;inext) { if (!setMessageSuppressionState(*((int *) (curr->value)), 1)) { printMessage(1,SOLLYA_MSG_SUPPRESSION_NUMBER_OMITTED,"Warning: The command will have had no effect for message number %d.\n",*((int *) (curr->value))); } } freeChain(tempChain,freeIntPtr); for (i=0;iarguments); tempChain = NULL; for (i=0;inext) { if (!setMessageSuppressionState(*((int *) (curr->value)), 0)) { printMessage(1,SOLLYA_MSG_SUPPRESSION_NUMBER_OMITTED,"Warning: The command will have had no effect for message number %d.\n",*((int *) (curr->value))); } } freeChain(tempChain,freeIntPtr); for (i=0;ichild1)) { fd = fopen(tempString,"w"); if (fd != NULL) { curr = tree->arguments; while (curr != NULL) { tempNode = evaluateThing((node *) (curr->value)); fPrintThing(fd,tempNode); freeThing(tempNode); if (curr->next != NULL) sollyaFprintf(fd," "); curr = curr->next; } sollyaFprintf(fd,"\n"); fclose(fd); } else { printMessage(1,SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING,"Warning: the file \"%s\" could not be opened for writing.\n",tempString); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case APPENDFILEPRINT: if (evaluateThingToString(&tempString, tree->child1)) { fd = fopen(tempString,"a"); if (fd != NULL) { curr = tree->arguments; while (curr != NULL) { tempNode = evaluateThing((node *) (curr->value)); fPrintThing(fd,tempNode); freeThing(tempNode); if (curr->next != NULL) sollyaFprintf(fd," "); curr = curr->next; } sollyaFprintf(fd,"\n"); fclose(fd); } else { printMessage(1,SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING,"Warning: the file \"%s\" could not be opened for writing.\n",tempString); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case PLOT: evaluateThingListToThingArray(&resA, &array, tree->arguments); resC = 0; if (isFilePostscriptFile(array[resA-2])) { if (evaluateThingToString(&tempString, array[resA-1])) { resB = resA - 2; resC = 1; switch ((accessThruMemRef(array[resA-2]))->nodeType) { case FILESYM: resD = PLOTFILE; break; case POSTSCRIPT: resD = PLOTPOSTSCRIPT; break; case POSTSCRIPTFILE: resD = PLOTPOSTSCRIPTFILE; break; default: resC = 0; } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { resB = resA; resC = 1; resD = PLOTFILE; tempString = NULL; } if (resC) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a, b, array[resB-1])) { if (evaluateThingArrayToListOfPureTrees(&tempList, resB-1, array)) { plotTree(tempList, a, b, defaultpoints, tools_precision, tempString, resD); freeChain(tempList,freeThingOnVoid); } else { if (isPureList(array[0]) && (resB-1 == 1)) { if (evaluateThingToPureListOfPureTrees(&tempList, array[0])) { plotTree(tempList, a, b, defaultpoints, tools_precision, tempString, resD); freeChain(tempList,freeThingOnVoid); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_LIST_OF_FUNCTIONS,"Warning: the first argument is not a list of pure functions.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_LIST_OF_FUNCTIONS,"Warning: at least one of the given expressions does not evaluate to a pure function.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Warning: the first argument is not a list of pure functions.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_RANGE,"Warning: the expression given does not evaluate to a range.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } mpfr_clear(a); mpfr_clear(b); } if (tempString != NULL) safeFree(tempString); for (i=0;iarguments); resG = 1; resD = 1; if (evaluateThingToPureTree(&tempNode, array[0])) { if (isConstant(tempNode)) { resB = 0; resC = 1; resE = 0; if (resA > 1) { if (evaluateThingToString(&tempString2, array[1])) { fd = fopen(tempString2,"w"); if (fd != NULL) { safeFree(tempString2); resB = 1; } else { if (resD) { freeThing(tempNode); resD = 0; } if (resG) { for (i=0;i 2)) { if (evaluateThingToStringWithDefault(&tempString, array[2], "const_something")) { resE = 1; } else { if (resD) { freeThing(tempNode); resD = 0; } if (resB) { fclose(fd); resB = 0; } if (resG) { for (i=0;ichild1, NULL, 0, 0)) { outputMode(); printDoubleInHexa(a); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_CONSTANT,"Warning: the expression given does not evaluate to a constant value.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } mpfr_clear(a); break; case PRINTFLOAT: mpfr_init2(a,tools_precision); if (evaluateThingToConstant(a, tree->child1, NULL, 0, 0)) { outputMode(); printSimpleInHexa(a); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_CONSTANT,"Warning: the expression given does not evaluate to a constant value.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } mpfr_clear(a); break; case PRINTBINARY: mpfr_init2(a,tools_precision); if (evaluateThingToConstant(a, tree->child1, NULL, 0, 0)) { outputMode(); printBinary(a); sollyaPrintf("\n"); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_CONSTANT,"Warning: the expression given does not evaluate to a constant value.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } mpfr_clear(a); break; case PRINTEXPANSION: outputMode(); if (evaluateThingToPureTree(&tempNode, tree->child1)) { if (printPolynomialAsDoubleExpansion(tempNode, tools_precision) == 1) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_WHILE_PRINTING,"\nWarning: rounding occurred while printing."); } } sollyaPrintf("\n"); freeThing(tempNode); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_A_FUNCTION,"Warning: the given expression does not evaluate to a function.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } break; case BASHEXECUTE: if (evaluateThingToString(&tempString, tree->child1)) { outputMode(); intTemp = bashExecute(tempString); normalMode(); outputMode(); printMessage(2,SOLLYA_MSG_BASH_RETURNS_A_CERTAIN_RETURN_VALUE,"Information: the bash return value is %d.\n",intTemp); safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case EXTERNALPLOT: evaluateThingListToThingArray(&resA, &array, tree->arguments); if (evaluateThingToString(&tempString,array[0])) { resB = RELATIVE; if (evaluateThingToExternalPlotMode(&resF,array[1],&resB)) { if (evaluateThingToPureTree(&tempNode,array[2])) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,array[3])) { if (evaluateThingToInteger(&resB, array[4], NULL)) { resC = 0; resD = 0; tempString2 = NULL; resE = PLOTFILE; if (resA >= 6) { if ((accessThruMemRef(array[5]))->nodeType == PERTURB) { resC = 1; if (resA >= 8) { if (isFilePostscriptFile(array[6])) { if (evaluateThingToString(&tempString2,array[7])) { resD = 1; switch ((accessThruMemRef(array[6]))->nodeType) { case FILESYM: resE = PLOTFILE; break; case POSTSCRIPT: resE = PLOTPOSTSCRIPT; break; case POSTSCRIPTFILE: resE = PLOTPOSTSCRIPTFILE; break; default: resD = 0; } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } } else { resD = 1; } } else { if (resA >= 7) { if (isFilePostscriptFile(array[5])) { if (evaluateThingToString(&tempString2,array[6])) { resD = 1; switch ((accessThruMemRef(array[5]))->nodeType) { case FILESYM: resE = PLOTFILE; break; case POSTSCRIPT: resE = PLOTPOSTSCRIPT; break; case POSTSCRIPTFILE: resE = PLOTPOSTSCRIPTFILE; break; default: resD = 0; } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } } } } else { resD = 1; } if (resD) { externalPlot(tempString, a, b, (mp_prec_t) resB, resC, tempNode, resF, tools_precision, tempString2, resE); } if (tempString2 != NULL) safeFree(tempString2); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_RANGE,"Warning: the expression given does not evaluate to a constant range.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } mpfr_clear(a); mpfr_clear(b); freeThing(tempNode); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_A_FUNCTION,"Warning: the expression given does not evaluate to a function.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ABS_NOR_REL,"Warning: the expression given does not evaluate to one of absolute or relative.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } for (i=0;iarguments; while (curr != NULL) { tempNode = evaluateThing((node *) (curr->value)); printThing(tempNode); freeThing(tempNode); curr = curr->next; } break; case NEWFILEWRITE: if (evaluateThingToString(&tempString, tree->child1)) { fd = fopen(tempString,"w"); if (fd != NULL) { curr = tree->arguments; while (curr != NULL) { tempNode = evaluateThing((node *) (curr->value)); fPrintThing(fd,tempNode); freeThing(tempNode); curr = curr->next; } fclose(fd); } else { printMessage(1,SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING,"Warning: the file \"%s\" could not be opened for writing.\n",tempString); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case APPENDFILEWRITE: if (evaluateThingToString(&tempString, tree->child1)) { fd = fopen(tempString,"a"); if (fd != NULL) { curr = tree->arguments; while (curr != NULL) { tempNode = evaluateThing((node *) (curr->value)); fPrintThing(fd,tempNode); freeThing(tempNode); curr = curr->next; } fclose(fd); } else { printMessage(1,SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_APPENDING,"Warning: the file \"%s\" could not be opened for appending.\n",tempString); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case ASCIIPLOT: outputMode(); if (evaluateThingToPureTree(&tempNode, tree->child1)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a, b, tree->child2)) { asciiPlotTree(tempNode, a, b, tools_precision); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_RANGE,"Warning: the given expression does not evaluate to a constant range.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } freeThing(tempNode); mpfr_clear(a); mpfr_clear(b); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_A_FUNCTION,"Warning: the given expression does not evaluate to a function.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } break; case PRINTXML: if (evaluateThingToPureTree(&tempNode, tree->child1)) { sollyaPrintf("\n"); outputMode(); printXml(tempNode); freeThing(tempNode); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_A_FUNCTION,"Warning: the given expression does not evaluate to a function.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } break; case EXECUTE: if (evaluateThingToString(&tempString, tree->child1)) { fd = fopen(tempString,"r"); if (fd != NULL) { executeFile(fd); fclose(fd); } else { printMessage(1,SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_READING,"Warning: the file \"%s\" could not be opened for reading.\n",tempString); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the given expression does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } break; case PRINTXMLNEWFILE: if (evaluateThingToPureTree(&tempNode, tree->child1)) { if (evaluateThingToString(&tempString, tree->child2)) { fd = fopen(tempString,"w"); if (fd != NULL) { fPrintXml(fd,tempNode); fclose(fd); } else { printMessage(1,SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING,"Warning: the file \"%s\" could not be opened for writing.\n",tempString); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the given expression does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } freeThing(tempNode); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_A_FUNCTION,"Warning: the given expression does not evaluate to a function.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } break; case PRINTXMLAPPENDFILE: if (evaluateThingToPureTree(&tempNode, tree->child1)) { if (evaluateThingToString(&tempString, tree->child2)) { fd = fopen(tempString,"a"); if (fd != NULL) { fPrintXml(fd,tempNode); fclose(fd); } else { printMessage(1,SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING,"Warning: the file \"%s\" could not be opened for writing.\n",tempString); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the given expression does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } freeThing(tempNode); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_A_FUNCTION,"Warning: the given expression does not evaluate to a function.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } break; case WORSTCASE: evaluateThingListToThingArray(&resA, &array, tree->arguments); resC = 0; if ((resA >= 6) && (isString(array[5]))) { fd = fopen((accessThruMemRef(array[5]))->string,"w"); if (fd != NULL) { resC = 1; } else { printMessage(1,SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING,"Warning: the file \"%s\" could not be opened for writing.\n",(array[5])->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { resC = 1; fd = NULL; } if (resC) { if (evaluateThingToPureTree(&tempNode,array[0])) { mpfr_init2(a,tools_precision); if (evaluateThingToConstant(a,array[1],NULL,0,0)) { mpfr_init2(b,tools_precision); mpfr_init2(c,tools_precision); if (evaluateThingToRange(b,c,array[2])) { mpfr_init2(d,tools_precision); if (evaluateThingToConstant(d,array[3],NULL,0,0)) { mpfr_init2(e,tools_precision); if (evaluateThingToConstant(e,array[4],NULL,0,0)) { tempRange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); tempRange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(tempRange.a),tools_precision); mpfr_init2(*(tempRange.b),tools_precision); mpfr_set(*(tempRange.a),b,GMP_RNDN); mpfr_set(*(tempRange.b),c,GMP_RNDN); outputMode(); printWorstCases(tempNode, a, tempRange, d, e, tools_precision, fd); mpfr_clear(*(tempRange.a)); mpfr_clear(*(tempRange.b)); safeFree(tempRange.a); safeFree(tempRange.b); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_CONSTANT,"Warning: the given expression does not evaluate to a constant.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } mpfr_clear(e); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_CONSTANT,"Warning: the given expression does not evaluate to a constant.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } mpfr_clear(d); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_RANGE,"Warning: the given expression does not evaluate to a constant range.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } mpfr_clear(b); mpfr_clear(c); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_CONSTANT,"Warning: the given expression does not evaluate to a constant.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } mpfr_clear(a); freeThing(tempNode); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_A_FUNCTION,"Warning: the given expression does not evaluate to a function.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } if (fd != NULL) fclose(fd); } for (i=0;iarguments->value)) + 1,sizeof(char)); strcpy(variablename,(char *) (tree->arguments->value)); printMessage(1,SOLLYA_MSG_FREE_VARIABLE_HAS_BEEN_NAMED_SOMEHOW,"Information: the free variable has been named \"%s\".\n", variablename); } else { if ((strcmp(variablename,tree->string) == 0) || (strcmp("_x_",tree->string) == 0)) { tempString = variablename; variablename = (char *) safeCalloc(strlen((char *) (tree->arguments->value)) + 1,sizeof(char)); strcpy(variablename,(char *) (tree->arguments->value)); printMessage(1,SOLLYA_MSG_FREE_VARIABLE_HAS_BEEN_RENAMED,"Information: the free variable has been renamed from \"%s\" to \"%s\".\n", tempString,(char *) (tree->arguments->value)); safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_CAN_RENAME_ONLY_FREE_VARIABLE,"Warning: the current free variable is named \"%s\" and not \"%s\". Can only rename the free variable.\n", variablename,tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"The last command will have no effect.\n"); considerDyingOnError(); } } break; case AUTOPRINT: curr = tree->arguments; if (curr->next == NULL) { tempNode = evaluateThing((node *) (curr->value)); autoprintAlreadyDone = 0; if (isPureTree(tempNode) && isConstant(tempNode) && (((accessThruMemRef((node *) (curr->value)))->nodeType == TABLEACCESSWITHSUBSTITUTE) || ((accessThruMemRef((node *) (curr->value)))->nodeType == APPLY)) && (lengthChain((accessThruMemRef((node *) (curr->value)))->arguments) == 1)) { if ((accessThruMemRef((node *) (curr->value)))->nodeType == APPLY) { tempNode2 = copyThing((accessThruMemRef((node *) (curr->value)))->child1); tempNode3 = copyThing(accessThruMemRef((node *) (((accessThruMemRef((node *) (curr->value)))->arguments)->value))); } else { tempNode2 = makeTableAccess((accessThruMemRef((node *) (curr->value)))->string); tempNode3 = copyThing(accessThruMemRef((node *) (((accessThruMemRef((node *) (curr->value)))->arguments)->value))); } tempNode4 = evaluateThing(tempNode2); tempNode5 = evaluateThing(tempNode3); if (isPureTree(tempNode4) && isPureTree(tempNode5) && (!isConstant(tempNode4)) && isConstant(tempNode5)) { outputMode(); autoprint(tempNode,0,tempNode4,tempNode5); sollyaPrintf("\n"); autoprintAlreadyDone = 1; } freeThing(tempNode2); freeThing(tempNode3); freeThing(tempNode4); freeThing(tempNode5); } if (!autoprintAlreadyDone) { if ((!isUnit(tempNode)) || ((verbosity >= 2) && oldVoidPrint)) { if (!isExternalProcedureUsage(tempNode)) { outputMode(); autoprint(tempNode,0,NULL,NULL); } else { outputMode(); if (oldExternalProcedurePrint) { printExternalProcedureUsageOldStyle(tempNode); } else { printExternalProcedureUsage(tempNode); } } sollyaPrintf("\n"); } } freeThing(tempNode); } else { while (curr != NULL) { tempNode = evaluateThing((node *) (curr->value)); autoprintAlreadyDone = 0; if (isPureTree(tempNode) && isConstant(tempNode) && (((accessThruMemRef((node *) (curr->value)))->nodeType == TABLEACCESSWITHSUBSTITUTE) || ((accessThruMemRef((node *) (curr->value)))->nodeType == APPLY)) && (lengthChain((accessThruMemRef((node *) (curr->value)))->arguments) == 1)) { if ((accessThruMemRef((node *) (curr->value)))->nodeType == APPLY) { tempNode2 = copyThing((accessThruMemRef((node *) (curr->value)))->child1); tempNode3 = copyThing(accessThruMemRef((node *) (((accessThruMemRef((node *) (curr->value)))->arguments)->value))); } else { tempNode2 = makeTableAccess((accessThruMemRef((node *) (curr->value)))->string); tempNode3 = copyThing(accessThruMemRef((node *) (((accessThruMemRef((node *) (curr->value)))->arguments)->value))); } tempNode4 = evaluateThing(tempNode2); tempNode5 = evaluateThing(tempNode3); if (isPureTree(tempNode4) && isPureTree(tempNode5) && (!isConstant(tempNode4)) && isConstant(tempNode5)) { outputMode(); autoprint(tempNode,0,tempNode4,tempNode5); autoprintAlreadyDone = 1; } freeThing(tempNode2); freeThing(tempNode3); freeThing(tempNode4); freeThing(tempNode5); } if (!autoprintAlreadyDone) { outputMode(); if (!isExternalProcedureUsage(tempNode)) { autoprint(tempNode,0,NULL,NULL); } else { if (oldExternalProcedurePrint) { printExternalProcedureUsageOldStyle(tempNode); } else { printExternalProcedureUsage(tempNode); } } freeThing(tempNode); } if (oldAutoPrint) { if (curr->next != NULL) sollyaPrintf(", "); } curr = curr->next; } sollyaPrintf("\n"); } break; case EXTERNALPROC: if ((variablename != NULL) && (strcmp(variablename,tree->string) == 0)) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_EXTERNAL,"Warning: the identifier \"%s\" is already be bound as the current free variable.\n",variablename); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to an external procedure. This command will have no effect.\n"); considerDyingOnError(); } else { if (containsEntry(symbolTable, tree->string) || containsDeclaredEntry(declaredSymbolTable, tree->string)) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_BOUND_TO_VAR_CANNOT_BE_EXTERNAL,"Warning: the identifier \"%s\" is already assigned to.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to an external procedure. This command will have no effect.\n"); considerDyingOnError(); } else { if (getFunction(tree->string) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_EXTERNAL,"Warning: the identifier \"%s\" is already bound to a library function.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to an external procedure. This command will have no effect.\n"); considerDyingOnError(); } else { if (getConstantFunction(tree->string) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_EXTERNAL,"Warning: the identifier \"%s\" is already bound to a library constant.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to an external procedure. This command will have no effect.\n"); considerDyingOnError(); } else { if (getProcedure(tree->string) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_EXTERNAL,"Warning: the identifier \"%s\" is already bound to an external procedure.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to an external procedure. This command will have no effect.\n"); considerDyingOnError(); } else { if (evaluateThingToString(&tempString, tree->child1)) { tempLibraryProcedure = bindProcedure(tempString, tree->string, tree->arguments); if(tempLibraryProcedure == NULL) { printMessage(1,SOLLYA_MSG_ERROR_OCCURRED_COMMAND_NOT_EXECUTED,"Warning: an error occurred. The last command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } } } } } break; case ASSIGNMENT: tempNode = addMemRef(evaluateThing(tree->child1)); if (!assignThingToTable(tree->string, tempNode)) { freeThing(tempNode); printMessage(1,SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT,"Warning: the last assignment will have no effect.\n"); considerDyingOnError(); } else { freeThing(tempNode); } break; case FLOATASSIGNMENT: tempNode = addMemRef(evaluateThing(tree->child1)); if (isPureTree(tempNode) && isConstant(tempNode)) { mpfr_init2(a, tools_precision); floatingPointEvaluationAlreadyDone = 0; if (isPureTree(tempNode) && isConstant(tempNode) && ((accessThruMemRef(tree->child1)->nodeType == TABLEACCESSWITHSUBSTITUTE) || (accessThruMemRef(tree->child1)->nodeType == APPLY)) && (lengthChain(accessThruMemRef(tree->child1)->arguments) == 1)) { if (accessThruMemRef(tree->child1)->nodeType == APPLY) { tempNode2 = copyThing(accessThruMemRef(tree->child1)->child1); tempNode3 = copyThing(accessThruMemRef((node *) ((accessThruMemRef(tree->child1)->arguments)->value))); } else { tempNode2 = makeTableAccess(accessThruMemRef(tree->child1)->string); tempNode3 = copyThing(accessThruMemRef((node *) ((accessThruMemRef(tree->child1)->arguments)->value))); } tempNode4 = evaluateThing(tempNode2); tempNode5 = evaluateThing(tempNode3); if (isPureTree(tempNode4) && isPureTree(tempNode5) && (!isConstant(tempNode4)) && isConstant(tempNode5)) { tempNode6 = simplifyTreeErrorfree(tempNode5); if ((accessThruMemRef(tempNode6)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(tempNode6)->value))) { if (evaluateFaithful(a, tempNode4, *(accessThruMemRef(tempNode6)->value), tools_precision)) { floatingPointEvaluationAlreadyDone = 1; } } freeThing(tempNode6); } freeThing(tempNode2); freeThing(tempNode3); freeThing(tempNode4); freeThing(tempNode5); } if (floatingPointEvaluationAlreadyDone || evaluateThingToConstant(a, tempNode, NULL,1,0)) { freeThing(tempNode); tempNode = makeConstant(a); } mpfr_clear(a); } if (!assignThingToTable(tree->string, tempNode)) { printMessage(1,SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT,"Warning: the last assignment will have no effect.\n"); considerDyingOnError(); } freeThing(tempNode); break; case ASSIGNMENTININDEXING: curr = tree->arguments; if ((accessThruMemRef((node *) (curr->value)))->nodeType == TABLEACCESS) { if ((tempNode = getThingFromTable((accessThruMemRef((node *) (curr->value)))->string, 1, NULL)) != NULL) { if (isPureList(tempNode) || isPureFinalEllipticList(tempNode)) { curr = tree->arguments; curr = curr->next; if (evaluateThingToInteger(&resB, accessThruMemRef((node *) (curr->value)), NULL)) { resC = 0; if (resB >= 0) { curr = curr->next; tempNode2 = evaluateThing(accessThruMemRef((node *) (curr->value))); if (resB == lengthChain(accessThruMemRef(tempNode)->arguments)) { tempList = addElement(copyChain(accessThruMemRef(tempNode)->arguments,copyThingOnVoid),copyThing(tempNode2)); tempList2 = copyChain(tempList,copyThingOnVoid); freeChain(tempList,freeThingOnVoid); tempNode3 = makeList(tempList2); tempNode3->nodeType = accessThruMemRef(tempNode)->nodeType; setupRandomAccessOnLists(tempNode3); resC = 1; } else { if (resB < lengthChain(accessThruMemRef(tempNode)->arguments)) { tempNode3 = makeList(copyChainAndReplaceNth(accessThruMemRef(tempNode)->arguments, resB, tempNode2, copyThingOnVoid)); tempNode3->nodeType = accessThruMemRef(tempNode)->nodeType; setupRandomAccessOnLists(tempNode3); resC = 1; } else { if (isFinalEllipticList(tempNode)) { resE = 0; if (isPureTree((node *) accessInList(accessThruMemRef(tempNode)->arguments, lengthChain(accessThruMemRef(tempNode)->arguments) - 1))) { mpfr_init2(a, tools_precision); if (evaluateThingToConstant(a, (node *) accessInList(accessThruMemRef(tempNode)->arguments, lengthChain(accessThruMemRef(tempNode)->arguments) - 1), NULL,0,0)) { if (mpfr_integer_p(a)) { resD = mpfr_get_si(a, GMP_RNDN); mpfr_init2(b, 8 * sizeof(resD) + 5); mpfr_set_si(b, resD, GMP_RNDN); if (mpfr_cmp(a, b) == 0) { tempList = copyChain(accessThruMemRef(tempNode)->arguments,copyThingOnVoid); for (i=lengthChain(accessThruMemRef(tempNode)->arguments);inodeType = accessThruMemRef(tempNode)->nodeType; setupRandomAccessOnLists(tempNode3); resC = 1; } else { resE = 1; } mpfr_clear(b); } else { resE = 1; } } else { resE = 1; } mpfr_clear(a); } else { resE = 1; } if (resE) { tempNode4 = (node *) accessInList(accessThruMemRef(tempNode)->arguments, lengthChain(accessThruMemRef(tempNode)->arguments) - 1); tempList = copyChain(accessThruMemRef(tempNode)->arguments,copyThingOnVoid); for (i=lengthChain(accessThruMemRef(tempNode)->arguments);inodeType = accessThruMemRef(tempNode)->nodeType; setupRandomAccessOnLists(tempNode3); resC = 1; } } } } freeThing(tempNode2); if (resC) { curr = tree->arguments; if (!assignThingToTable(accessThruMemRef((node *) (curr->value))->string, tempNode3)) { printMessage(1,SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT,"Warning: the last assignment will have no effect.\n"); considerDyingOnError(); } freeThing(tempNode3); } else { printMessage(1,SOLLYA_MSG_ASSIGNMENT_OF_INDEXED_ELEMENTS_NOT_IN_RANGE,"Warning: assigning to indexed elements of lists is only allowed on indexes in the existing range.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_ASSIGNMENT_OF_INDEXED_ELEMENTS_NOT_IN_RANGE,"Warning: assigning to indexed elements of lists is only allowed on indexes in the existing range.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { if (isEmptyList(tempNode)) { curr = tree->arguments; curr = curr->next; if (evaluateThingToInteger(&resB, (node *) (curr->value), NULL)) { if (resB == 0) { curr = curr->next; tempNode2 = evaluateThing((node *) (curr->value)); tempNode3 = makeList(addElement(NULL,tempNode2)); curr = tree->arguments; if (!assignThingToTable(accessThruMemRef((node *) (curr->value))->string, tempNode3)) { printMessage(1,SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT,"Warning: the last assignment will have no effect.\n"); considerDyingOnError(); } freeThing(tempNode3); } else { printMessage(1,SOLLYA_MSG_ASSIGNMENT_OF_INDEXED_EMPTY_LIST_ONLY_ON_ZERO,"Warning: assigning to indexed elements of empty lists is only allowed on index 0.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { if (isString(tempNode)) { curr = tree->arguments; curr = curr->next; if (evaluateThingToInteger(&resB, (node *) (curr->value), NULL)) { if ((resB >= 0) && (resB <= (int)strlen(accessThruMemRef(tempNode)->string))) { curr = curr->next; if (evaluateThingToString(&tempString,(node *) (curr->value))) { if (strlen(tempString) == 1) { if (resB == (int)strlen(accessThruMemRef(tempNode)->string)) { tempString2 = (char *) safeCalloc(resB + 2,sizeof(char)); strcpy(tempString2,accessThruMemRef(tempNode)->string); tempString2[resB] = tempString[0]; tempNode3 = makeString(tempString2); safeFree(tempString2); } else { tempNode3 = makeString(accessThruMemRef(tempNode)->string); (accessThruMemRef(tempNode3)->string)[resB] = tempString[0]; } curr = tree->arguments; if (!assignThingToTable(accessThruMemRef((node *) (curr->value))->string, tempNode3)) { printMessage(1,SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT,"Warning: the last assignment will have no effect.\n"); considerDyingOnError(); } freeThing(tempNode3); } else { printMessage(1,SOLLYA_MSG_STRING_NOT_OF_LENGTH_ONE,"Warning: the string to be assigned is not of length 1.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_ASSIGNMENT_OF_INDEXED_ELEMENTS_NOT_IN_RANGE,"Warning: assigning to indexed elements of strings is only allowed in the existing range.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { curr = tree->arguments; printMessage(1,SOLLYA_MSG_IDENTIFIER_NOT_BOUND_TO_LIST_OR_STRING,"Warning: the identifier \"%s\" is not assigned to a (empty) list or a string.\n", (accessThruMemRef((node *) (curr->value)))->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } } } freeThing(tempNode); } else { curr = tree->arguments; printMessage(1,SOLLYA_MSG_IDENTIFIER_NOT_ASSIGNED_TO,"Warning: the identifier \"%s\" is not assigned to.\n",(accessThruMemRef((node *) (curr->value)))->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_FIRST_ELMENT_OF_LEFT_SIDE_NOT_IDENTIFIER,"Warning: the first element of the left-hand side is not an identifier.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case FLOATASSIGNMENTININDEXING: curr = tree->arguments; if ((accessThruMemRef((node *) (curr->value)))->nodeType == TABLEACCESS) { if ((tempNode = getThingFromTable((accessThruMemRef((node *) (curr->value)))->string, 1, NULL)) != NULL) { if (isPureList(tempNode) || isPureFinalEllipticList(tempNode)) { curr = tree->arguments; curr = curr->next; if (evaluateThingToInteger(&resB, (node *) (curr->value), NULL)) { resC = 0; if (resB >= 0) { curr = curr->next; tempNode2 = evaluateThing((node *) (curr->value)); if (isPureTree(tempNode2) && isConstant(tempNode2)) { mpfr_init2(a, tools_precision); floatingPointEvaluationAlreadyDone = 0; if (isPureTree(tempNode2) && isConstant(tempNode2) && (((accessThruMemRef((node *) (curr->value)))->nodeType == TABLEACCESSWITHSUBSTITUTE) || ((accessThruMemRef((node *) (curr->value)))->nodeType == APPLY)) && (lengthChain((accessThruMemRef((node *) (curr->value)))->arguments) == 1)) { if ((accessThruMemRef((node *) (curr->value)))->nodeType == APPLY) { tempNode7 = copyThing((accessThruMemRef((node *) (curr->value)))->child1); tempNode3 = copyThing(accessThruMemRef((node *) (((accessThruMemRef((node *) (curr->value)))->arguments)->value))); } else { tempNode7 = makeTableAccess((accessThruMemRef((node *) (curr->value)))->string); tempNode3 = copyThing(accessThruMemRef((node *) (((accessThruMemRef((node *) (curr->value)))->arguments)->value))); } tempNode4 = evaluateThing(tempNode7); tempNode5 = evaluateThing(tempNode3); if (isPureTree(tempNode4) && isPureTree(tempNode5) && (!isConstant(tempNode4)) && isConstant(tempNode5)) { tempNode6 = simplifyTreeErrorfree(tempNode5); if ((accessThruMemRef(tempNode6)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(tempNode6)->value))) { if (evaluateFaithful(a, tempNode4, *(accessThruMemRef(tempNode6)->value), tools_precision)) { floatingPointEvaluationAlreadyDone = 1; } } freeThing(tempNode6); } freeThing(tempNode7); freeThing(tempNode3); freeThing(tempNode4); freeThing(tempNode5); } if (floatingPointEvaluationAlreadyDone || evaluateThingToConstant(a, tempNode2, NULL,1,0)) { freeThing(tempNode2); tempNode2 = makeConstant(a); } mpfr_clear(a); } if (resB == lengthChain(accessThruMemRef(tempNode)->arguments)) { tempList = addElement(copyChain(accessThruMemRef(tempNode)->arguments,copyThingOnVoid),copyThing(tempNode2)); tempList2 = copyChain(tempList,copyThingOnVoid); freeChain(tempList,freeThingOnVoid); tempNode3 = makeList(tempList2); tempNode3->nodeType = accessThruMemRef(tempNode)->nodeType; setupRandomAccessOnLists(tempNode3); resC = 1; } else { if (resB < lengthChain(accessThruMemRef(tempNode)->arguments)) { tempNode3 = makeList(copyChainAndReplaceNth(accessThruMemRef(tempNode)->arguments, resB, tempNode2, copyThingOnVoid)); tempNode3->nodeType = accessThruMemRef(tempNode)->nodeType; setupRandomAccessOnLists(tempNode3); resC = 1; } else { if (isFinalEllipticList(tempNode)) { resE = 0; if (isPureTree((node *) accessInList(accessThruMemRef(tempNode)->arguments, lengthChain(accessThruMemRef(tempNode)->arguments) - 1))) { mpfr_init2(a, tools_precision); if (evaluateThingToConstant(a, (node *) accessInList(accessThruMemRef(tempNode)->arguments, lengthChain(accessThruMemRef(tempNode)->arguments) - 1), NULL,0,0)) { if (mpfr_integer_p(a)) { resD = mpfr_get_si(a, GMP_RNDN); mpfr_init2(b, 8 * sizeof(resD) + 5); mpfr_set_si(b, resD, GMP_RNDN); if (mpfr_cmp(a, b) == 0) { tempList = copyChain(accessThruMemRef(tempNode)->arguments,copyThingOnVoid); for (i=lengthChain(accessThruMemRef(tempNode)->arguments);inodeType = accessThruMemRef(tempNode)->nodeType; setupRandomAccessOnLists(tempNode3); resC = 1; } else { resE = 1; } mpfr_clear(b); } else { resE = 1; } } else { resE = 1; } mpfr_clear(a); } else { resE = 1; } if (resE) { tempNode4 = (node *) accessInList(accessThruMemRef(tempNode)->arguments, lengthChain(accessThruMemRef(tempNode)->arguments) - 1); tempList = copyChain(accessThruMemRef(tempNode)->arguments,copyThingOnVoid); for (i=lengthChain(accessThruMemRef(tempNode)->arguments);inodeType = accessThruMemRef(tempNode)->nodeType; setupRandomAccessOnLists(tempNode3); resC = 1; } } } } freeThing(tempNode2); if (resC) { curr = tree->arguments; if (isPureTree(tempNode3) && isConstant(tempNode3)) { mpfr_init2(a, tools_precision); if (evaluateThingToConstant(a, tempNode3, NULL, 1,0)) { freeThing(tempNode3); tempNode3 = makeConstant(a); } mpfr_clear(a); } if (!assignThingToTable((accessThruMemRef((node *) (curr->value)))->string, tempNode3)) { printMessage(1,SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT,"Warning: the last assignment will have no effect.\n"); considerDyingOnError(); } freeThing(tempNode3); } else { printMessage(1,SOLLYA_MSG_ASSIGNMENT_OF_INDEXED_ELEMENTS_NOT_IN_RANGE,"Warning: assigning to indexed elements of lists is only allowed on indexes in the existing range.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_ASSIGNMENT_OF_INDEXED_ELEMENTS_NOT_IN_RANGE,"Warning: assigning to indexed elements of lists is only allowed on indexes in the existing range.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { if (isEmptyList(tempNode)) { curr = tree->arguments; curr = curr->next; if (evaluateThingToInteger(&resB, (node *) (curr->value), NULL)) { if (resB == 0) { curr = curr->next; tempNode2 = evaluateThing((node *) (curr->value)); if (isPureTree(tempNode2) && isConstant(tempNode2)) { mpfr_init2(a, tools_precision); floatingPointEvaluationAlreadyDone = 0; if (isPureTree(tempNode2) && isConstant(tempNode2) && (((accessThruMemRef((node *) (curr->value)))->nodeType == TABLEACCESSWITHSUBSTITUTE) || ((accessThruMemRef((node *) (curr->value)))->nodeType == APPLY)) && (lengthChain((accessThruMemRef((node *) (curr->value)))->arguments) == 1)) { if ((accessThruMemRef((node *) (curr->value)))->nodeType == APPLY) { tempNode7 = copyThing((accessThruMemRef((node *) (curr->value)))->child1); tempNode3 = copyThing(accessThruMemRef((node *) (((accessThruMemRef((node *) (curr->value)))->arguments)->value))); } else { tempNode7 = makeTableAccess((accessThruMemRef((node *) (curr->value)))->string); tempNode3 = copyThing(accessThruMemRef((node *) (((accessThruMemRef((node *) (curr->value)))->arguments)->value))); } tempNode4 = evaluateThing(tempNode7); tempNode5 = evaluateThing(tempNode3); if (isPureTree(tempNode4) && isPureTree(tempNode5) && (!isConstant(tempNode4)) && isConstant(tempNode5)) { tempNode6 = simplifyTreeErrorfree(tempNode5); if ((accessThruMemRef(tempNode6)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(tempNode6)->value))) { if (evaluateFaithful(a, tempNode4, *(accessThruMemRef(tempNode6)->value), tools_precision)) { floatingPointEvaluationAlreadyDone = 1; } } freeThing(tempNode6); } freeThing(tempNode7); freeThing(tempNode3); freeThing(tempNode4); freeThing(tempNode5); } if (floatingPointEvaluationAlreadyDone || evaluateThingToConstant(a, tempNode2, NULL, 1,0)) { freeThing(tempNode2); tempNode2 = makeConstant(a); } mpfr_clear(a); } tempNode3 = makeList(addElement(NULL,tempNode2)); setupRandomAccessOnLists(tempNode3); curr = tree->arguments; if (isPureTree(tempNode3) && isConstant(tempNode3)) { mpfr_init2(a, tools_precision); if (evaluateThingToConstant(a, tempNode3, NULL, 1,0)) { freeThing(tempNode3); tempNode3 = makeConstant(a); } mpfr_clear(a); } if (!assignThingToTable((accessThruMemRef((node *) (curr->value)))->string, tempNode3)) { printMessage(1,SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT,"Warning: the last assignment will have no effect.\n"); considerDyingOnError(); } freeThing(tempNode3); } else { printMessage(1,SOLLYA_MSG_ASSIGNMENT_OF_INDEXED_EMPTY_LIST_ONLY_ON_ZERO,"Warning: assigning to indexed elements of empty lists is only allowed on index 0.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { if (isString(tempNode)) { curr = tree->arguments; curr = curr->next; if (evaluateThingToInteger(&resB, (node *) (curr->value), NULL)) { if ((resB >= 0) && (resB <= (int)strlen(accessThruMemRef(tempNode)->string))) { curr = curr->next; if (evaluateThingToString(&tempString,accessThruMemRef((node *) (curr->value)))) { if (strlen(tempString) == 1) { if (resB == (int)strlen(accessThruMemRef(tempNode)->string)) { tempString2 = (char *) safeCalloc(resB + 2,sizeof(char)); strcpy(tempString2,accessThruMemRef(tempNode)->string); tempString2[resB] = tempString[0]; tempNode3 = makeString(tempString2); safeFree(tempString2); } else { tempNode3 = makeString(accessThruMemRef(tempNode)->string); (accessThruMemRef(tempNode3)->string)[resB] = tempString[0]; } curr = tree->arguments; if (isPureTree(tempNode3) && isConstant(tempNode3)) { mpfr_init2(a, tools_precision); if (evaluateThingToConstant(a, tempNode3, NULL, 1,0)) { freeThing(tempNode3); tempNode3 = makeConstant(a); } mpfr_clear(a); } if (!assignThingToTable(((node *) (curr->value))->string, tempNode3)) { printMessage(1,SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT,"Warning: the last assignment will have no effect.\n"); considerDyingOnError(); } freeThing(tempNode3); } else { printMessage(1,SOLLYA_MSG_STRING_NOT_OF_LENGTH_ONE,"Warning: the string to be assigned is not of length 1.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_ASSIGNMENT_OF_INDEXED_ELEMENTS_NOT_IN_RANGE,"Warning: assigning to indexed elements of strings is only allowed in the existing range.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { curr = tree->arguments; printMessage(1,SOLLYA_MSG_IDENTIFIER_NOT_BOUND_TO_LIST_OR_STRING,"Warning: the identifier \"%s\" is not assigned to a (empty) list or a string.\n", ((node *) (curr->value))->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"The command will not be executed.\n"); considerDyingOnError(); } } } freeThing(tempNode); } else { curr = tree->arguments; printMessage(1,SOLLYA_MSG_IDENTIFIER_NOT_ASSIGNED_TO,"Warning: the identifier \"%s\" is not assigned to.\n",((node *) (curr->value))->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_FIRST_ELMENT_OF_LEFT_SIDE_NOT_IDENTIFIER,"Warning: the first element of the left-hand side is not an identifier.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case ASSIGNMENTINSTRUCTURE: tempNode = evaluateThing(tree->child1); tempNode2 = getThingFromTable((char *) (tree->arguments->value), 1, NULL); tempNode3 = recomputeLeftHandSideForAssignmentInStructure(tempNode2, tempNode, tree->arguments->next); if (tempNode3 != NULL) { if (!assignThingToTable((char *) (tree->arguments->value), tempNode3)) { freeThing(tempNode); if (tempNode2 != NULL) freeThing(tempNode2); freeThing(tempNode3); printMessage(1,SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT,"Warning: the last assignment will have no effect.\n"); considerDyingOnError(); } else { freeThing(tempNode); if (tempNode2 != NULL) freeThing(tempNode2); freeThing(tempNode3); } } else { freeThing(tempNode); if (tempNode2 != NULL) freeThing(tempNode2); printMessage(1,SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT,"Warning: the last assignment will have no effect.\n"); considerDyingOnError(); } break; case FLOATASSIGNMENTINSTRUCTURE: tempNode = evaluateThing(tree->child1); if (isPureTree(tempNode) && isConstant(tempNode)) { mpfr_init2(a, tools_precision); floatingPointEvaluationAlreadyDone = 0; if (isPureTree(tempNode) && isConstant(tempNode) && ((accessThruMemRef(tree->child1)->nodeType == TABLEACCESSWITHSUBSTITUTE) || (accessThruMemRef(tree->child1)->nodeType == APPLY)) && (lengthChain(accessThruMemRef(tree->child1)->arguments) == 1)) { if (accessThruMemRef(tree->child1)->nodeType == APPLY) { tempNode2 = copyThing(accessThruMemRef(tree->child1)->child1); tempNode3 = copyThing(accessThruMemRef((node *) ((accessThruMemRef(tree->child1)->arguments)->value))); } else { tempNode2 = makeTableAccess(accessThruMemRef(tree->child1)->string); tempNode3 = copyThing(accessThruMemRef((node *) ((accessThruMemRef(tree->child1)->arguments)->value))); } tempNode4 = evaluateThing(tempNode2); tempNode5 = evaluateThing(tempNode3); if (isPureTree(tempNode4) && isPureTree(tempNode5) && (!isConstant(tempNode4)) && isConstant(tempNode5)) { tempNode6 = simplifyTreeErrorfree(tempNode5); if ((accessThruMemRef(tempNode6)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(tempNode6)->value))) { if (evaluateFaithful(a, tempNode4, *(accessThruMemRef(tempNode6)->value), tools_precision)) { floatingPointEvaluationAlreadyDone = 1; } } freeThing(tempNode6); } freeThing(tempNode2); freeThing(tempNode3); freeThing(tempNode4); freeThing(tempNode5); } if (floatingPointEvaluationAlreadyDone || evaluateThingToConstant(a, tempNode, NULL,1,0)) { freeThing(tempNode); tempNode = makeConstant(a); } mpfr_clear(a); } tempNode2 = getThingFromTable((char *) (tree->arguments->value), 1, NULL); tempNode3 = recomputeLeftHandSideForAssignmentInStructure(tempNode2, tempNode, tree->arguments->next); if (tempNode3 != NULL) { if (!assignThingToTable((char *) (tree->arguments->value), tempNode3)) { freeThing(tempNode); if (tempNode2 != NULL) freeThing(tempNode2); freeThing(tempNode3); printMessage(1,SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT,"Warning: the last assignment will have no effect.\n"); considerDyingOnError(); } else { freeThing(tempNode); if (tempNode2 != NULL) freeThing(tempNode2); freeThing(tempNode3); } } else { freeThing(tempNode); if (tempNode2 != NULL) freeThing(tempNode2); printMessage(1,SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT,"Warning: the last assignment will have no effect.\n"); considerDyingOnError(); } break; case PROTOASSIGNMENTINSTRUCTURE: if (tryToRewriteLeftHandStructAccess(&tempChain,tree->child1)) { tempNode = makeAssignmentInStructure(tempChain,copyThing(tree->child2)); res = executeCommand(tempNode); if (res) result = 1; freeThing(tempNode); } else { printMessage(1,SOLLYA_MSG_LEFT_HAND_SIDE_NOT_ELEMENT_OF_STRUCTURED_TYPE,"Warning: the left-hand side is not an access to an element of a structured type.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case PROTOFLOATASSIGNMENTINSTRUCTURE: if (tryToRewriteLeftHandStructAccess(&tempChain,tree->child1)) { tempNode = makeFloatAssignmentInStructure(tempChain,copyThing(tree->child2)); res = executeCommand(tempNode); if (res) result = 1; freeThing(tempNode); } else { printMessage(1,SOLLYA_MSG_LEFT_HAND_SIDE_NOT_ELEMENT_OF_STRUCTURED_TYPE,"Warning: the left-hand side is not an access to an element of a structured type.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case LIBRARYBINDING: if ((variablename != NULL) && (strcmp(variablename,tree->string) == 0)) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_LIBRARY,"Warning: the identifier \"%s\" is already be bound as the current free variable.\n",variablename); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to a library function. This command will have no effect.\n"); considerDyingOnError(); } else { if (containsEntry(symbolTable, tree->string) || containsDeclaredEntry(declaredSymbolTable, tree->string)) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_BOUND_TO_VAR_CANNOT_BE_LIBRARY,"Warning: the identifier \"%s\" is already assigned to.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to a library function. This command will have no effect.\n"); considerDyingOnError(); } else { if (getProcedure(tree->string) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_LIBRARY,"Warning: the identifier \"%s\" is already bound to an external procedure.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to a library function. This command will have no effect.\n"); considerDyingOnError(); } else { if (getFunction(tree->string) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_LIBRARY,"Warning: the identifier \"%s\" is already bound to a library function.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to a library function. This command will have no effect.\n"); considerDyingOnError(); } else { if (getConstantFunction(tree->string) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_LIBRARY,"Warning: the identifier \"%s\" is already bound to a library constant.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to a library function. This command will have no effect.\n"); considerDyingOnError(); } else { if (evaluateThingToString(&tempString, tree->child1)) { tempLibraryFunction = bindFunction(tempString, tree->string); if(tempLibraryFunction == NULL) { printMessage(1,SOLLYA_MSG_ERROR_OCCURRED_COMMAND_NOT_EXECUTED,"Warning: an error occurred. The last command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } } } } } break; case LIBRARYCONSTANTBINDING: if ((variablename != NULL) && (strcmp(variablename,tree->string) == 0)) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_LIBRARY,"Warning: the identifier \"%s\" is already bound as the current free variable.\n",variablename); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to a library constant. This command will have no effect.\n"); considerDyingOnError(); } else { if (containsEntry(symbolTable, tree->string) || containsDeclaredEntry(declaredSymbolTable, tree->string)) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_BOUND_TO_VAR_CANNOT_BE_LIBRARY,"Warning: the identifier \"%s\" is already assigned to.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to a library constant. This command will have no effect.\n"); considerDyingOnError(); } else { if (getProcedure(tree->string) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_LIBRARY,"Warning: the identifier \"%s\" is already bound to an external procedure.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to a library constant. This command will have no effect.\n"); considerDyingOnError(); } else { if (getFunction(tree->string) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_LIBRARY,"Warning: the identifier \"%s\" is already bound to a library function.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to a library constant. This command will have no effect.\n"); considerDyingOnError(); } else { if (getConstantFunction(tree->string) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_LIBRARY,"Warning: the identifier \"%s\" is already bound to a library constant.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"It cannot be bound to a library constant. This command will have no effect.\n"); considerDyingOnError(); } else { if (evaluateThingToString(&tempString, tree->child1)) { tempLibraryFunction = bindConstantFunction(tempString, tree->string); if(tempLibraryFunction == NULL) { printMessage(1,SOLLYA_MSG_ERROR_OCCURRED_COMMAND_NOT_EXECUTED,"Warning: an error occurred. The last command will have no effect.\n"); considerDyingOnError(); } safeFree(tempString); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING,"Warning: the expression given does not evaluate to a string.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } } } } } } break; case PRECASSIGN: defaultVal = DEFAULTPRECISION; if (evaluateThingToInteger(&resA, tree->child1, &defaultVal)) { if (resA < 12) { resA = 12; printMessage(1,SOLLYA_MSG_PREC_MUST_BE_AT_LEAST_TWELVE_BITS,"Warning: the precision of the tool must be at least 12 bits.\n"); } defaultprecision = resA; tools_precision = resA; outputMode(); sollyaPrintf("The precision has been set to %d bits.\n",resA); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case POINTSASSIGN: defaultVal = DEFAULTPOINTS; if (evaluateThingToInteger(&resA, tree->child1, &defaultVal)) { if (resA < 3) { resA = 3; printMessage(1,SOLLYA_MSG_POINTS_MUST_BE_AT_LEAST_THREE_POINTS,"Warning: the number of points must be at least 3 points.\n"); } defaultpoints = resA; outputMode(); sollyaPrintf("The number of points has been set to %d.\n",resA); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case DIAMASSIGN: mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); mpfr_set_d(b,DEFAULTDIAM,GMP_RNDN); if (evaluateThingToConstant(a, tree->child1, &b, 0,0)) { mpfr_clear(statediam); mpfr_init2(statediam,mpfr_get_prec(a)); mpfr_set(statediam,a,GMP_RNDN); outputMode(); sollyaPrintf("The diameter has been set to "); printMpfr(a); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_CONSTANT,"Warning: the expression given does not evaluate to a constant.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } mpfr_clear(a); mpfr_clear(b); break; case DISPLAYASSIGN: resB = 0; if (evaluateThingToDisplayMode(&resA, tree->child1, &resB)) { dyadic = resA; outputMode(); switch (dyadic) { case 0: sollyaPrintf("Display mode is decimal numbers.\n"); break; case 1: sollyaPrintf("Display mode is dyadic numbers.\n"); break; case 2: sollyaPrintf("Display mode is dyadic numbers in integer-power-of-2 notation.\n"); break; case 3: sollyaPrintf("Display mode is binary numbers.\n"); break; case 4: sollyaPrintf("Display mode is hexadecimal numbers.\n"); break; default: sollyaPrintf("Display mode in unknown state.\n"); } } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_DISPLAY_TYPE,"Warning: the expression given does not evaluate to default, dyadic, powers, hexadecimal or binary.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case VERBOSITYASSIGN: defaultVal = 1; if (evaluateThingToInteger(&resA, tree->child1, &defaultVal)) { if (resA < 0) { resA = 0; printMessage(1,SOLLYA_MSG_VERBOSITY_MUST_NOT_BE_NEGATIVE,"Warning: the verbosity of the tool must not be negative.\n"); } verbosity = resA; outputMode(); sollyaPrintf("The verbosity level has been set to %d.\n",resA); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case CANONICALASSIGN: defaultVal = 0; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { canonical = resA; outputMode(); if (canonical) sollyaPrintf("Canonical automatic printing output has been activated.\n"); else sollyaPrintf("Canonical automatic printing output has been deactivated.\n"); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case AUTOSIMPLIFYASSIGN: defaultVal = 1; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { autosimplify = resA; outputMode(); if (autosimplify) sollyaPrintf("Automatic pure tree simplification has been activated.\n"); else sollyaPrintf("Automatic pure tree simplification has been deactivated.\n"); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case SHOWMESSAGENUMBERSASSIGN: defaultVal = 1; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { activateMessageNumbers = resA; outputMode(); if (activateMessageNumbers) sollyaPrintf("Displaying of message numbers has been activated.\n"); else sollyaPrintf("Displaying of message numbers has been deactivated.\n"); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case TAYLORRECURSASSIGN: defaultVal = DEFAULTTAYLORRECURSIONS; if (evaluateThingToInteger(&resA, tree->child1, &defaultVal)) { if (resA < 0) { resA = 0; printMessage(1,SOLLYA_MSG_TAYLOR_RECURSIONS_MUST_NOT_BE_NEGATIVE,"Warning: the number of recursions for Taylor evaluation must not be negative.\n"); } taylorrecursions = resA; outputMode(); sollyaPrintf("The number of recursions for Taylor evaluation has been set to %d.\n",resA); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case TIMINGASSIGN: defaultVal = 0; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { timecounting = resA; outputMode(); if (timecounting) sollyaPrintf("Timing has been activated.\n"); else sollyaPrintf("Timing has been deactivated.\n"); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case FULLPARENASSIGN: defaultVal = 0; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { fullParentheses = resA; outputMode(); if (fullParentheses) sollyaPrintf("Full parentheses mode has been activated.\n"); else sollyaPrintf("Full parentheses mode has been deactivated.\n"); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case MIDPOINTASSIGN: defaultVal = 1; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { midpointMode = resA; outputMode(); if (midpointMode) sollyaPrintf("Midpoint mode has been activated.\n"); else sollyaPrintf("Midpoint mode has been deactivated.\n"); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case DIEONERRORMODEASSIGN: defaultVal = 1; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { dieOnErrorMode = resA; outputMode(); if (dieOnErrorMode) sollyaPrintf("Die-on-error mode has been activated.\n"); else sollyaPrintf("Die-on-error mode has been deactivated.\n"); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case RATIONALMODEASSIGN: defaultVal = 0; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { rationalMode = resA; outputMode(); if (rationalMode) sollyaPrintf("Rational mode has been activated.\n"); else sollyaPrintf("Rational mode has been deactivated.\n"); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case SUPPRESSWARNINGSASSIGN: defaultVal = eliminatePromptBackup; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { noRoundingWarnings = !resA; outputMode(); if (noRoundingWarnings) sollyaPrintf("Rounding warning mode has been deactivated.\n"); else sollyaPrintf("Rounding warning mode has been activated.\n"); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case HOPITALRECURSASSIGN: defaultVal = DEFAULTHOPITALRECURSIONS; if (evaluateThingToInteger(&resA, tree->child1, &defaultVal)) { if (resA < 0) { resA = 0; printMessage(1,SOLLYA_MSG_HOPITAL_RECURSIONS_MUST_NOT_BE_NEGATIVE,"Warning: the number of recursions for Hopital's rule must not be negative.\n"); } hopitalrecursions = resA; outputMode(); sollyaPrintf("The number of recursions for Hopital's rule has been set to %d.\n",resA); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case PRECSTILLASSIGN: defaultVal = DEFAULTPRECISION; if (evaluateThingToInteger(&resA, tree->child1, &defaultVal)) { if (resA < 12) { resA = 12; printMessage(2,SOLLYA_MSG_PREC_MUST_BE_AT_LEAST_TWELVE_BITS,"Warning: the precision of the tool must be at least 12 bits.\n"); } defaultprecision = resA; tools_precision = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case POINTSSTILLASSIGN: defaultVal = DEFAULTPOINTS; if (evaluateThingToInteger(&resA, tree->child1, &defaultVal)) { if (resA < 3) { resA = 3; printMessage(2,SOLLYA_MSG_POINTS_MUST_BE_AT_LEAST_THREE_POINTS,"Warning: the number of points must be at least 3 points.\n"); } defaultpoints = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case DIAMSTILLASSIGN: mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); mpfr_set_d(b,DEFAULTDIAM,GMP_RNDN); if (evaluateThingToConstant(a, tree->child1, &b, 0,0)) { mpfr_clear(statediam); mpfr_init2(statediam,mpfr_get_prec(a)); mpfr_set(statediam,a,GMP_RNDN); } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_CONSTANT,"Warning: the expression given does not evaluate to a constant.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } mpfr_clear(a); mpfr_clear(b); break; case DISPLAYSTILLASSIGN: resB = 0; if (evaluateThingToDisplayMode(&resA, tree->child1, &resB)) { dyadic = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_DISPLAY_TYPE,"Warning: the expression given does not evaluate to default, dyadic, powers, hexadecimal or binary.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case VERBOSITYSTILLASSIGN: defaultVal = 1; if (evaluateThingToInteger(&resA, tree->child1, &defaultVal)) { if (resA < 0) { resA = 0; printMessage(2,SOLLYA_MSG_VERBOSITY_MUST_NOT_BE_NEGATIVE,"Warning: the verbosity of the tool must not be negative.\n"); } verbosity = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case CANONICALSTILLASSIGN: defaultVal = 0; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { canonical = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case AUTOSIMPLIFYSTILLASSIGN: defaultVal = 1; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { autosimplify = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case SHOWMESSAGENUMBERSSTILLASSIGN: defaultVal = 1; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { activateMessageNumbers = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case TAYLORRECURSSTILLASSIGN: defaultVal = DEFAULTTAYLORRECURSIONS; if (evaluateThingToInteger(&resA, tree->child1, &defaultVal)) { if (resA < 0) { resA = 0; printMessage(2,SOLLYA_MSG_TAYLOR_RECURSIONS_MUST_NOT_BE_NEGATIVE,"Warning: the number of recursions for Taylor evaluation must not be negative.\n"); } taylorrecursions = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case TIMINGSTILLASSIGN: defaultVal = 0; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { timecounting = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case FULLPARENSTILLASSIGN: defaultVal = 0; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { fullParentheses = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case MIDPOINTSTILLASSIGN: defaultVal = 1; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { midpointMode = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case DIEONERRORMODESTILLASSIGN: defaultVal = 1; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { dieOnErrorMode = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case RATIONALMODESTILLASSIGN: defaultVal = 0; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { rationalMode = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case SUPPRESSWARNINGSSTILLASSIGN: defaultVal = eliminatePromptBackup; if (evaluateThingToOnOff(&resA, tree->child1, &defaultVal)) { noRoundingWarnings = !resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF,"Warning: the expression given does not evaluate to on or off.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; case HOPITALRECURSSTILLASSIGN: defaultVal = DEFAULTHOPITALRECURSIONS; if (evaluateThingToInteger(&resA, tree->child1, &defaultVal)) { if (resA < 0) { resA = 0; printMessage(2,SOLLYA_MSG_HOPITAL_RECURSIONS_MUST_NOT_BE_NEGATIVE,"Warning: the number of recursions for Hopital's rule must not be negative.\n"); } hopitalrecursions = resA; } else { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: the expression given does not evaluate to a machine integer.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command will have no effect.\n"); considerDyingOnError(); } break; default: sollyaFprintf(stderr,"Error: executeCommand: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } if (timingString != NULL) { popTimeCounter(timingString); safeFree(timingString); } return result; } node *makeCommandList(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = COMMANDLIST; res->arguments = thinglist; return res; } node *makeWhile(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = WHILE; res->child1 = thing1; res->child2 = thing2; return res; } node *makeIfElse(node *thing1, node *thing2, node *thing3) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = IFELSE; res->arguments = addElement(addElement(addElement(NULL, thing3), thing2), thing1); return res; } node *makeIf(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = IF; res->child1 = thing1; res->child2 = thing2; return res; } node *makeFor(char *string, node *thing1, node *thing2, node *thing3, node *thing4) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FOR; res->string = (char *) safeCalloc(strlen(string) + 1,sizeof(char)); strcpy(res->string, string); res->arguments = addElement(addElement(addElement(addElement(NULL, thing4), thing3), thing2), thing1); return res; } node *makeForIn(char *string, node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FORIN; res->child1 = thing1; res->child2 = thing2; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeQuit() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = QUIT; return res; } node *makeNop() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = NOP; return res; } node *makeNopArg(node *thing1) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = NOPARG; res->child1 = thing1; return res; } node *makeFalseQuit() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FALSEQUIT; return res; } node *makeFalseRestart() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FALSERESTART; return res; } node *makeRestart() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = RESTART; return res; } node *makePrint(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PRINT; res->arguments = thinglist; return res; } node *makeSuppressMessage(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SUPPRESSMESSAGE; res->arguments = thinglist; return res; } node *makeUnsuppressMessage(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = UNSUPPRESSMESSAGE; res->arguments = thinglist; return res; } node *makeVariableDeclaration(chain *stringlist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = VARIABLEDECLARATION; res->arguments = stringlist; return res; } node *makePrintXml(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PRINTXML; res->child1 = thing; return res; } node *makePrintXmlNewFile(node *thing, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PRINTXMLNEWFILE; res->child1 = thing; res->child2 = thing2; return res; } node *makePrintXmlAppendFile(node *thing, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PRINTXMLAPPENDFILE; res->child1 = thing; res->child2 = thing2; return res; } node *makeNewFilePrint(node *thing, chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = NEWFILEPRINT; res->arguments = thinglist; res->child1 = thing; return res; } node *makeAppendFilePrint(node *thing, chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = APPENDFILEPRINT; res->arguments = thinglist; res->child1 = thing; return res; } node *makePlot(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PLOT; res->arguments = thinglist; return res; } node *makePrintHexa(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PRINTHEXA; res->child1 = thing; return res; } node *makePrintFloat(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PRINTFLOAT; res->child1 = thing; return res; } node *makePrintBinary(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PRINTBINARY; res->child1 = thing; return res; } node *makePrintExpansion(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PRINTEXPANSION; res->child1 = thing; return res; } node *makeBashExecute(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = BASHEXECUTE; res->child1 = thing; return res; } node *makeExternalPlot(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = EXTERNALPLOT; res->arguments = thinglist; return res; } node *makeWrite(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = WRITE; res->arguments = thinglist; return res; } node *makeNewFileWrite(node *thing, chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = NEWFILEWRITE; res->child1 = thing; res->arguments = thinglist; return res; } node *makeAppendFileWrite(node *thing, chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = APPENDFILEWRITE; res->child1 = thing; res->arguments = thinglist; return res; } node *makeAsciiPlot(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ASCIIPLOT; res->child1 = thing1; res->child2 = thing2; return res; } node *makeWorstCase(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = WORSTCASE; res->arguments = thinglist; return res; } node *makeRename(char *string1, char *string2) { node *res; char *tempString; res = (node *) safeMalloc(sizeof(node)); res->nodeType = RENAME; res->string = (char *) safeCalloc(strlen(string1) + 1, sizeof(char)); strcpy(res->string,string1); tempString = (char *) safeCalloc(strlen(string2) + 1, sizeof(char)); strcpy(tempString,string2); res->arguments = addElement(NULL,tempString); return res; } node *makeAutoprint(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = AUTOPRINT; res->arguments = thinglist; return res; } node *makeAssignment(char *string, node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ASSIGNMENT; res->child1 = thing; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeFloatAssignment(char *string, node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FLOATASSIGNMENT; res->child1 = thing; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeExternalProc(char *string, node *thing, chain *typelist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = EXTERNALPROC; res->child1 = thing; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); res->arguments = typelist; return res; } node *makeLibraryBinding(char *string, node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = LIBRARYBINDING; res->child1 = thing; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeLibraryConstantBinding(char *string, node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = LIBRARYCONSTANTBINDING; res->child1 = thing; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makePrecAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PRECASSIGN; res->child1 = thing; return res; } node *makeProcedureFunction(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PROCEDUREFUNCTION; res->libFunDeriv = 0; res->child2 = thing; res->child1 = makeVariable(); return res; } node *makePointsAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = POINTSASSIGN; res->child1 = thing; return res; } node *makeDiamAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DIAMASSIGN; res->child1 = thing; return res; } node *makeDisplayAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DISPLAYASSIGN; res->child1 = thing; return res; } node *makeVerbosityAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = VERBOSITYASSIGN; res->child1 = thing; return res; } node *makeCanonicalAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = CANONICALASSIGN; res->child1 = thing; return res; } node *makeAutoSimplifyAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = AUTOSIMPLIFYASSIGN; res->child1 = thing; return res; } node *makeShowMessageNumbersAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SHOWMESSAGENUMBERSASSIGN; res->child1 = thing; return res; } node *makeTaylorRecursAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TAYLORRECURSASSIGN; res->child1 = thing; return res; } node *makeTimingAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TIMINGASSIGN; res->child1 = thing; return res; } node *makeTime(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TIME; res->child1 = thing; return res; } node *makeFullParenAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FULLPARENASSIGN; res->child1 = thing; return res; } node *makeMidpointAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = MIDPOINTASSIGN; res->child1 = thing; return res; } node *makeDieOnErrorAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DIEONERRORMODEASSIGN; res->child1 = thing; return res; } node *makeRationalModeAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = RATIONALMODEASSIGN; res->child1 = thing; return res; } node *makeSuppressWarningsAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SUPPRESSWARNINGSASSIGN; res->child1 = thing; return res; } node *makeHopitalRecursAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = HOPITALRECURSASSIGN; res->child1 = thing; return res; } node *makePrecStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PRECSTILLASSIGN; res->child1 = thing; return res; } node *makePointsStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = POINTSSTILLASSIGN; res->child1 = thing; return res; } node *makeDiamStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DIAMSTILLASSIGN; res->child1 = thing; return res; } node *makeDisplayStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DISPLAYSTILLASSIGN; res->child1 = thing; return res; } node *makeVerbosityStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = VERBOSITYSTILLASSIGN; res->child1 = thing; return res; } node *makeCanonicalStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = CANONICALSTILLASSIGN; res->child1 = thing; return res; } node *makeAutoSimplifyStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = AUTOSIMPLIFYSTILLASSIGN; res->child1 = thing; return res; } node *makeShowMessageNumbersStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SHOWMESSAGENUMBERSSTILLASSIGN; res->child1 = thing; return res; } node *makeTaylorRecursStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TAYLORRECURSSTILLASSIGN; res->child1 = thing; return res; } node *makeTimingStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TIMINGSTILLASSIGN; res->child1 = thing; return res; } node *makeFullParenStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FULLPARENSTILLASSIGN; res->child1 = thing; return res; } node *makeMidpointStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = MIDPOINTSTILLASSIGN; res->child1 = thing; return res; } node *makeDieOnErrorStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DIEONERRORMODESTILLASSIGN; res->child1 = thing; return res; } node *makeRationalModeStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = RATIONALMODESTILLASSIGN; res->child1 = thing; return res; } node *makeSuppressWarningsStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SUPPRESSWARNINGSSTILLASSIGN; res->child1 = thing; return res; } node *makeHopitalRecursStillAssign(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = HOPITALRECURSSTILLASSIGN; res->child1 = thing; return res; } node *makeAnd(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = AND; res->child1 = thing1; res->child2 = thing2; return res; } node *makeOr(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = OR; res->child1 = thing1; res->child2 = thing2; return res; } node *makeNegation(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = NEGATION; res->child1 = thing; return res; } node *makeIndex(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = INDEX; res->child1 = thing1; res->child2 = thing2; return res; } node *makeMatch(node *thing, chain *matchlist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = MATCH; res->child1 = thing; res->arguments = matchlist; return res; } node *makeCompareEqual(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = COMPAREEQUAL; res->child1 = thing1; res->child2 = thing2; return res; } node *makeCompareIn(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = COMPAREIN; res->child1 = thing1; res->child2 = thing2; return res; } node *makeCompareLess(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = COMPARELESS; res->child1 = thing1; res->child2 = thing2; return res; } node *makeCompareGreater(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = COMPAREGREATER; res->child1 = thing1; res->child2 = thing2; return res; } node *makeCompareLessEqual(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = COMPARELESSEQUAL; res->child1 = thing1; res->child2 = thing2; return res; } node *makeCompareGreaterEqual(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = COMPAREGREATEREQUAL; res->child1 = thing1; res->child2 = thing2; return res; } node *makeCompareNotEqual(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = COMPARENOTEQUAL; res->child1 = thing1; res->child2 = thing2; return res; } node *makeConcat(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = CONCAT; res->child1 = thing1; res->child2 = thing2; return res; } node *makeAddToList(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ADDTOLIST; res->child1 = thing1; res->child2 = thing2; return res; } node *makePrepend(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PREPEND; res->child1 = thing1; res->child2 = thing2; return res; } node *makeAppend(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = APPEND; res->child1 = thing1; res->child2 = thing2; return res; } node *makeOn() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ON; return res; } node *makeOff() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = OFF; return res; } node *makeDyadic() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DYADIC; return res; } node *makePowers() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = POWERS; return res; } node *makeBinaryThing() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = BINARY; return res; } node *makeHexadecimalThing() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = HEXADECIMAL; return res; } node *makeFile() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FILESYM; return res; } node *makePostscript() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = POSTSCRIPT; return res; } node *makePostscriptFile() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = POSTSCRIPTFILE; return res; } node *makePerturb() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PERTURB; return res; } node *makeRoundDown() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ROUNDDOWN; return res; } node *makeRoundUp() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ROUNDUP; return res; } node *makeRoundToZero() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ROUNDTOZERO; return res; } node *makeRoundToNearest() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ROUNDTONEAREST; return res; } node *makeHonorCoeff() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = HONORCOEFF; return res; } node *makeTrue() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TRUE; return res; } node *makeUnit() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = UNIT; return res; } node *makeFalse() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FALSE; return res; } node *makeDefault() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DEFAULT; return res; } node *makeDecimal() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DECIMAL; return res; } node *makeAbsolute() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ABSOLUTESYM; return res; } node *makeRelative() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = RELATIVESYM; return res; } node *makeFixed() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FIXED; return res; } node *makeFloating() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FLOATING; return res; } node *makeError() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ERRORSPECIAL; return res; } node *makeDoubleSymbol() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DOUBLESYMBOL; return res; } node *makeSingleSymbol() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SINGLESYMBOL; return res; } node *makeHalfPrecisionSymbol() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = HALFPRECISIONSYMBOL; return res; } node *makeQuadSymbol() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = QUADSYMBOL; return res; } node *makeDoubleextendedSymbol() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DOUBLEEXTENDEDSYMBOL; return res; } node *makeDoubleDoubleSymbol() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DOUBLEDOUBLESYMBOL; return res; } node *makeTripleDoubleSymbol() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TRIPLEDOUBLESYMBOL; return res; } node *makeString(char *string) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = STRING; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeTableAccess(char *string) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TABLEACCESS; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeIsBound(char *string) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ISBOUND; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeTableAccessWithSubstitute(char *string, chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TABLEACCESSWITHSUBSTITUTE; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); res->arguments = thinglist; return res; } node *makeStructAccess(node *thing, char *string) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = STRUCTACCESS; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); res->child1 = thing; return res; } node *makeApply(node *thing, chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = APPLY; res->child1 = thing; res->arguments = thinglist; return res; } node *makeDecimalConstant(char *string) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DECIMALCONSTANT; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeMidpointConstant(char *string) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = MIDPOINTCONSTANT; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeDyadicConstant(char *string) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DYADICCONSTANT; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeHexConstant(char *string) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = HEXCONSTANT; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeHexadecimalConstant(char *string) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = HEXADECIMALCONSTANT; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeBinaryConstant(char *string) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = BINARYCONSTANT; res->string = (char *) safeCalloc(strlen(string) + 1, sizeof(char)); strcpy(res->string, string); return res; } node *makeEmptyList() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = EMPTYLIST; return res; } node *makeList(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = LIST; res->arguments = thinglist; res->argArray = NULL; res->argArraySize = 0; res->argArrayAllocSize = 0; return res; } node *makeStructure(chain *assoclist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = STRUCTURE; res->arguments = assoclist; return res; } node *makeRevertedStructure(chain *assoclist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = STRUCTURE; res->arguments = copyChain(assoclist,copyEntryOnVoid); freeChain(assoclist,freeEntryOnVoid); return res; } node *makeRevertedList(chain *thinglist) { node *res; chain *tempList; res = (node *) safeMalloc(sizeof(node)); res->nodeType = LIST; tempList = copyChain(thinglist,copyThingOnVoid); freeChain(thinglist,freeThingOnVoid); res->arguments = tempList; res->argArray = NULL; res->argArraySize = 0; res->argArrayAllocSize = 0; return res; } node *makeFinalEllipticList(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FINALELLIPTICLIST; res->arguments = thinglist; res->argArray = NULL; res->argArraySize = 0; res->argArrayAllocSize = 0; return res; } node *makeRevertedFinalEllipticList(chain *thinglist) { node *res; chain *tempList; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FINALELLIPTICLIST; tempList = copyChain(thinglist,copyThingOnVoid); freeChain(thinglist,freeThingOnVoid); res->arguments = tempList; res->argArray = NULL; res->argArraySize = 0; res->argArrayAllocSize = 0; return res; } node *makeElliptic() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ELLIPTIC; return res; } node *makeRange(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = RANGE; res->child1 = thing1; res->child2 = thing2; return res; } node *makeDeboundMax(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DEBOUNDMAX; res->child1 = thing; return res; } node *makeEvalConst(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = EVALCONST; res->child1 = thing; return res; } node *makeDeboundMin(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DEBOUNDMIN; res->child1 = thing; return res; } node *makeDeboundMid(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DEBOUNDMID; res->child1 = thing; return res; } node *makeDiff(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DIFF; res->child1 = thing; return res; } node *makeDirtysimplify(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DIRTYSIMPLIFY; res->child1 = thing; return res; } node *makeRemez(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = REMEZ; res->arguments = thinglist; return res; } node *makeAnnotateFunction(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ANNOTATEFUNCTION; res->arguments = thinglist; return res; } node *makeBind(node *thing1, char *string1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = BIND; res->child1 = thing1; res->child2 = thing2; res->string = (char *) safeCalloc(strlen(string1) + 1, sizeof(char)); strcpy(res->string, string1); return res; } node *makeMax(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = MAX; res->arguments = thinglist; return res; } node *makeMin(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = MIN; res->arguments = thinglist; return res; } node *makeFPminimax(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FPMINIMAX; res->arguments = thinglist; return res; } node *makeHorner(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = HORNER; res->child1 = thing; return res; } node *makeCanonicalThing(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = CANONICAL; res->child1 = thing; return res; } node *makeExpand(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = EXPAND; res->child1 = thing; return res; } node *makeSimplifySafe(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SIMPLIFYSAFE; res->child1 = thing; return res; } node *makeTaylor(node *thing1, node *thing2, node *thing3) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TAYLOR; res->arguments = addElement(addElement(addElement(NULL, thing3), thing2), thing1); return res; } node *makeTaylorform(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TAYLORFORM; res->arguments = thinglist; return res; } node *makeChebyshevform(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = CHEBYSHEVFORM; res->arguments = thinglist; return res; } node *makeAutodiff(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = AUTODIFF; res->arguments = thinglist; return res; } node *makeDegree(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DEGREE; res->child1 = thing; return res; } node *makeNumerator(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = NUMERATOR; res->child1 = thing; return res; } node *makeDenominator(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DENOMINATOR; res->child1 = thing; return res; } node *makeSubstitute(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SUBSTITUTE; res->child1 = thing1; res->child2 = thing2; return res; } node *makeComposePolynomials(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = COMPOSEPOLYNOMIALS; res->child1 = thing1; res->child2 = thing2; return res; } node *makeCoeff(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = COEFF; res->child1 = thing1; res->child2 = thing2; return res; } node *makeSubpoly(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SUBPOLY; res->child1 = thing1; res->child2 = thing2; return res; } node *makeRoundcoefficients(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ROUNDCOEFFICIENTS; res->child1 = thing1; res->child2 = thing2; return res; } node *makeRationalapprox(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = RATIONALAPPROX; res->child1 = thing1; res->child2 = thing2; return res; } node *makeAccurateInfnorm(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ACCURATEINFNORM; res->arguments = thinglist; return res; } node *makeRoundToFormat(node *thing1, node *thing2, node *thing3) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ROUNDTOFORMAT; res->arguments = addElement(addElement(addElement(NULL, thing3), thing2), thing1); return res; } node *makeEvaluate(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = EVALUATE; res->child1 = thing1; res->child2 = thing2; return res; } node *makeParse(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PARSE; res->child1 = thing; return res; } node *makeReadXml(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = READXML; res->child1 = thing; return res; } node *makeExecute(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = EXECUTE; res->child1 = thing; return res; } node *makeInfnorm(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = INFNORM; res->arguments = thinglist; return res; } node *makeSupnorm(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SUPNORM; res->arguments = thinglist; return res; } node *makeFindZeros(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FINDZEROS; res->child1 = thing1; res->child2 = thing2; return res; } node *makeFPFindZeros(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FPFINDZEROS; res->child1 = thing1; res->child2 = thing2; return res; } node *makeDirtyInfnorm(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DIRTYINFNORM; res->child1 = thing1; res->child2 = thing2; return res; } node *makeNumberRoots(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = NUMBERROOTS; res->child1 = thing1; res->child2 = thing2; return res; } node *makeIntegral(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = INTEGRAL; res->child1 = thing1; res->child2 = thing2; return res; } node *makeDirtyIntegral(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DIRTYINTEGRAL; res->child1 = thing1; res->child2 = thing2; return res; } node *makeImplementPoly(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = IMPLEMENTPOLY; res->arguments = thinglist; return res; } node *makeImplementConst(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = IMPLEMENTCONST; res->arguments = thinglist; return res; } node *makeCheckInfnorm(node *thing1, node *thing2, node *thing3) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = CHECKINFNORM; res->arguments = addElement(addElement(addElement(NULL, thing3), thing2), thing1); return res; } node *makeZeroDenominators(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ZERODENOMINATORS; res->child1 = thing1; res->child2 = thing2; return res; } node *makeIsEvaluable(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ISEVALUABLE; res->child1 = thing1; res->child2 = thing2; return res; } node *makeSearchGal(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SEARCHGAL; res->arguments = thinglist; return res; } node *makeGuessDegree(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = GUESSDEGREE; res->arguments = thinglist; return res; } node *makeDirtyFindZeros(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DIRTYFINDZEROS; res->child1 = thing1; res->child2 = thing2; return res; } node *makeHead(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = HEAD; res->child1 = thing; return res; } node *makeRoundCorrectly(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ROUNDCORRECTLY; res->child1 = thing; return res; } node *makeReadFile(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = READFILE; res->child1 = thing; return res; } node *makeBashevaluate(chain *thinglist) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = BASHEVALUATE; res->arguments = thinglist; return res; } node *makeGetSuppressedMessages() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = GETSUPPRESSEDMESSAGES; return res; } node *makeGetBacktrace() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = GETBACKTRACE; return res; } node *makeRevert(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = REVERT; res->child1 = thing; return res; } node *makeSort(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SORT; res->child1 = thing; return res; } node *makeMantissa(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = MANTISSA; res->child1 = thing; return res; } node *makeExponent(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = EXPONENT; res->child1 = thing; return res; } node *makePrecision(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PRECISION; res->child1 = thing; return res; } node *makeTail(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TAIL; res->child1 = thing; return res; } node *makeLength(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = LENGTH; res->child1 = thing; return res; } node *makeObjectName(node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = OBJECTNAME; res->child1 = thing; return res; } node *makeExternalProcedureUsage(libraryProcedure *proc) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = EXTERNALPROCEDUREUSAGE; res->libProc = proc; return res; } node *makeProc(chain *stringlist, node *body, node *returnVal) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PROC; res->arguments = stringlist; res->child1 = body; res->child2 = returnVal; return res; } node *makeMatchElement(node *matcher, node *commands, node *returnVal) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = MATCHELEMENT; res->arguments = addElement(NULL,commands); res->child1 = matcher; res->child2 = returnVal; return res; } node *makeProcIllim(char *arg, node *body, node *returnVal) { node *res; chain *argList; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PROCILLIM; argList = addElement(NULL,arg); res->arguments = argList; res->child1 = body; res->child2 = returnVal; return res; } node *makePrecDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PRECDEREF; return res; } node *makePointsDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = POINTSDEREF; return res; } node *makeDiamDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DIAMDEREF; return res; } node *makeDisplayDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DISPLAYDEREF; return res; } node *makeVerbosityDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = VERBOSITYDEREF; return res; } node *makeCanonicalDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = CANONICALDEREF; return res; } node *makeAutoSimplifyDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = AUTOSIMPLIFYDEREF; return res; } node *makeShowMessageNumbersDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SHOWMESSAGENUMBERSDEREF; return res; } node *makeTaylorRecursDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TAYLORRECURSDEREF; return res; } node *makeTimingDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = TIMINGDEREF; return res; } node *makeFullParenDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FULLPARENDEREF; return res; } node *makeMidpointDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = MIDPOINTDEREF; return res; } node *makeDieOnErrorDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = DIEONERRORMODEDEREF; return res; } node *makeRationalModeDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = RATIONALMODEDEREF; return res; } node *makeSuppressWarningsDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = SUPPRESSWARNINGSDEREF; return res; } node *makeHopitalRecursDeref() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = HOPITALRECURSDEREF; return res; } node *makeAssignmentInIndexing(node *thing1, node *thing2, node *thing3) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ASSIGNMENTININDEXING; res->arguments = addElement(addElement(addElement(NULL,thing3),thing2),thing1); return res; } node *makeFloatAssignmentInIndexing(node *thing1, node *thing2, node *thing3) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FLOATASSIGNMENTININDEXING; res->arguments = addElement(addElement(addElement(NULL,thing3),thing2),thing1); return res; } node *makeAssignmentInStructure(chain *idents, node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = ASSIGNMENTINSTRUCTURE; res->arguments = idents; res->child1 = thing; return res; } node *makeFloatAssignmentInStructure(chain *idents, node *thing) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = FLOATASSIGNMENTINSTRUCTURE; res->arguments = idents; res->child1 = thing; return res; } node *makeProtoAssignmentInStructure(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PROTOASSIGNMENTINSTRUCTURE; res->child1 = thing1; res->child2 = thing2; return res; } node *makeProtoFloatAssignmentInStructure(node *thing1, node *thing2) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PROTOFLOATASSIGNMENTINSTRUCTURE; res->child1 = thing1; res->child2 = thing2; return res; } void freeThingOnVoid(void *tree) { freeThing((node *) tree); } void freeThing(node *tree) { if (tree == NULL) return; if (tree->nodeType == MEMREF) { tree->libFunDeriv--; if (tree->libFunDeriv < 1) { if (tree->simplifyCache != NULL) { freeThing(tree->simplifyCache); tree->simplifyCache = NULL; } if (tree->hornerCache != NULL) { freeThing(tree->hornerCache); tree->hornerCache = NULL; } if (tree->derivCache != NULL) { freeThing(tree->derivCache); tree->derivCache = NULL; } if (tree->derivUnsimplCache != NULL) { freeThing(tree->derivUnsimplCache); tree->derivUnsimplCache = NULL; } freeEvaluationHook(&(tree->evaluationHook)); if (tree->child1 != NULL) freeThing(tree->child1); if (tree->polynomialRepresentation != NULL) polynomialFree(tree->polynomialRepresentation); if (tree->arguments != NULL) { sollya_mpfi_clear(*((sollya_mpfi_t *) tree->arguments->next->value)); safeFree(tree->arguments->next->value); safeFree(tree->arguments->next); safeFree(tree->arguments->value); safeFree(tree->arguments); } if (tree->evalCacheX != NULL) { sollya_mpfi_clear(*(tree->evalCacheX)); safeFree(tree->evalCacheX); } if (tree->evalCacheY != NULL) { sollya_mpfi_clear(*(tree->evalCacheY)); safeFree(tree->evalCacheY); } if (tree->pointEvalCacheX != NULL) { mpfr_clear(*(tree->pointEvalCacheX)); safeFree(tree->pointEvalCacheX); } if (tree->pointEvalCacheY != NULL) { mpfr_clear(*(tree->pointEvalCacheY)); safeFree(tree->pointEvalCacheY); } safeFree(tree); } return; } switch (tree->nodeType) { case VARIABLE: safeFree(tree); break; case CONSTANT: mpfr_clear(*(tree->value)); safeFree(tree->value); safeFree(tree); break; case ADD: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case SUB: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case MUL: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case DIV: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case SQRT: freeThing(tree->child1); safeFree(tree); break; case EXP: freeThing(tree->child1); safeFree(tree); break; case LOG: freeThing(tree->child1); safeFree(tree); break; case LOG_2: freeThing(tree->child1); safeFree(tree); break; case LOG_10: freeThing(tree->child1); safeFree(tree); break; case SIN: freeThing(tree->child1); safeFree(tree); break; case COS: freeThing(tree->child1); safeFree(tree); break; case TAN: freeThing(tree->child1); safeFree(tree); break; case ASIN: freeThing(tree->child1); safeFree(tree); break; case ACOS: freeThing(tree->child1); safeFree(tree); break; case ATAN: freeThing(tree->child1); safeFree(tree); break; case SINH: freeThing(tree->child1); safeFree(tree); break; case COSH: freeThing(tree->child1); safeFree(tree); break; case TANH: freeThing(tree->child1); safeFree(tree); break; case ASINH: freeThing(tree->child1); safeFree(tree); break; case ACOSH: freeThing(tree->child1); safeFree(tree); break; case ATANH: freeThing(tree->child1); safeFree(tree); break; case POW: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case NEG: freeThing(tree->child1); safeFree(tree); break; case ABS: freeThing(tree->child1); safeFree(tree); break; case DOUBLE: freeThing(tree->child1); safeFree(tree); break; case SINGLE: freeThing(tree->child1); safeFree(tree); break; case HALFPRECISION: freeThing(tree->child1); safeFree(tree); break; case QUAD: freeThing(tree->child1); safeFree(tree); break; case DOUBLEDOUBLE: freeThing(tree->child1); safeFree(tree); break; case TRIPLEDOUBLE: freeThing(tree->child1); safeFree(tree); break; case ERF: freeThing(tree->child1); safeFree(tree); break; case ERFC: freeThing(tree->child1); safeFree(tree); break; case LOG_1P: freeThing(tree->child1); safeFree(tree); break; case EXP_M1: freeThing(tree->child1); safeFree(tree); break; case DOUBLEEXTENDED: freeThing(tree->child1); safeFree(tree); break; case LIBRARYFUNCTION: freeThing(tree->child1); safeFree(tree); break; case LIBRARYCONSTANT: safeFree(tree); break; case PROCEDUREFUNCTION: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case CEIL: freeThing(tree->child1); safeFree(tree); break; case FLOOR: freeThing(tree->child1); safeFree(tree); break; case NEARESTINT: freeThing(tree->child1); safeFree(tree); break; case PI_CONST: safeFree(tree); break; case COMMANDLIST: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case WHILE: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case IFELSE: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case IF: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case FOR: safeFree(tree->string); freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case FORIN: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree->string); safeFree(tree); break; case QUIT: safeFree(tree); break; case NOP: safeFree(tree); break; case NOPARG: freeThing(tree->child1); safeFree(tree); break; case FALSEQUIT: safeFree(tree); break; case FALSERESTART: safeFree(tree); break; case RESTART: safeFree(tree); break; case PRINT: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case SUPPRESSMESSAGE: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case UNSUPPRESSMESSAGE: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case VARIABLEDECLARATION: freeChain(tree->arguments, safeFree); safeFree(tree); break; case NEWFILEPRINT: freeChain(tree->arguments, freeThingOnVoid); freeThing(tree->child1); safeFree(tree); break; case APPENDFILEPRINT: freeChain(tree->arguments, freeThingOnVoid); freeThing(tree->child1); safeFree(tree); break; case PLOT: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case PRINTHEXA: freeThing(tree->child1); safeFree(tree); break; case PRINTFLOAT: freeThing(tree->child1); safeFree(tree); break; case PRINTBINARY: freeThing(tree->child1); safeFree(tree); break; case PRINTEXPANSION: freeThing(tree->child1); safeFree(tree); break; case BASHEXECUTE: freeThing(tree->child1); safeFree(tree); break; case EXTERNALPLOT: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case WRITE: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case NEWFILEWRITE: freeChain(tree->arguments, freeThingOnVoid); freeThing(tree->child1); safeFree(tree); break; case APPENDFILEWRITE: freeChain(tree->arguments, freeThingOnVoid); freeThing(tree->child1); safeFree(tree); break; case ASCIIPLOT: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case PRINTXML: freeThing(tree->child1); safeFree(tree); break; case PRINTXMLNEWFILE: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case PRINTXMLAPPENDFILE: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case WORSTCASE: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case RENAME: safeFree(tree->string); freeChain(tree->arguments, safeFree); safeFree(tree); break; case AUTOPRINT: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case ASSIGNMENT: freeThing(tree->child1); safeFree(tree->string); safeFree(tree); break; case FLOATASSIGNMENT: freeThing(tree->child1); safeFree(tree->string); safeFree(tree); break; case EXTERNALPROC: freeThing(tree->child1); safeFree(tree->string); freeChain(tree->arguments, freeIntPtr); safeFree(tree); break; case LIBRARYBINDING: freeThing(tree->child1); safeFree(tree->string); safeFree(tree); break; case LIBRARYCONSTANTBINDING: freeThing(tree->child1); safeFree(tree->string); safeFree(tree); break; case PRECASSIGN: freeThing(tree->child1); safeFree(tree); break; case POINTSASSIGN: freeThing(tree->child1); safeFree(tree); break; case DIAMASSIGN: freeThing(tree->child1); safeFree(tree); break; case DISPLAYASSIGN: freeThing(tree->child1); safeFree(tree); break; case VERBOSITYASSIGN: freeThing(tree->child1); safeFree(tree); break; case CANONICALASSIGN: freeThing(tree->child1); safeFree(tree); break; case AUTOSIMPLIFYASSIGN: freeThing(tree->child1); safeFree(tree); break; case SHOWMESSAGENUMBERSASSIGN: freeThing(tree->child1); safeFree(tree); break; case TAYLORRECURSASSIGN: freeThing(tree->child1); safeFree(tree); break; case TIMINGASSIGN: freeThing(tree->child1); safeFree(tree); break; case FULLPARENASSIGN: freeThing(tree->child1); safeFree(tree); break; case MIDPOINTASSIGN: freeThing(tree->child1); safeFree(tree); break; case DIEONERRORMODEASSIGN: freeThing(tree->child1); safeFree(tree); break; case RATIONALMODEASSIGN: freeThing(tree->child1); safeFree(tree); break; case SUPPRESSWARNINGSASSIGN: freeThing(tree->child1); safeFree(tree); break; case HOPITALRECURSASSIGN: freeThing(tree->child1); safeFree(tree); break; case PRECSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case POINTSSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case DIAMSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case DISPLAYSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case VERBOSITYSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case CANONICALSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case AUTOSIMPLIFYSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case SHOWMESSAGENUMBERSSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case TAYLORRECURSSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case TIMINGSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case FULLPARENSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case MIDPOINTSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case DIEONERRORMODESTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case RATIONALMODESTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case SUPPRESSWARNINGSSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case HOPITALRECURSSTILLASSIGN: freeThing(tree->child1); safeFree(tree); break; case AND: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case OR: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case NEGATION: freeThing(tree->child1); safeFree(tree); break; case INDEX: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case COMPAREEQUAL: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case COMPAREIN: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case COMPARELESS: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case COMPAREGREATER: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case COMPARELESSEQUAL: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case COMPAREGREATEREQUAL: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case COMPARENOTEQUAL: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case CONCAT: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case ADDTOLIST: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case PREPEND: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case APPEND: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case ON: safeFree(tree); break; case OFF: safeFree(tree); break; case DYADIC: safeFree(tree); break; case POWERS: safeFree(tree); break; case BINARY: safeFree(tree); break; case HEXADECIMAL: safeFree(tree); break; case FILESYM: safeFree(tree); break; case POSTSCRIPT: safeFree(tree); break; case POSTSCRIPTFILE: safeFree(tree); break; case PERTURB: safeFree(tree); break; case ROUNDDOWN: safeFree(tree); break; case ROUNDUP: safeFree(tree); break; case ROUNDTOZERO: safeFree(tree); break; case ROUNDTONEAREST: safeFree(tree); break; case HONORCOEFF: safeFree(tree); break; case TRUE: safeFree(tree); break; case UNIT: safeFree(tree); break; case FALSE: safeFree(tree); break; case DEFAULT: safeFree(tree); break; case DECIMAL: safeFree(tree); break; case ABSOLUTESYM: safeFree(tree); break; case RELATIVESYM: safeFree(tree); break; case FIXED: safeFree(tree); break; case FLOATING: safeFree(tree); break; case ERRORSPECIAL: safeFree(tree); break; case DOUBLESYMBOL: safeFree(tree); break; case SINGLESYMBOL: safeFree(tree); break; case HALFPRECISIONSYMBOL: safeFree(tree); break; case QUADSYMBOL: safeFree(tree); break; case DOUBLEEXTENDEDSYMBOL: safeFree(tree); break; case DOUBLEDOUBLESYMBOL: safeFree(tree); break; case TRIPLEDOUBLESYMBOL: safeFree(tree); break; case STRING: safeFree(tree->string); safeFree(tree); break; case TABLEACCESS: safeFree(tree->string); safeFree(tree); break; case ISBOUND: safeFree(tree->string); safeFree(tree); break; case TABLEACCESSWITHSUBSTITUTE: safeFree(tree->string); freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case STRUCTACCESS: safeFree(tree->string); freeThing(tree->child1); safeFree(tree); break; case APPLY: freeThing(tree->child1); freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case DECIMALCONSTANT: safeFree(tree->string); safeFree(tree); break; case MIDPOINTCONSTANT: safeFree(tree->string); safeFree(tree); break; case DYADICCONSTANT: safeFree(tree->string); safeFree(tree); break; case HEXCONSTANT: safeFree(tree->string); safeFree(tree); break; case HEXADECIMALCONSTANT: safeFree(tree->string); safeFree(tree); break; case BINARYCONSTANT: safeFree(tree->string); safeFree(tree); break; case EMPTYLIST: safeFree(tree); break; case LIST: freeChain(tree->arguments, freeThingOnVoid); if (tree->argArray != NULL) { safeFree(tree->argArray); tree->argArray = NULL; tree->argArraySize = 0; tree->argArrayAllocSize = 0; } safeFree(tree); break; case STRUCTURE: freeChain(tree->arguments, freeEntryOnVoid); safeFree(tree); break; case FINALELLIPTICLIST: freeChain(tree->arguments, freeThingOnVoid); if (tree->argArray != NULL) { safeFree(tree->argArray); tree->argArray = NULL; tree->argArraySize = 0; tree->argArrayAllocSize = 0; } safeFree(tree); break; case ELLIPTIC: safeFree(tree); break; case RANGE: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case DEBOUNDMAX: freeThing(tree->child1); safeFree(tree); break; case EVALCONST: freeThing(tree->child1); safeFree(tree); break; case DEBOUNDMIN: freeThing(tree->child1); safeFree(tree); break; case DEBOUNDMID: freeThing(tree->child1); safeFree(tree); break; case DIFF: freeThing(tree->child1); safeFree(tree); break; case BASHEVALUATE: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case GETSUPPRESSEDMESSAGES: safeFree(tree); break; case GETBACKTRACE: safeFree(tree); break; case DIRTYSIMPLIFY: freeThing(tree->child1); safeFree(tree); break; case SIMPLIFYSAFE: freeThing(tree->child1); safeFree(tree); break; case TIME: freeThing(tree->child1); safeFree(tree); break; case REMEZ: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case ANNOTATEFUNCTION: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case MATCH: freeThing(tree->child1); freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case MATCHELEMENT: freeThing(tree->child1); freeThing(tree->child2); freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case MIN: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case MAX: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case FPMINIMAX: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case HORNER: freeThing(tree->child1); safeFree(tree); break; case CANONICAL: freeThing(tree->child1); safeFree(tree); break; case EXPAND: freeThing(tree->child1); safeFree(tree); break; case TAYLOR: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case TAYLORFORM: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case CHEBYSHEVFORM: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case AUTODIFF: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case DEGREE: freeThing(tree->child1); safeFree(tree); break; case NUMERATOR: freeThing(tree->child1); safeFree(tree); break; case DENOMINATOR: freeThing(tree->child1); safeFree(tree); break; case SUBSTITUTE: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case COMPOSEPOLYNOMIALS: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case COEFF: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case SUBPOLY: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case ROUNDCOEFFICIENTS: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case RATIONALAPPROX: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case ACCURATEINFNORM: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case ROUNDTOFORMAT: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case EVALUATE: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case PARSE: freeThing(tree->child1); safeFree(tree); break; case READXML: freeThing(tree->child1); safeFree(tree); break; case EXECUTE: freeThing(tree->child1); safeFree(tree); break; case INFNORM: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case SUPNORM: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case FINDZEROS: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case FPFINDZEROS: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case DIRTYINFNORM: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case NUMBERROOTS: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case INTEGRAL: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case DIRTYINTEGRAL: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case IMPLEMENTPOLY: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case IMPLEMENTCONST: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case CHECKINFNORM: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case ZERODENOMINATORS: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case ISEVALUABLE: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case SEARCHGAL: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case GUESSDEGREE: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case ASSIGNMENTININDEXING: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case FLOATASSIGNMENTININDEXING: freeChain(tree->arguments, freeThingOnVoid); safeFree(tree); break; case ASSIGNMENTINSTRUCTURE: freeChain(tree->arguments, freeStringPtr); freeThing(tree->child1); safeFree(tree); break; case FLOATASSIGNMENTINSTRUCTURE: freeChain(tree->arguments, freeStringPtr); freeThing(tree->child1); safeFree(tree); break; case PROTOASSIGNMENTINSTRUCTURE: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case PROTOFLOATASSIGNMENTINSTRUCTURE: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case DIRTYFINDZEROS: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree); break; case HEAD: freeThing(tree->child1); safeFree(tree); break; case ROUNDCORRECTLY: freeThing(tree->child1); safeFree(tree); break; case READFILE: freeThing(tree->child1); safeFree(tree); break; case REVERT: freeThing(tree->child1); safeFree(tree); break; case SORT: freeThing(tree->child1); safeFree(tree); break; case MANTISSA: freeThing(tree->child1); safeFree(tree); break; case EXPONENT: freeThing(tree->child1); safeFree(tree); break; case PRECISION: freeThing(tree->child1); safeFree(tree); break; case TAIL: freeThing(tree->child1); safeFree(tree); break; case LENGTH: freeThing(tree->child1); safeFree(tree); break; case OBJECTNAME: freeThing(tree->child1); safeFree(tree); break; case EXTERNALPROCEDUREUSAGE: safeFree(tree); break; case PROC: freeThing(tree->child1); freeThing(tree->child2); freeChain(tree->arguments, safeFree); safeFree(tree); break; case BIND: freeThing(tree->child1); freeThing(tree->child2); safeFree(tree->string); safeFree(tree); break; case PROCILLIM: freeThing(tree->child1); freeThing(tree->child2); freeChain(tree->arguments, safeFree); safeFree(tree); break; case PRECDEREF: safeFree(tree); break; case POINTSDEREF: safeFree(tree); break; case DIAMDEREF: safeFree(tree); break; case DISPLAYDEREF: safeFree(tree); break; case VERBOSITYDEREF: safeFree(tree); break; case CANONICALDEREF: safeFree(tree); break; case AUTOSIMPLIFYDEREF: safeFree(tree); break; case SHOWMESSAGENUMBERSDEREF: safeFree(tree); break; case TAYLORRECURSDEREF: safeFree(tree); break; case TIMINGDEREF: safeFree(tree); break; case FULLPARENDEREF: safeFree(tree); break; case MIDPOINTDEREF: safeFree(tree); break; case DIEONERRORMODEDEREF: safeFree(tree); break; case RATIONALMODEDEREF: safeFree(tree); break; case SUPPRESSWARNINGSDEREF: safeFree(tree); break; case HOPITALRECURSDEREF: safeFree(tree); break; default: sollyaFprintf(stderr,"Error: freeThing: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return; } void fRawPrintThing(FILE *fd, node *tree) { char *str; if (tree == NULL) return; str = sRawPrintThing(tree); sollyaFprintf(fd,"%s",str); safeFree(str); return; } void rawPrintThing(node *tree) { fRawPrintThing(stdout,tree); return; } int isEqualThingOnVoid(void *tree, void *tree2) { return isEqualThing((node *) tree, (node *) tree2); } static inline int isEqualThingLibraryInner(node *tree, node *tree2); static inline int isEqualThingLibraryInnerOnVoid(void *tree, void *tree2) { return isEqualThingLibraryInner((node *) tree, (node *) tree2); } static inline int finalEllipticListEndIsSuperfluousGeneral(node *last, chain *ch, int (*cmpFunc)(node *, node *)) { chain *curr; if (last == NULL) return 0; if (ch == NULL) return 1; for (curr=ch;curr!=NULL;curr=curr->next) { if (!cmpFunc(last, ((node *) (curr->value)))) return 0; } return 1; } static inline int finalEllipticListEndIsSuperfluousInteger(mpz_t last, chain *ch) { chain *curr; mpfr_t t; mpz_t l, z; node *cn; if (ch == NULL) return 1; mpz_init(l); mpz_add_ui(l, last, 1u); mpfr_init2(t, tools_precision); mpz_init(z); curr = ch; while (curr != NULL) { cn = (node *) (curr->value); if (isPureTree(cn)) { if (evaluateThingToConstant(t, cn, NULL, 0, 0)) { if (mpfr_number_p(t) && mpfr_integer_p(t)) { mpfr_get_z(z, t, GMP_RNDN); if (mpz_cmp(z, l) != 0) { mpfr_clear(t); mpz_clear(z); mpz_clear(l); return 0; } } else { mpfr_clear(t); mpz_clear(z); mpz_clear(l); return 0; } } else { mpfr_clear(t); mpz_clear(z); mpz_clear(l); return 0; } } else { mpfr_clear(t); mpz_clear(z); mpz_clear(l); return 0; } curr = curr->next; mpz_add_ui(l, l, 1u); } mpfr_clear(t); mpz_clear(z); mpz_clear(l); return 1; } static inline int finalEllipticListEndIsSuperfluous(node *last, chain *ch, int (*cmpFunc)(node *, node *)) { mpfr_t temp; mpz_t z; int res; if (last == NULL) return 0; if (ch == NULL) return 1; if (isPureTree(last)) { mpfr_init2(temp, tools_precision); if (evaluateThingToConstant(temp, last, NULL, 0, 0)) { if (mpfr_number_p(temp) && mpfr_integer_p(temp)) { mpz_init(z); mpfr_get_z(z, temp, GMP_RNDN); mpfr_clear(temp); res = finalEllipticListEndIsSuperfluousInteger(z, ch); mpz_clear(z); return res; } else { mpfr_clear(temp); return finalEllipticListEndIsSuperfluousGeneral(last, ch, cmpFunc); } } else { mpfr_clear(temp); return finalEllipticListEndIsSuperfluousGeneral(last, ch, cmpFunc); } } else { return finalEllipticListEndIsSuperfluousGeneral(last, ch, cmpFunc); } return 0; } static inline int isEqualFinalEllipticList(chain *c1, chain *c2, int (*cmpFunc)(node *, node *)) { chain *curr1, *curr2, *curr, *prev1, *prev2, *prev; curr1=c1; curr2=c2; prev1=NULL; prev2=NULL; while ((curr1!=NULL)&&(curr2!=NULL)) { if (!cmpFunc(((node *) (curr1->value)), ((node *) (curr2->value)))) return 0; prev1=curr1; prev2=curr2; curr1=curr1->next; curr2=curr2->next; } if (curr1!=NULL) { curr = curr1; prev = prev1; } else { if (curr2!=NULL) { curr = curr2; prev = prev2; } else { return 1; } } if (prev == NULL) return 1; if (curr == NULL) return 1; return finalEllipticListEndIsSuperfluous((node *) (prev->value), curr, cmpFunc); } static inline int isEqualThingLibraryInner(node *tree, node *tree2) { chain *curri, *currj; int found; if (tree == NULL) return 0; if (tree2 == NULL) return 0; if (tree == tree2) return 1; if (((tree->nodeType == MEMREF) && (tree2->nodeType == MEMREF)) && ((tree->hashComputed) && (tree2->hashComputed))) { if (tree->hash != tree2->hash) return 0; } if ((tree->nodeType == MEMREF) && (tree2->nodeType == MEMREF) && (tree->polynomialRepresentation != NULL) && (tree2->polynomialRepresentation != NULL) && (tree->child1 == NULL) && (tree2->child2 == NULL)) { return polynomialStructurallyEqual(tree->polynomialRepresentation, tree2->polynomialRepresentation, 0); } if (tree->nodeType == MEMREF) { return isEqualThingLibraryInner(getMemRefChild(tree), tree2); } if (tree2->nodeType == MEMREF) { return isEqualThingLibraryInner(tree, getMemRefChild(tree2)); } if (tree->nodeType != tree2->nodeType) return 0; switch (tree->nodeType) { case VARIABLE: break; case CONSTANT: if (mpfr_nan_p(*(tree->value)) && mpfr_nan_p(*(tree2->value))) return 1; if (!mpfr_equal_p(*(tree->value),*(tree2->value))) return 0; break; case ADD: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case SUB: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case MUL: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case DIV: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case SQRT: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case EXP: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case LOG: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case LOG_2: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case LOG_10: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case SIN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case COS: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case TAN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case ASIN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case ACOS: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case ATAN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case SINH: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case COSH: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case TANH: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case ASINH: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case ACOSH: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case ATANH: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case POW: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case NEG: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case ABS: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DOUBLE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case SINGLE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case HALFPRECISION: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case QUAD: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DOUBLEDOUBLE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case TRIPLEDOUBLE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case ERF: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case ERFC: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case LOG_1P: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case EXP_M1: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DOUBLEEXTENDED: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case LIBRARYFUNCTION: if (tree->libFun != tree2->libFun) return 0; if (tree->libFunDeriv != tree2->libFunDeriv) return 0; if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case LIBRARYCONSTANT: if (tree->libFun != tree2->libFun) return 0; break; case PROCEDUREFUNCTION: if (tree->libFunDeriv != tree2->libFunDeriv) return 0; if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case CEIL: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case FLOOR: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case NEARESTINT: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case PI_CONST: break; case COMMANDLIST: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case WHILE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case IFELSE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case IF: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case FOR: if (strcmp(tree->string,tree2->string) != 0) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case FORIN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case QUIT: break; case NOP: break; case NOPARG: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case FALSEQUIT: break; case FALSERESTART: break; case RESTART: break; case VARIABLEDECLARATION: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case PRINT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case SUPPRESSMESSAGE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case UNSUPPRESSMESSAGE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case NEWFILEPRINT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case APPENDFILEPRINT: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case PLOT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case PRINTHEXA: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case PRINTFLOAT: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case PRINTBINARY: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case PRINTEXPANSION: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case BASHEXECUTE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case EXTERNALPLOT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case WRITE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case NEWFILEWRITE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case APPENDFILEWRITE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case ASCIIPLOT: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case PRINTXML: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case PRINTXMLNEWFILE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case PRINTXMLAPPENDFILE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case WORSTCASE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case RENAME: if (strcmp(tree->string,tree2->string) != 0) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case AUTOPRINT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case ASSIGNMENT: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case FLOATASSIGNMENT: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case EXTERNALPROC: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualIntPtrOnVoid)) return 0; case LIBRARYBINDING: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case LIBRARYCONSTANTBINDING: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case PRECASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case POINTSASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DIAMASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DISPLAYASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case VERBOSITYASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case CANONICALASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case AUTOSIMPLIFYASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case SHOWMESSAGENUMBERSASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case TAYLORRECURSASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case TIMINGASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case FULLPARENASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case MIDPOINTASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DIEONERRORMODEASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case RATIONALMODEASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case SUPPRESSWARNINGSASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case HOPITALRECURSASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case PRECSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case POINTSSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DIAMSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DISPLAYSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case VERBOSITYSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case CANONICALSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case AUTOSIMPLIFYSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case SHOWMESSAGENUMBERSSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case TAYLORRECURSSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case TIMINGSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case FULLPARENSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case MIDPOINTSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DIEONERRORMODESTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case RATIONALMODESTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case SUPPRESSWARNINGSSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case HOPITALRECURSSTILLASSIGN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case AND: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case OR: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case NEGATION: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case INDEX: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case COMPAREEQUAL: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case COMPAREIN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case COMPARELESS: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case COMPAREGREATER: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case COMPARELESSEQUAL: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case COMPAREGREATEREQUAL: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case COMPARENOTEQUAL: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case CONCAT: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case ADDTOLIST: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case APPEND: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case PREPEND: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case ON: break; case OFF: break; case DYADIC: break; case POWERS: break; case BINARY: break; case HEXADECIMAL: break; case FILESYM: break; case POSTSCRIPT: break; case POSTSCRIPTFILE: break; case PERTURB: break; case ROUNDDOWN: break; case ROUNDUP: break; case ROUNDTOZERO: break; case ROUNDTONEAREST: break; case HONORCOEFF: break; case TRUE: break; case UNIT: break; case FALSE: break; case DEFAULT: break; case DECIMAL: break; case ABSOLUTESYM: break; case RELATIVESYM: break; case FIXED: break; case FLOATING: break; case ERRORSPECIAL: break; case DOUBLESYMBOL: break; case SINGLESYMBOL: break; case HALFPRECISIONSYMBOL: break; case QUADSYMBOL: break; case DOUBLEEXTENDEDSYMBOL: break; case DOUBLEDOUBLESYMBOL: break; case TRIPLEDOUBLESYMBOL: break; case STRING: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case TABLEACCESS: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case ISBOUND: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case TABLEACCESSWITHSUBSTITUTE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case STRUCTACCESS: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case APPLY: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DECIMALCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case MIDPOINTCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case DYADICCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case HEXCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case HEXADECIMALCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case BINARYCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case EMPTYLIST: break; case LIST: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; setupRandomAccessOnLists(tree); setupRandomAccessOnLists(tree2); break; case STRUCTURE: if (lengthChain(tree->arguments) != lengthChain(tree2->arguments)) return 0; for (curri=tree->arguments;curri!=NULL;curri=curri->next) { found = 0; currj = tree2->arguments; while ((!found) && (currj != NULL)) { if ((!strcmp(((entry *) (curri->value))->name, ((entry *) (currj->value))->name)) && (isEqualThingLibraryInner(((node *) ((entry *) (curri->value))->value), ((node *) ((entry *) (currj->value))->value)))) { found = 1; } currj = currj->next; } if (!found) return 0; } break; case FINALELLIPTICLIST: if (!isEqualFinalEllipticList(tree->arguments,tree2->arguments,isEqualThingLibraryInner)) return 0; setupRandomAccessOnLists(tree); setupRandomAccessOnLists(tree2); break; case ELLIPTIC: break; case RANGE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case DEBOUNDMAX: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case EVALCONST: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DEBOUNDMIN: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DEBOUNDMID: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DIFF: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case BASHEVALUATE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case GETSUPPRESSEDMESSAGES: break; case GETBACKTRACE: break; case DIRTYSIMPLIFY: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case SIMPLIFYSAFE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case TIME: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case REMEZ: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case ANNOTATEFUNCTION: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case MATCH: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case MATCHELEMENT: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case MIN: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case MAX: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case FPMINIMAX: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case HORNER: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case CANONICAL: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case EXPAND: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case TAYLOR: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case TAYLORFORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case CHEBYSHEVFORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case AUTODIFF: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case DEGREE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case NUMERATOR: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case DENOMINATOR: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case SUBSTITUTE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case COMPOSEPOLYNOMIALS: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case COEFF: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case SUBPOLY: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case ROUNDCOEFFICIENTS: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case RATIONALAPPROX: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case ACCURATEINFNORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case ROUNDTOFORMAT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case EVALUATE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case PARSE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case READXML: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case EXECUTE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case INFNORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case SUPNORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case FINDZEROS: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case FPFINDZEROS: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case DIRTYINFNORM: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case NUMBERROOTS: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case INTEGRAL: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case DIRTYINTEGRAL: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case IMPLEMENTPOLY: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case IMPLEMENTCONST: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case CHECKINFNORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case ZERODENOMINATORS: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case ISEVALUABLE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case SEARCHGAL: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case GUESSDEGREE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case ASSIGNMENTININDEXING: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case FLOATASSIGNMENTININDEXING: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingLibraryInnerOnVoid)) return 0; break; case ASSIGNMENTINSTRUCTURE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case FLOATASSIGNMENTINSTRUCTURE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case PROTOASSIGNMENTINSTRUCTURE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case PROTOFLOATASSIGNMENTINSTRUCTURE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case DIRTYFINDZEROS: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; break; case HEAD: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case ROUNDCORRECTLY: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case READFILE: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case REVERT: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case SORT: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case MANTISSA: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case EXPONENT: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case PRECISION: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case TAIL: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case LENGTH: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case OBJECTNAME: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; break; case EXTERNALPROCEDUREUSAGE: if (tree->libProc != tree2->libProc) return 0; break; case PROC: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case BIND: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case PROCILLIM: if (!isEqualThingLibraryInner(tree->child1,tree2->child1)) return 0; if (!isEqualThingLibraryInner(tree->child2,tree2->child2)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case PRECDEREF: break; case POINTSDEREF: break; case DIAMDEREF: break; case DISPLAYDEREF: break; case VERBOSITYDEREF: break; case CANONICALDEREF: break; case AUTOSIMPLIFYDEREF: break; case SHOWMESSAGENUMBERSDEREF: break; case TAYLORRECURSDEREF: break; case TIMINGDEREF: break; case FULLPARENDEREF: break; case MIDPOINTDEREF: break; case DIEONERRORMODEDEREF: break; case RATIONALMODEDEREF: break; case SUPPRESSWARNINGSDEREF: break; case HOPITALRECURSDEREF: break; default: sollyaFprintf(stderr,"Error: isEqualThingLibraryInner: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return 1; } int isEqualThingLibrary(node *tree, node *tree2) { uint64_t hashTree, hashTree2; /* Stupid inputs */ if (tree == NULL) return 0; if (tree2 == NULL) return 0; /* Pointer equality */ if (tree == tree2) return 1; /* Decide many cases by the use of hashes */ hashTree = hashThing(tree); hashTree2 = hashThing(tree2); if (hashTree != hashTree2) return 0; /* Call inner function */ return isEqualThingLibraryInner(tree, tree2); } int isEqualThing(node *tree, node *tree2) { chain *curri, *currj; int found; if (tree == NULL) return 0; if (tree2 == NULL) return 0; if (tree == tree2) return 1; if (((tree->nodeType == MEMREF) && (tree2->nodeType == MEMREF)) && ((tree->hashComputed) && (tree2->hashComputed))) { if (tree->hash != tree2->hash) return 0; } if ((tree->nodeType == MEMREF) && (tree2->nodeType == MEMREF) && (tree->polynomialRepresentation != NULL) && (tree2->polynomialRepresentation != NULL)) { return polynomialEqual(tree->polynomialRepresentation, tree2->polynomialRepresentation, 0); } if (tree->nodeType == MEMREF) { return isEqualThing(getMemRefChild(tree), tree2); } if (tree2->nodeType == MEMREF) { return isEqualThing(tree, getMemRefChild(tree2)); } if (tree->nodeType != tree2->nodeType) return 0; switch (tree->nodeType) { case VARIABLE: break; case CONSTANT: if (!mpfr_equal_p(*(tree->value),*(tree2->value))) return 0; break; case ADD: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case SUB: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case MUL: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case DIV: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case SQRT: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case EXP: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case LOG: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case LOG_2: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case LOG_10: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case SIN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case COS: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case TAN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case ASIN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case ACOS: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case ATAN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case SINH: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case COSH: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case TANH: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case ASINH: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case ACOSH: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case ATANH: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case POW: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case NEG: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case ABS: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DOUBLE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case SINGLE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case HALFPRECISION: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case QUAD: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DOUBLEDOUBLE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case TRIPLEDOUBLE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case ERF: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case ERFC: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case LOG_1P: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case EXP_M1: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DOUBLEEXTENDED: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case LIBRARYFUNCTION: if (tree->libFun != tree2->libFun) return 0; if (tree->libFunDeriv != tree2->libFunDeriv) return 0; if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case LIBRARYCONSTANT: if (tree->libFun != tree2->libFun) return 0; break; case PROCEDUREFUNCTION: if (tree->libFunDeriv != tree2->libFunDeriv) return 0; if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case CEIL: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case FLOOR: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case NEARESTINT: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case PI_CONST: break; case COMMANDLIST: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case WHILE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case IFELSE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case IF: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case FOR: if (strcmp(tree->string,tree2->string) != 0) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case FORIN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case QUIT: break; case NOP: break; case NOPARG: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case FALSEQUIT: break; case FALSERESTART: break; case RESTART: break; case VARIABLEDECLARATION: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case PRINT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case SUPPRESSMESSAGE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case UNSUPPRESSMESSAGE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case NEWFILEPRINT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case APPENDFILEPRINT: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case PLOT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case PRINTHEXA: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case PRINTFLOAT: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case PRINTBINARY: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case PRINTEXPANSION: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case BASHEXECUTE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case EXTERNALPLOT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case WRITE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case NEWFILEWRITE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case APPENDFILEWRITE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case ASCIIPLOT: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case PRINTXML: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case PRINTXMLNEWFILE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case PRINTXMLAPPENDFILE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case WORSTCASE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case RENAME: if (strcmp(tree->string,tree2->string) != 0) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case AUTOPRINT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case ASSIGNMENT: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case FLOATASSIGNMENT: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case EXTERNALPROC: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualIntPtrOnVoid)) return 0; case LIBRARYBINDING: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case LIBRARYCONSTANTBINDING: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case PRECASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case POINTSASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DIAMASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DISPLAYASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case VERBOSITYASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case CANONICALASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case AUTOSIMPLIFYASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case SHOWMESSAGENUMBERSASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case TAYLORRECURSASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case TIMINGASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case FULLPARENASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case MIDPOINTASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DIEONERRORMODEASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case RATIONALMODEASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case SUPPRESSWARNINGSASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case HOPITALRECURSASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case PRECSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case POINTSSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DIAMSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DISPLAYSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case VERBOSITYSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case CANONICALSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case AUTOSIMPLIFYSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case SHOWMESSAGENUMBERSSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case TAYLORRECURSSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case TIMINGSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case FULLPARENSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case MIDPOINTSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DIEONERRORMODESTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case RATIONALMODESTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case SUPPRESSWARNINGSSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case HOPITALRECURSSTILLASSIGN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case AND: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case OR: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case NEGATION: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case INDEX: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case COMPAREEQUAL: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case COMPAREIN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case COMPARELESS: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case COMPAREGREATER: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case COMPARELESSEQUAL: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case COMPAREGREATEREQUAL: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case COMPARENOTEQUAL: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case CONCAT: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case ADDTOLIST: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case APPEND: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case PREPEND: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case ON: break; case OFF: break; case DYADIC: break; case POWERS: break; case BINARY: break; case HEXADECIMAL: break; case FILESYM: break; case POSTSCRIPT: break; case POSTSCRIPTFILE: break; case PERTURB: break; case ROUNDDOWN: break; case ROUNDUP: break; case ROUNDTOZERO: break; case ROUNDTONEAREST: break; case HONORCOEFF: break; case TRUE: break; case UNIT: break; case FALSE: break; case DEFAULT: break; case DECIMAL: break; case ABSOLUTESYM: break; case RELATIVESYM: break; case FIXED: break; case FLOATING: break; case ERRORSPECIAL: break; case DOUBLESYMBOL: break; case SINGLESYMBOL: break; case HALFPRECISIONSYMBOL: break; case QUADSYMBOL: break; case DOUBLEEXTENDEDSYMBOL: break; case DOUBLEDOUBLESYMBOL: break; case TRIPLEDOUBLESYMBOL: break; case STRING: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case TABLEACCESS: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case ISBOUND: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case TABLEACCESSWITHSUBSTITUTE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case STRUCTACCESS: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case APPLY: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DECIMALCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case MIDPOINTCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case DYADICCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case HEXCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case HEXADECIMALCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case BINARYCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case EMPTYLIST: break; case LIST: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; setupRandomAccessOnLists(tree); setupRandomAccessOnLists(tree2); break; case STRUCTURE: if (lengthChain(tree->arguments) != lengthChain(tree2->arguments)) return 0; for (curri=tree->arguments;curri!=NULL;curri=curri->next) { found = 0; currj = tree2->arguments; while ((!found) && (currj != NULL)) { if ((!strcmp(((entry *) (curri->value))->name, ((entry *) (currj->value))->name)) && (isEqualThing(((node *) ((entry *) (curri->value))->value), ((node *) ((entry *) (currj->value))->value)))) { found = 1; } currj = currj->next; } if (!found) return 0; } break; case FINALELLIPTICLIST: if (!isEqualFinalEllipticList(tree->arguments,tree2->arguments,isEqualThing)) return 0; setupRandomAccessOnLists(tree); setupRandomAccessOnLists(tree2); break; case ELLIPTIC: break; case RANGE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case DEBOUNDMAX: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case EVALCONST: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DEBOUNDMIN: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DEBOUNDMID: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DIFF: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case BASHEVALUATE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case GETSUPPRESSEDMESSAGES: break; case GETBACKTRACE: break; case DIRTYSIMPLIFY: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case SIMPLIFYSAFE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case TIME: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case REMEZ: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case ANNOTATEFUNCTION: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case MATCH: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case MATCHELEMENT: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case MIN: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case MAX: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case FPMINIMAX: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case HORNER: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case CANONICAL: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case EXPAND: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case TAYLOR: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case TAYLORFORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case CHEBYSHEVFORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case AUTODIFF: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case DEGREE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case NUMERATOR: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case DENOMINATOR: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case SUBSTITUTE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case COMPOSEPOLYNOMIALS: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case COEFF: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case SUBPOLY: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case ROUNDCOEFFICIENTS: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case RATIONALAPPROX: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case ACCURATEINFNORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case ROUNDTOFORMAT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case EVALUATE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case PARSE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case READXML: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case EXECUTE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case INFNORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case SUPNORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case FINDZEROS: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case FPFINDZEROS: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case DIRTYINFNORM: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case NUMBERROOTS: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case INTEGRAL: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case DIRTYINTEGRAL: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case IMPLEMENTPOLY: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case IMPLEMENTCONST: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case CHECKINFNORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case ZERODENOMINATORS: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case ISEVALUABLE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case SEARCHGAL: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case GUESSDEGREE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case ASSIGNMENTININDEXING: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case FLOATASSIGNMENTININDEXING: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingOnVoid)) return 0; break; case ASSIGNMENTINSTRUCTURE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case FLOATASSIGNMENTINSTRUCTURE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case PROTOASSIGNMENTINSTRUCTURE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case PROTOFLOATASSIGNMENTINSTRUCTURE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case DIRTYFINDZEROS: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; break; case HEAD: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case ROUNDCORRECTLY: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case READFILE: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case REVERT: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case SORT: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case MANTISSA: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case EXPONENT: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case PRECISION: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case TAIL: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case LENGTH: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case OBJECTNAME: if (!isEqualThing(tree->child1,tree2->child1)) return 0; break; case EXTERNALPROCEDUREUSAGE: if (tree->libProc != tree2->libProc) return 0; break; case PROC: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case BIND: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case PROCILLIM: if (!isEqualThing(tree->child1,tree2->child1)) return 0; if (!isEqualThing(tree->child2,tree2->child2)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case PRECDEREF: break; case POINTSDEREF: break; case DIAMDEREF: break; case DISPLAYDEREF: break; case VERBOSITYDEREF: break; case CANONICALDEREF: break; case AUTOSIMPLIFYDEREF: break; case SHOWMESSAGENUMBERSDEREF: break; case TAYLORRECURSDEREF: break; case TIMINGDEREF: break; case FULLPARENDEREF: break; case MIDPOINTDEREF: break; case DIEONERRORMODEDEREF: break; case RATIONALMODEDEREF: break; case SUPPRESSWARNINGSDEREF: break; case HOPITALRECURSDEREF: break; default: sollyaFprintf(stderr,"Error: isEqualThing: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return 1; } int isEqualThingNoPoly(node *tree, node *tree2); int isEqualThingNoPolyOnVoid(void *tree, void *tree2) { return isEqualThingNoPoly((node *) tree, (node *) tree2); } int isEqualThingNoPoly(node *tree, node *tree2) { chain *curri, *currj; int found; if (tree == NULL) return 0; if (tree2 == NULL) return 0; if (tree == tree2) return 1; if ((tree->nodeType == MEMREF) && (tree2->nodeType == MEMREF) && (tree->polynomialRepresentation != NULL) && (tree2->polynomialRepresentation != NULL)) { if (tree->polynomialRepresentation == tree2->polynomialRepresentation) return 1; } if (tree->nodeType == MEMREF) { return isEqualThingNoPoly(getMemRefChild(tree), tree2); } if (tree2->nodeType == MEMREF) { return isEqualThingNoPoly(tree, getMemRefChild(tree2)); } if (tree->nodeType != tree2->nodeType) return 0; switch (tree->nodeType) { case VARIABLE: break; case CONSTANT: if (!mpfr_equal_p(*(tree->value),*(tree2->value))) return 0; break; case ADD: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case SUB: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case MUL: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case DIV: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case SQRT: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case EXP: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case LOG: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case LOG_2: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case LOG_10: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case SIN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case COS: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case TAN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case ASIN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case ACOS: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case ATAN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case SINH: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case COSH: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case TANH: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case ASINH: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case ACOSH: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case ATANH: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case POW: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case NEG: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case ABS: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DOUBLE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case SINGLE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case HALFPRECISION: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case QUAD: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DOUBLEDOUBLE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case TRIPLEDOUBLE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case ERF: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case ERFC: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case LOG_1P: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case EXP_M1: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DOUBLEEXTENDED: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case LIBRARYFUNCTION: if (tree->libFun != tree2->libFun) return 0; if (tree->libFunDeriv != tree2->libFunDeriv) return 0; if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case LIBRARYCONSTANT: if (tree->libFun != tree2->libFun) return 0; break; case PROCEDUREFUNCTION: if (tree->libFunDeriv != tree2->libFunDeriv) return 0; if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case CEIL: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case FLOOR: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case NEARESTINT: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case PI_CONST: break; case COMMANDLIST: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case WHILE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case IFELSE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case IF: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case FOR: if (strcmp(tree->string,tree2->string) != 0) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case FORIN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case QUIT: break; case NOP: break; case NOPARG: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case FALSEQUIT: break; case FALSERESTART: break; case RESTART: break; case VARIABLEDECLARATION: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case PRINT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case SUPPRESSMESSAGE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case UNSUPPRESSMESSAGE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case NEWFILEPRINT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case APPENDFILEPRINT: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case PLOT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case PRINTHEXA: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case PRINTFLOAT: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case PRINTBINARY: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case PRINTEXPANSION: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case BASHEXECUTE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case EXTERNALPLOT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case WRITE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case NEWFILEWRITE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case APPENDFILEWRITE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case ASCIIPLOT: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case PRINTXML: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case PRINTXMLNEWFILE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case PRINTXMLAPPENDFILE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case WORSTCASE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case RENAME: if (strcmp(tree->string,tree2->string) != 0) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case AUTOPRINT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case ASSIGNMENT: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case FLOATASSIGNMENT: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case EXTERNALPROC: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualIntPtrOnVoid)) return 0; case LIBRARYBINDING: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case LIBRARYCONSTANTBINDING: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case PRECASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case POINTSASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DIAMASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DISPLAYASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case VERBOSITYASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case CANONICALASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case AUTOSIMPLIFYASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case SHOWMESSAGENUMBERSASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case TAYLORRECURSASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case TIMINGASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case FULLPARENASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case MIDPOINTASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DIEONERRORMODEASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case RATIONALMODEASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case SUPPRESSWARNINGSASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case HOPITALRECURSASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case PRECSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case POINTSSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DIAMSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DISPLAYSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case VERBOSITYSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case CANONICALSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case AUTOSIMPLIFYSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case SHOWMESSAGENUMBERSSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case TAYLORRECURSSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case TIMINGSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case FULLPARENSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case MIDPOINTSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DIEONERRORMODESTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case RATIONALMODESTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case SUPPRESSWARNINGSSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case HOPITALRECURSSTILLASSIGN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case AND: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case OR: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case NEGATION: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case INDEX: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case COMPAREEQUAL: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case COMPAREIN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case COMPARELESS: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case COMPAREGREATER: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case COMPARELESSEQUAL: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case COMPAREGREATEREQUAL: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case COMPARENOTEQUAL: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case CONCAT: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case ADDTOLIST: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case APPEND: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case PREPEND: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case ON: break; case OFF: break; case DYADIC: break; case POWERS: break; case BINARY: break; case HEXADECIMAL: break; case FILESYM: break; case POSTSCRIPT: break; case POSTSCRIPTFILE: break; case PERTURB: break; case ROUNDDOWN: break; case ROUNDUP: break; case ROUNDTOZERO: break; case ROUNDTONEAREST: break; case HONORCOEFF: break; case TRUE: break; case UNIT: break; case FALSE: break; case DEFAULT: break; case DECIMAL: break; case ABSOLUTESYM: break; case RELATIVESYM: break; case FIXED: break; case FLOATING: break; case ERRORSPECIAL: break; case DOUBLESYMBOL: break; case SINGLESYMBOL: break; case HALFPRECISIONSYMBOL: break; case QUADSYMBOL: break; case DOUBLEEXTENDEDSYMBOL: break; case DOUBLEDOUBLESYMBOL: break; case TRIPLEDOUBLESYMBOL: break; case STRING: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case TABLEACCESS: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case ISBOUND: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case TABLEACCESSWITHSUBSTITUTE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case STRUCTACCESS: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case APPLY: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DECIMALCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case MIDPOINTCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case DYADICCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case HEXCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case HEXADECIMALCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case BINARYCONSTANT: if (strcmp(tree->string,tree2->string) != 0) return 0; break; case EMPTYLIST: break; case LIST: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; setupRandomAccessOnLists(tree); setupRandomAccessOnLists(tree2); break; case STRUCTURE: if (lengthChain(tree->arguments) != lengthChain(tree2->arguments)) return 0; for (curri=tree->arguments;curri!=NULL;curri=curri->next) { found = 0; currj = tree2->arguments; while ((!found) && (currj != NULL)) { if ((!strcmp(((entry *) (curri->value))->name, ((entry *) (currj->value))->name)) && (isEqualThingNoPoly(((node *) ((entry *) (curri->value))->value), ((node *) ((entry *) (currj->value))->value)))) { found = 1; } currj = currj->next; } if (!found) return 0; } break; case FINALELLIPTICLIST: if (!isEqualFinalEllipticList(tree->arguments,tree2->arguments,isEqualThingNoPoly)) return 0; setupRandomAccessOnLists(tree); setupRandomAccessOnLists(tree2); break; case ELLIPTIC: break; case RANGE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case DEBOUNDMAX: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case EVALCONST: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DEBOUNDMIN: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DEBOUNDMID: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DIFF: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case BASHEVALUATE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case GETSUPPRESSEDMESSAGES: break; case GETBACKTRACE: break; case DIRTYSIMPLIFY: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case SIMPLIFYSAFE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case TIME: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case REMEZ: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case ANNOTATEFUNCTION: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case MATCH: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case MATCHELEMENT: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case MIN: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case MAX: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case FPMINIMAX: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case HORNER: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case CANONICAL: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case EXPAND: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case TAYLOR: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case TAYLORFORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case CHEBYSHEVFORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case AUTODIFF: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case DEGREE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case NUMERATOR: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case DENOMINATOR: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case SUBSTITUTE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case COMPOSEPOLYNOMIALS: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case COEFF: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case SUBPOLY: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case ROUNDCOEFFICIENTS: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case RATIONALAPPROX: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case ACCURATEINFNORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case ROUNDTOFORMAT: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case EVALUATE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case PARSE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case READXML: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case EXECUTE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case INFNORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case SUPNORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case FINDZEROS: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case FPFINDZEROS: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case DIRTYINFNORM: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case NUMBERROOTS: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case INTEGRAL: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case DIRTYINTEGRAL: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case IMPLEMENTPOLY: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case IMPLEMENTCONST: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case CHECKINFNORM: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case ZERODENOMINATORS: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case ISEVALUABLE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case SEARCHGAL: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case GUESSDEGREE: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case ASSIGNMENTININDEXING: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case FLOATASSIGNMENTININDEXING: if (!isEqualChain(tree->arguments,tree2->arguments,isEqualThingNoPolyOnVoid)) return 0; break; case ASSIGNMENTINSTRUCTURE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case FLOATASSIGNMENTINSTRUCTURE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case PROTOASSIGNMENTINSTRUCTURE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case PROTOFLOATASSIGNMENTINSTRUCTURE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case DIRTYFINDZEROS: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; break; case HEAD: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case ROUNDCORRECTLY: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case READFILE: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case REVERT: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case SORT: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case MANTISSA: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case EXPONENT: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case PRECISION: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case TAIL: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case LENGTH: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case OBJECTNAME: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; break; case EXTERNALPROCEDUREUSAGE: if (tree->libProc != tree2->libProc) return 0; break; case PROC: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case BIND: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; if (strcmp(tree->string,tree2->string) != 0) return 0; break; case PROCILLIM: if (!isEqualThingNoPoly(tree->child1,tree2->child1)) return 0; if (!isEqualThingNoPoly(tree->child2,tree2->child2)) return 0; if (!isEqualChain(tree->arguments,tree2->arguments,isEqualStringOnVoid)) return 0; break; case PRECDEREF: break; case POINTSDEREF: break; case DIAMDEREF: break; case DISPLAYDEREF: break; case VERBOSITYDEREF: break; case CANONICALDEREF: break; case AUTOSIMPLIFYDEREF: break; case SHOWMESSAGENUMBERSDEREF: break; case TAYLORRECURSDEREF: break; case TIMINGDEREF: break; case FULLPARENDEREF: break; case MIDPOINTDEREF: break; case DIEONERRORMODEDEREF: break; case RATIONALMODEDEREF: break; case SUPPRESSWARNINGSDEREF: break; case HOPITALRECURSDEREF: break; default: sollyaFprintf(stderr,"Error: isEqualThingNoPoly: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return 1; } int isEqualThingEnhanced(node *tree, node *tree2, int simplify) { int equal; if (tree == NULL) return 0; if (tree2 == NULL) return 0; if (tree == tree2) { switch (tree->nodeType) { case MEMREF: if (tree->child1 != NULL) { if (accessThruMemRef(tree)->nodeType == CONSTANT) { if (mpfr_nan_p(*(accessThruMemRef(tree)->value))) return 0; } } break; case CONSTANT: if (mpfr_nan_p(*(tree->value))) return 0; break; default: break; } } if (simplify) { equal = isEqualThing(tree, tree2); } else { equal = isEqualThingNoPoly(tree, tree2); } return equal; } int isCorrectlyTypedBaseSymbol(node *tree) { if (tree == NULL) return 0; if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) return 0; return isCorrectlyTypedBaseSymbol(getMemRefChild(tree)); } switch (tree->nodeType) { case ON: case OFF: case DYADIC: case POWERS: case BINARY: case HEXADECIMAL: case FILESYM: case POSTSCRIPT: case POSTSCRIPTFILE: case PERTURB: case ROUNDDOWN: case ROUNDUP: case ROUNDTOZERO: case ROUNDTONEAREST: case HONORCOEFF: case TRUE: case UNIT: case FALSE: case DEFAULT: case DECIMAL: case ABSOLUTESYM: case RELATIVESYM: case FIXED: case FLOATING: case DOUBLESYMBOL: case SINGLESYMBOL: case HALFPRECISIONSYMBOL: case QUADSYMBOL: case DOUBLEEXTENDEDSYMBOL: case DOUBLEDOUBLESYMBOL: case TRIPLEDOUBLESYMBOL: case STRING: case EMPTYLIST: case EXTERNALPROCEDUREUSAGE: case PROC: case PROCILLIM: return 1; default: return 0; } return 0; } int associationContainsDoubleEntries(chain *assoc) { chain *curri, *currj; for (curri=assoc;curri!=NULL;curri=curri->next) { for (currj=assoc;currj!=NULL;currj=currj->next) { if ((curri != currj) && (!strcmp(((entry *) (curri->value))->name, ((entry *) (currj->value))->name))) return 1; } } return 0; } int isCorrectlyTyped(node *tree) { chain *curr; if ((tree->nodeType == MEMREF) && (tree->isCorrectlyTyped)) return 1; if ((tree->nodeType == MEMREF) && (tree->polynomialRepresentation != NULL)) return 1; if (isPureTree(tree)) return 1; if (isCorrectlyTypedBaseSymbol(tree)) return 1; if (isRange(tree)) return 1; if (isPureList(tree)) { curr = accessThruMemRef(tree)->arguments; while (curr != NULL) { if ((!isCorrectlyTyped((node *) (curr->value))) && (!isError((node *) (curr->value)))) return 0; curr = curr->next; } return 1; } if (isStructure(tree)) { if (associationContainsDoubleEntries(accessThruMemRef(tree)->arguments)) return 0; curr = accessThruMemRef(tree)->arguments; while (curr != NULL) { if ((!isCorrectlyTyped((node *) (((entry *) (curr->value))->value))) && (!isError((node *) (((entry *) (curr->value))->value)))) return 0; curr = curr->next; } return 1; } if (isPureFinalEllipticList(tree)) { curr = accessThruMemRef(tree)->arguments; while (curr != NULL) { if ((!isCorrectlyTyped((node *) (curr->value))) && (!isError((node *) (curr->value)))) return 0; curr = curr->next; } return 1; } return 0; } int tryRepresentAsPolynomialNoConstants(node *tree) { polynomial_t p; if (tree->nodeType != MEMREF) return 0; if (tree->polynomialRepresentation != NULL) return 0; if (!isPureTree(tree)) return 0; if (isConstant(tree)) return 0; /* We don't want every constant to be represented twice: once as itself, once as a constant polynomial */ if (!polynomialFromExpressionOnlyRealCoeffs(&p, tree)) return 0; if ((tree->polynomialRepresentation == NULL) && (!polynomialReferencesExpression(p, tree))) { tree->polynomialRepresentation = p; return 1; } else { polynomialFree(p); } return 0; } int tryRepresentAsPolynomial(node *tree) { polynomial_t p; if (tree->nodeType != MEMREF) return 0; if (tree->polynomialRepresentation != NULL) return 0; if (!isPureTree(tree)) return 0; if (!polynomialFromExpressionOnlyRealCoeffs(&p, tree)) return 0; if ((tree->polynomialRepresentation == NULL) && (!polynomialReferencesExpression(p, tree))) { tree->polynomialRepresentation = p; return 1; } else { polynomialFree(p); } return 0; } node *evaluateThing(node *tree) { node *evaluated, *tempNode; int okay; okay = 1; if ((tree != NULL) && (tree->nodeType == MEMREF) && ((tree->isCorrectlyTyped) || (isCorrectlyTyped(tree) && (!(autosimplify && (isPureTree(tree) && (treeSize(tree) < MAXAUTOSIMPLSIZE))))))) { evaluated = addMemRef(copyThing(tree)); if (evaluated->nodeType == MEMREF) { evaluated->isCorrectlyTyped = 1; } return evaluated; } evaluated = evaluateThingInner(tree); if (!isCorrectlyTyped(evaluated)) { okay = 0; if (accessThruMemRef(evaluated)->nodeType == ERRORSPECIAL) { freeThing(evaluated); if ((accessThruMemRef(tree)->nodeType != ERRORSPECIAL) && (accessThruMemRef(tree)->nodeType != TABLEACCESS)) { printMessage(1,SOLLYA_MSG_EXPR_OR_COMMAND_COULD_NOT_BE_HANDLED,"Warning: the given expression or command could not be handled.\n"); considerDyingOnError(); } } else { printMessage(1,SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED,"Warning: at least one of the given expressions or a subexpression is not correctly typed\nor its evaluation has failed because of some error on a side-effect.\n"); printMessage(2,SOLLYA_MSG_CONTINUATION,"Information: the expression or a partial evaluation of it has been the following:\n%b\n",evaluated); freeThing(evaluated); considerDyingOnError(); } printMessage(3,SOLLYA_MSG_EVALUATION_CREATES_ERROR_SPECIAL_SYMBOL,"Information: evaluation creates an error special symbol.\n"); evaluated = makeError(); } if (autosimplify && isPureTree(evaluated)) { if (((evaluated->nodeType == MEMREF) && (evaluated->polynomialRepresentation != NULL)) || (treeSize(evaluated) < MAXAUTOSIMPLSIZE)) { tempNode = simplifyTreeErrorfree(evaluated); freeThing(evaluated); evaluated = tempNode; } else { printMessage(1,SOLLYA_MSG_EXPR_TOO_BIG_FOR_AUTOMATIC_SIMPLIFICATION,"Warning: the given expression is too big to be treated by the automatic simplification.\n"); } } if (okay && (evaluated->nodeType == MEMREF)) { tryRepresentAsPolynomialNoConstants(evaluated); evaluated->isCorrectlyTyped = 1; } return evaluated; } int evaluateFormatsListForFPminimax(chain **res, node *list, int n, int mode) { chain *result=NULL; chain *curr; int i, a; int *intptr; if( (accessThruMemRef(list)->nodeType==LIST) && (lengthChain(accessThruMemRef(list)->arguments) < n) ) { printMessage(1, SOLLYA_MSG_FPMINIMAX_LESS_FORMATS_THAN_MONOMIALS, "Error in fpminimax: there is less formats indications than monomials\n"); considerDyingOnError(); return 0; } if( (accessThruMemRef(list)->nodeType==LIST) && (lengthChain(accessThruMemRef(list)->arguments) > n) ) { printMessage(1, SOLLYA_MSG_FPMINIMAX_LESS_MONOMIALS_THAN_FORMATS, "Warning in fpminimax: there is more formats indications than monomials\nthe formats list will be truncated\n"); } curr=accessThruMemRef(list)->arguments; i = 1; while(i <= n) { switch((accessThruMemRef((node *)(curr->value)))->nodeType) { case SINGLESYMBOL: a=24; break; case QUADSYMBOL: a=113; break; case HALFPRECISIONSYMBOL: a=11; break; case DOUBLESYMBOL: a=53; break; case DOUBLEDOUBLESYMBOL: a=107; break; case TRIPLEDOUBLESYMBOL: a=161; break; case DOUBLEEXTENDEDSYMBOL: a=64; break; default: if (! evaluateThingToInteger(&a, (node *)(curr->value), NULL) ) { printMessage(1, SOLLYA_MSG_FPMINIMAX_FORMAT_LIST_MALFORMED, "Error in fpminimax: the formats list must contains only integers or formats\n"); considerDyingOnError(); freeChain(result, freeIntPtr); return 0; } } if ((a <= 0) && (mode == FLOATING)) { printMessage(1, SOLLYA_MSG_FPMINIMAX_FORMAT_NEGATIVE_FOR_FP_COEFFS, "Warning in fpminimax: a format indication is non-positive while floating-point coefficients are desired.\n"); printMessage(1, SOLLYA_MSG_CONTINUATION, "The corresponding format is replaced by 1.\n"); a = 1; } intptr = (int *)safeMalloc(sizeof(int)); *intptr = a; result = addElement(result, intptr); if(curr->next != NULL) curr=curr->next; i++; } *res = copyChain(result, copyIntPtrOnVoid); freeChain(result, freeIntPtr); return 1; } void mpfr_zero_sign_normalize(mpfr_t op) { if (mpfr_zero_p(op)) { mpfr_mul(op,op,op,GMP_RNDN); /* (+/- 0)^2 = +0 */ } } int evaluateArgumentForExternalProc(void **res, node *argument, int type) { int retVal; mpfr_t a, b; chain *curr; switch (type) { case VOID_TYPE: retVal = 0; break; case CONSTANT_TYPE: *res = safeMalloc(sizeof(mpfr_t)); mpfr_init2(*((mpfr_t *) (*res)), tools_precision); retVal = evaluateThingToConstant(*((mpfr_t *) (*res)), argument, NULL, 0,0); mpfr_zero_sign_normalize(*((mpfr_t *) (*res))); if (!retVal) { mpfr_clear(*((mpfr_t *) (*res))); safeFree(*res); } break; case FUNCTION_TYPE: retVal = evaluateThingToPureTree((node **) res, argument); break; case OBJECT_TYPE: *res = evaluateThing(argument); retVal = 1; break; case RANGE_TYPE: mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); retVal = evaluateThingToRange(a, b, argument); if (retVal) { *res = safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*((sollya_mpfi_t *) (*res)), tools_precision); sollya_mpfi_interv_fr_safe(*((sollya_mpfi_t *) (*res)), a, b); } mpfr_clear(a); mpfr_clear(b); break; case INTEGER_TYPE: *res = safeMalloc(sizeof(int)); retVal = evaluateThingToInteger((int *) (*res), argument, NULL); if (!retVal) { safeFree(*res); } break; case STRING_TYPE: retVal = evaluateThingToString((char **) res, argument); break; case BOOLEAN_TYPE: *res = safeMalloc(sizeof(int)); retVal = evaluateThingToBoolean((int *) (*res), argument, NULL); if (!retVal) { safeFree(*res); } break; case CONSTANT_LIST_TYPE: if (evaluateThingToEmptyList(argument)) { *((chain **) res) = NULL; retVal = 1; } else { retVal = evaluateThingToConstantList((chain **) res, argument); for (curr=*((chain **) res); curr != NULL; curr = curr->next) { mpfr_zero_sign_normalize(*((mpfr_t *) curr->value)); } } break; case FUNCTION_LIST_TYPE: if (evaluateThingToEmptyList(argument)) { *((chain **) res) = NULL; retVal = 1; } else retVal = evaluateThingToPureListOfPureTrees((chain **) res, argument); break; case OBJECT_LIST_TYPE: if (evaluateThingToEmptyList(argument)) { *((chain **) res) = NULL; retVal = 1; } else retVal = evaluateThingToPureListOfThings((chain **) res, argument); break; case RANGE_LIST_TYPE: if (evaluateThingToEmptyList(argument)) { *((chain **) res) = NULL; retVal = 1; } else retVal = evaluateThingToRangeList((chain **) res, argument); break; case INTEGER_LIST_TYPE: if (evaluateThingToEmptyList(argument)) { *((chain **) res) = NULL; retVal = 1; } else retVal = evaluateThingToIntegerList((chain **) res, NULL, argument); break; case STRING_LIST_TYPE: if (evaluateThingToEmptyList(argument)) { *((chain **) res) = NULL; retVal = 1; } else retVal = evaluateThingToStringList((chain **) res, argument); break; case BOOLEAN_LIST_TYPE: if (evaluateThingToEmptyList(argument)) { *((chain **) res) = NULL; retVal = 1; } else retVal = evaluateThingToBooleanList((chain **) res, argument); break; default: sollyaFprintf(stderr, "Error in evaluateArgumentForExternalProc: unknown type.\n"); exit(1); } return retVal; } void freeArgumentForExternalProc(void* arg, int type) { switch (type) { case VOID_TYPE: break; case CONSTANT_TYPE: mpfr_clear(*((mpfr_t *) arg)); safeFree(arg); break; case FUNCTION_TYPE: freeThing((node *) arg); break; case OBJECT_TYPE: freeThing((node *) arg); break; case RANGE_TYPE: sollya_mpfi_clear(*((sollya_mpfi_t *) arg)); safeFree(arg); break; case INTEGER_TYPE: safeFree(arg); break; case STRING_TYPE: safeFree(arg); break; case BOOLEAN_TYPE: safeFree(arg); break; case CONSTANT_LIST_TYPE: freeChain((chain *) arg, freeMpfrPtr); break; case FUNCTION_LIST_TYPE: freeChain((chain *) arg, freeThingOnVoid); break; case OBJECT_LIST_TYPE: freeChain((chain *) arg, freeThingOnVoid); break; case RANGE_LIST_TYPE: freeChain((chain *) arg, freeMpfiPtr); break; case INTEGER_LIST_TYPE: freeChain((chain *) arg, freeIntPtr); break; case STRING_LIST_TYPE: freeChain((chain *) arg, safeFree); break; case BOOLEAN_LIST_TYPE: freeChain((chain *) arg, freeIntPtr); break; default: sollyaFprintf(stderr, "Error in freeArgumentForExternalProc: unknown type.\n"); exit(1); } } int executeMatchBodyInner(node **resultThing, node *body, node *thingToReturn, chain *associations, node *thingToMatch) { int okay, failure; chain *curr; node *thingToDeclare; curr = accessThruMemRef(body)->arguments; okay = 1; while (curr != NULL) { if (isQuit((node *) (curr->value)) || isFalseQuit((node *) (curr->value)) || isRestart((node *) (curr->value)) || isFalseRestart((node *) (curr->value))) { printMessage(1,SOLLYA_MSG_QUIT_OR_RESTART_MUST_NOT_BE_IN_MATCH,"Warning: a quit or restart command may not be part of the body of a match-with construct.\nThe match-with construct will not be executed.\n"); considerDyingOnError(); okay = 0; break; } curr = curr->next; } if (!okay) { *resultThing = NULL; return 0; } declaredSymbolTable = pushFrame(declaredSymbolTable); okay = 1; curr = associations; while (curr != NULL) { failure = 1; if ((variablename != NULL) && (strcmp(variablename, ((entry *) (curr->value))->name) == 0)) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_MATCHED,"Warning: the identifier \"%s\" is already bound to the current free variable.\nIt cannot be used as a match variable. The match-with construct cannot be executed.\n", ((entry *) (curr->value))->name); considerDyingOnError(); } else { if (getFunction(((entry *) (curr->value))->name) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_MATCHED,"Warning: the identifier \"%s\" is already bound to a library function.\nIt cannot be used as a match variable. The match-with construct cannot be executed.\n", ((entry *) (curr->value))->name); considerDyingOnError(); } else { if (getConstantFunction(((entry *) (curr->value))->name) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_MATCHED,"Warning: the identifier \"%s\" is already bound to a library constant.\nIt cannot be used as a match variable. The match-with construct cannot be executed.\n", ((entry *) (curr->value))->name); considerDyingOnError(); } else { if (getProcedure(((entry *) (curr->value))->name) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_MATCHED,"Warning: the identifier \"%s\" is already bound to an external procedure.\nIt cannot be used as a match variable. The match-with cannot be executed.\n", ((entry *) (curr->value))->name); considerDyingOnError(); } else { if (declaredSymbolTable != NULL) { failure = 0; thingToDeclare = copyThingWithMemRefReuse((node *) (((entry *) (curr->value))->value),thingToMatch); declaredSymbolTable = declareNewEntry(declaredSymbolTable, ((entry *) (curr->value))->name, thingToDeclare, copyThingOnVoid); freeThing(thingToDeclare); } else { printMessage(1,SOLLYA_MSG_FRAME_SYSTEM_CORRUPTED_MATCH_NOT_EXECUTED,"Warning: previous command interruptions have corrupted the frame system.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The match variable \"%s\" cannot be bound to its actual value.\nThe match-with cannot be executed.\n",((entry *) (curr->value))->name); considerDyingOnError(); } } } } } if (failure) { okay = 0; break; } curr = curr->next; } if (!okay) { declaredSymbolTable = popFrame(declaredSymbolTable,freeThingOnVoid); *resultThing = NULL; return 0; } declaredSymbolTable = pushFrame(declaredSymbolTable); curr = accessThruMemRef(body)->arguments; okay = 1; while (curr != NULL) { if (isQuit((node *) (curr->value)) || isFalseQuit((node *) (curr->value)) || isRestart((node *) (curr->value)) || isRestart((node *) (curr->value))) { printMessage(1,SOLLYA_MSG_QUIT_OR_RESTART_MUST_NOT_BE_IN_MATCH,"Warning: a quit or restart command may not be part of the body of a match-with construct.\nThe match-with construct will no longer be executed.\n"); failure = 1; } else { failure = executeCommand((node *) (curr->value)); } if (failure) { okay = 0; break; } curr = curr->next; } if (!okay) { declaredSymbolTable = popFrame(declaredSymbolTable,freeThingOnVoid); declaredSymbolTable = popFrame(declaredSymbolTable,freeThingOnVoid); *resultThing = NULL; return 0; } *resultThing = evaluateThing(thingToReturn); declaredSymbolTable = popFrame(declaredSymbolTable,freeThingOnVoid); declaredSymbolTable = popFrame(declaredSymbolTable,freeThingOnVoid); return 1; } int executeMatchBody(node **resultThing, node *body, node *thingToReturn, chain *associations, node *thingToMatch) { int res; pushTimeCounter(); res = executeMatchBodyInner(resultThing, body, thingToReturn, associations, thingToMatch); popTimeCounter("executing the body of a match-with construct"); return res; } int executeMatch(node **result, node *thingToMatch, node **matchers, node **codesToRun, node **thingsToReturn, int numberMatchers) { int i, okay; chain *associations; okay = 0; associations = NULL; for (i=0;iprocedure = procedure; if (accessThruMemRef(procedure)->nodeType == PROCILLIM) { frame->arguments = args; frame->argsAreEndElliptic = !!elliptic; } else { frame->argsAreEndElliptic = 0; if ((args != NULL) && (args->next == NULL) && (isUnit((node *) (args->value)))) { frame->arguments = NULL; } else { frame->arguments = args; } } backtraceStack = addElement(backtraceStack, frame); } void backtracePopFrame() { chain *temp; if (backtraceStack == NULL) return; temp = backtraceStack; backtraceStack = backtraceStack->next; safeFree(temp->value); safeFree(temp); } node *getBacktrace() { chain *frames, *curr; node *res, *frameStruct, *argumentsNode; char *tempString; entry *structEntry; chain *assoclist; if (backtraceStack == NULL) { return makeEmptyList(); } frames = NULL; for (curr=backtraceStack;curr!=NULL;curr=curr->next) { structEntry = (entry *) safeMalloc(sizeof(entry)); tempString = "called_proc"; structEntry->name = (char *) safeCalloc(strlen(tempString)+1,sizeof(char)); strcpy(structEntry->name,tempString); structEntry->value = addMemRef(copyThing(((backtrace_frame_t) (curr->value))->procedure)); assoclist = addElement(NULL,(void *) structEntry); structEntry = (entry *) safeMalloc(sizeof(entry)); if (((backtrace_frame_t) (curr->value))->arguments == NULL) { argumentsNode = addMemRef(makeEmptyList()); } else { if (((backtrace_frame_t) (curr->value))->argsAreEndElliptic) { argumentsNode = addMemRef(makeFinalEllipticList(copyChainWithoutReversal(((backtrace_frame_t) (curr->value))->arguments, copyThingOnVoid))); } else { argumentsNode = addMemRef(makeList(copyChainWithoutReversal(((backtrace_frame_t) (curr->value))->arguments, copyThingOnVoid))); } } tempString = "passed_args"; structEntry->name = (char *) safeCalloc(strlen(tempString)+1,sizeof(char)); strcpy(structEntry->name,tempString); structEntry->value = argumentsNode; assoclist = addElement(assoclist,(void *) structEntry); frameStruct = addMemRef(makeStructure(assoclist)); frames = addElement(frames, frameStruct); } res = makeList(copyChain(frames, copyThingOnVoid)); freeChain(frames, freeThingOnVoid); return res; } int executeProcedureInner(node **resultThing, node *proc, chain *args, int elliptic) { int result, res, noError; chain *curr, *curr2; node *tempNode; if (accessThruMemRef(proc)->nodeType != PROCILLIM) { if (lengthChain(accessThruMemRef(proc)->arguments) != lengthChain(args)) { if (!((lengthChain(args) == 1) && (isUnit((node *) (args->value))) && (lengthChain(accessThruMemRef(proc)->arguments) == 0))) { *resultThing = NULL; return 1; } } } curr = accessThruMemRef(accessThruMemRef(proc)->child1)->arguments; result = 0; while (curr != NULL) { if (isQuit((node *) (curr->value)) || isFalseQuit((node *) (curr->value)) || isRestart((node *) (curr->value)) || isFalseRestart((node *) (curr->value))) { printMessage(1,SOLLYA_MSG_QUIT_OR_RESTART_MUST_NOT_BE_IN_PROC,"Warning: a quit or restart command may not be part of a procedure body.\nThe procedure will not be executed.\n"); considerDyingOnError(); result = 1; break; } curr = curr->next; } if (result) { *resultThing = NULL; return 0; } declaredSymbolTable = pushFrame(declaredSymbolTable); result = 0; curr = accessThruMemRef(proc)->arguments; curr2 = args; while (curr != NULL) { noError = 0; if ((variablename != NULL) && (strcmp(variablename, (char *) (curr->value)) == 0)) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_PARAMETER,"Warning: the identifier \"%s\" is already bound to the current free variable.\nIt cannot be used as a formal parameter of a procedure. The procedure cannot be executed.\n", (char *) (curr->value)); considerDyingOnError(); } else { if (getFunction((char *) (curr->value)) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_PARAMETER,"Warning: the identifier \"%s\" is already bound to a library function.\nIt cannot be used as a formal parameter of a procedure. The procedure cannot be executed.\n", (char *) (curr->value)); considerDyingOnError(); } else { if (getConstantFunction((char *) (curr->value)) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_PARAMETER,"Warning: the identifier \"%s\" is already bound to a library constant.\nIt cannot be used as a formal parameter of a procedure. The procedure cannot be executed.\n", (char *) (curr->value)); considerDyingOnError(); } else { if (getProcedure((char *) (curr->value)) != NULL) { printMessage(1,SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_PARAMETER,"Warning: the identifier \"%s\" is already bound to an external procedure.\nIt cannot be used as a formal parameter of a procedure. The procedure cannot be executed.\n", (char *) (curr->value),(char *) (curr->value)); considerDyingOnError(); } else { if (declaredSymbolTable != NULL) { noError = 1; if (accessThruMemRef(proc)->nodeType != PROCILLIM) { declaredSymbolTable = declareNewEntry(declaredSymbolTable, (char *) (curr->value), (node *) (curr2->value), copyThingOnVoid); } else { if (curr2 == NULL) { tempNode = makeEmptyList(); declaredSymbolTable = declareNewEntry(declaredSymbolTable, (char *) (curr->value), tempNode, copyThingOnVoid); freeThing(tempNode); } else { if (elliptic) tempNode = makeFinalEllipticList(copyChainWithoutReversal(curr2, copyThingOnVoid)); else tempNode = makeList(copyChainWithoutReversal(curr2, copyThingOnVoid)); declaredSymbolTable = declareNewEntry(declaredSymbolTable, (char *) (curr->value), tempNode, copyThingOnVoid); freeThing(tempNode); } } } else { printMessage(1,SOLLYA_MSG_FRAME_SYSTEM_CORRUPTED_PROC_NOT_EXECUTED,"Warning: previous command interruptions have corrupted the frame system.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The formal parameter \"%s\" cannot be bound to its actual value.\nThe procedure cannot be executed.\n",(char *) (curr->value)); considerDyingOnError(); } } } } } if (!noError) { result = 1; break; } if (accessThruMemRef(proc)->nodeType == PROCILLIM) break; curr = curr->next; curr2 = curr2->next; } if (result) { declaredSymbolTable = popFrame(declaredSymbolTable,freeThingOnVoid); *resultThing = NULL; return 0; } curr = accessThruMemRef(accessThruMemRef(proc)->child1)->arguments; result = 0; while (curr != NULL) { if (isQuit((node *) (curr->value)) || isFalseQuit((node *) (curr->value)) || isRestart((node *) (curr->value)) || isRestart((node *) (curr->value))) { printMessage(1,SOLLYA_MSG_QUIT_OR_RESTART_MUST_NOT_BE_IN_PROC,"Warning: a quit or restart command may not be part of a procedure body.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The procedure will no longer be executed.\n"); res = 1; } else { res = executeCommand((node *) (curr->value)); } if (res) { result = 1; break; } curr = curr->next; } if (result) { declaredSymbolTable = popFrame(declaredSymbolTable,freeThingOnVoid); *resultThing = NULL; return 0; } *resultThing = evaluateThing(accessThruMemRef(proc)->child2); declaredSymbolTable = popFrame(declaredSymbolTable,freeThingOnVoid); return 1; } int executeProcedure(node **resultThing, node *proc, chain *args, int elliptic) { int res; pushTimeCounter(); backtracePushFrame(proc, args, elliptic); res = executeProcedureInner(resultThing, proc, args, elliptic); backtracePopFrame(); popTimeCounter("executing a procedure"); return res; } void computeFunctionWithProcedureInner(sollya_mpfi_t y, node *proc, sollya_mpfi_t x, unsigned int derivN) { mpfr_t derivNAsMpfr, xleft, xright, precAsMpfr; chain *args; int res; node *resThing; if (isProcedure(proc)) { mpfr_init2(precAsMpfr,8 * sizeof(mp_prec_t) + 10); mpfr_set_ui(precAsMpfr,(unsigned int) sollya_mpfi_get_prec(y),GMP_RNDU); mpfr_init2(derivNAsMpfr,8 * sizeof(derivN) + 10); mpfr_set_ui(derivNAsMpfr,derivN,GMP_RNDN); mpfr_init2(xleft,sollya_mpfi_get_prec(x)); mpfr_init2(xright,sollya_mpfi_get_prec(x)); sollya_mpfi_get_left(xleft,x); sollya_mpfi_get_right(xright,x); args = addElement(addElement(addElement(NULL,makeConstant(precAsMpfr)), makeConstant(derivNAsMpfr)), makeRange(makeConstant(xleft),makeConstant(xright))); res = executeProcedure(&resThing, proc, args, 0); if (res) { if (resThing != NULL) { if (isRange(resThing)) { sollya_mpfi_interv_fr_safe(y,*(accessThruMemRef(accessThruMemRef(resThing)->child1)->value),*(accessThruMemRef(accessThruMemRef(resThing)->child2)->value)); } else { sollya_mpfi_set_nan(y); } freeThing(resThing); } else { sollya_mpfi_set_nan(y); } } else { sollya_mpfi_set_nan(y); } freeChain(args, freeThingOnVoid); mpfr_clear(xright); mpfr_clear(xleft); mpfr_clear(derivNAsMpfr); mpfr_clear(precAsMpfr); } else { sollya_mpfi_set_nan(y); } } void computeFunctionWithProcedure(sollya_mpfi_t y, node *proc, sollya_mpfi_t x, unsigned int derivN, node *mr) { if ((mr != NULL) && (mr->nodeType == MEMREF) && (mr->child1 != NULL) && (mr->child1->nodeType == PROCEDUREFUNCTION) && (mr->child1->child2 == proc) && (mr->evalCacheX != NULL) && (mr->evalCacheY != NULL) && (accessThruMemRef(mr->child1->child1)->nodeType == VARIABLE) && (sollya_mpfi_get_prec(*(mr->evalCacheY)) >= sollya_mpfi_get_prec(y)) && (mr->evalCachePrec >= sollya_mpfi_get_prec(y)) && (sollya_mpfi_equal_p(*(mr->evalCacheX), x))) { sollya_mpfi_set(y, *(mr->evalCacheY)); return; } computeFunctionWithProcedureInner(y, proc, x, derivN); } void computeFunctionWithProcedureMpfr(mpfr_t rop, node *proc, mpfr_t op, unsigned int derivN) { sollya_mpfi_t opI, ropI; sollya_mpfi_init2(opI,mpfr_get_prec(op)); sollya_mpfi_init2(ropI,mpfr_get_prec(rop)+2); sollya_mpfi_set_fr(opI,op); computeFunctionWithProcedure(ropI,proc,opI,derivN,NULL); sollya_mpfi_mid(rop,ropI); sollya_mpfi_clear(opI); sollya_mpfi_clear(ropI); } int executeExternalProcedureInner(node **resultThing, libraryProcedure *proc, chain *args) { chain *myArgs, *myArgSignature, *curr, *curr2; int myResultSignature; void **arguments; int numberArgs, i, res, k; int externalResult; void *resultSpace; mpfr_t a, b; mp_prec_t pr; node *tempNode; if ((lengthChain(args) == 1) && (isUnit((node *) (args->value)))) myArgs = NULL; else myArgs = args; if (*((int *) (proc->signature->next->value)) == VOID_TYPE) { myArgSignature = NULL; myResultSignature = *((int *) (proc->signature->value)); } else { myArgSignature = copyChainWithoutReversal(proc->signature->next,copyIntPtrOnVoid); myResultSignature = *((int *) (proc->signature->value)); } if ((numberArgs = lengthChain(myArgs)) != lengthChain(myArgSignature)) { freeChain(myArgSignature, freeIntPtr); *resultThing = NULL; return 1; } if (numberArgs != 0) { arguments = (void **) safeCalloc(numberArgs, sizeof(void *)); curr = myArgs; curr2 = myArgSignature; i = 0; res=0; /* useless */ while ((curr != NULL) && (curr2 != NULL)) { res = evaluateArgumentForExternalProc(&(arguments[i]),(node *) (curr->value),*((int *) (curr2->value))); if (!res) break; i++; curr = curr->next; curr2 = curr2->next; } if (!res) { k = 0; curr2 = myArgSignature; while ((curr2 != NULL) && (k < i)) { freeArgumentForExternalProc(arguments[k],*((int *) (curr2->value))); k++; curr2 = curr2->next; } safeFree(arguments); freeChain(myArgSignature, freeIntPtr); *resultThing = NULL; return 1; } } if (numberArgs != 0) { switch (myResultSignature) { case VOID_TYPE: if (proc->hasData) { externalResult = ((int (*)(void **, void *))(proc->code))(arguments, proc->data); } else { externalResult = ((int (*)(void **))(proc->code))(arguments); } if (externalResult) { *resultThing = makeUnit(); } break; case CONSTANT_TYPE: resultSpace = safeMalloc(sizeof(mpfr_t)); mpfr_init2(*((mpfr_t *) resultSpace),tools_precision); if (proc->hasData) { externalResult = ((int (*)(mpfr_t *, void **, void *))(proc->code))((mpfr_t *) resultSpace,arguments, proc->data); } else { externalResult = ((int (*)(mpfr_t *, void **))(proc->code))((mpfr_t *) resultSpace,arguments); } if (externalResult) { *resultThing = makeConstant(*((mpfr_t *) resultSpace)); } mpfr_clear(*((mpfr_t *) resultSpace)); safeFree(resultSpace); break; case FUNCTION_TYPE: if (proc->hasData) { externalResult = ((int (*)(node **, void **, void *))(proc->code))((node **) (&resultSpace),arguments, proc->data); } else { externalResult = ((int (*)(node **, void **))(proc->code))((node **) (&resultSpace),arguments); } if (externalResult) { *resultThing = (node *) resultSpace; } break; case OBJECT_TYPE: if (proc->hasData) { externalResult = ((int (*)(node **, void **, void *))(proc->code))((node **) (&resultSpace),arguments, proc->data); } else { externalResult = ((int (*)(node **, void **))(proc->code))((node **) (&resultSpace),arguments); } if (externalResult) { *resultThing = (node *) resultSpace; } break; case RANGE_TYPE: resultSpace = safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*((sollya_mpfi_t *) resultSpace),tools_precision); if (proc->hasData) { externalResult = ((int (*)(mpfi_t *, void **, void *))(proc->code))((mpfi_t *) resultSpace,arguments, proc->data); } else { externalResult = ((int (*)(mpfi_t *, void **))(proc->code))((mpfi_t *) resultSpace,arguments); } if (externalResult) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a, *((sollya_mpfi_t *) resultSpace)); sollya_mpfi_get_right(b, *((sollya_mpfi_t *) resultSpace)); *resultThing = makeRange(makeConstant(a), makeConstant(b)); mpfr_clear(b); mpfr_clear(a); } sollya_mpfi_clear(*((sollya_mpfi_t *) resultSpace)); safeFree(resultSpace); break; case INTEGER_TYPE: resultSpace = safeMalloc(sizeof(int)); if (proc->hasData) { externalResult = ((int (*)(int *, void **, void *))(proc->code))((int *) (resultSpace),arguments, proc->data); } else { externalResult = ((int (*)(int *, void **))(proc->code))((int *) (resultSpace),arguments); } if (externalResult) { mpfr_init2(a,(mp_prec_t) (8 * sizeof(int) + 5)); mpfr_set_si(a,*((int *) resultSpace), GMP_RNDN); *resultThing = makeConstant(a); mpfr_clear(a); } safeFree(resultSpace); break; case STRING_TYPE: if (proc->hasData) { externalResult = ((int (*)(char **, void **, void *))(proc->code))((char **) (&resultSpace),arguments, proc->data); } else { externalResult = ((int (*)(char **, void **))(proc->code))((char **) (&resultSpace),arguments); } if (externalResult) { *resultThing = makeString((char *) resultSpace); safeFree(resultSpace); } break; case BOOLEAN_TYPE: resultSpace = safeMalloc(sizeof(int)); if (proc->hasData) { externalResult = ((int (*)(int *, void **, void *))(proc->code))((int *) (resultSpace),arguments, proc->data); } else { externalResult = ((int (*)(int *, void **))(proc->code))((int *) (resultSpace),arguments); } if (externalResult) { if (*((int *) resultSpace)) { *resultThing = makeTrue(); } else { *resultThing = makeFalse(); } } safeFree(resultSpace); break; case CONSTANT_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void **, void *))(proc->code))((chain **) (&resultSpace),arguments, proc->data); } else { externalResult = ((int (*)(chain **, void **))(proc->code))((chain **) (&resultSpace),arguments); } if (externalResult) { curr = (chain *) resultSpace; if (curr == NULL) { *resultThing = makeEmptyList(); } else { curr2 = NULL; while (curr != NULL) { curr2 = addElement(curr2, makeConstant(*((mpfr_t *) (curr->value)))); curr = curr->next; } *resultThing = makeList(copyChain(curr2, copyThingOnVoid)); freeChain(curr2, freeThingOnVoid); freeChain((chain *) resultSpace, freeMpfrPtr); } } break; case FUNCTION_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void **, void *))(proc->code))((chain **) (&resultSpace),arguments, proc->data); } else { externalResult = ((int (*)(chain **, void **))(proc->code))((chain **) (&resultSpace),arguments); } if (externalResult) { if (((chain *) resultSpace) == NULL) { *resultThing = makeEmptyList(); } else { *resultThing = makeList((chain *) resultSpace); } } break; case OBJECT_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void **, void *))(proc->code))((chain **) (&resultSpace),arguments, proc->data); } else { externalResult = ((int (*)(chain **, void **))(proc->code))((chain **) (&resultSpace),arguments); } if (externalResult) { if (((chain *) resultSpace) == NULL) { *resultThing = makeEmptyList(); } else { *resultThing = makeList((chain *) resultSpace); } } break; case RANGE_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void **, void *))(proc->code))((chain **) (&resultSpace),arguments, proc->data); } else { externalResult = ((int (*)(chain **, void **))(proc->code))((chain **) (&resultSpace),arguments); } if (externalResult) { curr = (chain *) resultSpace; if (curr == NULL) { *resultThing = makeEmptyList(); } else { curr2 = NULL; while (curr != NULL) { pr = sollya_mpfi_get_prec(*((sollya_mpfi_t *) (curr->value))); mpfr_init2(a, pr); mpfr_init2(b, pr); sollya_mpfi_get_left(a, *((sollya_mpfi_t *) (curr->value))); sollya_mpfi_get_right(b, *((sollya_mpfi_t *) (curr->value))); curr2 = addElement(curr2, makeRange(makeConstant(a), makeConstant(b))); mpfr_clear(a); mpfr_clear(b); curr = curr->next; } *resultThing = makeList(copyChain(curr2, copyThingOnVoid)); freeChain(curr2, freeThingOnVoid); freeChain((chain *) resultSpace, freeMpfiPtr); } } break; case INTEGER_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void **, void *))(proc->code))((chain **) (&resultSpace),arguments, proc->data); } else { externalResult = ((int (*)(chain **, void **))(proc->code))((chain **) (&resultSpace),arguments); } if (externalResult) { curr = (chain *) resultSpace; if (curr == NULL) { *resultThing = makeEmptyList(); } else { curr2 = NULL; mpfr_init2(a,(mp_prec_t) (8 * sizeof(int) + 5)); while (curr != NULL) { mpfr_set_si(a, *((int *) (curr->value)), GMP_RNDN); curr2 = addElement(curr2, makeConstant(a)); curr = curr->next; } mpfr_clear(a); *resultThing = makeList(copyChain(curr2, copyThingOnVoid)); freeChain(curr2, freeThingOnVoid); freeChain((chain *) resultSpace, freeIntPtr); } } break; case STRING_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void **, void *))(proc->code))((chain **) (&resultSpace),arguments, proc->data); } else { externalResult = ((int (*)(chain **, void **))(proc->code))((chain **) (&resultSpace),arguments); } if (externalResult) { curr = (chain *) resultSpace; if (curr == NULL) { *resultThing = makeEmptyList(); } else { curr2 = NULL; while (curr != NULL) { curr2 = addElement(curr2, makeString((char *) (curr->value))); curr = curr->next; } *resultThing = makeList(copyChain(curr2, copyThingOnVoid)); freeChain(curr2, freeThingOnVoid); freeChain((chain *) resultSpace, safeFree); } } break; case BOOLEAN_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void **, void *))(proc->code))((chain **) (&resultSpace),arguments, proc->data); } else { externalResult = ((int (*)(chain **, void **))(proc->code))((chain **) (&resultSpace),arguments); } if (externalResult) { curr = (chain *) resultSpace; if (curr == NULL) { *resultThing = makeEmptyList(); } else { curr2 = NULL; while (curr != NULL) { if (*((int *) (curr->value))) { tempNode = makeTrue(); } else { tempNode = makeFalse(); } curr2 = addElement(curr2, tempNode); curr = curr->next; } *resultThing = makeList(copyChain(curr2, copyThingOnVoid)); freeChain(curr2, freeThingOnVoid); freeChain((chain *) resultSpace, freeIntPtr); } } break; default: sollyaFprintf(stderr, "Error in executeExternalProcedure: unknown type.\n"); exit(1); } } else { switch (myResultSignature) { case VOID_TYPE: if (proc->hasData) { externalResult = ((int (*)(void *))(proc->code))(proc->data); } else { externalResult = ((int (*)())(proc->code))(); } if (externalResult) { *resultThing = makeUnit(); } break; case CONSTANT_TYPE: resultSpace = safeMalloc(sizeof(mpfr_t)); mpfr_init2(*((mpfr_t *) resultSpace),tools_precision); if (proc->hasData) { externalResult = ((int (*)(mpfr_t *, void *))(proc->code))((mpfr_t *) resultSpace, proc->data); } else { externalResult = ((int (*)(mpfr_t *))(proc->code))((mpfr_t *) resultSpace); } if (externalResult) { *resultThing = makeConstant(*((mpfr_t *) resultSpace)); } mpfr_clear(*((mpfr_t *) resultSpace)); safeFree(resultSpace); break; case FUNCTION_TYPE: if (proc->hasData) { externalResult = ((int (*)(node **, void *))(proc->code))((node **) (&resultSpace), proc->data); } else { externalResult = ((int (*)(node **))(proc->code))((node **) (&resultSpace)); } if (externalResult) { *resultThing = (node *) resultSpace; } break; case OBJECT_TYPE: if (proc->hasData) { externalResult = ((int (*)(node **, void *))(proc->code))((node **) (&resultSpace), proc->data); } else { externalResult = ((int (*)(node **))(proc->code))((node **) (&resultSpace)); } if (externalResult) { *resultThing = (node *) resultSpace; } break; case RANGE_TYPE: resultSpace = safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*((sollya_mpfi_t *) resultSpace),tools_precision); if (proc->hasData) { externalResult = ((int (*)(sollya_mpfi_t *, void *))(proc->code))((sollya_mpfi_t *) resultSpace, proc->data); } else { externalResult = ((int (*)(sollya_mpfi_t *))(proc->code))((sollya_mpfi_t *) resultSpace); } if (externalResult) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a, *((sollya_mpfi_t *) resultSpace)); sollya_mpfi_get_right(b, *((sollya_mpfi_t *) resultSpace)); *resultThing = makeRange(makeConstant(a), makeConstant(b)); mpfr_clear(b); mpfr_clear(a); } sollya_mpfi_clear(*((sollya_mpfi_t *) resultSpace)); safeFree(resultSpace); break; case INTEGER_TYPE: resultSpace = safeMalloc(sizeof(int)); if (proc->hasData) { externalResult = ((int (*)(int *, void *))(proc->code))((int *) (resultSpace), proc->data); } else { externalResult = ((int (*)(int *))(proc->code))((int *) (resultSpace)); } if (externalResult) { mpfr_init2(a,(mp_prec_t) (8 * sizeof(int) + 5)); mpfr_set_si(a,*((int *) resultSpace), GMP_RNDN); *resultThing = makeConstant(a); mpfr_clear(a); } safeFree(resultSpace); break; case STRING_TYPE: if (proc->hasData) { externalResult = ((int (*)(char **, void *))(proc->code))((char **) (&resultSpace), proc->data); } else { externalResult = ((int (*)(char **))(proc->code))((char **) (&resultSpace)); } if (externalResult) { *resultThing = makeString((char *) resultSpace); safeFree(resultSpace); } break; case BOOLEAN_TYPE: resultSpace = safeMalloc(sizeof(int)); if (proc->hasData) { externalResult = ((int (*)(int *, void *))(proc->code))((int *) (resultSpace), proc->data); } else { externalResult = ((int (*)(int *))(proc->code))((int *) (resultSpace)); } if (externalResult) { if (*((int *) resultSpace)) { *resultThing = makeTrue(); } else { *resultThing = makeFalse(); } } safeFree(resultSpace); break; case CONSTANT_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void *))(proc->code))((chain **) (&resultSpace), proc->data); } else { externalResult = ((int (*)(chain **))(proc->code))((chain **) (&resultSpace)); } if (externalResult) { curr = (chain *) resultSpace; if (curr == NULL) { *resultThing = makeEmptyList(); } else { curr2 = NULL; while (curr != NULL) { curr2 = addElement(curr2, makeConstant(*((mpfr_t *) (curr->value)))); curr = curr->next; } *resultThing = makeList(copyChain(curr2, copyThingOnVoid)); freeChain(curr2, freeThingOnVoid); freeChain((chain *) resultSpace, freeMpfrPtr); } } break; case FUNCTION_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void *))(proc->code))((chain **) (&resultSpace), proc->data); } else { externalResult = ((int (*)(chain **))(proc->code))((chain **) (&resultSpace)); } if (externalResult) { if (((chain *) resultSpace) == NULL) { *resultThing = makeEmptyList(); } else { *resultThing = makeList((chain *) resultSpace); } } break; case OBJECT_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void *))(proc->code))((chain **) (&resultSpace), proc->data); } else { externalResult = ((int (*)(chain **))(proc->code))((chain **) (&resultSpace)); } if (externalResult) { if (((chain *) resultSpace) == NULL) { *resultThing = makeEmptyList(); } else { *resultThing = makeList((chain *) resultSpace); } } break; case RANGE_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void *))(proc->code))((chain **) (&resultSpace), proc->data); } else { externalResult = ((int (*)(chain **))(proc->code))((chain **) (&resultSpace)); } if (externalResult) { curr = (chain *) resultSpace; if (curr == NULL) { *resultThing = makeEmptyList(); } else { curr2 = NULL; while (curr != NULL) { pr = sollya_mpfi_get_prec(*((sollya_mpfi_t *) (curr->value))); mpfr_init2(a, pr); mpfr_init2(b, pr); sollya_mpfi_get_left(a, *((sollya_mpfi_t *) (curr->value))); sollya_mpfi_get_right(b, *((sollya_mpfi_t *) (curr->value))); curr2 = addElement(curr2, makeRange(makeConstant(a), makeConstant(b))); mpfr_clear(a); mpfr_clear(b); curr = curr->next; } *resultThing = makeList(copyChain(curr2, copyThingOnVoid)); freeChain(curr2, freeThingOnVoid); freeChain((chain *) resultSpace, freeMpfiPtr); } } break; case INTEGER_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void *))(proc->code))((chain **) (&resultSpace), proc->data); } else { externalResult = ((int (*)(chain **))(proc->code))((chain **) (&resultSpace)); } if (externalResult) { curr = (chain *) resultSpace; if (curr == NULL) { *resultThing = makeEmptyList(); } else { curr2 = NULL; mpfr_init2(a,(mp_prec_t) (8 * sizeof(int) + 5)); while (curr != NULL) { mpfr_set_si(a, *((int *) (curr->value)), GMP_RNDN); curr2 = addElement(curr2, makeConstant(a)); curr = curr->next; } mpfr_clear(a); *resultThing = makeList(copyChain(curr2, copyThingOnVoid)); freeChain(curr2, freeThingOnVoid); freeChain((chain *) resultSpace, freeIntPtr); } } break; case STRING_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void *))(proc->code))((chain **) (&resultSpace), proc->data); } else { externalResult = ((int (*)(chain **))(proc->code))((chain **) (&resultSpace)); } if (externalResult) { curr = (chain *) resultSpace; if (curr == NULL) { *resultThing = makeEmptyList(); } else { curr2 = NULL; while (curr != NULL) { curr2 = addElement(curr2, makeString((char *) (curr->value))); curr = curr->next; } *resultThing = makeList(copyChain(curr2, copyThingOnVoid)); freeChain(curr2, freeThingOnVoid); freeChain((chain *) resultSpace, safeFree); } } break; case BOOLEAN_LIST_TYPE: if (proc->hasData) { externalResult = ((int (*)(chain **, void *))(proc->code))((chain **) (&resultSpace), proc->data); } else { externalResult = ((int (*)(chain **))(proc->code))((chain **) (&resultSpace)); } if (externalResult) { curr = (chain *) resultSpace; if (curr == NULL) { *resultThing = makeEmptyList(); } else { curr2 = NULL; while (curr != NULL) { if (*((int *) (curr->value))) { tempNode = makeTrue(); } else { tempNode = makeFalse(); } curr2 = addElement(curr2, tempNode); curr = curr->next; } *resultThing = makeList(copyChain(curr2, copyThingOnVoid)); freeChain(curr2, freeThingOnVoid); freeChain((chain *) resultSpace, freeIntPtr); } } break; default: sollyaFprintf(stderr, "Error in executeExternalProcedure: unknown type.\n"); exit(1); } } if (numberArgs != 0) { k = 0; curr2 = myArgSignature; while ((curr2 != NULL) && (k <= numberArgs)) { freeArgumentForExternalProc(arguments[k],*((int *) (curr2->value))); k++; curr2 = curr2->next; } safeFree(arguments); } freeChain(myArgSignature, freeIntPtr); return externalResult; } int executeExternalProcedure(node **resultThing, libraryProcedure *proc, chain *args) { int res; pushTimeCounter(); res = executeExternalProcedureInner(resultThing, proc, args); popTimeCounter("executing an external procedure"); return res; } node *preevaluateMatcher(node *tree); void *preevaluateMatcherOnVoid(void *tree) { return (void *) preevaluateMatcher((node *) tree); } int variableUsePreventsPreevaluation(node *tree) { chain *curr; if (tree->nodeType == MEMREF) { return variableUsePreventsPreevaluation(getMemRefChild(tree)); } switch (tree->nodeType) { case RENAME: case ASSIGNMENT: case FLOATASSIGNMENT: case EXTERNALPROC: case LIBRARYBINDING: case LIBRARYCONSTANTBINDING: case DEFAULT: case ISBOUND: case STRUCTACCESS: case MATCH: case MATCHELEMENT: case VARIABLEDECLARATION: case ASSIGNMENTINSTRUCTURE: case FLOATASSIGNMENTINSTRUCTURE: case PROTOASSIGNMENTINSTRUCTURE: case PROTOFLOATASSIGNMENTINSTRUCTURE: case FOR: return 1; break; case TABLEACCESS: if ((variablename != NULL) && (!strcmp(variablename, tree->string))) { return 0; } else { return 1; } break; case TABLEACCESSWITHSUBSTITUTE: if ((variablename != NULL) && (!strcmp(variablename, tree->string))) { return variableUsePreventsPreevaluation(tree->child1); } else { return 1; } break; case VARIABLE: case CONSTANT: case LIBRARYCONSTANT: case PI_CONST: case QUIT: case NOP: case FALSEQUIT: case FALSERESTART: case RESTART: case ON: case OFF: case DYADIC: case POWERS: case BINARY: case HEXADECIMAL: case FILESYM: case POSTSCRIPT: case POSTSCRIPTFILE: case PERTURB: case ROUNDDOWN: case ROUNDUP: case ROUNDTOZERO: case ROUNDTONEAREST: case HONORCOEFF: case TRUE: case UNIT: case FALSE: case DECIMAL: case ABSOLUTESYM: case RELATIVESYM: case FIXED: case FLOATING: case ERRORSPECIAL: case DOUBLESYMBOL: case SINGLESYMBOL: case QUADSYMBOL: case HALFPRECISIONSYMBOL: case DOUBLEEXTENDEDSYMBOL: case DOUBLEDOUBLESYMBOL: case TRIPLEDOUBLESYMBOL: case STRING: case DECIMALCONSTANT: case MIDPOINTCONSTANT: case DYADICCONSTANT: case HEXCONSTANT: case HEXADECIMALCONSTANT: case BINARYCONSTANT: case EMPTYLIST: case ELLIPTIC: case EXTERNALPROCEDUREUSAGE: case PRECDEREF: case POINTSDEREF: case DIAMDEREF: case DISPLAYDEREF: case VERBOSITYDEREF: case CANONICALDEREF: case AUTOSIMPLIFYDEREF: case SHOWMESSAGENUMBERSDEREF: case TAYLORRECURSDEREF: case TIMINGDEREF: case FULLPARENDEREF: case MIDPOINTDEREF: case DIEONERRORMODEDEREF: case RATIONALMODEDEREF: case SUPPRESSWARNINGSDEREF: case HOPITALRECURSDEREF: case GETSUPPRESSEDMESSAGES: case GETBACKTRACE: return 0; break; case ADD: case SUB: case MUL: case DIV: case POW: case PROCEDUREFUNCTION: case WHILE: case IF: case FORIN: case ASCIIPLOT: case PRINTXMLNEWFILE: case PRINTXMLAPPENDFILE: case AND: case OR: case INDEX: case COMPAREEQUAL: case COMPAREIN: case COMPARELESS: case COMPAREGREATER: case COMPARELESSEQUAL: case COMPAREGREATEREQUAL: case COMPARENOTEQUAL: case CONCAT: case ADDTOLIST: case PREPEND: case APPEND: case RANGE: case SUBSTITUTE: case COMPOSEPOLYNOMIALS: case COEFF: case SUBPOLY: case ROUNDCOEFFICIENTS: case RATIONALAPPROX: case EVALUATE: case FINDZEROS: case FPFINDZEROS: case DIRTYINFNORM: case NUMBERROOTS: case INTEGRAL: case DIRTYINTEGRAL: case ZERODENOMINATORS: case ISEVALUABLE: case DIRTYFINDZEROS: case BIND: return (variableUsePreventsPreevaluation(tree->child1) && variableUsePreventsPreevaluation(tree->child2)); break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case DOUBLE: case SINGLE: case QUAD: case HALFPRECISION: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case LIBRARYFUNCTION: case CEIL: case FLOOR: case NEARESTINT: case NOPARG: case PRINTHEXA: case PRINTFLOAT: case PRINTBINARY: case PRINTEXPANSION: case BASHEXECUTE: case PRINTXML: case PRECASSIGN: case POINTSASSIGN: case DIAMASSIGN: case DISPLAYASSIGN: case VERBOSITYASSIGN: case CANONICALASSIGN: case AUTOSIMPLIFYASSIGN: case SHOWMESSAGENUMBERSASSIGN: case TAYLORRECURSASSIGN: case TIMINGASSIGN: case FULLPARENASSIGN: case MIDPOINTASSIGN: case DIEONERRORMODEASSIGN: case RATIONALMODEASSIGN: case SUPPRESSWARNINGSASSIGN: case HOPITALRECURSASSIGN: case PRECSTILLASSIGN: case POINTSSTILLASSIGN: case DIAMSTILLASSIGN: case DISPLAYSTILLASSIGN: case VERBOSITYSTILLASSIGN: case CANONICALSTILLASSIGN: case AUTOSIMPLIFYSTILLASSIGN: case SHOWMESSAGENUMBERSSTILLASSIGN: case TAYLORRECURSSTILLASSIGN: case TIMINGSTILLASSIGN: case FULLPARENSTILLASSIGN: case MIDPOINTSTILLASSIGN: case DIEONERRORMODESTILLASSIGN: case RATIONALMODESTILLASSIGN: case SUPPRESSWARNINGSSTILLASSIGN: case HOPITALRECURSSTILLASSIGN: case NEGATION: case HORNER: case CANONICAL: case EXPAND: case DEGREE: case NUMERATOR: case DENOMINATOR: case PARSE: case READXML: case EXECUTE: case HEAD: case ROUNDCORRECTLY: case READFILE: case REVERT: case SORT: case MANTISSA: case EXPONENT: case PRECISION: case TAIL: case LENGTH: case OBJECTNAME: case DEBOUNDMAX: case EVALCONST: case DEBOUNDMIN: case DEBOUNDMID: case DIFF: case DIRTYSIMPLIFY: case SIMPLIFYSAFE: case TIME: return variableUsePreventsPreevaluation(tree->child1); break; case PROC: case PROCILLIM: return ((tree->arguments == NULL) && variableUsePreventsPreevaluation(tree->child1) && variableUsePreventsPreevaluation(tree->child2)); break; case COMMANDLIST: case IFELSE: case PRINT: case SUPPRESSMESSAGE: case UNSUPPRESSMESSAGE: case PLOT: case EXTERNALPLOT: case WRITE: case WORSTCASE: case AUTOPRINT: case LIST: case FINALELLIPTICLIST: case REMEZ: case ANNOTATEFUNCTION: case BASHEVALUATE: case MIN: case MAX: case FPMINIMAX: case TAYLOR: case TAYLORFORM: case CHEBYSHEVFORM: case AUTODIFF: case ACCURATEINFNORM: case ROUNDTOFORMAT: case INFNORM: case SUPNORM: case IMPLEMENTPOLY: case IMPLEMENTCONST: case CHECKINFNORM: case SEARCHGAL: case GUESSDEGREE: case ASSIGNMENTININDEXING: case FLOATASSIGNMENTININDEXING: for (curr = tree->arguments; curr != NULL; curr = curr->next) { if (variableUsePreventsPreevaluation((node *) (curr->value))) return 1; } return 0; break; case NEWFILEPRINT: case NEWFILEWRITE: case APPENDFILEWRITE: case APPENDFILEPRINT: case APPLY: for (curr = tree->arguments; curr != NULL; curr = curr->next) { if (variableUsePreventsPreevaluation((node *) (curr->value))) return 1; } if (variableUsePreventsPreevaluation(tree->child1)) return 1; return 0; break; case STRUCTURE: for (curr = tree->arguments; curr != NULL; curr = curr->next) { if (variableUsePreventsPreevaluation((node *) (((entry *) (curr->value))->value))) return 1; } return 0; break; default: sollyaFprintf(stderr,"Error: variableUsePreventsPreevaluation: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return 1; } node *evaluateThingPreevaluateMatcher(node *tree) { node *temp, *res; temp = evaluateThing(tree); res = deepCopyThing(temp); freeThing(temp); return res; } node *preevaluateMatcher(node *tree) { node *copy, *tempNode2, *tempNode, *tempNodeExtra; int rangeEvaluateLeft, rangeEvaluateRight; chain *tempChain, *curr, *newChain; int resA, resB, resC, i; mpfr_t a, infinity; if (tree == NULL) return NULL; if (tree->nodeType == MEMREF) { return preevaluateMatcher(getMemRefChild(tree)); } copy = (node *) safeMalloc(sizeof(node)); copy->nodeType = tree->nodeType; switch (tree->nodeType) { case DECIMALCONSTANT: case MIDPOINTCONSTANT: case DYADICCONSTANT: case HEXCONSTANT: case HEXADECIMALCONSTANT: case BINARYCONSTANT: safeFree(copy); copy = evaluateThingPreevaluateMatcher(tree); break; case RANGE: rangeEvaluateLeft = !variableUsePreventsPreevaluation(tree->child1); rangeEvaluateRight = !variableUsePreventsPreevaluation(tree->child2); if (rangeEvaluateLeft && rangeEvaluateRight) { safeFree(copy); copy = evaluateThingPreevaluateMatcher(tree); if (accessThruMemRef(copy)->nodeType != RANGE) { freeThing(copy); copy = (node *) safeMalloc(sizeof(node)); copy->nodeType = tree->nodeType; copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); } } else { if (rangeEvaluateLeft) { copy->child2 = preevaluateMatcher(tree->child2); tempNode = (node *) safeMalloc(sizeof(node)); tempNode->nodeType = RANGE; tempNode->child1 = copyThing(tree->child1); mpfr_init2(infinity,12); mpfr_set_inf(infinity,1); tempNode->child2 = makeConstant(infinity); mpfr_clear(infinity); tempNodeExtra = evaluateThingPreevaluateMatcher(tempNode); tempNode2 = deepCopyThing(tempNodeExtra); freeThing(tempNodeExtra); if (tempNode2->nodeType == RANGE) { copy->child1 = tempNode2->child1; freeThing(tempNode2->child2); safeFree(tempNode2); } else { copy->child1 = preevaluateMatcher(tree->child1); freeThing(tempNode2); } freeThing(tempNode); } else { if (rangeEvaluateRight) { copy->child1 = preevaluateMatcher(tree->child1); tempNode = (node *) safeMalloc(sizeof(node)); tempNode->nodeType = RANGE; mpfr_init2(infinity,12); mpfr_set_inf(infinity,-1); tempNode->child1 = makeConstant(infinity); tempNode->child2 = copyThing(tree->child2); mpfr_clear(infinity); tempNodeExtra = evaluateThingPreevaluateMatcher(tempNode); tempNode2 = deepCopyThing(tempNodeExtra); freeThing(tempNodeExtra); if (tempNode2->nodeType == RANGE) { copy->child2 = tempNode2->child2; freeThing(tempNode2->child1); safeFree(tempNode2); } else { copy->child2 = preevaluateMatcher(tree->child2); freeThing(tempNode2); } freeThing(tempNode); } else { copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); } } } break; case DIFF: switch (accessThruMemRef(tree->child1)->nodeType) { case LIBRARYFUNCTION: case PROCEDUREFUNCTION: if ((accessThruMemRef(accessThruMemRef(tree->child1)->child1)->nodeType == VARIABLE) || ((variablename != NULL) && ((accessThruMemRef(accessThruMemRef(tree->child1)->child1)->nodeType == TABLEACCESS) && (!strcmp(variablename,accessThruMemRef(accessThruMemRef(tree->child1)->child1)->string))))) { safeFree(copy); copy = evaluateThingPreevaluateMatcher(tree); } else { copy->child1 = preevaluateMatcher(tree->child1); } break; default: copy->child1 = preevaluateMatcher(tree->child1); break; } break; case LIST: tempChain = copyChain(tree->arguments, preevaluateMatcherOnVoid); curr = tempChain; newChain = NULL; resC = 0; while (curr != NULL) { if ((curr->next != NULL) && (curr->next->next != NULL) && isElliptic((node *) (curr->next->value)) && isPureTree((node *) (curr->value)) && isPureTree((node *) (curr->next->next->value)) && isConstant((node *) (curr->value)) && isConstant((node *) (curr->next->next->value)) && evaluateThingToInteger(&resA,(node *) (curr->value), NULL) && evaluateThingToInteger(&resB,(node *) (curr->next->next->value),NULL) && (resA >= resB)) { mpfr_init2(a,sizeof(int) * 8); resC = 1; for (i=resA;i>=resB;i--) { mpfr_set_si(a,i,GMP_RNDN); newChain = addElement(newChain,makeConstant(a)); } mpfr_clear(a); curr = curr->next->next; } else { newChain = addElement(newChain,copyThing((node *) (curr->value))); } curr = curr->next; } freeChain(tempChain, freeThingOnVoid); copy->arguments = newChain; copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; if (resC && (!isPureList(copy))) { tempNode = preevaluateMatcher(copy); freeThing(copy); copy = tempNode; } break; case FINALELLIPTICLIST: tempChain = copyChain(tree->arguments, preevaluateMatcherOnVoid); curr = tempChain; newChain = NULL; resC = 0; while (curr != NULL) { if ((curr->next != NULL) && (curr->next->next != NULL) && isElliptic((node *) (curr->next->value)) && isPureTree((node *) (curr->value)) && isPureTree((node *) (curr->next->next->value)) && isConstant((node *) (curr->value)) && isConstant((node *) (curr->next->next->value)) && evaluateThingToInteger(&resA,(node *) (curr->value), NULL) && evaluateThingToInteger(&resB,(node *) (curr->next->next->value),NULL) && (resA >= resB)) { mpfr_init2(a,sizeof(int) * 8); resC = 1; for (i=resA;i>=resB;i--) { mpfr_set_si(a,i,GMP_RNDN); newChain = addElement(newChain,makeConstant(a)); } mpfr_clear(a); curr = curr->next->next; } else { newChain = addElement(newChain,copyThing((node *) (curr->value))); } curr = curr->next; } freeChain(tempChain, freeThingOnVoid); copy->arguments = newChain; copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; if (resC && (!isPureFinalEllipticList(copy))) { tempNode = preevaluateMatcher(copy); freeThing(copy); copy = tempNode; } break; case VARIABLE: break; case CONSTANT: copy->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(copy->value),mpfr_get_prec(*(tree->value))); mpfr_set(*(copy->value),*(tree->value),GMP_RNDN); break; case ADD: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case SUB: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case MUL: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case DIV: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case SQRT: copy->child1 = preevaluateMatcher(tree->child1); break; case EXP: copy->child1 = preevaluateMatcher(tree->child1); break; case LOG: copy->child1 = preevaluateMatcher(tree->child1); break; case LOG_2: copy->child1 = preevaluateMatcher(tree->child1); break; case LOG_10: copy->child1 = preevaluateMatcher(tree->child1); break; case SIN: copy->child1 = preevaluateMatcher(tree->child1); break; case COS: copy->child1 = preevaluateMatcher(tree->child1); break; case TAN: copy->child1 = preevaluateMatcher(tree->child1); break; case ASIN: copy->child1 = preevaluateMatcher(tree->child1); break; case ACOS: copy->child1 = preevaluateMatcher(tree->child1); break; case ATAN: copy->child1 = preevaluateMatcher(tree->child1); break; case SINH: copy->child1 = preevaluateMatcher(tree->child1); break; case COSH: copy->child1 = preevaluateMatcher(tree->child1); break; case TANH: copy->child1 = preevaluateMatcher(tree->child1); break; case ASINH: copy->child1 = preevaluateMatcher(tree->child1); break; case ACOSH: copy->child1 = preevaluateMatcher(tree->child1); break; case ATANH: copy->child1 = preevaluateMatcher(tree->child1); break; case POW: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case NEG: copy->child1 = preevaluateMatcher(tree->child1); break; case ABS: copy->child1 = preevaluateMatcher(tree->child1); break; case DOUBLE: copy->child1 = preevaluateMatcher(tree->child1); break; case SINGLE: copy->child1 = preevaluateMatcher(tree->child1); break; case QUAD: copy->child1 = preevaluateMatcher(tree->child1); break; case HALFPRECISION: copy->child1 = preevaluateMatcher(tree->child1); break; case DOUBLEDOUBLE: copy->child1 = preevaluateMatcher(tree->child1); break; case TRIPLEDOUBLE: copy->child1 = preevaluateMatcher(tree->child1); break; case ERF: copy->child1 = preevaluateMatcher(tree->child1); break; case ERFC: copy->child1 = preevaluateMatcher(tree->child1); break; case LOG_1P: copy->child1 = preevaluateMatcher(tree->child1); break; case EXP_M1: copy->child1 = preevaluateMatcher(tree->child1); break; case DOUBLEEXTENDED: copy->child1 = preevaluateMatcher(tree->child1); break; case LIBRARYFUNCTION: copy->libFun = tree->libFun; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = preevaluateMatcher(tree->child1); break; case LIBRARYCONSTANT: copy->libFun = tree->libFun; break; case PROCEDUREFUNCTION: copy->libFunDeriv = tree->libFunDeriv; copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case CEIL: copy->child1 = preevaluateMatcher(tree->child1); break; case FLOOR: copy->child1 = preevaluateMatcher(tree->child1); break; case NEARESTINT: copy->child1 = preevaluateMatcher(tree->child1); break; case PI_CONST: break; case COMMANDLIST: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case WHILE: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case IFELSE: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case IF: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case FOR: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case FORIN: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case QUIT: break; case FALSEQUIT: break; case FALSERESTART: break; case RESTART: break; case PRINT: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case SUPPRESSMESSAGE: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case UNSUPPRESSMESSAGE: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case VARIABLEDECLARATION: copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case NOP: break; case NOPARG: copy->child1 = preevaluateMatcher(tree->child1); break; case NEWFILEPRINT: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); copy->child1 = preevaluateMatcher(tree->child1); break; case APPENDFILEPRINT: copy->child1 = preevaluateMatcher(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case PLOT: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case PRINTHEXA: copy->child1 = preevaluateMatcher(tree->child1); break; case PRINTFLOAT: copy->child1 = preevaluateMatcher(tree->child1); break; case PRINTBINARY: copy->child1 = preevaluateMatcher(tree->child1); break; case PRINTEXPANSION: copy->child1 = preevaluateMatcher(tree->child1); break; case BASHEXECUTE: copy->child1 = preevaluateMatcher(tree->child1); break; case EXTERNALPLOT: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case WRITE: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case NEWFILEWRITE: copy->child1 = preevaluateMatcher(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case APPENDFILEWRITE: copy->child1 = preevaluateMatcher(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case ASCIIPLOT: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case PRINTXML: copy->child1 = preevaluateMatcher(tree->child1); break; case PRINTXMLNEWFILE: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case PRINTXMLAPPENDFILE: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case WORSTCASE: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case RENAME: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case AUTOPRINT: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case EXTERNALPROC: copy->child1 = preevaluateMatcher(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); copy->arguments = copyChainWithoutReversal(tree->arguments, copyIntPtrOnVoid); break; case ASSIGNMENT: copy->child1 = preevaluateMatcher(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case FLOATASSIGNMENT: copy->child1 = preevaluateMatcher(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case LIBRARYBINDING: copy->child1 = preevaluateMatcher(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case LIBRARYCONSTANTBINDING: copy->child1 = preevaluateMatcher(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case PRECASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case POINTSASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case DIAMASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case DISPLAYASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case VERBOSITYASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case CANONICALASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case AUTOSIMPLIFYASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case SHOWMESSAGENUMBERSASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case TAYLORRECURSASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case TIMINGASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case FULLPARENASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case MIDPOINTASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case DIEONERRORMODEASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case RATIONALMODEASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case SUPPRESSWARNINGSASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case HOPITALRECURSASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case PRECSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case POINTSSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case DIAMSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case DISPLAYSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case VERBOSITYSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case CANONICALSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case AUTOSIMPLIFYSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case SHOWMESSAGENUMBERSSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case TAYLORRECURSSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case TIMINGSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case FULLPARENSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case MIDPOINTSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case DIEONERRORMODESTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case RATIONALMODESTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case SUPPRESSWARNINGSSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case HOPITALRECURSSTILLASSIGN: copy->child1 = preevaluateMatcher(tree->child1); break; case AND: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case OR: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case NEGATION: copy->child1 = preevaluateMatcher(tree->child1); break; case INDEX: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case COMPAREEQUAL: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case COMPAREIN: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case COMPARELESS: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case COMPAREGREATER: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case COMPARELESSEQUAL: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case COMPAREGREATEREQUAL: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case COMPARENOTEQUAL: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case CONCAT: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case ADDTOLIST: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case PREPEND: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case APPEND: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case ON: break; case OFF: break; case DYADIC: break; case POWERS: break; case BINARY: break; case HEXADECIMAL: break; case FILESYM: break; case POSTSCRIPT: break; case POSTSCRIPTFILE: break; case PERTURB: break; case ROUNDDOWN: break; case ROUNDUP: break; case ROUNDTOZERO: break; case ROUNDTONEAREST: break; case HONORCOEFF: break; case TRUE: break; case UNIT: break; case FALSE: break; case DEFAULT: break; case DECIMAL: break; case ABSOLUTESYM: break; case RELATIVESYM: break; case FIXED: break; case FLOATING: break; case ERRORSPECIAL: break; case DOUBLESYMBOL: break; case SINGLESYMBOL: break; case QUADSYMBOL: break; case HALFPRECISIONSYMBOL: break; case DOUBLEEXTENDEDSYMBOL: break; case DOUBLEDOUBLESYMBOL: break; case TRIPLEDOUBLESYMBOL: break; case STRING: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case TABLEACCESS: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case ISBOUND: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case TABLEACCESSWITHSUBSTITUTE: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case STRUCTACCESS: copy->child1 = preevaluateMatcher(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case APPLY: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); copy->child1 = preevaluateMatcher(tree->child1); break; case EMPTYLIST: break; case STRUCTURE: copy->arguments = copyChainWithoutReversal(tree->arguments, copyEntryOnVoid); break; case ELLIPTIC: break; case DEBOUNDMAX: copy->child1 = preevaluateMatcher(tree->child1); break; case DEBOUNDMIN: copy->child1 = preevaluateMatcher(tree->child1); break; case DEBOUNDMID: copy->child1 = preevaluateMatcher(tree->child1); break; case EVALCONST: copy->child1 = preevaluateMatcher(tree->child1); break; case DIRTYSIMPLIFY: copy->child1 = preevaluateMatcher(tree->child1); break; case SIMPLIFYSAFE: copy->child1 = preevaluateMatcher(tree->child1); break; case TIME: copy->child1 = preevaluateMatcher(tree->child1); break; case REMEZ: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case ANNOTATEFUNCTION: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case BASHEVALUATE: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case GETSUPPRESSEDMESSAGES: break; case GETBACKTRACE: break; case MATCH: copy->child1 = preevaluateMatcher(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case MATCHELEMENT: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case MIN: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case MAX: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case FPMINIMAX: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case HORNER: copy->child1 = preevaluateMatcher(tree->child1); break; case CANONICAL: copy->child1 = preevaluateMatcher(tree->child1); break; case EXPAND: copy->child1 = preevaluateMatcher(tree->child1); break; case TAYLOR: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case TAYLORFORM: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case CHEBYSHEVFORM: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case AUTODIFF: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case DEGREE: copy->child1 = preevaluateMatcher(tree->child1); break; case NUMERATOR: copy->child1 = preevaluateMatcher(tree->child1); break; case DENOMINATOR: copy->child1 = preevaluateMatcher(tree->child1); break; case SUBSTITUTE: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case COMPOSEPOLYNOMIALS: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case COEFF: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case SUBPOLY: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case ROUNDCOEFFICIENTS: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case RATIONALAPPROX: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case ACCURATEINFNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case ROUNDTOFORMAT: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case EVALUATE: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case PARSE: copy->child1 = preevaluateMatcher(tree->child1); break; case READXML: copy->child1 = preevaluateMatcher(tree->child1); break; case EXECUTE: copy->child1 = preevaluateMatcher(tree->child1); break; case INFNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case SUPNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case FINDZEROS: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case FPFINDZEROS: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case DIRTYINFNORM: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case NUMBERROOTS: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case INTEGRAL: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case DIRTYINTEGRAL: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case IMPLEMENTPOLY: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case IMPLEMENTCONST: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case CHECKINFNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case ZERODENOMINATORS: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case ISEVALUABLE: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case SEARCHGAL: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case GUESSDEGREE: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case ASSIGNMENTININDEXING: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case FLOATASSIGNMENTININDEXING: copy->arguments = copyChainWithoutReversal(tree->arguments, preevaluateMatcherOnVoid); break; case ASSIGNMENTINSTRUCTURE: copy->child1 = preevaluateMatcher(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case FLOATASSIGNMENTINSTRUCTURE: copy->child1 = preevaluateMatcher(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case PROTOASSIGNMENTINSTRUCTURE: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case PROTOFLOATASSIGNMENTINSTRUCTURE: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case DIRTYFINDZEROS: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); break; case HEAD: copy->child1 = preevaluateMatcher(tree->child1); break; case ROUNDCORRECTLY: copy->child1 = preevaluateMatcher(tree->child1); break; case READFILE: copy->child1 = preevaluateMatcher(tree->child1); break; case REVERT: copy->child1 = preevaluateMatcher(tree->child1); break; case SORT: copy->child1 = preevaluateMatcher(tree->child1); break; case MANTISSA: copy->child1 = preevaluateMatcher(tree->child1); break; case EXPONENT: copy->child1 = preevaluateMatcher(tree->child1); break; case PRECISION: copy->child1 = preevaluateMatcher(tree->child1); break; case TAIL: copy->child1 = preevaluateMatcher(tree->child1); break; case LENGTH: copy->child1 = preevaluateMatcher(tree->child1); break; case OBJECTNAME: copy->child1 = preevaluateMatcher(tree->child1); break; case EXTERNALPROCEDUREUSAGE: copy->libProc = tree->libProc; break; case PROC: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case BIND: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case PROCILLIM: copy->child1 = preevaluateMatcher(tree->child1); copy->child2 = preevaluateMatcher(tree->child2); copy->arguments = copyChainWithoutReversal(tree->arguments, copyString); break; case PRECDEREF: break; case POINTSDEREF: break; case DIAMDEREF: break; case DISPLAYDEREF: break; case VERBOSITYDEREF: break; case CANONICALDEREF: break; case AUTOSIMPLIFYDEREF: break; case SHOWMESSAGENUMBERSDEREF: break; case TAYLORRECURSDEREF: break; case TIMINGDEREF: break; case FULLPARENDEREF: break; case MIDPOINTDEREF: break; case DIEONERRORMODEDEREF: break; case RATIONALMODEDEREF: break; case SUPPRESSWARNINGSDEREF: break; case HOPITALRECURSDEREF: break; default: sollyaFprintf(stderr,"Error: preevaluateMatcher: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return copy; } node *performBind(node *proc, char *ident, node *thing) { int hasArg; chain *curr, *newArgs, *actualArgs; char *newStr; node *newActualArg; /* Start by checking if proc has an argument ident. */ hasArg = 0; curr = proc->arguments; while ((!hasArg) && (curr != NULL)) { if (!strcmp(((char *) (curr->value)),ident)) { hasArg = 1; } curr = curr->next; } /* If we do not find the argument, we return NULL */ if (!hasArg) return NULL; /* Here, we are sure that we can find the argument We continue by generating the list of arguments different from ident. */ newArgs = NULL; curr = proc->arguments; while (curr != NULL) { if (strcmp(((char *) (curr->value)),ident)) { /* The argument is different from ident */ newStr = safeCalloc(strlen(((char *) (curr->value))) + 1, sizeof(char)); strcpy(newStr, ((char *) (curr->value))); newArgs = addElement(newArgs, newStr); } curr = curr->next; } /* The list of new arguments is inverted, we have to revert it */ curr = copyChain(newArgs, copyString); freeChain(newArgs, safeFree); newArgs = curr; /* Now we have to build the list of things to apply to the original procedure */ actualArgs = NULL; curr = proc->arguments; while (curr != NULL) { if (!strcmp(((char *) (curr->value)),ident)) { /* Here, we have to replace the argument ident by the new thing */ newActualArg = copyThing(thing); } else { /* Here, we have to keep the argument */ newActualArg = makeTableAccess(((char *) (curr->value))); } actualArgs = addElement(actualArgs, newActualArg); curr = curr->next; } /* This list actualArgs needs to be reverted, too */ curr = copyChain(actualArgs, copyThingOnVoid); freeChain(actualArgs, freeThingOnVoid); actualArgs = curr; /* Now build up and return the new procedure */ return makeProc(newArgs, makeCommandList(addElement(NULL,makeNop())), makeApply(copyThing(proc), actualArgs)); } char *getObjectNameInner(node *thing) { char *res; node *otherThing; int didCopy, sameThing; /* Look for a symbol that corresponds to the given object */ res = getEntryName(symbolTable, declaredSymbolTable, (void *) thing, isEqualThingOnVoid); /* We didn't find any symbol to check for */ if (res == NULL) return NULL; /* We found a possible symbol. Check if it doesn't get shadowed by something else. */ didCopy = 0; otherThing = getThingFromTable(res, 0, &didCopy); if (otherThing == NULL) { /* This case should never happen. Just be conservative. */ safeFree(res); return NULL; } /* Check if we just found the same thing */ sameThing = isEqualThing(thing, otherThing); /* Free the memory for the other thing, if we need to free it. */ if (didCopy) { freeThing(otherThing); } /* If we didn't find the same thing, the thing is bound but shadowed. */ if (!sameThing) { safeFree(res); return NULL; } /* The thing is bound to the identifier in res and not shadowed */ return res; } char *getObjectName(node *thing) { char * res; res = getObjectNameInner(thing); if (res != NULL) return res; res = getReparsableString(thing); return res; } void *evaluateThingInnerOnVoid(void *tree) { return (void *) evaluateThingInner((node *) tree); } void *evaluateThingOnVoid(void *tree) { return (void *) evaluateThing((node *) tree); } void *makeMonomialFromIntOnVoid(void *n) { int a; a = *((int *)n); if (a==0) return makeConstantDouble(1.0); if (a==1) return makeVariable(); return (void *)makePow(makeVariable(), makeConstantInt(a)); } /* Check that tree is a finite non-empty list that does not contain the symbol "..." Return 1 if, moreover, one of the following conditions is satisfied: * either the list contains only non-negative and distinct integers; * or the list contains only pure trees (i.e. mathematical expressions). In case of success, a list of pure trees is stored in monomials. If tree is a list of integers [n1...nk], monomials contain the functions [x^n1...x^nk], and otherwise monomials is just the content of tree. In case of failure, returns 0, without doing anything with monomials */ int evaluateThingToPseudoMonomialsList(chain **monom, node *tree) { int useless; chain *curr; chain *monomials; int prev; int failure = 0; if (!isPureList(tree)) return 0; if (evaluateThingToIntegerList(&monomials, &useless, tree)) { sortChain(monomials, cmpIntPtr); prev = -1; for (curr = monomials; curr != NULL; curr = curr->next) { if (*(int *)(curr->value) < 0) { printMessage(1,SOLLYA_MSG_REMEZ_MONOMIAL_DEGREES_MUST_NOT_BE_NEGATIVE,"Error: monomial degrees must be non-negative.\n"); failure = 1; break; } if (*(int *)(curr->value) == prev) { printMessage(1,SOLLYA_MSG_REMEZ_MONOMIAL_DEGREE_GIVEN_TWICE,"Error: monomial degree is given twice in argument to Remez algorithm.\n"); failure = 1; break; } prev = *(int *)(curr->value); } if (failure) { freeChain(monomials,freeMemoryOnVoid); return 0; } else { *monom = copyChainWithoutReversal(monomials, makeMonomialFromIntOnVoid); freeChain(monomials,freeIntPtr); return 1; } } else { if (!evaluateThingToPureListOfPureTrees(monom, tree)) return 0; } return 1; } node *evaluateThingInnerRemez(node *tree, char *timingString) { chain *curr; chain *arguments; chain *monomials = NULL; node *firstArg, *secondArg, *thirdArg, *fourthArg, *fifthArg, *sixthArg; node *result; int failure = 0; int n = -1; mpfr_t tmp, a, b, c, d, quality; /* We process the arguments: * the first one must be a function f * the second one can be an integer n, a list of integers [|n1...nk|] or a list of functions [|g1...gk|] n is equivalent to [|0...n|] and [|n1...nk|] is equivalent to [|x^n1...x^nk|] * the third argument must be an interval * the fourth argument is optional and must be a function w (default is 1) * the fifth argument is optional and must be a postive number (default is 1e-5). This is the required quality. * the sixth argument is optional and must be a positive number r or an interval [r1, r2] (default is [0, +Inf]). r is equivalent to [r,r]. This argument is officially undocumented. The description of this argument is given in the commit message of revision 1405. Note: the parser has already ensured that the first three arguments exist. */ arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = arguments; firstArg = copyThing((node *) (curr->value)); curr = curr->next; secondArg = copyThing((node *) (curr->value)); curr = curr->next; thirdArg = copyThing((node *) (curr->value)); curr = curr->next; fourthArg = NULL; fifthArg = NULL; sixthArg = NULL; if (curr != NULL) { fourthArg = copyThing((node *) (curr->value)); curr = curr->next; } if (curr != NULL) { fifthArg = copyThing((node *) (curr->value)); curr = curr->next; } if (curr != NULL) { sixthArg = copyThing((node *) (curr->value)); curr = curr->next; } if (curr != NULL) { printMessage(1,SOLLYA_MSG_REMEZ_TOO_MANY_ARGUMENTS,"Warning: too many arguments given to remez command. The remaining arguments will be ignored.\n"); considerDyingOnError(); } if ( (fourthArg == NULL) || isDefault(fourthArg) ) { freeThing(fourthArg); fourthArg = makeConstantDouble(1.0); } if ( (fifthArg == NULL) || isDefault(fifthArg) ) { freeThing(fifthArg); fifthArg = makeConstantDouble(0.00001); } if ( (sixthArg == NULL) || isDefault(sixthArg) ) { freeThing(sixthArg); mpfr_init2(tmp, 53); mpfr_set_inf(tmp, 1); sixthArg = makeRange(makeConstantDouble(0.0), makeConstant(tmp)); mpfr_clear(tmp); } /* Now we check the types of the arguments */ if (!isPureTree(firstArg)) failure = 1; /* Second argument */ if (isPureTree(secondArg)) { /* secondArg can be an integer */ if (!evaluateThingToInteger(&n, secondArg, NULL)) failure = 1; else { if (n<0) { printMessage(1,SOLLYA_MSG_REMEZ_SECND_ARG_MUST_BE_NONNEGATIVE_INT_OR_LIST,"Error: the second argument of remez must be a non-negative integer or a list.\n"); failure = 1; } else { /* The second argument is a valid integer n. Converting it to a list. */ freeThing(secondArg); secondArg = makeList(makeConstantIntChain(n)); } } } if (!evaluateThingToPseudoMonomialsList(&monomials, secondArg)) failure = 1; /* Third argument */ mpfr_init2(a, tools_precision); mpfr_init2(b, tools_precision); /* Only for avoiding future reallocation. The precision of a and b will be set to a suitable value by evaluateThingToRange anyway */ if (!evaluateThingToRange(a, b, thirdArg)) failure = 1; /* Fourth argument */ if (!isPureTree(fourthArg)) failure = 1; /* Fifth argument */ mpfr_init2(quality, tools_precision); if (!evaluateThingToConstant(quality, fifthArg, NULL, 0,0)) failure = 1; /* Sixth argument */ mpfr_init2(c, tools_precision); mpfr_init2(d, tools_precision); if (isPureTree(sixthArg)) { /* sixthArg can be a number */ if (!evaluateThingToConstant(c, sixthArg, NULL, 0,0)) failure = 1; else { mpfr_set_prec(d, mpfr_get_prec(c)); mpfr_set(d, c, GMP_RNDN); /* exact */ } } else { if (!evaluateThingToRange(c, d, sixthArg)) failure = 1; } /* Now, if (failure), we cannot run the algorithm, otherwise we can */ if (failure) { result = copyThing(tree); } else { if (timingString != NULL) pushTimeCounter(); result = remez(firstArg, fourthArg, monomials, a, b, quality, c, d, tools_precision); if (timingString != NULL) popTimeCounter(timingString); } /* If ever result is NULL, we replace it with its original tree before evaluation */ if (result == NULL) result = copyThing(tree); mpfr_clear(a); mpfr_clear(b); mpfr_clear(c); mpfr_clear(d); mpfr_clear(quality); freeChain(monomials,freeMemoryOnVoid); freeChain(arguments,freeThingOnVoid); freeThing(firstArg); freeThing(secondArg); freeThing(thirdArg); freeThing(fourthArg); freeThing(fifthArg); freeThing(sixthArg); return result; } node *evaluateThingInnerFpminimax(node *tree, char *timingString) { chain *curr; chain *arguments; chain *monomials = NULL; chain *formats = NULL; chain *pointsList = NULL; node *firstArg, *secondArg, *thirdArg, *fourthArg, *fifthArg, *sixthArg, *seventhArg, *eighthArg; int relabsArg, fpfixedArg; node *pstarArg, *constrainedPartArg; node *result; int failure = 0; int n = -1; mpfr_t a, b; arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = arguments; /* We process the arguments: * the first one must be a function f * the second one can be an integer, a list of integers or a list of functions as for remez * the third argument must be a list containing only integers and keywords D, DD, etc. * the fourth argument must be an interval or a list of constants * the fifth, sixth and seventh arguments are optional and can be - RELATIVE | ABSOLUTE (default is RELATIVE) - FIXED | FLOATING (default is FLOATING) - a function (default is 0) * the eighth argument is optional and is a function q (constrained part) Note: the parser has already ensured that the first four arguments exist. */ firstArg = copyThing((node *) (curr->value)); curr = curr->next; secondArg = copyThing((node *) (curr->value)); curr = curr->next; thirdArg = copyThing((node *) (curr->value)); curr = curr->next; fourthArg = copyThing((node *) (curr->value)); curr = curr->next; fifthArg = sixthArg = seventhArg = eighthArg = NULL; if (curr != NULL) { fifthArg = copyThing((node *) (curr->value)); curr = curr->next; } if (curr != NULL) { sixthArg = copyThing((node *) (curr->value)); curr = curr->next; } if (curr != NULL) { seventhArg = copyThing((node *) (curr->value)); curr = curr->next; } if (curr != NULL) { eighthArg = copyThing((node *) (curr->value)); curr = curr->next; } if (curr != NULL) { printMessage(1,SOLLYA_MSG_FPMINIMAX_TOO_MANY_ARGUMENTS,"Warning: too many arguments given to fpminimax command. The remaining arguments will be ignored.\n"); considerDyingOnError(); } /* We now handle the three optional parameters that can be permuted */ relabsArg = RELATIVESYM; fpfixedArg = FLOATING; constrainedPartArg = makeConstantDouble(0.0); if ( (fifthArg != NULL) && (!isDefault(fifthArg)) ) { switch(accessThruMemRef(fifthArg)->nodeType) { case RELATIVESYM: case ABSOLUTESYM: relabsArg = accessThruMemRef(fifthArg)->nodeType; break; case FLOATING: case FIXED: fpfixedArg = accessThruMemRef(fifthArg)->nodeType; break; default: if (isPureTree(fifthArg)) { freeThing(constrainedPartArg); constrainedPartArg = copyTree(fifthArg); } else { printMessage(1, SOLLYA_MSG_INVALID_FIFTH_ARGUMENT, "Error in fpminimax: invalid fifth argument\n"); failure = 1; } } } if ( (sixthArg != NULL) && (!isDefault(sixthArg)) ) { switch(accessThruMemRef(sixthArg)->nodeType) { case RELATIVESYM: case ABSOLUTESYM: relabsArg = accessThruMemRef(sixthArg)->nodeType; break; case FLOATING: case FIXED: fpfixedArg = accessThruMemRef(sixthArg)->nodeType; break; default: if (isPureTree(sixthArg)) { freeThing(constrainedPartArg); constrainedPartArg = copyTree(sixthArg); } else { printMessage(1, SOLLYA_MSG_INVALID_FIFTH_ARGUMENT, "Error in fpminimax: invalid fifth argument\n"); failure = 1; } } } if ( (seventhArg != NULL) && (!isDefault(seventhArg)) ) { switch(accessThruMemRef(seventhArg)->nodeType) { case RELATIVESYM: case ABSOLUTESYM: relabsArg = accessThruMemRef(seventhArg)->nodeType; break; case FLOATING: case FIXED: fpfixedArg = accessThruMemRef(seventhArg)->nodeType; break; default: if (isPureTree(seventhArg)) { freeThing(constrainedPartArg); constrainedPartArg = copyTree(seventhArg); } else { printMessage(1, SOLLYA_MSG_INVALID_FIFTH_ARGUMENT, "Error in fpminimax: invalid fifth argument\n"); failure = 1; } } } /* Finally we handle the eighth optional argument */ if ( (eighthArg == NULL) || isDefault(eighthArg) ) pstarArg = NULL; else pstarArg = copyThing(eighthArg); /* Now, we check the type of the arguments. Arguments 5, 6 and 7 have already been done */ if (!isPureTree(firstArg)) failure = 1; /* Second argument. This code is a copy-paste from evaluateThingInnerRemez */ if (isPureTree(secondArg)) { /* secondArg can be an integer */ if (!evaluateThingToInteger(&n, secondArg, NULL)) failure = 1; else { if (n<0) { printMessage(1,SOLLYA_MSG_FPMINIMAX_SECND_ARG_MUST_BE_NONNEG_INT_OR_LIST,"Error: the second argument of fpminimax must be a non-negative integer or a list.\n"); failure = 1; } else { /* The second argument is a valid integer n. Converting it to a list. */ freeThing(secondArg); secondArg = makeList(makeConstantIntChain(n)); } } } if (!evaluateThingToPseudoMonomialsList(&monomials, secondArg)) failure = 1; /* Third argument: must be a list. Note that negative formats are allowed in FIXED mode but not in FLOATING mode */ if( (accessThruMemRef(thirdArg)->nodeType == LIST) || (accessThruMemRef(thirdArg)->nodeType == FINALELLIPTICLIST) ) { if (!evaluateFormatsListForFPminimax(&formats, thirdArg, lengthChain(monomials), fpfixedArg)) { failure = 1; } } else { printMessage(1, SOLLYA_MSG_FPMINIMAX_THIRD_ARG_MUST_BE_FORMAT_INDICATIONS, "Error in fpminimax: the third argument of fpminimax must be a list of formats indications.\n"); failure = 1; } /* Fourth argument: either a range or a list of points */ mpfr_init2(a, tools_precision); mpfr_init2(b, tools_precision); /* Only for avoiding future reallocation. The precision of a and b will be set to a suitable value by evaluateThingToRange anyway */ if (!evaluateThingToRange(a, b, fourthArg)) { if (!evaluateThingToConstantList(&pointsList, fourthArg)) { printMessage(1, SOLLYA_MSG_FPMINIMAX_FOURTH_ARG_INTERVAL_OR_LIST_OF_POINTS, "Error in fpminimax: the fourth argument of fpminimax must be either an interval or a list of points\n"); failure = 1; } } if (pointsList != NULL) { curr = pointsList; mpfr_set_prec(a, mpfr_get_prec(*(mpfr_t *)(curr->value))); mpfr_set(a, *(mpfr_t *)(curr->value), GMP_RNDD); /* exact */ while(curr->next != NULL) curr = curr->next; mpfr_set_prec(b, mpfr_get_prec(*(mpfr_t *)(curr->value))); mpfr_set(b, *(mpfr_t *)(curr->value), GMP_RNDU); /* exact */ } /* Eighth argument */ if ( (pstarArg != NULL) && (!isPureTree(pstarArg)) ) failure = 1; /* Now, if (failure), we cannot run the algorithm, otherwise we can */ if (failure) { result = copyThing(tree); } else { if (timingString != NULL) pushTimeCounter(); result = FPminimax(firstArg, monomials, formats, pointsList, a, b, fpfixedArg, relabsArg, constrainedPartArg, pstarArg); /* FPminimax can return NULL if does not succeed, either because not enough points or format inidications were prrovided, or because it did not manage to find correct exponents (for floating-point formats). In this case, we return error */ if (result == NULL) result = makeError(); if (timingString != NULL) popTimeCounter(timingString); } mpfr_clear(a); mpfr_clear(b); freeChain(monomials,freeMemoryOnVoid); freeChain(arguments,freeThingOnVoid); freeChain(formats, freeIntPtr); freeChain(pointsList, freeMpfrPtr); freeThing(firstArg); freeThing(secondArg); freeThing(thirdArg); freeThing(fourthArg); freeThing(fifthArg); freeThing(sixthArg); freeThing(seventhArg); freeThing(eighthArg); freeThing(pstarArg); free_memory(constrainedPartArg); return result; } node *evaluateThingInnerRationalapprox(node *tree, char *timingString) { node *result; node *firstArg, *secondArg; int failure = 0; mpfr_t a; int n; firstArg = evaluateThingInner(tree->child1); secondArg = evaluateThingInner(tree->child2); /* firstArg must be a constant expression */ mpfr_init2(a, tools_precision); if (!isPureTree(firstArg)) failure = 1; else { if (!evaluateThingToConstant(a, firstArg, NULL, 0, 0)) failure = 1; } /* secondArg must be an integer */ if (!isPureTree(secondArg)) failure = 1; else {if (!evaluateThingToInteger(&n, secondArg, NULL)) failure = 1; } if (failure) { result = copyThing(tree); } else { if (timingString != NULL) pushTimeCounter(); result = rationalApprox(a, n); if (timingString != NULL) popTimeCounter(timingString); } freeThing(firstArg); freeThing(secondArg); mpfr_clear(a); return result; } node *evaluateThingInnerst(node *); node *evaluateThingInner(node *tree) { node *res; if ((tree != NULL) && (tree->nodeType == MEMREF) && ((tree->isCorrectlyTyped) || isCorrectlyTyped(tree))) { return addMemRef(copyThing(tree)); } res = addMemRef(evaluateThingInnerst(tree)); if ((tree != NULL) && (res != NULL) && (tree->nodeType == MEMREF) && (tree != res)) { if (isEqualThing(tree,res)) { freeThing(res); res = copyThing(tree); } else { if (res->nodeType == MEMREF) { if (isPureTree(tree) && isPureTree(res)) { if (treeContainsHooks(tree) && (!treeContainsHooks(res))) { res = addMemRef(rewriteThingWithMemRefReuse(res, tree)); } } } } } return res; } node *evaluateThingInnerst(node *tree) { node *copy, *tempNode, *tempNode2, *tempNode3, *tempNode4, *tempNode5, *tempNode6; int *intptr; int resA, resB, i, resC, resD, resE, resF, resG, resH, resI, resJ, resK, resL, resM, resN; char *tempString, *tempString2, *timingString, *tempString3, *tempString4, *tempString5; char *str1, *str2, *str3; mpfr_t a, b, c, d, e; chain *tempChain, *curr, *newChain, *tempChain2, *tempChain3, *curr2, *tempChain4, *tempChain5; rangetype yrange, xrange, yrange2; node *firstArg, *secondArg, *thirdArg, *fourthArg, *fifthArg, *sixthArg, *seventhArg, *eighthArg; rangetype *rangeTempPtr; FILE *fd, *fd2; mp_exp_t expo; mp_prec_t pTemp, pTemp2, pTemp3; int undoVariableTrick; sollya_mpfi_t tempIA, tempIB, tempIC, tempID; int alreadyDisplayed; sollya_mpfi_t *tmpInterv1, *tmpInterv2; sollya_mpfi_t *tmpInterv11; mpfr_t bb,cc; sollya_mpfi_t tempIA2; unsigned int tempUI; node **thingArray1, **thingArray2, **thingArray3; entry *structEntry; chain *assoclist; int floatingPointEvaluationAlreadyDone; mpz_t tempMpz; char *decString; int negate; /* Make compiler happy: */ pTemp = 12; pTemp2 = 12; /* End of compiler happiness */ if (tree == NULL) return NULL; if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) return copyThing(tree); return evaluateThingInner(getMemRefChild(tree)); } timingString = NULL; if (timecounting) { timingString = getTimingStringForThing(tree); } copy = (node *) safeMalloc(sizeof(node)); copy->nodeType = tree->nodeType; switch (tree->nodeType) { case VARIABLE: break; case CONSTANT: copy->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(copy->value),mpfr_get_prec(*(tree->value))); mpfr_set(*(copy->value),*(tree->value),GMP_RNDN); break; case ADD: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isRangeNonEmpty(copy->child1) && isRangeNonEmpty(copy->child2)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIB,pTemp); sollya_mpfi_interv_fr(tempIB,*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_add(tempIC,tempIA,tempIB); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIC); } else { if (isRangeNonEmpty(copy->child1) && isPureTree(copy->child2) && isConstant(copy->child2)) { if (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)) && mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value))) { tempNode = makeAdd(makeVariable(),copyTree(copy->child2)); xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value))); mpfr_init2(*(xrange.b),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value))); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),GMP_RNDD); mpfr_set(*(xrange.b),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value),GMP_RNDU); evaluateRangeFunction(yrange, tempNode, xrange, tools_precision); freeThing(copy); copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); freeThing(tempNode); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_init2(tempIB,tools_precision); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); evaluateConstantExpressionToSharpInterval(tempIB, copy->child2); sollya_mpfi_add(tempIC, tempIA, tempIB); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIC); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIA); } } else { if (isRangeNonEmpty(copy->child2) && isPureTree(copy->child1) && isConstant(copy->child1)) { if (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)) && mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value))) { tempNode = makeAdd(copyTree(copy->child1),makeVariable()); xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value))); mpfr_init2(*(xrange.b),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value))); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),GMP_RNDD); mpfr_set(*(xrange.b),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value),GMP_RNDU); evaluateRangeFunction(yrange, tempNode, xrange, tools_precision); freeThing(copy); copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); freeThing(tempNode); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_init2(tempIB,tools_precision); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); evaluateConstantExpressionToSharpInterval(tempIB, copy->child1); sollya_mpfi_add(tempIC, tempIB, tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIC); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIA); } } } } break; case SUB: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isRangeNonEmpty(copy->child1) && isRangeNonEmpty(copy->child2)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIB,pTemp); sollya_mpfi_interv_fr(tempIB,*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_sub(tempIC,tempIA,tempIB); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIC); } else { if (isRangeNonEmpty(copy->child1) && isPureTree(copy->child2) && isConstant(copy->child2)) { if (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)) && mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value))) { tempNode = makeSub(makeVariable(),copyTree(copy->child2)); xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value))); mpfr_init2(*(xrange.b),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value))); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),GMP_RNDD); mpfr_set(*(xrange.b),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value),GMP_RNDU); evaluateRangeFunction(yrange, tempNode, xrange, tools_precision); freeThing(copy); copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); freeThing(tempNode); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_init2(tempIB,tools_precision); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); evaluateConstantExpressionToSharpInterval(tempIB, copy->child2); sollya_mpfi_sub(tempIC, tempIA, tempIB); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIC); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIA); } } else { if (isRangeNonEmpty(copy->child2) && isPureTree(copy->child1) && isConstant(copy->child1)) { if (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)) && mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value))) { tempNode = makeSub(copyTree(copy->child1),makeVariable()); xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value))); mpfr_init2(*(xrange.b),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value))); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),GMP_RNDD); mpfr_set(*(xrange.b),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value),GMP_RNDU); evaluateRangeFunction(yrange, tempNode, xrange, tools_precision); freeThing(copy); copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); freeThing(tempNode); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_init2(tempIB,tools_precision); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); evaluateConstantExpressionToSharpInterval(tempIB, copy->child1); sollya_mpfi_sub(tempIC, tempIB, tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIC); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIA); } } } } break; case MUL: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isRangeNonEmpty(copy->child1) && isRangeNonEmpty(copy->child2)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIB,pTemp); sollya_mpfi_interv_fr(tempIB,*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_mul(tempIC,tempIA,tempIB); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIC); } else { if (isRangeNonEmpty(copy->child1) && isPureTree(copy->child2) && isConstant(copy->child2)) { if (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)) && mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value))) { tempNode = makeMul(makeVariable(),copyTree(copy->child2)); xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value))); mpfr_init2(*(xrange.b),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value))); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),GMP_RNDD); mpfr_set(*(xrange.b),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value),GMP_RNDU); evaluateRangeFunction(yrange, tempNode, xrange, tools_precision); freeThing(copy); copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); freeThing(tempNode); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_init2(tempIB,tools_precision); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); evaluateConstantExpressionToSharpInterval(tempIB, copy->child2); sollya_mpfi_mul(tempIC, tempIA, tempIB); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIC); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIA); } } else { if (isRangeNonEmpty(copy->child2) && isPureTree(copy->child1) && isConstant(copy->child1)) { if (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)) && mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value))) { tempNode = makeMul(copyTree(copy->child1),makeVariable()); xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value))); mpfr_init2(*(xrange.b),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value))); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),GMP_RNDD); mpfr_set(*(xrange.b),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value),GMP_RNDU); evaluateRangeFunction(yrange, tempNode, xrange, tools_precision); freeThing(copy); copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); freeThing(tempNode); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_init2(tempIB,tools_precision); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); evaluateConstantExpressionToSharpInterval(tempIB, copy->child1); sollya_mpfi_mul(tempIC, tempIB, tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIC); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIA); } } } } break; case DIV: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isRangeNonEmpty(copy->child1) && isRangeNonEmpty(copy->child2)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIB,pTemp); sollya_mpfi_interv_fr(tempIB,*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_div(tempIC,tempIA,tempIB); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIC); } else { if (isRangeNonEmpty(copy->child1) && isPureTree(copy->child2) && isConstant(copy->child2)) { if (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)) && mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value))) { tempNode = makeDiv(makeVariable(),copyTree(copy->child2)); xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value))); mpfr_init2(*(xrange.b),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value))); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),GMP_RNDD); mpfr_set(*(xrange.b),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value),GMP_RNDU); evaluateRangeFunction(yrange, tempNode, xrange, tools_precision); freeThing(copy); copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); freeThing(tempNode); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_init2(tempIB,tools_precision); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); evaluateConstantExpressionToSharpInterval(tempIB, copy->child2); sollya_mpfi_div(tempIC, tempIA, tempIB); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIC); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIA); } } else { if (isRangeNonEmpty(copy->child2) && isPureTree(copy->child1) && isConstant(copy->child1)) { if (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)) && mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value))) { tempNode = makeDiv(copyTree(copy->child1),makeVariable()); xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value))); mpfr_init2(*(xrange.b),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value))); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),GMP_RNDD); mpfr_set(*(xrange.b),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value),GMP_RNDU); evaluateRangeFunction(yrange, tempNode, xrange, tools_precision); freeThing(copy); copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); freeThing(tempNode); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_init2(tempIB,tools_precision); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); evaluateConstantExpressionToSharpInterval(tempIB, copy->child1); sollya_mpfi_div(tempIC, tempIB, tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIC); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIA); } } } } break; case SQRT: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_sqrt(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case EXP: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_exp(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case LOG: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_log(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case LOG_2: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_log2(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case LOG_10: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_log10(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case SIN: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_sin(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case COS: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_cos(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case TAN: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_tan(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case ASIN: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_asin(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case ACOS: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_acos(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case ATAN: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_atan(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case SINH: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_sinh(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case COSH: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_cosh(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case TANH: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_tanh(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case ASINH: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_asinh(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case ACOSH: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_acosh(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case ATANH: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_atanh(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case POW: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isRangeNonEmpty(copy->child1) && isRangeNonEmpty(copy->child2)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIB,pTemp); sollya_mpfi_interv_fr(tempIB,*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_pow(tempIC,tempIA,tempIB); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIC); } else { if (isRangeNonEmpty(copy->child1) && isPureTree(copy->child2) && isConstant(copy->child2)) { if (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)) && mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value))) { tempNode = makePow(makeVariable(),copyTree(copy->child2)); xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value))); mpfr_init2(*(xrange.b),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value))); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),GMP_RNDD); mpfr_set(*(xrange.b),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value),GMP_RNDU); evaluateRangeFunction(yrange, tempNode, xrange, tools_precision); freeThing(copy); copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); freeThing(tempNode); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_init2(tempIB,tools_precision); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); evaluateConstantExpressionToSharpInterval(tempIB, copy->child2); sollya_mpfi_pow(tempIC, tempIA, tempIB); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIC); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIA); } } else { if (isRangeNonEmpty(copy->child2) && isPureTree(copy->child1) && isConstant(copy->child1)) { if (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)) && mpfr_number_p(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value))) { tempNode = makePow(copyTree(copy->child1),makeVariable()); xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value))); mpfr_init2(*(xrange.b),mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value))); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),GMP_RNDD); mpfr_set(*(xrange.b),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value),GMP_RNDU); evaluateRangeFunction(yrange, tempNode, xrange, tools_precision); freeThing(copy); copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); freeThing(tempNode); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_init2(tempIB,tools_precision); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); evaluateConstantExpressionToSharpInterval(tempIB, copy->child1); sollya_mpfi_pow(tempIC, tempIB, tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIC); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIA); } } } } break; case NEG: copy->child1 = evaluateThing(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_neg(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } else { if (accessThruMemRef(copy->child1)->nodeType == CONSTANT) { if (!mpfr_nan_p(*((accessThruMemRef(copy->child1))->value))) { mpfr_init2(a, mpfr_get_prec(*((accessThruMemRef(copy->child1))->value))); mpfr_neg(a, *((accessThruMemRef(copy->child1))->value), GMP_RNDN); /* exact */ tempNode = makeConstant(a); mpfr_clear(a); freeThing(copy); copy = tempNode; } } } break; case ABS: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_abs(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case DOUBLE: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_round_to_double(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case SINGLE: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_round_to_single(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case QUAD: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_round_to_quad(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case HALFPRECISION: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_round_to_halfprecision(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case DOUBLEDOUBLE: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_round_to_doubledouble(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case TRIPLEDOUBLE: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_round_to_tripledouble(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case ERF: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_erf(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case ERFC: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_erfc(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case LOG_1P: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_log1p(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case EXP_M1: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_expm1(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case DOUBLEEXTENDED: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_round_to_doubleextended(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case LIBRARYFUNCTION: copy->libFun = tree->libFun; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); mpfi_init2(tempID,tools_precision); if (copy->libFun->hasData) { ((int (*)(mpfi_t, mpfi_t, int, void *)) (copy->libFun->code))(tempID, tempIA, copy->libFunDeriv, copy->libFun->data); } else { ((int (*)(mpfi_t, mpfi_t, int)) (copy->libFun->code))(tempID, tempIA, copy->libFunDeriv); } sollya_init_and_convert_interval(tempIC, tempID); mpfi_clear(tempID); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case PROCEDUREFUNCTION: copy->libFunDeriv = tree->libFunDeriv; copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); computeFunctionWithProcedure(tempIC, copy->child2, tempIA, (unsigned int) copy->libFunDeriv, copy); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case LIBRARYCONSTANT: copy->libFun = tree->libFun; break; case CEIL: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_ceil(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case FLOOR: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_floor(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case NEARESTINT: copy->child1 = evaluateThingInner(tree->child1); if (isRangeNonEmpty(copy->child1)) { pTemp = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value)); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,*(accessThruMemRef(accessThruMemRef(copy->child1)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child1)->child2)->value)); sollya_mpfi_init2(tempIC,tools_precision); sollya_mpfi_nearestint(tempIC,tempIA); freeThing(copy); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); sollya_mpfi_get_left(a,tempIC); sollya_mpfi_get_right(b,tempIC); copy = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIC); } break; case PI_CONST: break; case AND: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isBoolean(copy->child1) && isBoolean(copy->child2)) { if ((accessThruMemRef(copy->child1)->nodeType == TRUE) && (accessThruMemRef(copy->child2)->nodeType == TRUE)) { copy->nodeType = TRUE; } else { copy->nodeType = FALSE; } freeThing(copy->child1); freeThing(copy->child2); } break; case OR: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isBoolean(copy->child1) && isBoolean(copy->child2)) { if ((accessThruMemRef(copy->child1)->nodeType == FALSE) && (accessThruMemRef(copy->child2)->nodeType == FALSE)) { copy->nodeType = FALSE; } else { copy->nodeType = TRUE; } freeThing(copy->child1); freeThing(copy->child2); } break; case NEGATION: copy->child1 = evaluateThingInner(tree->child1); if (isBoolean(copy->child1)) { if (accessThruMemRef(copy->child1)->nodeType == FALSE) { copy->nodeType = TRUE; } else { copy->nodeType = FALSE; } freeThing(copy->child1); } break; case INDEX: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isString(copy->child1) || isPureList(copy->child1) || isPureFinalEllipticList(copy->child1)) { if (evaluateThingToInteger(&resA,copy->child2,NULL)) { if (isString(copy->child1)) { if ((resA >= 0) && (resA < (int)strlen(accessThruMemRef(copy->child1)->string))) { if (timingString != NULL) pushTimeCounter(); tempString = (char *) safeCalloc(2,sizeof(char)); tempString[0] = (accessThruMemRef(copy->child1)->string)[resA]; copy->nodeType = STRING; copy->string = tempString; freeThing(copy->child1); freeThing(copy->child2); if (timingString != NULL) popTimeCounter(timingString); } } else { if (isPureList(copy->child1)) { if ((accessThruMemRef(copy->child1)->argArray != NULL) && ((resA >= 0) && (resA < accessThruMemRef(copy->child1)->argArraySize))) { if (timingString != NULL) pushTimeCounter(); tempNode = copyThing((accessThruMemRef(copy->child1)->argArray)[(accessThruMemRef(copy->child1)->argArraySize - 1) - resA]); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } else { if (resA >= 0) { setupRandomAccessOnLists(copy->child1); if (resA < lengthChain(accessThruMemRef(copy->child1)->arguments)) { if (timingString != NULL) pushTimeCounter(); tempNode = copyThing((node *) accessInList(accessThruMemRef(copy->child1)->arguments, resA)); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } } } } else { if (isPureFinalEllipticList(copy->child1)) { if ((accessThruMemRef(copy->child1)->argArray != NULL) && ((resA >= 0) && (resA < accessThruMemRef(copy->child1)->argArraySize))) { if (timingString != NULL) pushTimeCounter(); tempNode = copyThing((accessThruMemRef(copy->child1)->argArray)[(accessThruMemRef(copy->child1)->argArraySize - 1) - resA]); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } else { if (resA >= 0) { setupRandomAccessOnLists(copy->child1); if (resA < lengthChain(accessThruMemRef(copy->child1)->arguments)) { if (timingString != NULL) pushTimeCounter(); tempNode = copyThing((node *) accessInList(accessThruMemRef(copy->child1)->arguments, resA)); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } else { if (isPureTree((node *) accessInList(accessThruMemRef(copy->child1)->arguments, lengthChain(accessThruMemRef(copy->child1)->arguments) - 1))) { mpfr_init2(a, tools_precision); if (evaluateThingToConstant(a, (node *) accessInList(accessThruMemRef(copy->child1)->arguments, lengthChain(accessThruMemRef(copy->child1)->arguments) - 1), NULL, 0, 0)) { if (mpfr_integer_p(a)) { resB = mpfr_get_si(a, GMP_RNDN); mpfr_init2(b, 8 * sizeof(resB) + 5); mpfr_set_si(b, resB, GMP_RNDN); if (mpfr_cmp(a, b) == 0) { resB = resA + resB - lengthChain(accessThruMemRef(copy->child1)->arguments) + 1; mpfr_set_si(b, resB, GMP_RNDN); if (timingString != NULL) pushTimeCounter(); tempNode = makeConstant(b); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } else { if (timingString != NULL) pushTimeCounter(); tempNode = copyThing((node *) accessInList(accessThruMemRef(copy->child1)->arguments, lengthChain(accessThruMemRef(copy->child1)->arguments) - 1)); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } mpfr_clear(b); } else { if (timingString != NULL) pushTimeCounter(); tempNode = copyThing((node *) accessInList(accessThruMemRef(copy->child1)->arguments, lengthChain(accessThruMemRef(copy->child1)->arguments) - 1)); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } } else { if (timingString != NULL) pushTimeCounter(); tempNode = copyThing((node *) accessInList(accessThruMemRef(copy->child1)->arguments, lengthChain(accessThruMemRef(copy->child1)->arguments) - 1)); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } mpfr_clear(a); } else { if (timingString != NULL) pushTimeCounter(); tempNode = copyThing((node *) accessInList(accessThruMemRef(copy->child1)->arguments, lengthChain(accessThruMemRef(copy->child1)->arguments) - 1)); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } } } } } } } } } break; case COMPAREEQUAL: resJ = 0; copy->child1 = evaluateThing(tree->child1); copy->child2 = evaluateThing(tree->child2); if (timingString != NULL) pushTimeCounter(); if ((isError(copy->child1) && (!isError(tree->child1)) && (!isError(tree->child2))) || (isError(copy->child2) && (!isError(tree->child2)) && (!isError(tree->child1)))) { printMessage(1,SOLLYA_MSG_TEST_COMPARES_ERROR_TO_SOMETHING,"Warning: the evaluation of one of the sides of an equality test yields error due to a syntax error or an error on a side-effect.\nThe other side either also yields error due to an syntax or side-effect error or does not evaluate to error.\nThe boolean returned may be meaningless.\n"); } if (autosimplify) { tryRepresentAsPolynomialNoConstants(copy->child1); tryRepresentAsPolynomialNoConstants(copy->child2); } if (isEqualThingEnhanced(copy->child1,copy->child2, autosimplify)) { if (!isError(copy->child1)) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } else { if (isPureTree(copy->child1) && isPureTree(copy->child2) && isConstant(copy->child1) && isConstant(copy->child2)) { if (checkInequalityFast(&resF, copy->child1, copy->child2)) { freeThing(copy); copy = makeFalse(); } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if ((resA = evaluateThingToConstant(a,copy->child1,NULL,1,1)) && (resB = evaluateThingToConstant(b,copy->child2,NULL,1,1))) { if ((resA == 3) || (resB == 3)) { if ((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2))) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL,"Warning: equality test relies on floating-point result that is not faithfully evaluated.\n"); } else { if (resJ) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: equality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); resJ = 1; } } } if ((!resJ) && (!((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2))))) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: equality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); resJ = 1; } resC = mpfr_equal_p(a,b); if ((resA == 1) || (resB == 1)) { if (mpfr_number_p(a) && mpfr_number_p(b)) { resE = 0; if (resC) { /* a == b */ resE = 1; } else { /* a != b */ if (mpfr_cmp(a,b) < 0) { /* a < b */ if (resA == 1) mpfr_nextabove(a); if (resB == 1) mpfr_nextbelow(b); resE = (mpfr_cmp(a,b) >= 0); } else { /* b < a */ if (resA == 1) mpfr_nextbelow(a); if (resB == 1) mpfr_nextabove(b); resE = (mpfr_cmp(a,b) <= 0); } } if (resE) { if (compareConstant(&resD, copy->child1, copy->child2, NULL, 0)) { resC = (resD == 0); } else { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED,"Warning: the tool is unable to decide an equality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n"); resC = 1; } } else printMessage(2,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT,"Information: equality test relies on floating-point result.\n"); } else { if ((!((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2)))) && (!resJ)) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: equality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); resJ = 1; } } } if (resC) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } mpfr_clear(a); mpfr_clear(b); } } else { freeThing(copy); copy = makeFalse(); } } if (timingString != NULL) popTimeCounter(timingString); break; case COMPAREIN: copy->child1 = evaluateThing(tree->child1); copy->child2 = evaluateThing(tree->child2); resE = 0; if (isPureTree(copy->child1) && isConstant(copy->child1) && isRange(copy->child2)) { if (timingString != NULL) pushTimeCounter(); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); mpfr_init2(c,tools_precision); if (evaluateThingToRange(b,c,copy->child2)) { tempNode = makeConstant(b); tempNode2 = makeConstant(c); resI = ((checkInequalityFast(&resJ, tempNode, copy->child1)) && (checkInequalityFast(&resK, copy->child1, tempNode2))); free_memory(tempNode); free_memory(tempNode2); if (resI) { if ((resJ <= 0) && (resK <= 0)) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } resE = 1; } else { if ((resA = evaluateThingToConstant(a,copy->child1,NULL,1,1))) { if (resA == 3) printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL,"Warning: containment test relies on floating-point result that is not faithfully evaluated.\n"); resC = ((mpfr_cmp(b,a) <= 0) && (mpfr_cmp(a,c) <= 0) && (!mpfr_unordered_p(a,b)) && (!mpfr_unordered_p(a,c))); resH = (mpfr_number_p(a) && mpfr_number_p(b) && mpfr_number_p(c)); resB = 0; if (resA == 1) { mpfr_init2(d,mpfr_get_prec(a)); mpfr_set(d,a,GMP_RNDN); if (resC) { /* b <= a <= c */ mpfr_nextbelow(a); resB = (resC != ((mpfr_cmp(b,a) <= 0) && (mpfr_cmp(a,c) <= 0) && (!mpfr_unordered_p(a,b)) && (!mpfr_unordered_p(a,c)))); if (!resB) { mpfr_set(a,d,GMP_RNDN); mpfr_nextabove(a); resB = (resC != ((mpfr_cmp(b,a) <= 0) && (mpfr_cmp(a,c) <= 0) && (!mpfr_unordered_p(a,b)) && (!mpfr_unordered_p(a,c)))); } } else { /* a < b or c < a */ mpfr_nextabove(a); resB = (resC != ((mpfr_cmp(b,a) <= 0) && (mpfr_cmp(a,c) <= 0) && (!mpfr_unordered_p(a,b)) && (!mpfr_unordered_p(a,c)))); if (!resB) { mpfr_set(a,d,GMP_RNDN); mpfr_nextbelow(a); resB = (resC != ((mpfr_cmp(b,a) <= 0) && (mpfr_cmp(a,c) <= 0) && (!mpfr_unordered_p(a,b)) && (!mpfr_unordered_p(a,c)))); } } if (resB) { tempNode = makeConstant(b); tempNode2 = makeConstant(c); if (compareConstant(&resA, tempNode, copy->child1, NULL, 0) && compareConstant(&resB, copy->child1, tempNode2, NULL, 0)) { resC = (resA <= 0) && (resB <= 0); } else { if (resH) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED,"Warning: the tool is unable to decide a containment test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n"); resC = 1; } else { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: containment test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); } } freeThing(tempNode); freeThing(tempNode2); } else printMessage(2,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT,"Information: containment test relies on floating-point result.\n"); mpfr_clear(d); } if (resC) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } resE = 1; } } } mpfr_clear(a); mpfr_clear(b); mpfr_clear(c); if (timingString != NULL) popTimeCounter(timingString); } if ((!resE) && isRange(copy->child1) && isRange(copy->child1)) { if (timingString != NULL) pushTimeCounter(); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); mpfr_init2(c,tools_precision); mpfr_init2(d,tools_precision); if (evaluateThingToRange(a,b,copy->child1) && evaluateThingToRange(c,d,copy->child2)) { resC = ((mpfr_cmp(c,a) <= 0) && (!mpfr_unordered_p(c,a)) && (mpfr_cmp(b,d) <= 0) && (!mpfr_unordered_p(b,d))); if (resC) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } mpfr_clear(a); mpfr_clear(b); mpfr_clear(c); mpfr_clear(d); if (timingString != NULL) popTimeCounter(timingString); } break; case COMPARELESS: copy->child1 = evaluateThing(tree->child1); copy->child2 = evaluateThing(tree->child2); if (isPureTree(copy->child1) && isPureTree(copy->child2) && isConstant(copy->child1) && isConstant(copy->child2)) { if (timingString != NULL) pushTimeCounter(); if (checkInequalityFast(&resF, copy->child1, copy->child2)) { if (resF < 0) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if ((resA = evaluateThingToConstant(a,copy->child1,NULL,1,1)) && (resB = evaluateThingToConstant(b,copy->child2,NULL,1,1))) { resI = ((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2))); resJ = 0; if ((resA == 3) || (resB == 3)) { if (resI) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL,"Warning: inequality test relies on floating-point result that is not faithfully evaluated.\n"); } else { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: inequality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); resJ = 1; } } resC = ((mpfr_cmp(a,b) < 0) && (!mpfr_unordered_p(a,b))); resH = (mpfr_number_p(a) && mpfr_number_p(b)); if ((resA == 1) || (resB == 1)) { if (resC) { /* a < b */ if (resA == 1) mpfr_nextabove(a); if (resB == 1) mpfr_nextbelow(b); } else { /* a >= b */ if (resA == 1) mpfr_nextbelow(a); if (resB == 1) mpfr_nextabove(b); } if ((mpfr_cmp(a,b) < 0) != resC) { if (compareConstant(&resD, copy->child1, copy->child2, NULL, 0)) { resC = (resD < 0); } else { if (resH) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED,"Warning: the tool is unable to decide an inequality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n"); resC = 0; } else { if ((!resI) && (!resJ)) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: inequality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); } } } } else printMessage(2,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT,"Information: inequality test relies on floating-point result.\n"); } if (resC) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } mpfr_clear(a); mpfr_clear(b); } if (timingString != NULL) popTimeCounter(timingString); } break; case MIN: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; if (isList((node *) (curr->value))) { curr = accessThruMemRef(((node *) (curr->value)))->arguments; resE = 1; while (curr != NULL) { if (!(isPureTree((node *) (curr->value)) && isConstant((node *) (curr->value)))) { resE = 0; break; } curr = curr->next; } if (resE) { if (timingString != NULL) pushTimeCounter(); curr = copy->arguments; curr = accessThruMemRef(((node *) (curr->value)))->arguments; if (curr->next == NULL) { tempNode = copyThing((node *) (curr->value)); freeThing(copy); copy = tempNode; } else { tempNode = (node *) (curr->value); resK = 0; resM = 0; curr = curr->next; while (curr != NULL) { tempNode2 = (node *) (curr->value); if (checkInequalityFast(&resF, tempNode, tempNode2)) { if (resF > 0) { tempNode = tempNode2; resK = 0; resM = 0; } } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if ((resA = evaluateThingToConstant(a,tempNode,NULL,1,1)) && (resB = evaluateThingToConstant(b,tempNode2,NULL,1,1))) { resL = 0; resN = 0; resI = ((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2))); resJ = 0; if ((resA == 3) || (resB == 3)) { if (resI) { resN = 1; } else { printMessage(1,SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: minimum computation relies on floating-point result that is faithfully evaluated and at least one of the terms is not a real number.\n"); resJ = 1; } } resC = ((mpfr_cmp(a,b) < 0) && (!mpfr_unordered_p(a,b))); resG = mpfr_number_p(b) || ((resB == 2) && mpfr_inf_p(b)); resH = (mpfr_number_p(a) && mpfr_number_p(b)); if ((resA == 1) || (resB == 1)) { if (resC) { /* a < b */ if (resA == 1) mpfr_nextabove(a); if (resB == 1) mpfr_nextbelow(b); } else { /* a >= b */ if (resA == 1) mpfr_nextbelow(a); if (resB == 1) mpfr_nextabove(b); } if ((mpfr_cmp(a,b) < 0) != resC) { if (compareConstant(&resD, tempNode, tempNode2, NULL, 0)) { resC = (resD < 0); resG = 1; } else { if (resH) { resL = 1; resC = 0; } else { if ((!resI) && (!resJ)) { printMessage(1,SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: minimum computation relies on floating-point result that is faithfully evaluated and at least one of the terms is not a real number.\n"); } } } } else printMessage(2,SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT,"Information: minimum computation relies on floating-point result.\n"); } if ((!resC) && (resG)) { tempNode = tempNode2; resK = resL; resM = resN; } resK = resK || resL; resM = resM || resN; } else { resE = 0; } mpfr_clear(a); mpfr_clear(b); } curr = curr->next; } if (resE) { if (resK) { printMessage(1,SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED,"Warning: the tool is unable to decide a minimum computation by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n"); } if (resM) { printMessage(1,SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL,"Warning: minimum computation relies on floating-point result that is not faithfully evaluated.\n"); } tempNode3 = copyThing(tempNode); freeThing(copy); copy = tempNode3; } } if (timingString != NULL) popTimeCounter(timingString); } } else { resE = 1; while (curr != NULL) { if (!(isPureTree((node *) (curr->value)) && isConstant((node *) (curr->value)))) { resE = 0; break; } curr = curr->next; } if (resE) { if (timingString != NULL) pushTimeCounter(); curr = copy->arguments; if (curr->next == NULL) { tempNode = copyThing((node *) (curr->value)); freeThing(copy); copy = tempNode; } else { tempNode = (node *) (curr->value); curr = curr->next; resK = 0; resM = 0; while (curr != NULL) { tempNode2 = (node *) (curr->value); if (checkInequalityFast(&resF, tempNode, tempNode2)) { if (resF > 0) { tempNode = tempNode2; resK = 0; resM = 0; } } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if ((resA = evaluateThingToConstant(a,tempNode,NULL,1,1)) && (resB = evaluateThingToConstant(b,tempNode2,NULL,1,1))) { resL = 0; resN = 0; resI = ((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2))); resJ = 0; if ((resA == 3) || (resB == 3)) { if (resI) { resN = 1; } else { printMessage(1,SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: minimum computation relies on floating-point result that is faithfully evaluated and at least one of the terms is not a real number.\n"); resJ = 1; } } resC = ((mpfr_cmp(a,b) < 0) && (!mpfr_unordered_p(a,b))); resG = mpfr_number_p(b) || ((resB == 2) && mpfr_inf_p(b)); resH = (mpfr_number_p(a) && mpfr_number_p(b)); if ((resA == 1) || (resB == 1)) { if (resC) { /* a < b */ if (resA == 1) mpfr_nextabove(a); if (resB == 1) mpfr_nextbelow(b); } else { /* a >= b */ if (resA == 1) mpfr_nextbelow(a); if (resB == 1) mpfr_nextabove(b); } if ((mpfr_cmp(a,b) < 0) != resC) { if (compareConstant(&resD, tempNode, tempNode2, NULL, 0)) { resC = (resD < 0); resG = 1; } else { if (resH) { resL = 1; resC = 0; } else { if ((!resI) && (resJ)) { printMessage(1,SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: minimum computation relies on floating-point result that is faithfully evaluated and at least one of the terms is not a real number.\n"); } } } } else printMessage(2,SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT,"Information: minimum computation relies on floating-point result.\n"); } if ((!resC) && (resG)) { tempNode = tempNode2; resK = resL; resM = resN; } resK = resK || resL; resM = resM || resN; } else { resE = 0; } mpfr_clear(a); mpfr_clear(b); } curr = curr->next; } if (resE) { if (resK) { printMessage(1,SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED,"Warning: the tool is unable to decide a minimum computation by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n"); } if (resM) { printMessage(1,SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL,"Warning: minimum computation relies on floating-point result that is not faithfully evaluated.\n"); } tempNode3 = copyThing(tempNode); freeThing(copy); copy = tempNode3; } } if (timingString != NULL) popTimeCounter(timingString); } } break; case MAX: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; if (isList((node *) (curr->value))) { curr = accessThruMemRef(((node *) (curr->value)))->arguments; resE = 1; while (curr != NULL) { if (!(isPureTree((node *) (curr->value)) && isConstant((node *) (curr->value)))) { resE = 0; break; } curr = curr->next; } if (resE) { if (timingString != NULL) pushTimeCounter(); curr = copy->arguments; curr = accessThruMemRef(((node *) (curr->value)))->arguments; if (curr->next == NULL) { tempNode = copyThing((node *) (curr->value)); freeThing(copy); copy = tempNode; } else { tempNode = (node *) (curr->value); resK = 0; resM = 0; curr = curr->next; while (curr != NULL) { tempNode2 = (node *) (curr->value); if (checkInequalityFast(&resF, tempNode, tempNode2)) { if (resF < 0) { tempNode = tempNode2; resK = 0; resM = 0; } } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if ((resA = evaluateThingToConstant(a,tempNode,NULL,1,1)) && (resB = evaluateThingToConstant(b,tempNode2,NULL,1,1))) { resL = 0; resN = 0; resI = ((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2))); resJ = 0; if ((resA == 3) || (resB == 3)) { if (resI) { resN = 1; } else { printMessage(1,SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: maximum computation relies on floating-point result that is faithfully evaluated and at least one of the terms is not a real number.\n"); resJ = 1; } } resC = ((mpfr_cmp(a,b) < 0) || (mpfr_unordered_p(a,b))); resG = mpfr_number_p(b) || ((resB == 2) && mpfr_inf_p(b)); resH = (mpfr_number_p(a) && mpfr_number_p(b)); if ((resA == 1) || (resB == 1)) { if (resC) { /* a < b */ if (resA == 1) mpfr_nextabove(a); if (resB == 1) mpfr_nextbelow(b); } else { /* a >= b */ if (resA == 1) mpfr_nextbelow(a); if (resB == 1) mpfr_nextabove(b); } if ((mpfr_cmp(a,b) < 0) != resC) { if (compareConstant(&resD, tempNode, tempNode2, NULL, 0)) { resC = (resD < 0); resG = 1; } else { if (resH) { resL = 1; resC = 0; } else { if ((!resI) && (!resJ)) { printMessage(1,SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: maximum computation relies on floating-point result that is faithfully evaluated and at least one of the terms is not a real number.\n"); } } } } else printMessage(2,SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT,"Information: maximum computation relies on floating-point result.\n"); } if (resC && resG) { tempNode = tempNode2; resK = resL; resM = resN; } resK = resK || resL; resM = resM || resN; } else { resE = 0; } mpfr_clear(a); mpfr_clear(b); } curr = curr->next; } if (resE) { if (resK) { printMessage(1,SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED,"Warning: the tool is unable to decide a maximum computation by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n"); } if (resM) { printMessage(1,SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL,"Warning: maximum computation relies on floating-point result that is not faithfully evaluated.\n"); } tempNode3 = copyThing(tempNode); freeThing(copy); copy = tempNode3; } } if (timingString != NULL) popTimeCounter(timingString); } } else { resE = 1; while (curr != NULL) { if (!(isPureTree((node *) (curr->value)) && isConstant((node *) (curr->value)))) { resE = 0; break; } curr = curr->next; } if (resE) { if (timingString != NULL) pushTimeCounter(); curr = copy->arguments; if (curr->next == NULL) { tempNode = copyThing((node *) (curr->value)); freeThing(copy); copy = tempNode; } else { tempNode = (node *) (curr->value); resK = 0; resM = 0; curr = curr->next; while (curr != NULL) { tempNode2 = (node *) (curr->value); if (checkInequalityFast(&resF, tempNode, tempNode2)) { if (resF < 0) { tempNode = tempNode2; resK = 0; resM = 0; } } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if ((resA = evaluateThingToConstant(a,tempNode,NULL,1,1)) && (resB = evaluateThingToConstant(b,tempNode2,NULL,1,1))) { resL = 0; resN = 0; resI = ((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2))); resJ = 0; if ((resA == 3) || (resB == 3)) { if (resI) { resN = 1; } else { printMessage(1,SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: maximum computation relies on floating-point result that is faithfully evaluated and at least one of the terms is not a real number.\n"); resJ = 1; } } resC = ((mpfr_cmp(a,b) < 0) || (mpfr_unordered_p(a,b))); resG = mpfr_number_p(b) || ((resB == 2) && mpfr_inf_p(b)); resH = (mpfr_number_p(a) && mpfr_number_p(b)); if ((resA == 1) || (resB == 1)) { if (resC) { /* a < b */ if (resA == 1) mpfr_nextabove(a); if (resB == 1) mpfr_nextbelow(b); } else { /* a >= b */ if (resA == 1) mpfr_nextbelow(a); if (resB == 1) mpfr_nextabove(b); } if ((mpfr_cmp(a,b) < 0) != resC) { if (compareConstant(&resD, tempNode, tempNode2, NULL, 0)) { resC = (resD < 0); resG = 1; } else { if (resH) { resL = 1; resC = 0; } else { if ((!resI) && (!resJ)) { printMessage(1,SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: maximum computation relies on floating-point result that is faithfully evaluated and at least one of the terms is not a real number.\n"); } } } } else printMessage(2,SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT,"Information: maximum computation relies on floating-point result.\n"); } if (resC && resG) { tempNode = tempNode2; resK = resL; resM = resN; } resK = resK || resL; resM = resM || resN; } else { resE = 0; } mpfr_clear(a); mpfr_clear(b); } curr = curr->next; } if (resE) { if (resK) { printMessage(1,SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED,"Warning: the tool is unable to decide a maximum computation by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n"); } if (resM) { printMessage(1,SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL,"Warning: maximum computation relies on floating-point result that is not faithfully evaluated.\n"); } tempNode3 = copyThing(tempNode); freeThing(copy); copy = tempNode3; } } if (timingString != NULL) popTimeCounter(timingString); } } break; case COMPAREGREATER: copy->child1 = evaluateThing(tree->child1); copy->child2 = evaluateThing(tree->child2); if (isPureTree(copy->child1) && isPureTree(copy->child2) && isConstant(copy->child1) && isConstant(copy->child2)) { if (timingString != NULL) pushTimeCounter(); if (checkInequalityFast(&resF, copy->child1, copy->child2)) { if (resF > 0) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if ((resA = evaluateThingToConstant(a,copy->child1,NULL,1,1)) && (resB = evaluateThingToConstant(b,copy->child2,NULL,1,1))) { resI = ((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2))); resJ = 0; if ((resA == 3) || (resB == 3)) { if (resI) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL,"Warning: inequality test relies on floating-point result that is not faithfully evaluated.\n"); } else { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: inequality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); resJ = 1; } } resC = ((mpfr_cmp(a,b) > 0) && (!mpfr_unordered_p(a,b))); resH = (mpfr_number_p(a) && mpfr_number_p(b)); if ((resA == 1) || (resB == 1)) { if (resC) { /* a > b */ if (resA == 1) mpfr_nextbelow(a); if (resB == 1) mpfr_nextabove(b); } else { /* a <= b */ if (resA == 1) mpfr_nextabove(a); if (resB == 1) mpfr_nextbelow(b); } if ((mpfr_cmp(a,b) > 0) != resC) { if (compareConstant(&resD, copy->child1, copy->child2, NULL, 0)) { resC = (resD > 0); } else { if (resH) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED,"Warning: the tool is unable to decide an inequality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n"); resC = 0; } else { if ((!resI) && (!resJ)) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: inequality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); } } } } else printMessage(2,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT,"Information: inequality test relies on floating-point result.\n"); } if (resC) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } mpfr_clear(a); mpfr_clear(b); } if (timingString != NULL) popTimeCounter(timingString); } break; case COMPARELESSEQUAL: copy->child1 = evaluateThing(tree->child1); copy->child2 = evaluateThing(tree->child2); if (isPureTree(copy->child1) && isPureTree(copy->child2) && isConstant(copy->child1) && isConstant(copy->child2)) { if (timingString != NULL) pushTimeCounter(); if (checkInequalityFast(&resF, copy->child1, copy->child2)) { if (resF < 0) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if ((resA = evaluateThingToConstant(a,copy->child1,NULL,1,1)) && (resB = evaluateThingToConstant(b,copy->child2,NULL,1,1))) { resI = ((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2))); resJ = 0; if ((resA == 3) || (resB == 3)) { if (resI) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL,"Warning: inequality test relies on floating-point result that is not faithfully evaluated.\n"); } else { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: inequality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); resJ = 1; } } resC = ((mpfr_cmp(a,b) <= 0) && (!mpfr_unordered_p(a,b))); resH = (mpfr_number_p(a) && mpfr_number_p(b)); if ((resA == 1) || (resB == 1)) { if (resC) { /* a <= b */ if (resA == 1) mpfr_nextabove(a); if (resB == 1) mpfr_nextbelow(b); } else { /* a > b */ if (resA == 1) mpfr_nextbelow(a); if (resB == 1) mpfr_nextabove(b); } if ((mpfr_cmp(a,b) <= 0) != resC) { if (compareConstant(&resD, copy->child1, copy->child2, NULL, 0)) { resC = (resD <= 0); } else { if (resH) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED,"Warning: the tool is unable to decide an inequality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n"); resC = 1; } else { if ((!resI) && (!resJ)) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: inequality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); } } } } else printMessage(2,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT,"Information: inequality test relies on floating-point result.\n"); } if (resC) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } mpfr_clear(a); mpfr_clear(b); } if (timingString != NULL) popTimeCounter(timingString); } break; case COMPAREGREATEREQUAL: copy->child1 = evaluateThing(tree->child1); copy->child2 = evaluateThing(tree->child2); if (isPureTree(copy->child1) && isPureTree(copy->child2) && isConstant(copy->child1) && isConstant(copy->child2)) { if (timingString != NULL) pushTimeCounter(); if (checkInequalityFast(&resF, copy->child1, copy->child2)) { if (resF > 0) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if ((resA = evaluateThingToConstant(a,copy->child1,NULL,1,1)) && (resB = evaluateThingToConstant(b,copy->child2,NULL,1,1))) { resI = ((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2))); resJ = 0; if ((resA == 3) || (resB == 3)) { if (resI) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL,"Warning: inequality test relies on floating-point result that is not faithfully evaluated.\n"); } else { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: inequality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); resJ = 1; } } resC = ((mpfr_cmp(a,b) >= 0) && (!mpfr_unordered_p(a,b))); resH = (mpfr_number_p(a) && mpfr_number_p(b)); if ((resA == 1) || (resB == 1)) { if (resC) { /* a >= b */ if (resA == 1) mpfr_nextbelow(a); if (resB == 1) mpfr_nextabove(b); } else { /* a < b */ if (resA == 1) mpfr_nextabove(a); if (resB == 1) mpfr_nextbelow(b); } if ((mpfr_cmp(a,b) >= 0) != resC) { if (compareConstant(&resD, copy->child1, copy->child2, NULL, 0)) { resC = (resD >= 0); } else { if (resH) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED,"Warning: the tool is unable to decide an inequality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n"); resC = 1; } else { if ((!resI) && (!resJ)) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: inequality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); } } } } else printMessage(2,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT,"Information: inequality test relies on floating-point result.\n"); } if (resC) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } mpfr_clear(a); mpfr_clear(b); } if (timingString != NULL) popTimeCounter(timingString); } break; case COMPARENOTEQUAL: resJ = 0; copy->child1 = evaluateThing(tree->child1); copy->child2 = evaluateThing(tree->child2); if (timingString != NULL) pushTimeCounter(); if ((isError(copy->child1) && (!isError(tree->child1)) && (!isError(tree->child2))) || (isError(copy->child2) && (!isError(tree->child2)) && (!isError(tree->child1)))) { printMessage(1,SOLLYA_MSG_TEST_COMPARES_ERROR_TO_SOMETHING,"Warning: the evaluation of one of the sides of an equality test yields error due to a syntax error or an error on a side-effect.\nThe other side either also yields error due to an syntax or side-effect error or does not evaluate to error.\nThe boolean returned may be meaningless.\n"); } if (autosimplify) { tryRepresentAsPolynomialNoConstants(copy->child1); tryRepresentAsPolynomialNoConstants(copy->child2); } if (isEqualThingEnhanced(copy->child1,copy->child2, autosimplify)) { if (!isError(copy->child1)) { freeThing(copy); copy = makeFalse(); } else { freeThing(copy); copy = makeFalse(); } } else { if (isPureTree(copy->child1) && isPureTree(copy->child2) && isConstant(copy->child1) && isConstant(copy->child2)) { if (checkInequalityFast(&resF, copy->child1, copy->child2)) { freeThing(copy); copy = makeTrue(); } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if ((resA = evaluateThingToConstant(a,copy->child1,NULL,1,1)) && (resB = evaluateThingToConstant(b,copy->child2,NULL,1,1))) { resI = ((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2))); if ((resA == 3) || (resB == 3)) { if (resI) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL,"Warning: equality test relies on floating-point result that is not faithfully evaluated.\n"); } else { if (!resJ) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: equality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); resJ = 1; } } } resC = !(mpfr_equal_p(a,b) || mpfr_unordered_p(a,b)); resH = (mpfr_number_p(a) && mpfr_number_p(b)); if ((resA == 1) || (resB == 1)) { if (mpfr_number_p(a) && mpfr_number_p(b)) { resE = 0; if (!resC) { /* a == b */ resE = 1; } else { /* a != b */ if (mpfr_cmp(a,b) < 0) { /* a < b */ if (resA == 1) mpfr_nextabove(a); if (resB == 1) mpfr_nextbelow(b); resE = (mpfr_cmp(a,b) >= 0); } else { /* b < a */ if (resA == 1) mpfr_nextbelow(a); if (resB == 1) mpfr_nextabove(b); resE = (mpfr_cmp(a,b) <= 0); } } if (resE) { if (compareConstant(&resD, copy->child1, copy->child2, NULL, 0)) { resC = (resD != 0); } else { if (resH) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED,"Warning: the tool is unable to decide an equality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n"); resC = 0; } else { if ((!resI) && (!resJ)) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: equality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); resJ = 1; } } } } else printMessage(2,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT,"Information: equality test relies on floating-point result.\n"); } else { if ((!((mpfr_number_p(a) || (resA == 2)) && (mpfr_number_p(b) || (resB == 2)))) && (!resJ)) { printMessage(1,SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL,"Warning: equality test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number.\n"); resJ = 1; } } } if (resC) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } mpfr_clear(a); mpfr_clear(b); } } else { if (!(isError(copy->child1) || isError(copy->child2))) { freeThing(copy); copy = makeTrue(); } else { freeThing(copy); copy = makeFalse(); } } } if (timingString != NULL) popTimeCounter(timingString); break; case CONCAT: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isString(copy->child1) && isString(copy->child2)) { if (timingString != NULL) pushTimeCounter(); tempString = (char *) safeCalloc(strlen(accessThruMemRef(copy->child1)->string) + strlen(accessThruMemRef(copy->child2)->string) + 1, sizeof(char)); sprintf(tempString,"%s%s",accessThruMemRef(copy->child1)->string,accessThruMemRef(copy->child2)->string); freeThing(copy->child1); freeThing(copy->child2); copy->nodeType = STRING; copy->string = tempString; if (timingString != NULL) popTimeCounter(timingString); } else { if (isString(copy->child1) && isPureTree(copy->child2) && isConstant(copy->child2)) { if (timingString != NULL) pushTimeCounter(); mpfr_init2(a,tools_precision); if (evaluateThingToConstant(a, copy->child2, NULL,0,0)) { tempString2 = sprintValue(&a); tempString = (char *) safeCalloc(strlen(accessThruMemRef(copy->child1)->string) + strlen(tempString2) + 1, sizeof(char)); sprintf(tempString,"%s%s",accessThruMemRef(copy->child1)->string,tempString2); freeThing(copy->child1); freeThing(copy->child2); copy->nodeType = STRING; copy->string = tempString; safeFree(tempString2); } mpfr_clear(a); if (timingString != NULL) popTimeCounter(timingString); } else { if (isString(copy->child2) && isPureTree(copy->child1) && isConstant(copy->child1)) { if (timingString != NULL) pushTimeCounter(); mpfr_init2(a,tools_precision); if (evaluateThingToConstant(a, copy->child1, NULL,0,0)) { tempString2 = sprintValue(&a); tempString = (char *) safeCalloc(strlen(accessThruMemRef(copy->child2)->string) + strlen(tempString2) + 1, sizeof(char)); sprintf(tempString,"%s%s",tempString2,accessThruMemRef(copy->child2)->string); freeThing(copy->child1); freeThing(copy->child2); copy->nodeType = STRING; copy->string = tempString; safeFree(tempString2); } mpfr_clear(a); if (timingString != NULL) popTimeCounter(timingString); } else { if (isString(copy->child1)) { if (timingString != NULL) pushTimeCounter(); tempNode2 = evaluateThing(copy->child2); if (!isError(tempNode2) || isError(copy->child2)) { tempString2 = sPrintThing(tempNode2); tempString = (char *) safeCalloc(strlen(accessThruMemRef(copy->child1)->string) + strlen(tempString2) + 1, sizeof(char)); sprintf(tempString,"%s%s",accessThruMemRef(copy->child1)->string,tempString2); freeThing(copy->child1); freeThing(copy->child2); copy->nodeType = STRING; copy->string = tempString; safeFree(tempString2); } freeThing(tempNode2); if (timingString != NULL) popTimeCounter(timingString); } else { if (isString(copy->child2)) { if (timingString != NULL) pushTimeCounter(); tempNode2 = evaluateThing(copy->child1); if (!isError(tempNode2) || isError(copy->child1)) { tempString2 = sPrintThing(tempNode2); tempString = (char *) safeCalloc(strlen(accessThruMemRef(copy->child2)->string) + strlen(tempString2) + 1, sizeof(char)); sprintf(tempString,"%s%s",tempString2,accessThruMemRef(copy->child2)->string); freeThing(copy->child1); freeThing(copy->child2); copy->nodeType = STRING; copy->string = tempString; safeFree(tempString2); } freeThing(tempNode2); if (timingString != NULL) popTimeCounter(timingString); } else { if (isEmptyList(copy->child1) && isEmptyList(copy->child2)) { freeThing(copy->child1); freeThing(copy->child2); copy->nodeType = EMPTYLIST; } else { if (isEmptyList(copy->child1) && (isList(copy->child2) || isFinalEllipticList(copy->child2))) { copy->nodeType = accessThruMemRef(copy->child2)->nodeType; copy->arguments = copyChainWithoutReversal(accessThruMemRef(copy->child2)->arguments,copyThingOnVoid); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; freeThing(copy->child1); freeThing(copy->child2); } else { if (isEmptyList(copy->child2) && isList(copy->child1)) { if (timingString != NULL) pushTimeCounter(); copy->nodeType = LIST; copy->arguments = copyChainWithoutReversal(accessThruMemRef(copy->child1)->arguments,copyThingOnVoid); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; freeThing(copy->child2); freeThing(copy->child1); if (timingString != NULL) popTimeCounter(timingString); } else { if (isList(copy->child1) && isList(copy->child2)) { if (timingString != NULL) pushTimeCounter(); copy->nodeType = LIST; copy->arguments = concatChains(copyChainWithoutReversal(accessThruMemRef(copy->child1)->arguments,copyThingOnVoid), copyChainWithoutReversal(accessThruMemRef(copy->child2)->arguments,copyThingOnVoid)); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; freeThing(copy->child1); freeThing(copy->child2); if (timingString != NULL) popTimeCounter(timingString); } else { if (isList(copy->child1) && isFinalEllipticList(copy->child2)) { if (timingString != NULL) pushTimeCounter(); copy->nodeType = FINALELLIPTICLIST; copy->arguments = concatChains(copyChainWithoutReversal(accessThruMemRef(copy->child1)->arguments,copyThingOnVoid), copyChainWithoutReversal(accessThruMemRef(copy->child2)->arguments,copyThingOnVoid)); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; freeThing(copy->child1); freeThing(copy->child2); if (timingString != NULL) popTimeCounter(timingString); } else { if (isProcedure(copy->child1) && (isList(copy->child2) || ((accessThruMemRef(copy->child1)->nodeType == PROCILLIM) && isFinalEllipticList(copy->child2)))) { tempChain = copyChainWithoutReversal(accessThruMemRef(copy->child2)->arguments, evaluateThingOnVoid); tempNode = evaluateThing(copy->child1); tempNode2 = NULL; if (executeProcedure(&tempNode2, tempNode, tempChain, isFinalEllipticList(copy->child2))) { if (tempNode2 != NULL) { freeThing(copy); copy = tempNode2; } } else { printMessage(1,SOLLYA_MSG_ERROR_WHILE_EXECUTING_A_PROCEDURE,"Warning: an error occurred while executing a procedure.\n"); considerDyingOnError(); freeThing(copy); copy = makeError(); } freeChain(tempChain, freeThingOnVoid); freeThing(tempNode); } else { if (isProcedure(copy->child1) && isEmptyList(copy->child2)) { tempNode = evaluateThing(copy->child1); tempNode2 = NULL; if (executeProcedure(&tempNode2, tempNode, NULL, 0)) { if (tempNode2 != NULL) { freeThing(copy); copy = tempNode2; } } else { printMessage(1,SOLLYA_MSG_ERROR_WHILE_EXECUTING_A_PROCEDURE,"Warning: an error occurred while executing a procedure.\n"); considerDyingOnError(); freeThing(copy); copy = makeError(); } freeThing(tempNode); } else { if (isExternalProcedureUsage(copy->child1) && isEmptyList(copy->child2)) { tempNode2 = NULL; if (executeExternalProcedure(&tempNode2, accessThruMemRef(copy->child1)->libProc, NULL)) { if (tempNode2 != NULL) { freeThing(copy); copy = tempNode2; } } else { printMessage(1,SOLLYA_MSG_EXTERNAL_PROCEDURE_SIGNALED_FAILURE,"Warning: external procedure has signalized failure.\n"); considerDyingOnError(); freeThing(copy); copy = makeError(); } } else { if (isExternalProcedureUsage(copy->child1) && isList(copy->child2)) { tempChain = copyChainWithoutReversal(accessThruMemRef(copy->child2)->arguments, evaluateThingOnVoid); tempNode2 = NULL; if (executeExternalProcedure(&tempNode2, accessThruMemRef(copy->child1)->libProc, tempChain)) { if (tempNode2 != NULL) { freeThing(copy); copy = tempNode2; } freeChain(tempChain, freeThingOnVoid); } else { printMessage(1,SOLLYA_MSG_EXTERNAL_PROCEDURE_SIGNALED_FAILURE,"Warning: external procedure has signalized failure.\n"); considerDyingOnError(); freeThing(copy); copy = makeError(); freeChain(tempChain, freeThingOnVoid); } } } } } } } } } } } } } } } break; case ADDTOLIST: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isList(copy->child2)) { if (timingString != NULL) pushTimeCounter(); copy->nodeType = LIST; copy->arguments = addElement(copyChainWithoutReversal(accessThruMemRef(copy->child2)->arguments, copyThingOnVoid),copy->child1); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; freeThing(copy->child2); if (timingString != NULL) popTimeCounter(timingString); } else { if (isEmptyList(copy->child2)) { if (timingString != NULL) pushTimeCounter(); copy->nodeType = LIST; copy->arguments = addElement(NULL, copy->child1); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; freeThing(copy->child2); if (timingString != NULL) popTimeCounter(timingString); } else { if (isFinalEllipticList(copy->child2)) { if (timingString != NULL) pushTimeCounter(); copy->nodeType = FINALELLIPTICLIST; copy->arguments = addElement(copyChainWithoutReversal(accessThruMemRef(copy->child2)->arguments, copyThingOnVoid),copy->child1); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; freeThing(copy->child2); if (timingString != NULL) popTimeCounter(timingString); } else { if (isList(copy->child1)) { if (timingString != NULL) pushTimeCounter(); tempChain = addElement(copyChain(accessThruMemRef(copy->child1)->arguments,copyThingOnVoid),copyThing(copy->child2)); tempNode = makeList(copyChain(tempChain,copyThingOnVoid)); freeChain(tempChain,freeThingOnVoid); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } else { if (isEmptyList(copy->child1)) { if (timingString != NULL) pushTimeCounter(); copy->nodeType = LIST; copy->arguments = addElement(NULL, copy->child2); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; freeThing(copy->child1); if (timingString != NULL) popTimeCounter(timingString); } } } } } break; case PREPEND: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isList(copy->child2)) { if (timingString != NULL) pushTimeCounter(); copy->nodeType = LIST; copy->arguments = addElement(copyChainWithoutReversal(accessThruMemRef(copy->child2)->arguments, copyThingOnVoid),copy->child1); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; setupRandomAccessOnLists(copy); freeThing(copy->child2); if (timingString != NULL) popTimeCounter(timingString); } else { if (isEmptyList(copy->child2)) { if (timingString != NULL) pushTimeCounter(); copy->nodeType = LIST; copy->arguments = addElement(NULL, copy->child1); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; setupRandomAccessOnLists(copy); freeThing(copy->child2); if (timingString != NULL) popTimeCounter(timingString); } else { if (isFinalEllipticList(copy->child2)) { if (timingString != NULL) pushTimeCounter(); copy->nodeType = FINALELLIPTICLIST; copy->arguments = addElement(copyChainWithoutReversal(accessThruMemRef(copy->child2)->arguments, copyThingOnVoid),copy->child1); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; setupRandomAccessOnLists(copy); freeThing(copy->child2); if (timingString != NULL) popTimeCounter(timingString); } } } break; case APPEND: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isList(copy->child1)) { if (timingString != NULL) pushTimeCounter(); tempChain = addElement(copyChain(accessThruMemRef(copy->child1)->arguments,copyThingOnVoid),copyThing(copy->child2)); tempNode = makeList(copyChain(tempChain,copyThingOnVoid)); freeChain(tempChain,freeThingOnVoid); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } else { if (isEmptyList(copy->child1)) { if (timingString != NULL) pushTimeCounter(); copy->nodeType = LIST; copy->arguments = addElement(NULL, copy->child2); copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; freeThing(copy->child1); if (timingString != NULL) popTimeCounter(timingString); } } break; case ON: break; case OFF: break; case DYADIC: break; case POWERS: break; case BINARY: break; case HEXADECIMAL: break; case FILESYM: break; case POSTSCRIPT: break; case POSTSCRIPTFILE: break; case PERTURB: break; case ROUNDDOWN: break; case ROUNDUP: break; case ROUNDTOZERO: break; case ROUNDTONEAREST: break; case HONORCOEFF: break; case TRUE: break; case UNIT: break; case FALSE: break; case DEFAULT: break; case DECIMAL: break; case ABSOLUTESYM: break; case RELATIVESYM: break; case FIXED: break; case FLOATING: break; case ERRORSPECIAL: break; case DOUBLESYMBOL: break; case SINGLESYMBOL: break; case QUADSYMBOL: break; case HALFPRECISIONSYMBOL: break; case DOUBLEEXTENDEDSYMBOL: break; case DOUBLEDOUBLESYMBOL: break; case TRIPLEDOUBLESYMBOL: break; case STRING: copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); break; case TABLEACCESS: if (timingString != NULL) pushTimeCounter(); if ((tempNode = getThingFromTable(tree->string, 1, NULL)) == NULL) { if (variablename == NULL) { variablename = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(variablename, tree->string); } else { printMessage(1,SOLLYA_MSG_IDENTIFIER_NOT_ASSIGNED_TO,"Warning: the identifier \"%s\" is neither assigned to, nor bound to a library function nor external procedure, nor equal to the current free variable.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"Will interpret \"%s\" as \"%s\".\n",tree->string,variablename); } tempNode = makeVariable(); } safeFree(copy); copy = evaluateThingInner(tempNode); freeThing(tempNode); if (timingString != NULL) popTimeCounter(timingString); break; case ISBOUND: if (timingString != NULL) pushTimeCounter(); if ((tempNode = getThingFromTable(tree->string, 1, NULL)) != NULL) { freeThing(tempNode); tempNode = makeTrue(); } else { if ((variablename != NULL) && (strcmp(variablename,tree->string) == 0)) { tempNode = makeTrue(); } else { tempNode = makeFalse(); } } safeFree(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); break; case TABLEACCESSWITHSUBSTITUTE: if (timingString != NULL) pushTimeCounter(); undoVariableTrick = 0; if (variablename == NULL) { variablename = (char *) safeCalloc(4, sizeof(char)); variablename[0] = '_'; variablename[1] = 'x'; variablename[2] = '_'; undoVariableTrick = 1; } if ((tempNode = getThingFromTable(tree->string, 1, NULL)) == NULL) { if (undoVariableTrick) { safeFree(variablename); variablename = NULL; undoVariableTrick = 0; } if (variablename == NULL) { variablename = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(variablename, tree->string); } else { printMessage(1,SOLLYA_MSG_IDENTIFIER_NOT_ASSIGNED_TO,"Warning: the identifier \"%s\" is neither assigned to, nor bound to a library function nor external procedure, nor equal to the current free variable.\n",tree->string); printMessage(1,SOLLYA_MSG_CONTINUATION,"Will interpret \"%s\" as \"%s\".\n",tree->string,variablename); } tempNode = makeVariable(); } if (undoVariableTrick) { safeFree(variablename); variablename = NULL; undoVariableTrick = 0; } if (isPureTree(tempNode)) { if (lengthChain(tree->arguments) == 1) { if (evaluateThingToPureTree(&tempNode2,(node *) (tree->arguments->value))) { safeFree(copy); if ((tempNode->nodeType == MEMREF) && (tempNode->polynomialRepresentation != NULL)) { if (polynomialIsIdentity(tempNode->polynomialRepresentation, 0)) { if (variablename != NULL) { printMessage(1,SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION,"Warning: the identifier \"%s\" is bound to the current free variable. In a functional context it will be considered as the identity function.\n", variablename); } else { printMessage(1,SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION,"Warning: \"_x_\" is the free variable. In a functional context it will be considered as the identity function.\n"); } } } else { if (accessThruMemRef(tempNode)->nodeType == VARIABLE) { if (variablename != NULL) { printMessage(1,SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION,"Warning: the identifier \"%s\" is bound to the current free variable. In a functional context it will be considered as the identity function.\n", variablename); } else { printMessage(1,SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION,"Warning: \"_x_\" is the free variable. In a functional context it will be considered as the identity function.\n"); } } } copy = substituteEnhanced(tempNode, tempNode2, 0, autosimplify); freeThing(tempNode2); } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,(node *) (tree->arguments->value))) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(a)); mpfr_init2(*(xrange.b),mpfr_get_prec(b)); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),a,GMP_RNDD); mpfr_set(*(xrange.b),b,GMP_RNDU); evaluateRangeFunction(yrange, tempNode, xrange, tools_precision); safeFree(copy); copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); } mpfr_clear(a); mpfr_clear(b); } } else { copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); } } else { if (isExternalProcedureUsage(tempNode)) { tempChain = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); tempNode2 = NULL; if (executeExternalProcedure(&tempNode2, accessThruMemRef(tempNode)->libProc, tempChain)) { if (tempNode2 != NULL) { safeFree(copy); copy = tempNode2; freeChain(tempChain, freeThingOnVoid); } else { copy->arguments = tempChain; copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); } } else { printMessage(1,SOLLYA_MSG_EXTERNAL_PROCEDURE_SIGNALED_FAILURE,"Warning: external procedure has signalized failure.\n"); considerDyingOnError(); safeFree(copy); copy = makeError(); freeChain(tempChain, freeThingOnVoid); } } else { if (isProcedure(tempNode)) { tempChain = copyChainWithoutReversal(tree->arguments, evaluateThingOnVoid); tempNode2 = NULL; if (executeProcedure(&tempNode2, tempNode, tempChain, 0)) { if (tempNode2 != NULL) { safeFree(copy); copy = tempNode2; freeChain(tempChain, freeThingOnVoid); } else { copy->arguments = tempChain; copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); } } else { printMessage(1,SOLLYA_MSG_ERROR_WHILE_EXECUTING_A_PROCEDURE,"Warning: an error occurred while executing a procedure.\n"); considerDyingOnError(); safeFree(copy); copy = makeError(); freeChain(tempChain, freeThingOnVoid); } } else { copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); } } } freeThing(tempNode); if (timingString != NULL) popTimeCounter(timingString); break; case STRUCTACCESS: if (isStructure(tree->child1) && (!associationContainsDoubleEntries(accessThruMemRef(tree->child1)->arguments))) { tempChain = accessThruMemRef(tree->child1)->arguments; resA = 0; tempNode = NULL; while ((!resA) && (tempChain != NULL)) { if (!strcmp(tree->string,((entry *) (tempChain->value))->name)) { resA = 1; tempNode = (node *) (((entry *) (tempChain->value))->value); } tempChain = tempChain->next; } if ((resA) && (tempNode != NULL)) { safeFree(copy); copy = evaluateThing(tempNode); } else { copy->child1 = evaluateThingInner(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); } } else { copy->child1 = evaluateThingInner(tree->child1); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); if (isStructure(copy->child1) && (!associationContainsDoubleEntries(accessThruMemRef(copy->child1)->arguments))) { tempChain = accessThruMemRef(copy->child1)->arguments; resA = 0; tempNode = NULL; while ((!resA) && (tempChain != NULL)) { if (!strcmp(copy->string,((entry *) (tempChain->value))->name)) { resA = 1; tempNode = (node *) (((entry *) (tempChain->value))->value); } tempChain = tempChain->next; } if ((resA) && (tempNode != NULL)) { tempNode2 = evaluateThing(tempNode); freeThing(copy); copy = tempNode2; } } } break; case EXTERNALPROCEDUREUSAGE: copy->libProc = tree->libProc; break; case APPLY: if (timingString != NULL) pushTimeCounter(); tempNode = evaluateThingInner(tree->child1); if (isPureTree(tempNode)) { if (lengthChain(tree->arguments) == 1) { if (evaluateThingToPureTree(&tempNode2,(node *) (tree->arguments->value))) { safeFree(copy); if ((tempNode->nodeType == MEMREF) && (tempNode->polynomialRepresentation != NULL)) { if (polynomialIsIdentity(tempNode->polynomialRepresentation, 0)) { if (variablename != NULL) { printMessage(1,SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION,"Warning: the identifier \"%s\" is bound to the current free variable. In a functional context it will be considered as the identity function.\n", variablename); } else { printMessage(1,SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION,"Warning: \"_x_\" is the free variable. In a functional context it will be considered as the identity function.\n"); } } } else { if (accessThruMemRef(tempNode)->nodeType == VARIABLE) { if (variablename != NULL) { printMessage(1,SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION,"Warning: the identifier \"%s\" is bound to the current free variable. In a functional context it will be considered as the identity function.\n", variablename); } else { printMessage(1,SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION,"Warning: \"_x_\" is the free variable. In a functional context it will be considered as the identity function.\n"); } } } copy = substituteEnhanced(tempNode, tempNode2, 0, autosimplify); freeThing(tempNode2); } else { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,(node *) (tree->arguments->value))) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(a)); mpfr_init2(*(xrange.b),mpfr_get_prec(b)); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),a,GMP_RNDD); mpfr_set(*(xrange.b),b,GMP_RNDU); evaluateRangeFunction(yrange, tempNode, xrange, tools_precision); safeFree(copy); copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); copy->child1 = copyThing(tempNode); } mpfr_clear(a); mpfr_clear(b); } } else { copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); copy->child1 = copyThing(tempNode); } } else { if (isExternalProcedureUsage(tempNode)) { tempChain = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); tempNode2 = NULL; if (executeExternalProcedure(&tempNode2, accessThruMemRef(tempNode)->libProc, tempChain)) { if (tempNode2 != NULL) { safeFree(copy); copy = tempNode2; freeChain(tempChain, freeThingOnVoid); } else { copy->arguments = tempChain; copy->child1 = copyThing(tempNode); } } else { printMessage(1,SOLLYA_MSG_EXTERNAL_PROCEDURE_SIGNALED_FAILURE,"Warning: external procedure has signalized failure.\n"); considerDyingOnError(); safeFree(copy); copy = makeError(); freeChain(tempChain, freeThingOnVoid); } } else { if (isProcedure(tempNode)) { tempChain = copyChainWithoutReversal(tree->arguments, evaluateThingOnVoid); tempNode2 = NULL; if (executeProcedure(&tempNode2, tempNode, tempChain, 0)) { if (tempNode2 != NULL) { safeFree(copy); copy = tempNode2; freeChain(tempChain, freeThingOnVoid); } else { copy->arguments = tempChain; copy->child1 = copyThing(tempNode); } } else { printMessage(1,SOLLYA_MSG_ERROR_WHILE_EXECUTING_A_PROCEDURE,"Warning: an error occurred while executing a procedure.\n"); considerDyingOnError(); safeFree(copy); copy = makeError(); freeChain(tempChain, freeThingOnVoid); } } else { copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); copy->child1 = copyThing(tempNode); } } } freeThing(tempNode); if (timingString != NULL) popTimeCounter(timingString); break; case DECIMALCONSTANT: if (timingString != NULL) pushTimeCounter(); resA = 0; tempString2 = sollya_strchr(tree->string,'%'); tempString3 = sollya_strrchr(tree->string,'%'); if ((tempString2 != NULL) && (tempString3 != NULL) && (tempString2 != tempString3) && (*(tempString2 + 1) != '\0') && (tempString3 != tree->string) && (*(tempString3 + 1) != '\0')) { tempString = (char *) safeCalloc(strlen(tempString3 + 1) + 1, sizeof(char)); strcpy(tempString,tempString3 + 1); tempString4 = (char *) safeCalloc(strlen(tempString2 + 1) + 1, sizeof(char)); tempString5 = tempString4; tempString2++; while ((*tempString2 != '\0') && (tempString2 != tempString3)) { *tempString5 = *tempString2; tempString5++; tempString2++; } resB = atoi(tempString4); safeFree(tempString4); if (resB < 12) { printMessage(1,SOLLYA_MSG_PRECISION_OF_NUMS_MUST_BE_AT_LEAST_TWELVE_BITS,"Warning: the precision of values in the tool must be at least 12 bits.\n"); resB = 12; } pTemp = (mp_prec_t) resB; pTemp2 = pTemp; resA = 1; } if (!resA) { tempString = (char *) safeCalloc(strlen(tree->string) + 1, sizeof(char)); strcpy(tempString,tree->string); pTemp = 4 * strlen(tempString) + 3324; if (tools_precision > pTemp) pTemp = tools_precision; pTemp2 = tools_precision; } if (sollya_strchr(tempString,'%') == NULL) { mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); mpfr_set_str(a,tempString,10,GMP_RNDD); mpfr_set_str(b,tempString,10,GMP_RNDU); if (mpfr_cmp(a,b) != 0) { pTemp = pTemp2; } mpfr_clear(a); mpfr_clear(b); mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); mpfr_set_str(a,tempString,10,GMP_RNDD); mpfr_set_str(b,tempString,10,GMP_RNDU); if (mpfr_cmp(a,b) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT, "Warning: Rounding occurred when converting the constant \"%s\" to floating-point with %d bits.\n", tempString,(int) pTemp); printMessage(1,SOLLYA_MSG_CONTINUATION,"If safe computation is needed, try to increase the precision.\n"); } mpfr_set_str(a,tempString,10,GMP_RNDN); } mpfr_init2(c,pTemp); if (!resA) simplifyMpfrPrec(c, a); else mpfr_set(c,a,GMP_RNDN); tempNode = makeConstant(c); mpfr_clear(c); mpfr_clear(b); mpfr_clear(a); safeFree(copy); copy = tempNode; } safeFree(tempString); if (timingString != NULL) popTimeCounter(timingString); break; case MIDPOINTCONSTANT: if (timingString != NULL) pushTimeCounter(); str1 = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); str2 = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); cutMidpointStringIntoTwo(str1,str2,tree->string); mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); mpfr_set_str(a,str1,10,GMP_RNDD); mpfr_set_str(b,str2,10,GMP_RNDU); if (mpfr_cmp(a,b) > 0) { printMessage(1,SOLLYA_MSG_RANGE_BOUNDS_IN_INVERSE_ORDER,"Warning: the range bounds are given in inverse order. Will revert them.\n"); str3 = str1; str1 = str2; str2 = str3; } mpfr_clear(a); mpfr_clear(b); pTemp = 4 * strlen(str1) + 3324; if (tools_precision > pTemp) pTemp = tools_precision; mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); mpfr_set_str(a,str1,10,GMP_RNDD); mpfr_set_str(b,str1,10,GMP_RNDU); if (mpfr_cmp(a,b) != 0) { pTemp = tools_precision; } mpfr_clear(a); mpfr_clear(b); mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); mpfr_set_str(a,str1,10,GMP_RNDD); mpfr_set_str(b,str1,10,GMP_RNDU); if (mpfr_cmp(a,b) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT, "Warning: Rounding occurred when converting the constant \"%s\" to floating-point with %d bits.\n", str1,(int) pTemp); printMessage(1,SOLLYA_MSG_CONTINUATION,"The inclusion property is nevertheless satisfied.\n"); } mpfr_set_str(a,str1,10,GMP_RNDD); } mpfr_init2(c,pTemp); simplifyMpfrPrec(c, a); mpfr_clear(b); mpfr_clear(a); pTemp = 4 * strlen(str2) + 3324; if (tools_precision > pTemp) pTemp = tools_precision; mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); mpfr_set_str(a,str2,10,GMP_RNDD); mpfr_set_str(b,str2,10,GMP_RNDU); if (mpfr_cmp(a,b) != 0) { pTemp = tools_precision; } mpfr_clear(a); mpfr_clear(b); mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); mpfr_set_str(a,str2,10,GMP_RNDD); mpfr_set_str(b,str2,10,GMP_RNDU); if (mpfr_cmp(a,b) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT, "Warning: Rounding occurred when converting the constant \"%s\" to floating-point with %d bits.\n", str2,(int) pTemp); printMessage(1,SOLLYA_MSG_CONTINUATION,"The inclusion property is nevertheless satisfied.\n"); } mpfr_set_str(a,str2,10,GMP_RNDU); } mpfr_init2(d,pTemp); simplifyMpfrPrec(d, a); tempNode = makeConstant(c); tempNode2 = makeConstant(d); mpfr_clear(c); mpfr_clear(d); mpfr_clear(b); mpfr_clear(a); tempNode3 = makeRange(tempNode,tempNode2); safeFree(copy); copy = tempNode3; safeFree(str1); safeFree(str2); if (timingString != NULL) popTimeCounter(timingString); break; case DYADICCONSTANT: if (timingString != NULL) pushTimeCounter(); pTemp = 4 * strlen(tree->string); if (tools_precision > pTemp) pTemp = tools_precision; mpfr_init2(a,pTemp); if (!readDyadic(a,tree->string)) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT, "Warning: Rounding occurred when converting the dyadic constant \"%s\" to floating-point with %d bits.\n", tree->string,(int) pTemp); printMessage(1,SOLLYA_MSG_CONTINUATION,"If safe computation is needed, try to increase the precision.\n"); } } tempNode = makeConstant(a); mpfr_clear(a); safeFree(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); break; case HEXCONSTANT: if (timingString != NULL) pushTimeCounter(); pTemp = 53; if (tools_precision > pTemp) pTemp = tools_precision; mpfr_init2(a,pTemp); if (!readHexa(a,tree->string)) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT, "Warning: Rounding occurred when converting the hexadecimal constant \"%s\" to floating-point with %d bits.\n", tree->string,(int) pTemp); printMessage(1,SOLLYA_MSG_CONTINUATION,"If safe computation is needed, try to increase the precision.\n"); } } tempNode = makeConstant(a); mpfr_clear(a); safeFree(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); break; case HEXADECIMALCONSTANT: if (timingString != NULL) pushTimeCounter(); pTemp = 4 * strlen(tree->string); if (tools_precision > pTemp) pTemp = tools_precision; mpfr_init2(a,pTemp); if (!readHexadecimal(a,tree->string)) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT, "Warning: Rounding occurred when converting the hexadecimal constant \"%s\" to floating-point with %d bits.\n", tree->string,(int) pTemp); printMessage(1,SOLLYA_MSG_CONTINUATION,"If safe computation is needed, try to increase the precision.\n"); } } tempNode = makeConstant(a); mpfr_clear(a); safeFree(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); break; case BINARYCONSTANT: if (timingString != NULL) pushTimeCounter(); pTemp = strlen(tree->string); if (tools_precision > pTemp) pTemp = tools_precision; mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); mpfr_set_str(a,tree->string,2,GMP_RNDD); mpfr_set_str(b,tree->string,2,GMP_RNDU); if (mpfr_cmp(a,b) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT, "Warning: Rounding occurred when converting the binary constant \"%s_2\" to floating-point with %d bits.\n", tree->string,(int) pTemp); printMessage(1,SOLLYA_MSG_CONTINUATION,"If safe computation is needed, try to increase the precision.\n"); } mpfr_set_str(a,tree->string,2,GMP_RNDN); } tempNode = makeConstant(a); mpfr_clear(b); mpfr_clear(a); safeFree(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); break; case EMPTYLIST: break; case LIST: tempChain = copyChain(tree->arguments, evaluateThingInnerOnVoid); if (timingString != NULL) pushTimeCounter(); curr = tempChain; newChain = NULL; resC = 0; while (curr != NULL) { if ((curr->next != NULL) && (curr->next->next != NULL) && isElliptic((node *) (curr->next->value)) && isPureTree((node *) (curr->value)) && isPureTree((node *) (curr->next->next->value)) && isConstant((node *) (curr->value)) && isConstant((node *) (curr->next->next->value)) && evaluateThingToInteger(&resA,(node *) (curr->value), NULL) && evaluateThingToInteger(&resB,(node *) (curr->next->next->value),NULL) && (resA >= resB)) { mpfr_init2(a,sizeof(int) * 8); resC = 1; for (i=resA;i>=resB;i--) { mpfr_set_si(a,i,GMP_RNDN); newChain = addElement(newChain,makeConstant(a)); } mpfr_clear(a); curr = curr->next->next; } else { newChain = addElement(newChain,copyThing((node *) (curr->value))); } curr = curr->next; } freeChain(tempChain, freeThingOnVoid); copy->arguments = newChain; copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; if (resC && (!isPureList(copy))) { tempNode = evaluateThing(copy); freeThing(copy); copy = tempNode; } setupRandomAccessOnLists(copy); if (timingString != NULL) popTimeCounter(timingString); break; case STRUCTURE: if (!associationContainsDoubleEntries(tree->arguments)) { if (timingString != NULL) pushTimeCounter(); copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateEntryOnVoid); if (timingString != NULL) popTimeCounter(timingString); } else { printMessage(1,SOLLYA_MSG_LITERAL_STRUCTURE_CONTAINS_ENTRY_TWICE,"Warning: a literal structure contains at least one entry twice. This is not allowed.\n"); copy->arguments = copyChainWithoutReversal(tree->arguments, copyEntryOnVoid); } break; case FINALELLIPTICLIST: tempChain = copyChain(tree->arguments, evaluateThingInnerOnVoid); if (timingString != NULL) pushTimeCounter(); curr = tempChain; newChain = NULL; resC = 0; while (curr != NULL) { if ((curr->next != NULL) && (curr->next->next != NULL) && isElliptic((node *) (curr->next->value)) && isPureTree((node *) (curr->value)) && isPureTree((node *) (curr->next->next->value)) && isConstant((node *) (curr->value)) && isConstant((node *) (curr->next->next->value)) && evaluateThingToInteger(&resA,(node *) (curr->value), NULL) && evaluateThingToInteger(&resB,(node *) (curr->next->next->value),NULL) && (resA >= resB)) { mpfr_init2(a,sizeof(int) * 8); resC = 1; for (i=resA;i>=resB;i--) { mpfr_set_si(a,i,GMP_RNDN); newChain = addElement(newChain,makeConstant(a)); } mpfr_clear(a); curr = curr->next->next; } else { newChain = addElement(newChain,copyThing((node *) (curr->value))); } curr = curr->next; } freeChain(tempChain, freeThingOnVoid); copy->arguments = newChain; copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; if (resC && (!isPureFinalEllipticList(copy))) { tempNode = evaluateThing(copy); freeThing(copy); copy = tempNode; } setupRandomAccessOnLists(copy); if (timingString != NULL) popTimeCounter(timingString); break; case ELLIPTIC: break; case RANGE: alreadyDisplayed = 0; if ((accessThruMemRef(tree->child1)->nodeType == DECIMALCONSTANT) || ((accessThruMemRef(tree->child1)->nodeType == NEG) && (accessThruMemRef(accessThruMemRef(tree->child1)->child1)->nodeType == DECIMALCONSTANT))) { if ((accessThruMemRef(tree->child1)->nodeType == NEG) && (accessThruMemRef(accessThruMemRef(tree->child1)->child1)->nodeType == DECIMALCONSTANT)) { negate = 1; decString = accessThruMemRef(accessThruMemRef(tree->child1)->child1)->string; if ((accessThruMemRef(tree->child2)->nodeType == NEG) && (accessThruMemRef(accessThruMemRef(tree->child2)->child1)->nodeType == DECIMALCONSTANT)) { if (!strcmp(decString,accessThruMemRef(accessThruMemRef(tree->child2)->child1)->string)) alreadyDisplayed = 1; } } else { negate = 0; decString = accessThruMemRef(tree->child1)->string; if (accessThruMemRef(tree->child2)->nodeType == DECIMALCONSTANT) { if (!strcmp(decString,accessThruMemRef(tree->child2)->string)) alreadyDisplayed = 1; } } resA = 0; tempString2 = sollya_strchr(decString,'%'); tempString3 = sollya_strrchr(decString,'%'); if ((tempString2 != NULL) && (tempString3 != NULL) && (tempString2 != tempString3) && (*(tempString2 + 1) != '\0') && (tempString3 != decString) && (*(tempString3 + 1) != '\0')) { tempString = (char *) safeCalloc(strlen(tempString3 + 1) + 1, sizeof(char)); strcpy(tempString,tempString3 + 1); tempString4 = (char *) safeCalloc(strlen(tempString2 + 1) + 1, sizeof(char)); tempString5 = tempString4; tempString2++; while ((*tempString2 != '\0') && (tempString2 != tempString3)) { *tempString5 = *tempString2; tempString5++; tempString2++; } resB = atoi(tempString4); safeFree(tempString4); if (resB < 12) { printMessage(1,SOLLYA_MSG_PRECISION_OF_NUMS_MUST_BE_AT_LEAST_TWELVE_BITS,"Warning: the precision of values in the tool must be at least 12 bits.\n"); resB = 12; } pTemp = (mp_prec_t) resB; pTemp2 = pTemp; resA = 1; } if (!resA) { tempString = (char *) safeCalloc(strlen(decString) + 1, sizeof(char)); strcpy(tempString,decString); pTemp = 4 * strlen(tempString) + 3324; if (tools_precision > pTemp) pTemp = tools_precision; pTemp2 = tools_precision; } if (sollya_strchr(tempString,'%') == NULL) { mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); mpfr_set_str(a,tempString,10,GMP_RNDD); mpfr_set_str(b,tempString,10,GMP_RNDU); if (mpfr_cmp(a,b) != 0) { pTemp = pTemp2; } mpfr_clear(a); mpfr_clear(b); mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); mpfr_set_str(a,tempString,10,GMP_RNDD); mpfr_set_str(b,tempString,10,GMP_RNDU); if (mpfr_cmp(a,b) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT, "Warning: Rounding occurred when converting the constant \"%s\" to floating-point with %d bits.\n", tempString,(int) pTemp); printMessage(1,SOLLYA_MSG_CONTINUATION,"The inclusion property is nevertheless satisfied.\n"); } if (negate) { mpfr_set_str(a,tempString,10,GMP_RNDU); } else { mpfr_set_str(a,tempString,10,GMP_RNDD); } } mpfr_init2(c,pTemp); if (!resA) { simplifyMpfrPrec(c, a); if (negate) mpfr_neg(c, c, GMP_RNDN); } else { if (negate) { mpfr_set(c,a,GMP_RNDU); mpfr_neg(c, c, GMP_RNDN); } else { mpfr_set(c,a,GMP_RNDD); } } tempNode = makeConstant(c); mpfr_clear(c); mpfr_clear(b); mpfr_clear(a); copy->child1 = tempNode; } safeFree(tempString); } else { copy->child1 = evaluateThingInner(tree->child1); } if ((accessThruMemRef(tree->child2)->nodeType == DECIMALCONSTANT) || ((accessThruMemRef(tree->child2)->nodeType == NEG) && (accessThruMemRef(accessThruMemRef(tree->child2)->child1)->nodeType == DECIMALCONSTANT))) { if ((accessThruMemRef(tree->child2)->nodeType == NEG) && (accessThruMemRef(accessThruMemRef(tree->child2)->child1)->nodeType == DECIMALCONSTANT)) { negate = 1; decString = accessThruMemRef(accessThruMemRef(tree->child2)->child1)->string; } else { negate = 0; decString = accessThruMemRef(tree->child2)->string; } resA = 0; tempString2 = sollya_strchr(decString,'%'); tempString3 = sollya_strrchr(decString,'%'); if ((tempString2 != NULL) && (tempString3 != NULL) && (tempString2 != tempString3) && (*(tempString2 + 1) != '\0') && (tempString3 != decString) && (*(tempString3 + 1) != '\0')) { tempString = (char *) safeCalloc(strlen(tempString3 + 1) + 1, sizeof(char)); strcpy(tempString,tempString3 + 1); tempString4 = (char *) safeCalloc(strlen(tempString2 + 1) + 1, sizeof(char)); tempString5 = tempString4; tempString2++; while ((*tempString2 != '\0') && (tempString2 != tempString3)) { *tempString5 = *tempString2; tempString5++; tempString2++; } resB = atoi(tempString4); safeFree(tempString4); if ((resB < 12) && (!alreadyDisplayed)) { printMessage(1,SOLLYA_MSG_PRECISION_OF_NUMS_MUST_BE_AT_LEAST_TWELVE_BITS,"Warning: the precision of values in the tool must be at least 12 bits.\n"); resB = 12; } pTemp = (mp_prec_t) resB; pTemp2 = pTemp; resA = 1; } if (!resA) { tempString = (char *) safeCalloc(strlen(decString) + 1, sizeof(char)); strcpy(tempString,decString); pTemp = 4 * strlen(tempString) + 3324; if (tools_precision > pTemp) pTemp = tools_precision; pTemp2 = tools_precision; } if (sollya_strchr(tempString,'%') == NULL) { mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); mpfr_set_str(a,tempString,10,GMP_RNDD); mpfr_set_str(b,tempString,10,GMP_RNDU); if (mpfr_cmp(a,b) != 0) { pTemp = pTemp2; } mpfr_clear(a); mpfr_clear(b); mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); mpfr_set_str(a,tempString,10,GMP_RNDD); mpfr_set_str(b,tempString,10,GMP_RNDU); if (mpfr_cmp(a,b) != 0) { if ((!noRoundingWarnings) && (!alreadyDisplayed)) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT, "Warning: Rounding occurred when converting the constant \"%s\" to floating-point with %d bits.\n", tempString,(int) pTemp); printMessage(1,SOLLYA_MSG_CONTINUATION,"The inclusion property is nevertheless satisfied.\n"); } if (negate) { mpfr_set_str(a,tempString,10,GMP_RNDD); } else { mpfr_set_str(a,tempString,10,GMP_RNDU); } } mpfr_init2(c,pTemp); if (!resA) { simplifyMpfrPrec(c, a); if (negate) mpfr_neg(c, c, GMP_RNDN); } else { if (negate) { mpfr_set(c,a,GMP_RNDD); mpfr_neg(c, c, GMP_RNDN); } else { mpfr_set(c,a,GMP_RNDU); } } tempNode = makeConstant(c); mpfr_clear(c); mpfr_clear(b); mpfr_clear(a); copy->child2 = tempNode; } safeFree(tempString); } else { copy->child2 = evaluateThingInner(tree->child2); } if (isPureTree(copy->child1) && isPureTree(copy->child2)) { if (timingString != NULL) pushTimeCounter(); mpfr_init2(a,tools_precision + 5); resA = evaluateThingToConstant(a,copy->child1,NULL,1,1); if(resA) { mpfr_init2(b,tools_precision + 5); if (isSyntacticallyEqual(copy->child1,copy->child2)) { resB = resA; mpfr_set_prec(b,mpfr_get_prec(a)); mpfr_set(b,a,GMP_RNDN); } else { resB = evaluateThingToConstant(b,copy->child2,NULL,1,1); } if(resB) { if ((resA == 3) || (resB == 3)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),tools_precision); mpfr_init2(*(xrange.b),tools_precision); mpfr_set_d(*(xrange.a),1.0,GMP_RNDN); mpfr_set_d(*(xrange.b),1.0,GMP_RNDN); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); yrange2.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange2.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(yrange2.a),tools_precision); mpfr_init2(*(yrange2.b),tools_precision); evaluateRangeFunction(yrange, copy->child1, xrange, 256 * tools_precision); evaluateRangeFunction(yrange2, copy->child2, xrange, 256 * tools_precision); if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_NOT_LEAST_POSSIBLE_INCLUSION_INTERVAL,"Warning: inclusion property is satisfied but the diameter may be greater than the least possible.\n"); } sollya_mpfr_min(a,*(yrange.a),*(yrange2.a),GMP_RNDD); sollya_mpfr_max(b,*(yrange.b),*(yrange2.b),GMP_RNDU); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); safeFree(xrange.a); safeFree(xrange.b); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(yrange.a); safeFree(yrange.b); mpfr_clear(*(yrange2.a)); mpfr_clear(*(yrange2.b)); safeFree(yrange2.a); safeFree(yrange2.b); } freeThing(copy->child1); freeThing(copy->child2); if (mpfr_cmp(a,b) > 0) { printMessage(1,SOLLYA_MSG_RANGE_BOUNDS_IN_INVERSE_ORDER,"Warning: the bounds of the given range are in wrong order. Will reverse them.\n"); if (resA != 2) { if (tools_precision > mpfr_get_prec(a)) { mpfr_prec_round(a, tools_precision, GMP_RNDU); /* No rounding as precision always higher */ } mpfr_nextabove(a); mpfr_prec_round(a, tools_precision, GMP_RNDU); } if (resB != 2) { if (tools_precision > mpfr_get_prec(b)) { mpfr_prec_round(b, tools_precision, GMP_RNDD); /* No rounding as precision always higher */ } mpfr_nextbelow(b); mpfr_prec_round(b, tools_precision, GMP_RNDD); } copy->child1 = makeConstant(b); copy->child2 = makeConstant(a); if (!(!((!(!(mpfr_nan_p(*(accessThruMemRef(copy->child1)->value))))) ^ (!(!(mpfr_nan_p(*(accessThruMemRef(copy->child2)->value)))))))) { printMessage(1,SOLLYA_MSG_ONLY_ONE_ENDPOINT_OF_RANGE_IS_NAN,"Warning: one bound of a range is NaN while the other is not. Will normalize the range to have two NaN endpoints.\n"); mpfr_set_nan(*(accessThruMemRef(copy->child1)->value)); mpfr_set_nan(*(accessThruMemRef(copy->child2)->value)); } else { if ((resA != 2) || (resB != 2)) { if (resA != 2) { pTemp = mpfr_get_prec(a); if (resB != 2) { if (mpfr_get_prec(b) < pTemp) { pTemp = mpfr_get_prec(b); } } } else { pTemp = mpfr_get_prec(b); } if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_SAFE_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST,"Warning: at least one of the given expressions is not a constant but requires evaluation.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Evaluation is guaranteed to ensure the inclusion property. The approximate result is at least %d bit accurate.\n", pTemp); } } } } else { if (resA != 2) { if (tools_precision > mpfr_get_prec(a)) { mpfr_prec_round(a, tools_precision, GMP_RNDD); /* No rounding as precision always higher */ } mpfr_nextbelow(a); mpfr_prec_round(a, tools_precision, GMP_RNDD); } if (resB != 2) { if (tools_precision > mpfr_get_prec(b)) { mpfr_prec_round(b, tools_precision, GMP_RNDU); /* No rounding as precision always higher */ } mpfr_nextabove(b); mpfr_prec_round(b, tools_precision, GMP_RNDU); } copy->child1 = makeConstant(a); copy->child2 = makeConstant(b); if (!(!((!(!(mpfr_nan_p(*(accessThruMemRef(copy->child1)->value))))) ^ (!(!(mpfr_nan_p(*(accessThruMemRef(copy->child2)->value)))))))) { printMessage(1,SOLLYA_MSG_ONLY_ONE_ENDPOINT_OF_RANGE_IS_NAN,"Warning: one bound of a range is NaN while the other is not. Will normalize the range to have two NaN endpoints.\n"); mpfr_set_nan(*(accessThruMemRef(copy->child1)->value)); mpfr_set_nan(*(accessThruMemRef(copy->child2)->value)); } else { if ((resA != 2) || (resB != 2)) { if (resA != 2) { pTemp = mpfr_get_prec(a); if (resB != 2) { if (mpfr_get_prec(b) < pTemp) { pTemp = mpfr_get_prec(b); } } } else { pTemp = mpfr_get_prec(b); } if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_SAFE_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST,"Warning: at least one of the given expressions is not a constant but requires evaluation.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Evaluation is guaranteed to ensure the inclusion property. The approximate result is at least %d bit accurate.\n", pTemp); } } } } } mpfr_clear(b); } mpfr_clear(a); if (timingString != NULL) popTimeCounter(timingString); } break; case DEBOUNDMAX: copy->child1 = evaluateThingInner(tree->child1); if (isRange(copy->child1)) { if (timingString != NULL) pushTimeCounter(); tempNode = copyThing(accessThruMemRef(copy->child1)->child2); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } else { if (isPureTree(copy->child1) && isConstant(copy->child1)) { tempNode = copyThing(copy->child1); freeThing(copy); copy = tempNode; } } break; case EVALCONST: copy->child1 = evaluateThingInner(tree->child1); if (isPureTree(copy->child1)) { tempNode = simplifyTreeErrorfree(copy->child1); if (isConstant(tempNode)) { mpfr_init2(a,tools_precision); floatingPointEvaluationAlreadyDone = 0; if (isPureTree(copy->child1) && isConstant(copy->child1) && ((accessThruMemRef(tree->child1)->nodeType == TABLEACCESSWITHSUBSTITUTE) || (accessThruMemRef(tree->child1)->nodeType == APPLY)) && (lengthChain(accessThruMemRef(tree->child1)->arguments) == 1)) { if (accessThruMemRef(tree->child1)->nodeType == APPLY) { tempNode2 = copyThing(accessThruMemRef(tree->child1)->child1); tempNode3 = copyThing((node *) ((accessThruMemRef(tree->child1)->arguments)->value)); } else { tempNode2 = makeTableAccess(accessThruMemRef(tree->child1)->string); tempNode3 = copyThing((node *) ((accessThruMemRef(tree->child1)->arguments)->value)); } tempNode4 = evaluateThing(tempNode2); tempNode5 = evaluateThing(tempNode3); if (isPureTree(tempNode4) && isPureTree(tempNode5) && (!isConstant(tempNode4)) && isConstant(tempNode5)) { tempNode6 = simplifyTreeErrorfree(tempNode5); if ((accessThruMemRef(tempNode6)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(tempNode6)->value))) { if (evaluateFaithful(a, tempNode4, *(accessThruMemRef(tempNode6)->value), tools_precision)) { floatingPointEvaluationAlreadyDone = 1; } } freeThing(tempNode6); } freeThing(tempNode2); freeThing(tempNode3); freeThing(tempNode4); freeThing(tempNode5); } if (floatingPointEvaluationAlreadyDone || evaluateThingToConstant(a,tempNode,NULL,1,0)) { tempNode2 = makeConstant(a); freeThing(copy); copy = tempNode2; } else { tempNode2 = copy->child1; safeFree(copy); copy = tempNode2; } mpfr_clear(a); } else { tempNode2 = copy->child1; safeFree(copy); copy = tempNode2; } freeThing(tempNode); } else { tempNode2 = copy->child1; safeFree(copy); copy = tempNode2; } break; case DEBOUNDMIN: copy->child1 = evaluateThingInner(tree->child1); if (isRange(copy->child1)) { if (timingString != NULL) pushTimeCounter(); tempNode = copyThing(accessThruMemRef(copy->child1)->child1); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } else { if (isPureTree(copy->child1) && isConstant(copy->child1)) { tempNode = copyThing(copy->child1); freeThing(copy); copy = tempNode; } } break; case DEBOUNDMID: copy->child1 = evaluateThingInner(tree->child1); if (isRange(copy->child1)) { if (timingString != NULL) pushTimeCounter(); tempNode = makeDiv(makeAdd(copyThing(accessThruMemRef(copy->child1)->child1),copyThing(accessThruMemRef(copy->child1)->child2)),makeConstantDouble(2.0)); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } else { if (isPureTree(copy->child1) && isConstant(copy->child1)) { tempNode = copyThing(copy->child1); freeThing(copy); copy = tempNode; } } break; case DIFF: copy->child1 = evaluateThingInner(tree->child1); if (isPureTree(copy->child1)) { if (timingString != NULL) pushTimeCounter(); tempNode = differentiate(copy->child1); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } break; case DIRTYSIMPLIFY: copy->child1 = evaluateThingInner(tree->child1); if (isPureTree(copy->child1)) { if (isConstant(copy->child1)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); mpfr_set_d(a,1.0,GMP_RNDN); if (timingString != NULL) pushTimeCounter(); if (evaluateFaithful(b, copy->child1, a, tools_precision)) { tempNode = makeConstant(b); freeThing(copy); copy = tempNode; } else { printMessage(2,SOLLYA_MSG_TREE_IS_CONSTANT_BUT_CANNOT_DO_FAITHFUL_EVAL,"Information: the given tree is constant but cannot be evaluated faithfully.\n"); tempNode = simplifyTree(copy->child1); freeThing(copy); copy = tempNode; } if (timingString != NULL) popTimeCounter(timingString); mpfr_clear(a); mpfr_clear(b); } else { if (timingString != NULL) pushTimeCounter(); tempNode = simplifyTree(copy->child1); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } } break; case SIMPLIFYSAFE: copy->child1 = evaluateThing(tree->child1); if (isPureTree(copy->child1)) { if (timingString != NULL) pushTimeCounter(); tempNode = simplifyTreeErrorfree(copy->child1); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } break; case TIME: mpfr_init2(a,tools_precision); if (timingString != NULL) pushTimeCounter(); resA = timeCommand(a,tree->child1); if (timingString != NULL) popTimeCounter(timingString); safeFree(copy); copy = makeConstant(a); mpfr_clear(a); if (resA) { printMessage(1,SOLLYA_MSG_TIMED_COMMAND_HAS_QUIT_THE_TOOL,"Warning: a command executed in a timed environment required quitting the tool. This is not possible. The quit command has been discarded.\n"); } break; case REMEZ: safeFree(copy); copy = evaluateThingInnerRemez(tree, timingString); break; case ANNOTATEFUNCTION: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingOnVoid); curr = copy->arguments; if (isPureTree((node *) (curr->value))) { tempNode = (node *) (curr->value); curr = curr->next; if (isPureTree((node *) (curr->value))) { tempNode2 = (node *) (curr->value); curr = curr->next; mpfr_init2(bb,tools_precision); mpfr_init2(cc,tools_precision); if (isRange((node *) (curr->value)) && evaluateThingToRange(bb,cc,(node *) (curr->value))) { curr = curr->next; mpfr_init2(b,tools_precision); mpfr_init2(c,tools_precision); if (isRange((node *) (curr->value)) && evaluateThingToRange(b,c,(node *) (curr->value))) { curr = curr->next; resA = 0; if (curr != NULL) { if (isDefault((node *) (curr->value))) { resA = 1; tempNode3 = makeConstantInt(0); } else { if (isPureTree((node *) (curr->value)) && isConstant((node *) (curr->value))) { resA = 1; tempNode3 = copyThing((node *) (curr->value)); } else { tempNode3 = NULL; resA = 0; } } } else { resA = 1; tempNode3 = makeConstantInt(0); } if (resA) { sollya_mpfi_init2(tempIA, (mpfr_get_prec(bb) > mpfr_get_prec(cc) ? mpfr_get_prec(bb) : mpfr_get_prec(cc))); sollya_mpfi_interv_fr(tempIA, bb, cc); sollya_mpfi_init2(tempIB, (mpfr_get_prec(b) > mpfr_get_prec(c) ? mpfr_get_prec(b) : mpfr_get_prec(c))); sollya_mpfi_interv_fr(tempIB, b, c); sollya_mpfi_init2(tempIC, tools_precision); evaluateConstantExpressionToSharpInterval(tempIC, tempNode3); if (!(sollya_mpfi_has_nan(tempIC) || sollya_mpfi_has_infinity(tempIC))) { resB = copyFunctionAndChooseAndAddEvaluationHook(&tempNode4, tempNode, tempNode2, tempIA, tempIB, tempIC, tools_precision); if (!resB) { printMessage(1,SOLLYA_MSG_ANNOTATION_COULD_NOT_BE_SET_UP,"Warning: the annotation could not be set up. The function is returned as-is.\n"); tempNode4 = copyThing(tempNode); } freeThing(copy); copy = tempNode4; } sollya_mpfi_clear(tempIC); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIA); freeThing(tempNode3); } } mpfr_clear(c); mpfr_clear(b); } mpfr_clear(cc); mpfr_clear(bb); } } break; case BIND: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); copy->string = (char *) safeCalloc(strlen(tree->string)+1,sizeof(char)); strcpy(copy->string,tree->string); if (isProcedureNotIllim(copy->child1)) { tempNode = performBind(accessThruMemRef(copy->child1),copy->string,accessThruMemRef(copy->child2)); if (tempNode == NULL) { printMessage(1,SOLLYA_MSG_PARAM_OF_PROCEDURE_DOES_NOT_EXIST,"Warning: the given procedure has no argument named \"%s\". The procedure is returned unchanged.\n",copy->string); tempNode = copyThing(copy->child1); } freeThing(copy); copy = tempNode; } break; case MATCH: copy->child1 = evaluateThingInner(tree->child1); copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); if (isCorrectlyTyped(copy->child1)) { resA = 1; for (curr = copy->arguments; curr != NULL; curr=curr->next) { if (!isMatchElement((node *) (curr->value))) { resA = 0; break; } } if (resA) { resB = lengthChain(copy->arguments); thingArray1 = (node **) safeCalloc(resB, sizeof(node *)); thingArray2 = (node **) safeCalloc(resB, sizeof(node *)); thingArray3 = (node **) safeCalloc(resB, sizeof(node *)); resC = 0; for (curr = copy->arguments; curr != NULL; curr=curr->next) { thingArray1[resC] = preevaluateMatcher(accessThruMemRef(((node *) (curr->value)))->child1); thingArray3[resC] = accessThruMemRef(((node *) (curr->value)))->child2; thingArray2[resC] = accessThruMemRef((node *) (accessThruMemRef(((node *) (curr->value)))->arguments->value)); resC++; } resD = 1; for (resC=0;resCchild1,thingArray1,thingArray2,thingArray3,resB)) && (tempNode != NULL)) { tempNode = rewriteThingWithMemRefReuse(tempNode, copy->child1); freeThing(copy); copy = tempNode; } } for (resC=0;resCchild1 = copyThing(tree->child1); copy->child2 = copyThing(tree->child2); copy->arguments = copyChainWithoutReversal(tree->arguments, copyThingOnVoid); break; case FPMINIMAX: safeFree(copy); copy = evaluateThingInnerFpminimax(tree, timingString); break; case HORNER: copy->child1 = evaluateThingInner(tree->child1); if (isPureTree(copy->child1)) { if (timingString != NULL) pushTimeCounter(); tempNode = horner(copy->child1); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } break; case CANONICAL: copy->child1 = evaluateThingInner(tree->child1); if (isPureTree(copy->child1)) { if (timingString != NULL) pushTimeCounter(); tempNode = makeCanonical(copy->child1, tools_precision); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } break; case EXPAND: copy->child1 = evaluateThingInner(tree->child1); if (isPureTree(copy->child1)) { if (timingString != NULL) pushTimeCounter(); tempNode = expand(copy->child1); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } break; case TAYLOR: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; if (isPureTree((node *) (curr->value))) { curr = curr->next; if (isPureTree((node *) (curr->value)) && evaluateThingToInteger(&resA,(node *) (curr->value),NULL)) { curr = curr->next; mpfr_init2(a,tools_precision); if (isPureTree((node *) (curr->value)) && evaluateThingToConstant(a,(node *) (curr->value),NULL,0,0)) { if (timingString != NULL) pushTimeCounter(); tempNode = makeConstant(a); curr = copy->arguments; tempNode2 = taylor((node *) (curr->value), resA, tempNode, tools_precision); freeThing(tempNode); freeThing(copy); copy = tempNode2; if (timingString != NULL) popTimeCounter(timingString); } mpfr_clear(a); } } break; case TAYLORFORM: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; if (isPureTree((node *) (curr->value))) { curr = curr->next; if (isPureTree((node *) (curr->value)) && evaluateThingToInteger(&resA,(node *) (curr->value),NULL)) { curr = curr->next; tmpInterv11 = NULL; intptr = NULL; resB = 1; if (curr != NULL) { if (isRange((node *) (curr->value)) || isPureTree((node *) (curr->value))) { if (isRange((node *) (curr->value))) { mpfr_init2(bb,tools_precision); mpfr_init2(cc,tools_precision); if (evaluateThingToRange(bb,cc,(node *) (curr->value))) { pTemp = mpfr_get_prec(bb); pTemp2 = mpfr_get_prec(cc); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA2,pTemp); sollya_mpfi_interv_fr_safe(tempIA2,bb,cc); tmpInterv11 = &tempIA2; } else { resB = 0; } mpfr_clear(bb); mpfr_clear(cc); } else { if (isPureTree((node *) (curr->value))) { mpfr_init2(bb,tools_precision); if (evaluateThingToConstant(bb,(node *) (curr->value),NULL,0,0)) { sollya_mpfi_init2(tempIA2,tools_precision); sollya_mpfi_interv_fr(tempIA2,bb,bb); tmpInterv11 = &tempIA2; } else { resB = 0; } mpfr_clear(bb); } else { resB = 0; } } curr = curr->next; tmpInterv1 = NULL; intptr = NULL; resB = 1; if (curr != NULL) { if (isRange((node *) (curr->value))) { mpfr_init2(b,tools_precision); mpfr_init2(c,tools_precision); if (evaluateThingToRange(b,c,(node *) (curr->value))) { pTemp = mpfr_get_prec(b); pTemp2 = mpfr_get_prec(c); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr_safe(tempIA,b,c); tmpInterv1 = &tempIA; } else { resB = 0; } mpfr_clear(b); mpfr_clear(c); curr = curr->next; if (curr != NULL) { if (isExternalPlotMode((node *) (curr->value)) || isDefault((node *) (curr->value))) { resC = ABSOLUTE; if (evaluateThingToExternalPlotMode(&resD, (node *) (curr->value), &resC)) { intptr = &resD; } else { resB = 0; } } else { resB = 0; } } } else { if (isExternalPlotMode((node *) (curr->value)) || isDefault((node *) (curr->value))) { resC = ABSOLUTE; if (evaluateThingToExternalPlotMode(&resD, (node *) (curr->value), &resC)) { intptr = &resD; } else { resB = 0; } } else { resB = 0; } } } if (resB) { curr = copy->arguments; if (timingString != NULL) pushTimeCounter(); tempNode2 = NULL; tempChain2 = NULL; tmpInterv2 = NULL; if (intptr != NULL) resC = *intptr; else resC = ABSOLUTE; taylorform(&tempNode2, &tempChain2, &tmpInterv2, (node *) (curr->value), resA, tmpInterv11, tmpInterv1, resC); if (timingString != NULL) popTimeCounter(timingString); if (tempNode2 != NULL) { tempChain3 = NULL; curr2 = tempChain2; while (curr2 != NULL) { pTemp = sollya_mpfi_get_prec(*((sollya_mpfi_t *) (curr2->value))); mpfr_init2(b,pTemp); mpfr_init2(c,pTemp); sollya_mpfi_get_left(b,*((sollya_mpfi_t *) (curr2->value))); sollya_mpfi_get_right(c,*((sollya_mpfi_t *) (curr2->value))); tempChain3 = addElement(tempChain3,makeRange(makeConstant(b), makeConstant(c))); mpfr_clear(b); mpfr_clear(c); curr2 = curr2->next; } tempChain4 = copyChain(tempChain3,copyThingOnVoid); freeChain(tempChain3,freeThingOnVoid); tempChain3 = addElement(addElement(NULL,tempNode2),makeList(tempChain4)); if (tmpInterv2 != NULL) { pTemp = sollya_mpfi_get_prec(*tmpInterv2); mpfr_init2(b,pTemp); mpfr_init2(c,pTemp); sollya_mpfi_get_left(b,*tmpInterv2); sollya_mpfi_get_right(c,*tmpInterv2); tempChain3 = addElement(tempChain3,makeRange(makeConstant(b), makeConstant(c))); mpfr_clear(b); mpfr_clear(c); } tempChain4 = copyChain(tempChain3,copyThingOnVoid); freeChain(tempChain3,freeThingOnVoid); tempNode = makeList(tempChain4); freeThing(copy); copy = tempNode; } if (tempChain2 != NULL) { freeChain(tempChain2, freeMpfiPtr); } if (tmpInterv2 != NULL) { sollya_mpfi_clear(*tmpInterv2); safeFree(tmpInterv2); } } if (tmpInterv1 != NULL) sollya_mpfi_clear(*tmpInterv1); } } if (tmpInterv11 != NULL) sollya_mpfi_clear(*tmpInterv11); } } break; case CHEBYSHEVFORM: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; firstArg = (node *) curr->value; curr = curr->next; secondArg = (node *) curr->value; curr = curr->next; thirdArg = (node *) curr->value; if (isPureTree(firstArg)) { if (isPureTree(secondArg) && evaluateThingToInteger(&resA, secondArg, NULL)) { if (resA >= 0) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); resC = (isRange(thirdArg) && evaluateThingToRange(a,b,thirdArg)); if (resC || (isPureTree(thirdArg) && evaluateThingToConstant(a,thirdArg,NULL,0,0))) { if (!resC) { mpfr_set_prec(b,mpfr_get_prec(a)); mpfr_set(b,a,GMP_RNDN); } if (timingString != NULL) pushTimeCounter(); pTemp = mpfr_get_prec(a); if (mpfr_get_prec(b) > pTemp) pTemp = mpfr_get_prec(b); sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr(tempIA,a,b); sollya_mpfi_init2(tempIA2,tools_precision); if (timingString != NULL) pushTimeCounter(); tempNode = NULL; tempChain2 = NULL; tempChain3 = NULL; chebyshevform(&tempNode, &tempChain2, tempIA2, &tempChain3, firstArg, resA, tempIA, tools_precision); if (timingString != NULL) popTimeCounter(timingString); sollya_mpfi_clear(tempIA); mpfr_clear(a); mpfr_clear(b); if ((tempNode != NULL) && (tempChain2 != NULL) && (tempChain3 != NULL)) { tempChain4 = NULL; curr2 = tempChain3; while (curr2 != NULL) { pTemp = sollya_mpfi_get_prec(*((sollya_mpfi_t *) (curr2->value))); mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); sollya_mpfi_get_left(a,*((sollya_mpfi_t *) (curr2->value))); sollya_mpfi_get_right(b,*((sollya_mpfi_t *) (curr2->value))); tempChain4 = addElement(tempChain4, makeRange(makeConstant(a),makeConstant(b))); mpfr_clear(a); mpfr_clear(b); curr2 = curr2->next; } tempChain5 = copyChain(tempChain4, copyThingOnVoid); tempNode3 = makeList(tempChain5); freeChain(tempChain4, freeThingOnVoid); tempChain4 = NULL; curr2 = tempChain2; while (curr2 != NULL) { pTemp = sollya_mpfi_get_prec(*((sollya_mpfi_t *) (curr2->value))); mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); sollya_mpfi_get_left(a,*((sollya_mpfi_t *) (curr2->value))); sollya_mpfi_get_right(b,*((sollya_mpfi_t *) (curr2->value))); tempChain4 = addElement(tempChain4, makeRange(makeConstant(a),makeConstant(b))); mpfr_clear(a); mpfr_clear(b); curr2 = curr2->next; } tempChain5 = copyChain(tempChain4, copyThingOnVoid); tempNode4 = makeList(tempChain5); freeChain(tempChain4, freeThingOnVoid); pTemp = sollya_mpfi_get_prec(tempIA2); mpfr_init2(a,pTemp); mpfr_init2(b,pTemp); sollya_mpfi_get_left(a,tempIA2); sollya_mpfi_get_right(b,tempIA2); tempNode5 = makeRange(makeConstant(a),makeConstant(b)); mpfr_clear(a); mpfr_clear(b); tempChain4 = addElement(addElement(addElement(addElement(NULL, tempNode3), tempNode5), tempNode4), tempNode); tempNode6 = makeList(tempChain4); freeChain(tempChain2, freeMpfiPtr); freeChain(tempChain3, freeMpfiPtr); freeThing(copy); copy = tempNode6; } else { printMessage(1,SOLLYA_MSG_CHEBYSHEVFORM_ERROR_IN_COMPUTATION,"Warning: an error occurred during computation of a Chebyshev form.\n"); } sollya_mpfi_clear(tempIA2); } } else { printMessage(1,SOLLYA_MSG_CHEBYSHEVFORM_DEGREE_MUST_NOT_BE_NEGATIVE,"Warning: the degree of a Chebyshev must not be negative.\n"); } } } break; case AUTODIFF: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; if (isPureTree((node *) (curr->value))) { curr = curr->next; if (isPureTree((node *) (curr->value)) && evaluateThingToInteger(&resA,(node *) (curr->value),NULL)) { if (resA >= 0) { curr = curr->next; mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); resC = (isRange((node *) (curr->value)) && evaluateThingToRange(a,b,(node *) (curr->value))); if (resC || (isPureTree((node *) (curr->value)) && evaluateThingToConstant(a,(node *) (curr->value),NULL,0,0))) { if (!resC) { mpfr_set_prec(b,mpfr_get_prec(a)); mpfr_set(b,a,GMP_RNDN); } if (timingString != NULL) pushTimeCounter(); pTemp = mpfr_get_prec(a); if (mpfr_get_prec(b) > pTemp) pTemp = mpfr_get_prec(b); sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr_safe(tempIA,a,b); tmpInterv1 = (sollya_mpfi_t *) safeCalloc(resA + 1, sizeof(sollya_mpfi_t)); for (resB=0;resBarguments->value)), tempIA, resA); curr = NULL; for (resB=resA;resB>=0;resB--) { pTemp = sollya_mpfi_get_prec(tmpInterv1[resB]); mpfr_init2(c,pTemp); mpfr_init2(d,pTemp); sollya_mpfi_get_left(c,tmpInterv1[resB]); sollya_mpfi_get_right(d,tmpInterv1[resB]); curr = addElement(curr,makeRange(makeConstant(c), makeConstant(d))); mpfr_clear(c); mpfr_clear(d); } tempNode = makeList(curr); freeThing(copy); copy = tempNode; for (resB=0;resBchild1 = evaluateThingInner(tree->child1); if (isPureTree(copy->child1)) { if (timingString != NULL) pushTimeCounter(); mpz_init(tempMpz); getDegreeMpzVerified(tempMpz, copy->child1); tempNode = makeConstantMpz(tempMpz); mpz_clear(tempMpz); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } break; case NUMERATOR: copy->child1 = evaluateThingInner(tree->child1); if (isPureTree(copy->child1)) { if (timingString != NULL) pushTimeCounter(); if (!getNumeratorDenominator(&tempNode,&tempNode2,copy->child1)) { printMessage(1,SOLLYA_MSG_EXPR_IS_NO_FRACTION,"Warning: the expression given is not a fraction. Will consider it as a fraction with denominator 1.\n"); } else { freeThing(tempNode2); } freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } break; case DENOMINATOR: copy->child1 = evaluateThingInner(tree->child1); if (isPureTree(copy->child1)) { if (timingString != NULL) pushTimeCounter(); if (!getNumeratorDenominator(&tempNode2,&tempNode,copy->child1)) { printMessage(1,SOLLYA_MSG_EXPR_IS_NO_FRACTION,"Warning: the expression given is not a fraction. Will consider it as a fraction with denominator 1.\n"); tempNode = makeConstantDouble(1.0); } freeThing(tempNode2); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } break; case SUBSTITUTE: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && isPureTree(copy->child2)) { if (timingString != NULL) pushTimeCounter(); tempNode = substituteEnhanced(copy->child1,copy->child2,0,autosimplify); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } break; case COMPOSEPOLYNOMIALS: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && isPureTree(copy->child2)) { if (timingString != NULL) pushTimeCounter(); tempChain = NULL; tempNode2 = NULL; composePolynomials(&tempNode2,&tempChain,copy->child1,copy->child2,tools_precision); if (timingString != NULL) popTimeCounter(timingString); if (tempNode2 != NULL) { if (tempChain == NULL) { tempNode3 = makeEmptyList(); } else { tempChain2 = NULL; for (curr=tempChain;curr!=NULL;curr=curr->next) { mpfr_init2(a,sollya_mpfi_get_prec(*((sollya_mpfi_t *) (curr->value)))); mpfr_init2(b,sollya_mpfi_get_prec(*((sollya_mpfi_t *) (curr->value)))); sollya_mpfi_get_left(a,*((sollya_mpfi_t *) (curr->value))); sollya_mpfi_get_right(b,*((sollya_mpfi_t *) (curr->value))); tempChain2 = addElement(tempChain2,makeRange(makeConstant(a),makeConstant(b))); mpfr_clear(a); mpfr_clear(b); } tempNode3 = makeList(tempChain2); } structEntry = (entry *) safeMalloc(sizeof(entry)); tempString = "poly"; structEntry->name = (char *) safeCalloc(strlen(tempString)+1,sizeof(char)); strcpy(structEntry->name,tempString); structEntry->value = tempNode2; assoclist = addElement(NULL,(void *) structEntry); structEntry = (entry *) safeMalloc(sizeof(entry)); tempString = "radii"; structEntry->name = (char *) safeCalloc(strlen(tempString)+1,sizeof(char)); strcpy(structEntry->name,tempString); structEntry->value = tempNode3; assoclist = addElement(assoclist,(void *) structEntry); tempNode = makeStructure(assoclist); freeThing(copy); copy = tempNode; } if (tempChain != NULL) freeChain(tempChain,freeMpfiPtr); } break; case COEFF: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && isPureTree(copy->child2)) { if (evaluateThingToInteger(&resA,copy->child2,NULL)) { if (timingString != NULL) pushTimeCounter(); tempNode = getIthCoefficient(copy->child1, resA); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } } break; case SUBPOLY: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && (isPureList(copy->child2) || isPureFinalEllipticList(copy->child2))) { if (evaluateThingToIntegerList(&tempChain, &resA, copy->child2)) { if (timingString != NULL) pushTimeCounter(); tempNode = getSubpolynomial(copy->child1, tempChain, resA, tools_precision); freeThing(copy); copy = tempNode; freeChain(tempChain,freeIntPtr); if (timingString != NULL) popTimeCounter(timingString); } } break; case ROUNDCOEFFICIENTS: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && (isPureList(copy->child2) || isPureFinalEllipticList(copy->child2))) { if (evaluateThingToExtendedExpansionFormatList(&tempChain, copy->child2)) { if (timingString != NULL) pushTimeCounter(); tempNode = roundPolynomialCoefficients(copy->child1, tempChain, tools_precision); freeThing(copy); copy = tempNode; freeChain(tempChain,freeIntPtr); if (timingString != NULL) popTimeCounter(timingString); } } break; case RATIONALAPPROX: safeFree(copy); copy = evaluateThingInnerRationalapprox(tree, timingString); break; case ACCURATEINFNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; firstArg = (node *) (curr->value); curr = curr->next; secondArg = (node *) (curr->value); curr = curr->next; thirdArg = (node *) (curr->value); curr = curr->next; resA = 1; tempChain = NULL; if (curr != NULL) { if (isPureList((node *) (curr->value))) { tempChain = accessThruMemRef(((node *) (curr->value)))->arguments; curr = tempChain; while (curr != NULL) { if (!isRange((node *) (curr->value))) { resA = 0; break; } curr = curr->next; } } else { resA = 0; } } if (isPureTree(firstArg) && isRange(secondArg) && isPureTree(thirdArg) && resA ) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,secondArg)) { resB = tools_precision >> 1; if (evaluateThingToInteger(&resA,thirdArg,&resB)) { if (resA > 2) { mpfr_init2(c,(mp_prec_t) resA); newChain = NULL; if (tempChain != NULL) { curr = tempChain; while (curr != NULL) { rangeTempPtr = (rangetype *) safeMalloc(sizeof(rangetype)); rangeTempPtr->a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); rangeTempPtr->b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(rangeTempPtr->a),tools_precision); mpfr_init2(*(rangeTempPtr->b),tools_precision); evaluateThingToRange(*(rangeTempPtr->a),*(rangeTempPtr->b),(node *) (curr->value)); newChain = addElement(newChain, rangeTempPtr); curr = curr->next; } } xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),tools_precision); mpfr_init2(*(xrange.b),tools_precision); mpfr_set(*(xrange.a),a,GMP_RNDN); mpfr_set(*(xrange.b),b,GMP_RNDN); if (timingString != NULL) pushTimeCounter(); resB = accurateInfnorm(c, firstArg, xrange, newChain, tools_precision); if (timingString != NULL) popTimeCounter(timingString); if (!resB) { mpfr_set_nan(c); } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); safeFree(xrange.a); safeFree(xrange.b); if (newChain != NULL) freeChain(newChain,freeRangetypePtr); tempNode = makeConstant(c); freeThing(copy); copy = tempNode; mpfr_clear(c); } } } mpfr_clear(a); mpfr_clear(b); } break; case ROUNDTOFORMAT: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; if (isPureTree((node *) (curr->value))) { curr = curr->next; if (isPureTree((node *) (curr->value)) || isDefault((node *) (curr->value)) || isExpansionFormat((node *) (curr->value))) { curr = curr->next; if (isRoundingSymbol((node *) (curr->value)) || isDefault((node *) (curr->value))) { curr = copy->arguments; firstArg = (node *) (curr->value); if (isConstant(firstArg)) { curr = curr->next; resB = tools_precision; if (isPureTree((node *) (curr->value)) || isDefault((node *) (curr->value))) { if (evaluateThingToInteger(&resA,(node *) (curr->value),&resB)) { if (resA >= 2) { curr = curr->next; resD = GMP_RNDN; if (evaluateThingToRoundingSymbol(&resC,(node *) (curr->value),&resD)) { if (timingString != NULL) pushTimeCounter(); mpfr_init2(b,(((mp_prec_t) tools_precision > (mp_prec_t) (resA + 10)) ? (mp_prec_t) tools_precision : (mp_prec_t) (resA + 10))); resG = 0; if (timingString != NULL) pushTimeCounter(); resF = round_constant_expr_to_format_or_expansion_format(&resE, &resG, b, firstArg, 0, 1, resA, (mp_rnd_t) resC); if (timingString != NULL) popTimeCounter(timingString); if (resG) { if (resE == 0) { printMessage(2,SOLLYA_MSG_NO_ROUNDING_HAS_HAPPENED,"Information: no rounding has happened.\n"); } else { if (resE < 0) { printMessage(2,SOLLYA_MSG_ROUND_DOWN_HAS_HAPPENED,"Information: rounding down has happened.\n"); } else { printMessage(2,SOLLYA_MSG_ROUND_UP_HAS_HAPPENED,"Information: rounding up has happened.\n"); } } } if (resF) { tempNode = makeConstant(b); freeThing(copy); copy = tempNode; } mpfr_clear(b); } } else { printMessage(1,SOLLYA_MSG_ROUND_PREC_MUST_BE_AT_LEAST_TWO_BITS, "Warning: the precision specified when rounding to a particular format must be at least 2 bits.\n"); } } } else { if (evaluateThingToExpansionFormat(&resA,(node *) (curr->value))) { curr = curr->next; resD = GMP_RNDN; if (evaluateThingToRoundingSymbol(&resC,(node *) (curr->value),&resD)) { mpfr_init2(b,((tools_precision > 200) ? tools_precision : 200)); resG = 0; if (timingString != NULL) pushTimeCounter(); resF = round_constant_expr_to_format_or_expansion_format(&resE, &resG, b, firstArg, 1, resA, 1, (mp_rnd_t) resC); if (timingString != NULL) popTimeCounter(timingString); if (resG) { if (resE == 0) { printMessage(2,SOLLYA_MSG_NO_ROUNDING_HAS_HAPPENED,"Information: no rounding has happened.\n"); } else { if (resE < 0) { printMessage(2,SOLLYA_MSG_ROUND_DOWN_HAS_HAPPENED,"Information: rounding down has happened.\n"); } else { printMessage(2,SOLLYA_MSG_ROUND_UP_HAS_HAPPENED,"Information: rounding up has happened.\n"); } } } if (resF) { tempNode = makeConstant(b); freeThing(copy); copy = tempNode; } mpfr_clear(b); } } } } } } } break; case EVALUATE: copy->child1 = addMemRef(evaluateThingInner(tree->child1)); copy->child2 = addMemRef(evaluateThingInner(tree->child2)); if (isPureTree(copy->child1)) { if (isPureTree(copy->child2)) { if (isConstant(copy->child2)) { mpfr_init2(a,tools_precision); if (evaluateThingToConstant(a,copy->child2,NULL,0,0)) { mpfr_init2(b,tools_precision); if (timingString != NULL) pushTimeCounter(); if (evaluateFaithful(b, copy->child1, a, tools_precision)) { freeThing(copy); copy = makeConstant(b); } else { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),mpfr_get_prec(a)); mpfr_init2(*(xrange.b),mpfr_get_prec(a)); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_set(*(xrange.a),a,GMP_RNDD); mpfr_set(*(xrange.b),a,GMP_RNDU); evaluateRangeFunction(yrange, copy->child1, xrange, tools_precision * 256); freeThing(copy); if ((mpfr_inf_p(*(yrange.a)) && mpfr_inf_p(*(yrange.b)) && (mpfr_sgn(*(yrange.a)) == mpfr_sgn(*(yrange.b)))) || (mpfr_number_p(*(yrange.a)) && mpfr_number_p(*(yrange.b)) && (mpfr_cmp(*(yrange.a),*(yrange.b)) == 0))) { copy = makeConstant(*(yrange.a)); } else { copy = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } if (timingString != NULL) popTimeCounter(timingString); mpfr_clear(b); } mpfr_clear(a); } else { tempNode = substituteEnhanced(copy->child1,copy->child2,0,autosimplify); freeThing(copy); copy = tempNode; } } else { if (isRange(copy->child2)) { if (timingString != NULL) pushTimeCounter(); resA = 0; pTemp = tools_precision; if (mpfr_cmp(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value))==0) { mpfr_init2(a,tools_precision+1); if (evaluateFaithful(a, copy->child1, *(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value), tools_precision+1)) { mpfr_init2(b,mpfr_get_prec(a)); mpfr_set(b,a,GMP_RNDN); mpfr_nextabove(b); mpfr_nextbelow(a); pTemp2 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value)); pTemp3 = mpfr_get_prec(*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); sollya_mpfi_init2(tempIA, (pTemp2 > pTemp3) ? pTemp2 : pTemp3); sollya_mpfi_interv_fr(tempIA, *(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value), *(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value)); sollya_mpfi_init2(tempIB, tools_precision + 10); pTemp2 = mpfr_get_prec(a); pTemp2 = mpfr_get_prec(b); sollya_mpfi_init2(tempIC, (pTemp2 > pTemp3) ? pTemp2 : pTemp3); sollya_mpfi_interv_fr(tempIC, a, b); evaluateInterval(tempIB, copy->child1, NULL, tempIA); sollya_mpfi_intersect(tempIC, tempIC, tempIB); sollya_mpfi_get_left(a, tempIC); sollya_mpfi_get_right(b, tempIC); sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIB); sollya_mpfi_clear(tempIC); freeThing(copy); mpfr_init2(c,tools_precision); mpfr_init2(d,tools_precision); mpfr_set(c,a,GMP_RNDD); mpfr_set(d,b,GMP_RNDU); copy = makeRange(makeConstant(c),makeConstant(d)); mpfr_clear(c); mpfr_clear(d); resA = 1; mpfr_clear(b); } else { pTemp = 256 * tools_precision; } mpfr_clear(a); } if (!resA) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),pTemp); mpfr_init2(*(xrange.b),pTemp); mpfr_init2(*(yrange.a),pTemp); mpfr_init2(*(yrange.b),pTemp); mpfr_set(*(xrange.a),*(accessThruMemRef(accessThruMemRef(copy->child2)->child1)->value),GMP_RNDD); mpfr_set(*(xrange.b),*(accessThruMemRef(accessThruMemRef(copy->child2)->child2)->value),GMP_RNDU); evaluateRangeFunction(yrange, copy->child1, xrange, pTemp); freeThing(copy); mpfr_init2(c,tools_precision); mpfr_init2(d,tools_precision); mpfr_set(c,*(yrange.a),GMP_RNDD); mpfr_set(d,*(yrange.b),GMP_RNDU); copy = makeRange(makeConstant(c),makeConstant(d)); mpfr_clear(c); mpfr_clear(d); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } if (timingString != NULL) popTimeCounter(timingString); } } } break; case PARSE: copy->child1 = evaluateThingInner(tree->child1); if (isString(copy->child1)) { if (timingString != NULL) pushTimeCounter(); if ((tempNode = parseStringInternal(accessThruMemRef(copy->child1)->string)) != NULL) { freeThing(copy); copy = tempNode; } else { printMessage(1,SOLLYA_MSG_STRING_CANNOT_BE_PARSED_BY_MINIPARSER,"Warning: the string \"%s\" could not be parsed by the miniparser.\n",accessThruMemRef(copy->child1)->string); considerDyingOnError(); } if (timingString != NULL) popTimeCounter(timingString); } break; case READXML: copy->child1 = evaluateThingInner(tree->child1); if (isString(copy->child1)) { if (timingString != NULL) pushTimeCounter(); if ((tempNode = readXml(accessThruMemRef(copy->child1)->string)) != NULL) { freeThing(copy); copy = tempNode; } else { printMessage(1,SOLLYA_MSG_XML_FILE_CANNOT_BE_READ,"Warning: the file \"%s\" could not be read as an XML file.\n",accessThruMemRef(copy->child1)->string); considerDyingOnError(); } if (timingString != NULL) popTimeCounter(timingString); } break; case INFNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; firstArg = (node *) (curr->value); curr = curr->next; secondArg = (node *) (curr->value); curr = curr->next; fourthArg = NULL; if (curr != NULL) { if (isString((node *) (curr->value))) { fourthArg = (node *) (curr->value); curr = curr->next; } } resA = 1; tempChain = NULL; if (curr != NULL) { if (isPureList((node *) (curr->value))) { tempChain = accessThruMemRef(((node *) (curr->value)))->arguments; curr = tempChain; while (curr != NULL) { if (!isRange((node *) (curr->value))) { resA = 0; break; } curr = curr->next; } } else { resA = 0; } } if (isPureTree(firstArg) && isRange(secondArg) && resA ) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,secondArg)) { resB = 0; fd = NULL; if (fourthArg == NULL) resB = 1; else { if (evaluateThingToString(&tempString,fourthArg)) { resB = 1; if ((fd = fopen(tempString,"w")) == NULL) { printMessage(1,SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING_IGNORING,"Warning: the file \"%s\" could not be opened for writing. The proof argument will be ignored.\n",tempString); considerDyingOnError(); } safeFree(tempString); } } if (resB) { newChain = NULL; if (tempChain != NULL) { curr = tempChain; while (curr != NULL) { rangeTempPtr = (rangetype *) safeMalloc(sizeof(rangetype)); rangeTempPtr->a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); rangeTempPtr->b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(rangeTempPtr->a),tools_precision); mpfr_init2(*(rangeTempPtr->b),tools_precision); evaluateThingToRange(*(rangeTempPtr->a),*(rangeTempPtr->b),(node *) (curr->value)); newChain = addElement(newChain, rangeTempPtr); curr = curr->next; } } xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),tools_precision); mpfr_init2(*(xrange.b),tools_precision); mpfr_set(*(xrange.a),a,GMP_RNDN); mpfr_set(*(xrange.b),b,GMP_RNDN); if (timingString != NULL) pushTimeCounter(); yrange = infnorm(firstArg, xrange, newChain, tools_precision, statediam, fd); if (timingString != NULL) popTimeCounter(timingString); if (fd != NULL) fclose(fd); tempNode = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(yrange.a); safeFree(yrange.b); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); safeFree(xrange.a); safeFree(xrange.b); if (newChain != NULL) freeChain(newChain,freeRangetypePtr); freeThing(copy); copy = tempNode; } } mpfr_clear(a); mpfr_clear(b); } break; case SUPNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); /* supnorm(poly,func,range,mode,accuracy) The parser ensures that we have exactly five arguments */ curr = copy->arguments; firstArg = (node *) (curr->value); curr = curr->next; secondArg = (node *) (curr->value); curr = curr->next; thirdArg = (node *) (curr->value); curr = curr->next; fourthArg = (node *) (curr->value); curr = curr->next; fifthArg = (node *) (curr->value); if (isPureTree(firstArg) && isPureTree(secondArg) && isPureTree(fifthArg) && isRange(thirdArg) && isExternalPlotMode(fourthArg)) { if (isConstant(fifthArg)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,thirdArg)) { mpfr_init2(c,tools_precision); if (evaluateThingToConstant(c,fifthArg,NULL,0,0)) { if (evaluateThingToExternalPlotMode(&resA, fourthArg, NULL)) { pTemp = mpfr_get_prec(a); pTemp2 = mpfr_get_prec(b); if (pTemp2 > pTemp) pTemp = pTemp2; sollya_mpfi_init2(tempIA,pTemp); sollya_mpfi_interv_fr_safe(tempIA,a,b); mpfr_init2(bb,8 * sizeof(mp_prec_t) + 10); mpfr_abs(bb,c,GMP_RNDN); mpfr_log2(bb,bb,GMP_RNDN); mpfr_floor(bb,bb); mpfr_neg(bb,bb,GMP_RNDN); tempUI = mpfr_get_ui(bb,GMP_RNDN); tempUI += 10; mpfr_clear(bb); if (((mp_prec_t) tempUI < tools_precision) || ((mp_prec_t) tempUI > (mp_prec_t) 2048 * tools_precision)) pTemp = (mp_prec_t) tools_precision + 10; else pTemp = (mp_prec_t) tempUI; sollya_mpfi_init2(tempIB,pTemp); resB = supremumnorm(tempIB, firstArg, secondArg, tempIA, resA, c); if (resB) { pTemp = sollya_mpfi_get_prec(tempIB); mpfr_init2(d,pTemp); mpfr_init2(e,pTemp); sollya_mpfi_get_left(d,tempIB); sollya_mpfi_get_right(e,tempIB); tempNode = makeRange(makeConstant(d),makeConstant(e)); freeThing(copy); copy = tempNode; mpfr_clear(d); mpfr_clear(e); } else { printMessage(1,SOLLYA_MSG_SUPNORM_DID_NOT_WORK_OUT_WELL,"Warning: the supremum norm on the error function between the given polynomial and the given function could not be computed.\n"); considerDyingOnError(); tempNode = makeError(); freeThing(copy); copy = tempNode; } sollya_mpfi_clear(tempIA); sollya_mpfi_clear(tempIB); } } mpfr_clear(c); } mpfr_clear(a); mpfr_clear(b); } } break; case FINDZEROS: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && isRange(copy->child2)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,copy->child2)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),tools_precision); mpfr_init2(*(xrange.b),tools_precision); mpfr_set(*(xrange.a),a,GMP_RNDN); mpfr_set(*(xrange.b),b,GMP_RNDN); if (timingString != NULL) pushTimeCounter(); tempChain = findZerosFunction(copy->child1, xrange, tools_precision, statediam); if (timingString != NULL) popTimeCounter(timingString); if (tempChain == NULL) { tempNode = makeEmptyList(); } else { newChain = NULL; curr = tempChain; while (curr != NULL) { newChain = addElement(newChain,makeRange(makeConstant(*(((rangetype *) (curr->value))->a)),makeConstant(*(((rangetype *) (curr->value))->b)))); curr = curr->next; } curr = copyChain(newChain,copyThingOnVoid); freeChain(newChain,freeThingOnVoid); newChain = curr; tempNode = makeList(newChain); } freeChain(tempChain,freeRangetypePtr); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); safeFree(xrange.a); safeFree(xrange.b); freeThing(copy); copy = tempNode; } mpfr_clear(a); mpfr_clear(b); } break; case FPFINDZEROS: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && isRange(copy->child2)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,copy->child2)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),tools_precision); mpfr_init2(*(xrange.b),tools_precision); mpfr_set(*(xrange.a),a,GMP_RNDN); mpfr_set(*(xrange.b),b,GMP_RNDN); if (timingString != NULL) pushTimeCounter(); tempChain = fpFindZerosFunction(copy->child1, xrange, tools_precision); if (timingString != NULL) popTimeCounter(timingString); if (tempChain == NULL) { tempNode = makeEmptyList(); } else { newChain = NULL; curr = tempChain; while (curr != NULL) { newChain = addElement(newChain,makeConstant(*((mpfr_t *) (curr->value)))); curr = curr->next; } curr = copyChain(newChain,copyThingOnVoid); freeChain(newChain,freeThingOnVoid); newChain = curr; tempNode = makeList(newChain); } freeChain(tempChain,freeMpfrPtr); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); safeFree(xrange.a); safeFree(xrange.b); freeThing(copy); copy = tempNode; } mpfr_clear(a); mpfr_clear(b); } break; case NUMBERROOTS: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && isRange(copy->child2)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,copy->child2)) { mpfr_init2(c,tools_precision); sollya_mpfi_init2(tempIA,tools_precision); sollya_mpfi_interv_fr_safe(tempIA,a,b); if (timingString != NULL) pushTimeCounter(); resA = getNrRoots(c, copy->child1, tempIA, tools_precision, 0); if (timingString != NULL) popTimeCounter(timingString); sollya_mpfi_clear(tempIA); if (resA) { tempNode = makeConstant(c); freeThing(copy); copy = tempNode; } mpfr_clear(c); } mpfr_clear(a); mpfr_clear(b); } break; case DIRTYINFNORM: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && isRange(copy->child2)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,copy->child2)) { mpfr_init2(c,tools_precision); if (timingString != NULL) pushTimeCounter(); uncertifiedInfnorm(c, NULL, copy->child1, a, b, defaultpoints, tools_precision); if (timingString != NULL) popTimeCounter(timingString); tempNode = makeConstant(c); mpfr_clear(c); freeThing(copy); copy = tempNode; } mpfr_clear(a); mpfr_clear(b); } break; case INTEGRAL: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && isRange(copy->child2)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,copy->child2)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),tools_precision); mpfr_init2(*(xrange.b),tools_precision); mpfr_set(*(xrange.a),a,GMP_RNDN); mpfr_set(*(xrange.b),b,GMP_RNDN); if (timingString != NULL) pushTimeCounter(); yrange = integral(copy->child1, xrange, tools_precision, statediam); if (timingString != NULL) popTimeCounter(timingString); tempNode = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(yrange.a); safeFree(yrange.b); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); safeFree(xrange.a); safeFree(xrange.b); freeThing(copy); copy = tempNode; } mpfr_clear(a); mpfr_clear(b); } break; case DIRTYINTEGRAL: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && isRange(copy->child2)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,copy->child2)) { mpfr_init2(c,tools_precision); if (timingString != NULL) pushTimeCounter(); uncertifiedIntegral(c, copy->child1, a, b, defaultpoints, tools_precision); if (timingString != NULL) popTimeCounter(timingString); tempNode = makeConstant(c); mpfr_clear(c); freeThing(copy); copy = tempNode; } mpfr_clear(a); mpfr_clear(b); } break; case IMPLEMENTPOLY: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; firstArg = (node *) (curr->value); curr = curr->next; secondArg = (node *) (curr->value); curr = curr->next; thirdArg = (node *) (curr->value); curr = curr->next; fourthArg = (node *) (curr->value); curr = curr->next; fifthArg = (node *) (curr->value); curr = curr->next; sixthArg = (node *) (curr->value); curr = curr->next; resA = 1; resB = 0; tempString = NULL; if (curr != NULL) { seventhArg = (node *) (curr->value); if (!(isHonorcoeffprec(seventhArg) || isString(seventhArg))) { resA = 0; } if (resA) { if (isHonorcoeffprec(seventhArg)) { resB = 1; } else { if (!evaluateThingToString(&tempString,seventhArg)) { resA = 0; } } } curr = curr->next; if (curr != NULL) { eighthArg = (node *) (curr->value); if (!(isHonorcoeffprec(eighthArg) || isString(eighthArg))) { resA = 0; } if (resA) { if (isHonorcoeffprec(eighthArg)) { resB = 1; } else { if (tempString != NULL) { resA = 0; } else { if (!evaluateThingToString(&tempString,eighthArg)) { resA = 0; } } } } } } fd = NULL; if (tempString != NULL) { if ((fd = fopen(tempString,"w")) == NULL) { printMessage(1,SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING_IGNORING,"Warning: the file \"%s\" could not be opened for writing. The proof argument will be ignored.\n",tempString); considerDyingOnError(); } safeFree(tempString); } if (isPureTree(firstArg) && isRange(secondArg) && isPureTree(thirdArg) && isRestrictedExpansionFormat(fourthArg) && isString(fifthArg) && isString(sixthArg) && resA) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); mpfr_init2(c,tools_precision); if (evaluateThingToRange(a,b,secondArg) && evaluateThingToConstant(c,thirdArg,NULL,0,0) && evaluateThingToRestrictedExpansionFormat(&resC,fourthArg) && evaluateThingToString(&tempString2, fifthArg) && evaluateThingToString(&tempString3, sixthArg)) { if ((fd2 = fopen(tempString3,"w")) != NULL) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),tools_precision); mpfr_init2(*(xrange.b),tools_precision); mpfr_set(*(xrange.a),a,GMP_RNDN); mpfr_set(*(xrange.b),b,GMP_RNDN); if (timingString != NULL) pushTimeCounter(); tempNode = implementpoly(firstArg, xrange, &c, resC, fd2, tempString2, resB, tools_precision, fd); if (timingString != NULL) popTimeCounter(timingString); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); safeFree(xrange.a); safeFree(xrange.b); if (tempNode == NULL) { printMessage(1,SOLLYA_MSG_IMPLEMENTATION_HAS_NOT_SUCCEEDED,"Warning: the implementation has not succeeded. The command could not be executed.\n"); considerDyingOnError(); tempNode = makeError(); } fclose(fd2); } else { printMessage(1,SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING,"Warning: the file \"%s\" could not be opened for writing. The command cannot be executed.\n",tempString3); considerDyingOnError(); tempNode = makeError(); } safeFree(tempString2); safeFree(tempString3); freeThing(copy); copy = tempNode; } mpfr_clear(a); mpfr_clear(b); mpfr_clear(c); } if (fd != NULL) fclose(fd); break; case CHECKINFNORM: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; firstArg = (node *) (curr->value); curr = curr->next; secondArg = (node *) (curr->value); curr = curr->next; thirdArg = (node *) (curr->value); if (isPureTree(firstArg) && isRange(secondArg) && isPureTree(thirdArg)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,secondArg)) { mpfr_init2(c,tools_precision); if (evaluateThingToConstant(c,thirdArg,NULL,0,0)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),tools_precision); mpfr_init2(*(xrange.b),tools_precision); mpfr_set(*(xrange.a),a,GMP_RNDN); mpfr_set(*(xrange.b),b,GMP_RNDN); if (timingString != NULL) pushTimeCounter(); resA = checkInfnorm(firstArg, xrange, c, statediam, tools_precision); if (timingString != NULL) popTimeCounter(timingString); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); safeFree(xrange.a); safeFree(xrange.b); freeThing(copy); if (resA) copy = makeTrue(); else copy = makeFalse(); } mpfr_clear(c); } mpfr_clear(a); mpfr_clear(b); } break; case ZERODENOMINATORS: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && isRange(copy->child2)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,copy->child2)) { if (timingString != NULL) pushTimeCounter(); tempChain = uncertifiedZeroDenominators(copy->child1, a, b, tools_precision); if (timingString != NULL) popTimeCounter(timingString); if (tempChain == NULL) { tempNode = makeEmptyList(); } else { newChain = NULL; curr = tempChain; while (curr != NULL) { newChain = addElement(newChain,makeConstant(*((mpfr_t *) (curr->value)))); curr = curr->next; } curr = copyChain(newChain,copyThingOnVoid); freeChain(newChain,freeThingOnVoid); newChain = curr; tempNode = makeList(newChain); } freeChain(tempChain,freeMpfrPtr); freeThing(copy); copy = tempNode; } mpfr_clear(a); mpfr_clear(b); } break; case ISEVALUABLE: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && isPureTree(copy->child2)) { mpfr_init2(a,tools_precision); if (evaluateThingToConstant(a,copy->child2,NULL,0,0)) { if (timingString != NULL) pushTimeCounter(); mpfr_init2(b,tools_precision); if (isEvaluable(copy->child1, a, &b, tools_precision) != ISNOTEVALUABLE) { tempNode = makeTrue(); } else { tempNode = makeFalse(); } mpfr_clear(b); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } mpfr_clear(a); } break; case SEARCHGAL: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); if (lengthChain(copy->arguments) >= 6) { curr = copy->arguments; firstArg = copyThing((node *) (curr->value)); curr = curr->next; if (isPureTree(firstArg)) { firstArg = makeList(addElement(NULL,firstArg)); } secondArg = copyThing((node *) (curr->value)); curr = curr->next; thirdArg = copyThing((node *) (curr->value)); curr = curr->next; fourthArg = copyThing((node *) (curr->value)); curr = curr->next; fifthArg = copyThing((node *) (curr->value)); curr = curr->next; if (isExpansionFormat(fifthArg)) { fifthArg = makeList(addElement(NULL,fifthArg)); } sixthArg = copyThing((node *) (curr->value)); if (isPureTree(sixthArg)) { sixthArg = makeList(addElement(NULL,sixthArg)); } if (isPureList(firstArg) && isPureTree(secondArg) && isPureTree(thirdArg) && isPureTree(fourthArg) && isPureList(fifthArg) && isPureList(sixthArg) && (lengthChain(accessThruMemRef(firstArg)->arguments) == lengthChain(accessThruMemRef(fifthArg)->arguments)) && (lengthChain(accessThruMemRef(fifthArg)->arguments) == lengthChain(accessThruMemRef(sixthArg)->arguments))) { if (evaluateThingToPureListOfPureTrees(&tempChain, firstArg)) { mpfr_init2(a,tools_precision); if (evaluateThingToConstant(a,secondArg,NULL,0,0) && evaluateThingToInteger(&resA,thirdArg,NULL) && evaluateThingToInteger(&resB,fourthArg,NULL)) { if (evaluateThingToExpansionFormatList(&tempChain2, fifthArg)) { if (evaluateThingToConstantList(&tempChain3, sixthArg)) { mpfr_init2(c,tools_precision); if (timingString != NULL) pushTimeCounter(); resC = searchGalValue(tempChain, c, a, (mp_prec_t) resA, resB, tempChain2, tempChain3, tools_precision); if (timingString != NULL) popTimeCounter(timingString); if (resC) { tempNode = makeList(addElement(NULL,makeConstant(c))); } else { tempNode = makeEmptyList(); } freeThing(copy); copy = tempNode; mpfr_clear(c); freeChain(tempChain3, freeMpfrPtr); } freeChain(tempChain2, freeIntPtr); } } mpfr_clear(a); freeChain(tempChain,freeThingOnVoid); } } freeThing(firstArg); freeThing(secondArg); freeThing(thirdArg); freeThing(fourthArg); freeThing(fifthArg); freeThing(sixthArg); } break; case GUESSDEGREE: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; firstArg = copyThing((node *) (curr->value)); curr = curr->next; secondArg = copyThing((node *) (curr->value)); curr = curr->next; thirdArg = copyThing((node *) (curr->value)); curr = curr->next; fourthArg = NULL; if (curr != NULL) { fourthArg = copyThing((node *) (curr->value)); curr = curr->next; } if ( (fourthArg==NULL)||(isDefault(fourthArg)) ) { if (fourthArg!=NULL) freeThing(fourthArg); fourthArg = makeConstantDouble(1.0); } fifthArg = NULL; if (curr != NULL) fifthArg = copyThing((node *) (curr->value)); if ( (fifthArg==NULL)||(isDefault(fifthArg)) ) { if (fifthArg!=NULL) freeThing(fifthArg); fifthArg = makeConstantDouble(128.0); } if (isPureTree(firstArg) && isRange(secondArg) && isPureTree(thirdArg) && isPureTree(fourthArg) && isPureTree(fifthArg)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); mpfr_init2(c,tools_precision); if (evaluateThingToRange(a,b,secondArg) && evaluateThingToConstant(c,thirdArg, NULL,0,0) && evaluateThingToInteger(&resA,fifthArg,NULL)) { if (resA < 0) { printMessage(1, SOLLYA_MSG_GUESSDEGREE_FIFTH_ARGUMENT_MUST_BE_NUMBER, "Error: guessdegree: the optional fifth argument must be a positive number.\n"); } else { if (timingString != NULL) pushTimeCounter(); yrange = guessDegreeWrapper(firstArg, fourthArg, a, b, c, resA+1); if (timingString != NULL) popTimeCounter(timingString); if ((yrange.a != NULL) && (yrange.b != NULL)) { tempNode = makeRange(makeConstant(*(yrange.a)),makeConstant(*(yrange.b))); freeThing(copy); copy = tempNode; mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(yrange.a); safeFree(yrange.b); } } } mpfr_clear(a); mpfr_clear(b); mpfr_clear(c); } freeThing(firstArg); freeThing(secondArg); freeThing(thirdArg); freeThing(fourthArg); freeThing(fifthArg); break; case DIRTYFINDZEROS: copy->child1 = evaluateThingInner(tree->child1); copy->child2 = evaluateThingInner(tree->child2); if (isPureTree(copy->child1) && isRange(copy->child2)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,copy->child2)) { if (mpfr_number_p(a) && mpfr_number_p(b)) { if (timingString != NULL) pushTimeCounter(); tempChain = uncertifiedFindZeros(copy->child1, a, b, defaultpoints, tools_precision); if (timingString != NULL) popTimeCounter(timingString); } else { tempChain = NULL; printMessage(1,SOLLYA_MSG_DOMAIN_IS_NO_CLOSED_INTERVAL_ON_THE_REALS,"Warning: the range to search for zeros in is not bounded by real numbers.\n"); } if (tempChain == NULL) { tempNode = makeEmptyList(); } else { newChain = NULL; curr = tempChain; while (curr != NULL) { newChain = addElement(newChain,makeConstant(*((mpfr_t *) (curr->value)))); curr = curr->next; } curr = copyChain(newChain,copyThingOnVoid); freeChain(newChain,freeThingOnVoid); newChain = curr; tempNode = makeList(newChain); } freeChain(tempChain,freeMpfrPtr); freeThing(copy); copy = tempNode; } mpfr_clear(a); mpfr_clear(b); } break; case HEAD: copy->child1 = evaluateThingInner(tree->child1); if (isList(copy->child1)) { if (!isElliptic((node *) (accessThruMemRef(copy->child1)->arguments->value))) { if (timingString != NULL) pushTimeCounter(); tempNode = copyThing((node *) (accessThruMemRef(copy->child1)->arguments->value)); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } } else { if (isFinalEllipticList(copy->child1)) { if (!isElliptic((node *) (accessThruMemRef(copy->child1)->arguments->value))) { if (timingString != NULL) pushTimeCounter(); tempNode = copyThing((node *) (accessThruMemRef(copy->child1)->arguments->value)); freeThing(copy); copy = tempNode; if (timingString != NULL) popTimeCounter(timingString); } } } break; case ROUNDCORRECTLY: copy->child1 = evaluateThingInner(tree->child1); if (isRange(copy->child1)) { mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); if (evaluateThingToRange(a,b,copy->child1)) { mpfr_init2(c,tools_precision); if (timingString != NULL) pushTimeCounter(); if (!roundRangeCorrectly(c, a, b)) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUND_TO_NEAREST_IMPOSSIBLE_WITH_BOUNDING,"Warning: correct rounding to nearest impossible with the given bounding.\n"); } } if (timingString != NULL) popTimeCounter(timingString); tempNode = makeConstant(c); freeThing(copy); copy = tempNode; mpfr_clear(c); } mpfr_clear(a); mpfr_clear(b); } break; case READFILE: copy->child1 = evaluateThingInner(tree->child1); if (isString(copy->child1)) { fd = fopen(accessThruMemRef(copy->child1)->string,"r"); if (fd != NULL) { if (timingString != NULL) pushTimeCounter(); tempString = readFileIntoString(fd); if (timingString != NULL) popTimeCounter(timingString); if (tempString != NULL) { tempNode = makeString(tempString); safeFree(tempString); freeThing(copy); copy = tempNode; } fclose(fd); } else { printMessage(1,SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_READING,"Warning: the file \"%s\" could not be opened for reading.\n",accessThruMemRef(copy->child1)->string); considerDyingOnError(); } } break; case BASHEVALUATE: copy->arguments = copyChainWithoutReversal(tree->arguments, evaluateThingInnerOnVoid); curr = copy->arguments; if (isString((node *) (curr->value))) { tempString2 = NULL; resA = 1; if (curr->next != NULL) { if (isString((node *) (curr->next->value))) { tempString2 = accessThruMemRef(((node *) (curr->next->value)))->string; } else { resA = 0; } } if (resA) { if (timingString != NULL) pushTimeCounter(); tempString = NULL; tempString = evaluateStringAsBashCommand(accessThruMemRef(((node *) (curr->value)))->string, tempString2); if (timingString != NULL) popTimeCounter(timingString); if (tempString != NULL) { tempNode = makeString(tempString); safeFree(tempString); freeThing(copy); copy = tempNode; } } } break; case GETSUPPRESSEDMESSAGES: if (timingString != NULL) pushTimeCounter(); if ((suppressedMessages == NULL) || ((resA = getMaxIndexOfSetBit(suppressedMessages)) < 0)) { tempNode = makeEmptyList(); } else { tempChain = NULL; mpfr_init2(a, 5 + 8 * sizeof(int)); for (i=resA;i>=0;i--) { if (getBitInBitfield(suppressedMessages, (unsigned int) i)) { mpfr_set_si(a, i, GMP_RNDN); /* exact */ tempChain = addElement(tempChain, makeConstant(a)); } } mpfr_clear(a); if (tempChain == NULL) { tempNode = makeEmptyList(); } else { tempNode = makeList(tempChain); } } if (timingString != NULL) popTimeCounter(timingString); freeThing(copy); copy = tempNode; break; case GETBACKTRACE: if (timingString != NULL) pushTimeCounter(); tempNode = getBacktrace(); if (tempNode != NULL) { freeThing(copy); copy = addMemRef(tempNode); } if (timingString != NULL) popTimeCounter(timingString); break; case REVERT: copy->child1 = evaluateThingInner(tree->child1); if (isList(copy->child1)) { if (timingString != NULL) pushTimeCounter(); setupRandomAccessOnLists(tree->child1); tempNode = makeList(copyChain(accessThruMemRef(copy->child1)->arguments,copyThingOnVoid)); freeThing(copy); copy = tempNode; setupRandomAccessOnLists(copy); if (timingString != NULL) popTimeCounter(timingString); } else { if (isEmptyList(copy->child1)) { tempNode = makeEmptyList(); freeThing(copy); copy = tempNode; } } break; case SORT: copy->child1 = evaluateThingInner(tree->child1); if (isPureList(copy->child1)) { if (evaluateThingToConstantList(&tempChain, copy->child1)) { if (timingString != NULL) pushTimeCounter(); sortChain(tempChain, cmpMpfrPtr); newChain = NULL; curr = tempChain; while (curr != NULL) { newChain = addElement(newChain,makeConstant(*((mpfr_t *) (curr->value)))); curr = curr->next; } tempNode = makeList(newChain); freeThing(copy); copy = tempNode; freeChain(tempChain,freeMpfrPtr); if (timingString != NULL) popTimeCounter(timingString); } } else { if (isEmptyList(copy->child1)) { tempNode = copyThing(copy->child1); freeThing(copy); copy = tempNode; } } break; case MANTISSA: copy->child1 = evaluateThingInner(tree->child1); if (isPureTree(copy->child1)) { mpfr_init2(a,tools_precision); if (evaluateThingToConstant(a,copy->child1,NULL,0,0)) { mpfr_init2(b,mpfr_get_prec(a)); if (timingString != NULL) pushTimeCounter(); if (mpfr_mant_exp(b, &expo, a) == 0) { tempNode = makeConstant(b); freeThing(copy); copy = tempNode; } if (timingString != NULL) popTimeCounter(timingString); mpfr_clear(b); } mpfr_clear(a); } break; case EXPONENT: copy->child1 = evaluateThingInner(tree->child1); if (isPureTree(copy->child1)) { mpfr_init2(a,tools_precision); if (evaluateThingToConstant(a,copy->child1,NULL,0,0)) { mpfr_init2(b,mpfr_get_prec(a)); if (timingString != NULL) pushTimeCounter(); if (mpfr_mant_exp(b, &expo, a) == 0) { mpfr_init2(c,sizeof(expo) * 8 + 5); mpfr_set_si(c,expo,GMP_RNDN); tempNode = makeConstant(c); mpfr_clear(c); freeThing(copy); copy = tempNode; } if (timingString != NULL) popTimeCounter(timingString); mpfr_clear(b); } mpfr_clear(a); } break; case PRECISION: copy->child1 = evaluateThingInner(tree->child1); if (isPureTree(copy->child1)) { mpfr_init2(a,tools_precision); if (evaluateThingToConstant(a,copy->child1,NULL,0,0)) { mpfr_init2(b,mpfr_get_prec(a)); if (timingString != NULL) pushTimeCounter(); if (mpfr_mant_exp(b, &expo, a) == 0) { if (mpfr_zero_p(b)) { tempNode = makeConstantDouble(0.0); } else { pTemp = sizeof(mp_prec_t) * 8 + 5; if (tools_precision > pTemp) pTemp = tools_precision; mpfr_init2(c,pTemp); mpfr_abs(b,b,GMP_RNDN); mpfr_log2(c,b,GMP_RNDU); mpfr_ceil(c,c); if (mpfr_zero_p(c)) { mpfr_set_d(c,1.0,GMP_RNDN); } tempNode = makeConstant(c); mpfr_clear(c); } freeThing(copy); copy = tempNode; } if (timingString != NULL) popTimeCounter(timingString); mpfr_clear(b); } mpfr_clear(a); } break; case TAIL: copy->child1 = evaluateThingInner(tree->child1); if (isList(copy->child1)) { if (accessThruMemRef(copy->child1)->arguments->next == NULL) { if (timingString != NULL) pushTimeCounter(); freeThing(copy->child1); copy->nodeType = EMPTYLIST; if (timingString != NULL) popTimeCounter(timingString); } else { if (!isElliptic((node *) (accessThruMemRef(copy->child1)->arguments->next->value))) { if (timingString != NULL) pushTimeCounter(); copy->arguments = copyChainWithoutReversal(accessThruMemRef(copy->child1)->arguments->next,copyThingOnVoid); freeThing(copy->child1); copy->nodeType = LIST; copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; setupRandomAccessOnLists(copy); if (timingString != NULL) popTimeCounter(timingString); } } } else { if (isFinalEllipticList(copy->child1)) { if (accessThruMemRef(copy->child1)->arguments->next != NULL) { if (!isElliptic((node *) (accessThruMemRef(copy->child1)->arguments->next->value))) { if (timingString != NULL) pushTimeCounter(); copy->arguments = copyChainWithoutReversal(accessThruMemRef(copy->child1)->arguments->next,copyThingOnVoid); freeThing(copy->child1); copy->nodeType = FINALELLIPTICLIST; copy->argArray = NULL; copy->argArraySize = 0; copy->argArrayAllocSize = 0; setupRandomAccessOnLists(copy); if (timingString != NULL) popTimeCounter(timingString); } } else { if (isPureTree((node *) (accessThruMemRef(copy->child1)->arguments->value))) { mpfr_init2(a,tools_precision); if (evaluateThingToConstant(a,(node *) (accessThruMemRef(copy->child1)->arguments->value),NULL,0,0)) { if (mpfr_integer_p(a)) { resA = mpfr_get_si(a, GMP_RNDN); mpfr_init2(b, 8 * sizeof(resA) + 5); mpfr_set_si(b, resA, GMP_RNDN); if (mpfr_cmp(a, b) == 0) { resA++; mpfr_set_si(b, resA, GMP_RNDN); freeThing(copy); copy = makeFinalEllipticList(addElement(NULL, makeConstant(b))); } else { tempNode = copyThing(copy->child1); freeThing(copy); copy = tempNode; } mpfr_clear(b); } else { tempNode = copyThing(copy->child1); freeThing(copy); copy = tempNode; } } else { tempNode = copyThing(copy->child1); freeThing(copy); copy = tempNode; } mpfr_clear(a); } else { tempNode = copyThing(copy->child1); freeThing(copy); copy = tempNode; } } } } break; case LENGTH: copy->child1 = evaluateThingInner(tree->child1); if (isEmptyList(copy->child1)) { if (timingString != NULL) pushTimeCounter(); freeThing(copy); copy = makeConstantDouble(0.0); if (timingString != NULL) popTimeCounter(timingString); } else { if (isPureList(copy->child1)) { if (timingString != NULL) pushTimeCounter(); if (accessThruMemRef(copy->child1)->argArray != NULL) { resA = accessThruMemRef(copy->child1)->argArraySize; } else { setupRandomAccessOnLists(copy->child1); resA = lengthChain(accessThruMemRef(copy->child1)->arguments); } mpfr_init2(a,sizeof(int) * 8); mpfr_set_si(a,resA,GMP_RNDN); freeThing(copy); copy = makeConstant(a); mpfr_clear(a); if (timingString != NULL) popTimeCounter(timingString); } else { if (isFinalEllipticList(copy->child1)) { if (timingString != NULL) pushTimeCounter(); mpfr_init2(a,sizeof(int) * 8); mpfr_set_inf(a,1); freeThing(copy); copy = makeConstant(a); mpfr_clear(a); if (timingString != NULL) popTimeCounter(timingString); } else { if (isString(copy->child1)) { if (timingString != NULL) pushTimeCounter(); resA = strlen(accessThruMemRef(copy->child1)->string); mpfr_init2(a,sizeof(int) * 8); mpfr_set_si(a,resA,GMP_RNDN); freeThing(copy); copy = makeConstant(a); mpfr_clear(a); if (timingString != NULL) popTimeCounter(timingString); } } } } break; case OBJECTNAME: copy->child1 = evaluateThing(tree->child1); tempString = NULL; if (timingString != NULL) pushTimeCounter(); tempString = getObjectName(copy->child1); if (timingString != NULL) popTimeCounter(timingString); if (tempString != NULL) { tempNode = makeString(tempString); safeFree(tempString); freeThing(copy); copy = tempNode; } break; case PRECDEREF: if (timingString != NULL) pushTimeCounter(); mpfr_init2(a,sizeof(int) * 8); mpfr_set_ui(a,tools_precision,GMP_RNDN); freeThing(copy); copy = makeConstant(a); mpfr_clear(a); if (timingString != NULL) popTimeCounter(timingString); break; case POINTSDEREF: if (timingString != NULL) pushTimeCounter(); mpfr_init2(a,sizeof(int) * 8); mpfr_set_si(a,defaultpoints,GMP_RNDN); freeThing(copy); copy = makeConstant(a); mpfr_clear(a); if (timingString != NULL) popTimeCounter(timingString); break; case DIAMDEREF: if (timingString != NULL) pushTimeCounter(); freeThing(copy); copy = makeConstant(statediam); if (timingString != NULL) popTimeCounter(timingString); break; case DISPLAYDEREF: if (timingString != NULL) pushTimeCounter(); freeThing(copy); switch (dyadic) { case 0: copy = makeDecimal(); break; case 1: copy = makeDyadic(); break; case 2: copy = makePowers(); break; case 3: copy = makeBinaryThing(); break; case 4: copy = makeHexadecimalThing(); break; default: sollyaFprintf(stderr,"Error: display mode in unknown state.\n"); exit(1); } if (timingString != NULL) popTimeCounter(timingString); break; case VERBOSITYDEREF: if (timingString != NULL) pushTimeCounter(); mpfr_init2(a,sizeof(int) * 8); mpfr_set_si(a,verbosity,GMP_RNDN); freeThing(copy); copy = makeConstant(a); mpfr_clear(a); if (timingString != NULL) popTimeCounter(timingString); break; case CANONICALDEREF: if (timingString != NULL) pushTimeCounter(); freeThing(copy); if (canonical) { copy = makeOn(); } else { copy = makeOff(); } if (timingString != NULL) popTimeCounter(timingString); break; case AUTOSIMPLIFYDEREF: if (timingString != NULL) pushTimeCounter(); freeThing(copy); if (autosimplify) { copy = makeOn(); } else { copy = makeOff(); } if (timingString != NULL) popTimeCounter(timingString); break; case SHOWMESSAGENUMBERSDEREF: if (timingString != NULL) pushTimeCounter(); freeThing(copy); if (activateMessageNumbers) { copy = makeOn(); } else { copy = makeOff(); } if (timingString != NULL) popTimeCounter(timingString); break; case TAYLORRECURSDEREF: if (timingString != NULL) pushTimeCounter(); mpfr_init2(a,sizeof(int) * 8); mpfr_set_si(a,taylorrecursions,GMP_RNDN); freeThing(copy); copy = makeConstant(a); mpfr_clear(a); if (timingString != NULL) popTimeCounter(timingString); break; case TIMINGDEREF: if (timingString != NULL) pushTimeCounter(); freeThing(copy); if (timecounting) { copy = makeOn(); } else { copy = makeOff(); } if (timingString != NULL) popTimeCounter(timingString); break; case FULLPARENDEREF: if (timingString != NULL) pushTimeCounter(); freeThing(copy); if (fullParentheses) { copy = makeOn(); } else { copy = makeOff(); } if (timingString != NULL) popTimeCounter(timingString); break; case MIDPOINTDEREF: if (timingString != NULL) pushTimeCounter(); freeThing(copy); if (midpointMode) { copy = makeOn(); } else { copy = makeOff(); } if (timingString != NULL) popTimeCounter(timingString); break; case DIEONERRORMODEDEREF: if (timingString != NULL) pushTimeCounter(); freeThing(copy); if (dieOnErrorMode) { copy = makeOn(); } else { copy = makeOff(); } if (timingString != NULL) popTimeCounter(timingString); break; case RATIONALMODEDEREF: if (timingString != NULL) pushTimeCounter(); freeThing(copy); if (rationalMode) { copy = makeOn(); } else { copy = makeOff(); } if (timingString != NULL) popTimeCounter(timingString); break; case SUPPRESSWARNINGSDEREF: if (timingString != NULL) pushTimeCounter(); freeThing(copy); if (noRoundingWarnings) { copy = makeOff(); } else { copy = makeOn(); } if (timingString != NULL) popTimeCounter(timingString); break; case HOPITALRECURSDEREF: if (timingString != NULL) pushTimeCounter(); mpfr_init2(a,sizeof(int) * 8); mpfr_set_si(a,hopitalrecursions,GMP_RNDN); freeThing(copy); copy = makeConstant(a); mpfr_clear(a); if (timingString != NULL) popTimeCounter(timingString); break; case PROC: safeFree(copy); copy = copyThing(tree); break; case PROCILLIM: safeFree(copy); copy = copyThing(tree); break; default: sollyaFprintf(stderr,"Error: evaluateThingInner: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } if (timingString != NULL) safeFree(timingString); return copy; } sollya-6.0+ds/execute.h000066400000000000000000000461731300174114700151100ustar00rootroot00000000000000/* Copyright 2007-2016 by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2) and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef EXECUTE_H #define EXECUTE_H #include #include #include "general.h" #include "expression.h" extern int miniyyparse(); extern void startBuffer(char *str); extern void endBuffer(void); #define COMMANDLIST 50 #define WHILE 51 #define IFELSE 52 #define IF 53 #define FOR 54 #define FORIN 56 #define QUIT 57 #define FALSEQUIT 58 #define RESTART 59 #define PRINT 60 #define NEWFILEPRINT 61 #define APPENDFILEPRINT 62 #define PLOT 63 #define PRINTHEXA 64 #define PRINTBINARY 65 #define PRINTEXPANSION 66 #define BASHEXECUTE 67 #define EXTERNALPLOT 68 #define WRITE 69 #define NEWFILEWRITE 70 #define APPENDFILEWRITE 71 #define ASCIIPLOT 72 #define WORSTCASE 73 #define RENAME 74 #define AUTOPRINT 75 #define ASSIGNMENT 76 #define LIBRARYBINDING 77 #define PRECASSIGN 78 #define POINTSASSIGN 79 #define DIAMASSIGN 80 #define DISPLAYASSIGN 81 #define VERBOSITYASSIGN 82 #define CANONICALASSIGN 83 #define AUTOSIMPLIFYASSIGN 84 #define TAYLORRECURSASSIGN 85 #define TIMINGASSIGN 86 #define FULLPARENASSIGN 87 #define MIDPOINTASSIGN 88 #define HOPITALRECURSASSIGN 89 #define PRECSTILLASSIGN 90 #define POINTSSTILLASSIGN 91 #define DIAMSTILLASSIGN 92 #define DISPLAYSTILLASSIGN 93 #define VERBOSITYSTILLASSIGN 94 #define CANONICALSTILLASSIGN 95 #define AUTOSIMPLIFYSTILLASSIGN 96 #define TAYLORRECURSSTILLASSIGN 97 #define TIMINGSTILLASSIGN 98 #define FULLPARENSTILLASSIGN 99 #define MIDPOINTSTILLASSIGN 100 #define HOPITALRECURSSTILLASSIGN 101 #define AND 102 #define OR 103 #define NEGATION 104 #define INDEX 105 #define COMPAREEQUAL 106 #define COMPARELESS 107 #define COMPAREGREATER 108 #define COMPARELESSEQUAL 109 #define COMPAREGREATEREQUAL 110 #define COMPARENOTEQUAL 111 #define CONCAT 112 #define ADDTOLIST 113 #define ON 114 #define OFF 115 #define DYADIC 116 #define POWERS 117 #define BINARY 118 #define FILESYM 119 #define POSTSCRIPT 120 #define POSTSCRIPTFILE 121 #define PERTURB 122 #define ROUNDDOWN 123 #define ROUNDUP 124 #define ROUNDTOZERO 125 #define ROUNDTONEAREST 126 #define HONORCOEFF 127 #define TRUE 128 #define FALSE 129 #define DEFAULT 130 #define DOUBLESYMBOL 131 #define DOUBLEDOUBLESYMBOL 132 #define TRIPLEDOUBLESYMBOL 133 #define STRING 134 #define TABLEACCESS 135 #define TABLEACCESSWITHSUBSTITUTE 136 #define DECIMALCONSTANT 137 #define DYADICCONSTANT 138 #define HEXCONSTANT 139 #define BINARYCONSTANT 140 #define EMPTYLIST 141 #define LIST 142 #define FINALELLIPTICLIST 143 #define ELLIPTIC 144 #define RANGE 145 #define DEBOUNDMAX 146 #define DEBOUNDMIN 147 #define DEBOUNDMID 148 #define DIFF 149 #define DIRTYSIMPLIFY 150 #define SIMPLIFYSAFE 151 #define REMEZ 152 #define HORNER 153 #define CANONICAL 154 #define EXPAND 155 #define TAYLOR 156 #define DEGREE 157 #define NUMERATOR 158 #define DENOMINATOR 159 #define SUBSTITUTE 160 #define COEFF 161 #define SUBPOLY 162 #define ROUNDCOEFFICIENTS 163 #define RATIONALAPPROX 164 #define ACCURATEINFNORM 165 #define ROUNDTOFORMAT 166 #define EVALUATE 167 #define PARSE 168 #define INFNORM 169 #define FINDZEROS 170 #define FPFINDZEROS 171 #define DIRTYINFNORM 172 #define INTEGRAL 173 #define DIRTYINTEGRAL 174 #define IMPLEMENTPOLY 175 #define CHECKINFNORM 176 #define ZERODENOMINATORS 177 #define ISEVALUABLE 178 #define SEARCHGAL 179 #define GUESSDEGREE 180 #define DIRTYFINDZEROS 181 #define HEAD 182 #define TAIL 183 #define LENGTH 184 #define PRECDEREF 185 #define POINTSDEREF 186 #define DIAMDEREF 187 #define DISPLAYDEREF 188 #define VERBOSITYDEREF 189 #define CANONICALDEREF 190 #define AUTOSIMPLIFYDEREF 191 #define TAYLORRECURSDEREF 192 #define TIMINGDEREF 193 #define FULLPARENDEREF 194 #define MIDPOINTDEREF 195 #define HOPITALRECURSDEREF 196 #define ABSOLUTESYM 197 #define RELATIVESYM 198 #define DECIMAL 199 #define ASSIGNMENTININDEXING 200 #define DOUBLEEXTENDEDSYMBOL 201 #define ERRORSPECIAL 202 #define PRINTXML 203 #define PRINTXMLNEWFILE 204 #define PRINTXMLAPPENDFILE 205 #define READXML 206 #define MANTISSA 207 #define EXPONENT 208 #define PRECISION 209 #define REVERT 210 #define SORT 211 #define READFILE 212 #define ROUNDCORRECTLY 213 #define NOP 214 #define EXECUTE 215 #define FALSERESTART 216 #define ISBOUND 217 #define APPEND 218 #define PREPEND 219 #define PRINTFLOAT 220 #define HEXADECIMAL 221 #define HEXADECIMALCONSTANT 222 #define EXTERNALPROC 223 #define UNIT 224 #define EXTERNALPROCEDUREUSAGE 225 #define VARIABLEDECLARATION 226 #define PROC 227 #define APPLY 228 #define FLOATASSIGNMENT 229 #define FLOATASSIGNMENTININDEXING 230 #define SUPPRESSWARNINGSASSIGN 231 #define SUPPRESSWARNINGSSTILLASSIGN 232 #define SUPPRESSWARNINGSDEREF 233 #define MIDPOINTCONSTANT 234 #define EVALCONST 235 #define FIXED 236 #define FLOATING 237 #define FPMINIMAX 238 #define RATIONALMODEASSIGN 239 #define RATIONALMODESTILLASSIGN 240 #define RATIONALMODEDEREF 241 #define SINGLESYMBOL 242 #define TAYLORFORM 243 #define NUMBERROOTS 244 #define TIME 245 #define NOPARG 246 #define PROCILLIM 247 #define DIEONERRORMODEASSIGN 248 #define DIEONERRORMODESTILLASSIGN 249 #define DIEONERRORMODEDEREF 250 #define COMPAREIN 251 #define AUTODIFF 252 #define MIN 253 #define MAX 254 #define SUPNORM 255 #define STRUCTACCESS 256 #define STRUCTURE 257 #define ASSIGNMENTINSTRUCTURE 258 #define FLOATASSIGNMENTINSTRUCTURE 259 #define PROTOASSIGNMENTINSTRUCTURE 260 #define PROTOFLOATASSIGNMENTINSTRUCTURE 261 #define IMPLEMENTCONST 262 #define LIBRARYCONSTANTBINDING 263 #define MATCH 264 #define MATCHELEMENT 265 #define BASHEVALUATE 266 #define HALFPRECISIONSYMBOL 267 #define QUADSYMBOL 268 #define COMPOSEPOLYNOMIALS 269 #define BIND 270 #define SHOWMESSAGENUMBERSASSIGN 271 #define SHOWMESSAGENUMBERSSTILLASSIGN 272 #define SHOWMESSAGENUMBERSDEREF 273 #define SUPPRESSMESSAGE 274 #define UNSUPPRESSMESSAGE 275 #define GETSUPPRESSEDMESSAGES 276 #define CHEBYSHEVFORM 277 /* Attention: #define MEMREF 278 is used elsewhere */ #define ANNOTATEFUNCTION 279 #define OBJECTNAME 280 #define GETBACKTRACE 281 int executeCommand(node *); node *copyThing(node *); node *deepCopyThing(node *); void *copyThingOnVoid(void *); void freeThing(node *); void rawPrintThing(node *); void freeThingOnVoid(void *); node *rewriteThingWithMemRefReuse(node *, node *); node *makeCommandList(chain *thinglist); node *makeWhile(node *thing1, node *thing2); node *makeIfElse(node *thing1, node *thing2, node *thing3); node *makeIf(node *thing1, node *thing2); node *makeFor(char *string, node *thing1, node *thing2, node *thing3, node *thing4); node *makeForIn(char *string, node *thing1, node *thing2); node *makeQuit(); node *makeFalseQuit(); node *makeFalseRestart(); node *makeRestart(); node *makePrint(chain *thinglist); node *makeSuppressMessage(chain *thinglist); node *makeUnsuppressMessage(chain *thinglist); node *makeNewFilePrint(node *thing, chain *thinglist); node *makeAppendFilePrint(node *thing, chain *thinglist); node *makePlot(chain *thinglist); node *makePrintHexa(node *thing); node *makePrintFloat(node *thing); node *makePrintBinary(node *thing); node *makePrintExpansion(node *thing); node *makeBashExecute(node *thing); node *makeExternalPlot(chain *thinglist); node *makeWrite(chain *thinglist); node *makeMatch(node *thing, chain *matchlist); node *makeNewFileWrite(node *thing, chain *thinglist); node *makeAppendFileWrite(node *thing, chain *thinglist); node *makeAsciiPlot(node *thing1, node *thing2); node *makeWorstCase(chain *thinglist); node *makeRename(char *string1, char *string2); node *makeBind(node *thing1, char *string1, node *thing2); node *makeAutoprint(chain *thinglist); node *makeAssignment(char *string, node *thing); node *makeFloatAssignment(char *string, node *thing); node *makeLibraryBinding(char *string, node *thing); node *makeLibraryConstantBinding(char *string, node *thing); node *makePrecAssign(node *thing); node *makeProcedureFunction(node *thing); node *makePointsAssign(node *thing); node *makeDiamAssign(node *thing); node *makeDisplayAssign(node *thing); node *makeVerbosityAssign(node *thing); node *makeShowMessageNumbersAssign(node *thing); node *makeCanonicalAssign(node *thing); node *makeAutoSimplifyAssign(node *thing); node *makeTaylorRecursAssign(node *thing); node *makeTimingAssign(node *thing); node *makeTime(node *thing); node *makeFullParenAssign(node *thing); node *makeMidpointAssign(node *thing); node *makeDieOnErrorAssign(node *thing); node *makeRationalModeAssign(node *thing); node *makeRationalModeStillAssign(node *thing); node *makeSuppressWarningsAssign(node *thing); node *makeSuppressWarningsStillAssign(node *thing); node *makeHopitalRecursAssign(node *thing); node *makePrecStillAssign(node *thing); node *makePointsStillAssign(node *thing); node *makeDiamStillAssign(node *thing); node *makeDisplayStillAssign(node *thing); node *makeVerbosityStillAssign(node *thing); node *makeShowMessageNumbersStillAssign(node *thing); node *makeCanonicalStillAssign(node *thing); node *makeAutoSimplifyStillAssign(node *thing); node *makeTaylorRecursStillAssign(node *thing); node *makeTimingStillAssign(node *thing); node *makeFullParenStillAssign(node *thing); node *makeMidpointStillAssign(node *thing); node *makeDieOnErrorStillAssign(node *thing); node *makeHopitalRecursStillAssign(node *thing); node *makeAnd(node *thing1, node *thing2); node *makeOr(node *thing1, node *thing2); node *makeNegation(node *thing); node *makeIndex(node *thing1, node *thing2); node *makeCompareEqual(node *thing1, node *thing2); node *makeCompareIn(node *thing1, node *thing2); node *makeCompareLess(node *thing1, node *thing2); node *makeCompareGreater(node *thing1, node *thing2); node *makeCompareLessEqual(node *thing1, node *thing2); node *makeCompareGreaterEqual(node *thing1, node *thing2); node *makeCompareNotEqual(node *thing1, node *thing2); node *makeConcat(node *thing1, node *thing2); node *makeAddToList(node *thing1, node *thing2); node *makePrepend(node *thing1, node *thing2); node *makeAppend(node *thing1, node *thing2); node *makeOn(); node *makeNop(); node *makeNopArg(node *thing1); node *makeOff(); node *makeDyadic(); node *makePowers(); node *makeBinaryThing(); node *makeHexadecimalThing(); node *makeFile(); node *makePostscript(); node *makePostscriptFile(); node *makePerturb(); node *makeRoundDown(); node *makeRoundUp(); node *makeRoundToZero(); node *makeRoundToNearest(); node *makeHonorCoeff(); node *makeTrue(); node *makeFalse(); node *makeDefault(); node *makeDecimal(); node *makeAbsolute(); node *makeRelative(); node *makeFixed(); node *makeFloating(); node *makeError(); node *makeDoubleSymbol(); node *makeSingleSymbol(); node *makeQuadSymbol(); node *makeHalfPrecisionSymbol(); node *makeDoubleDoubleSymbol(); node *makeTripleDoubleSymbol(); node *makeString(char *string); node *makeTableAccess(char *string); node *makeIsBound(char *string); node *makeTableAccessWithSubstitute(char *string, chain *thinglist); node *makeStructAccess(node *thing, char *string); node *makeDecimalConstant(char *string); node *makeMidpointConstant(char *string); node *makeDyadicConstant(char *string); node *makeHexConstant(char *string); node *makeHexadecimalConstant(char *string); node *makeBinaryConstant(char *string); node *makeEmptyList(); node *makeList(chain *thinglist); node *makeStructure(chain *assoclist); node *makeRevertedStructure(chain *assoclist); node *makeFinalEllipticList(chain *thinglist); node *makeRevertedList(chain *thinglist); node *makeRevertedFinalEllipticList(chain *thinglist); node *makeElliptic(); node *makeRange(node *thing1, node *thing2); node *makeDeboundMax(node *thing); node *makeDeboundMin(node *thing); node *makeDeboundMid(node *thing); node *makeEvalConst(node *thing); node *makeDiff(node *thing); node *makeBashevaluate(chain *thinglist); node *makeGetSuppressedMessages(); node *makeGetBacktrace(); node *makeDirtysimplify(node *thing); node *makeSimplifySafe(node *thing); node *makeRemez(chain *thinglist); node *makeAnnotateFunction(chain *thinglist); node *makeMin(chain *thinglist); node *makeMax(chain *thinglist); node *makeFPminimax(chain *thinglist); node *makeHorner(node *thing); node *makeCanonicalThing(node *thing); node *makeExpand(node *thing); node *makeTaylor(node *thing1, node *thing2, node *thing3); node *makeTaylorform(chain *thinglist); node *makeChebyshevform(chain *thinglist); node *makeAutodiff(chain *thinglist); node *makeDegree(node *thing); node *makeNumerator(node *thing); node *makeDenominator(node *thing); node *makeSubstitute(node *thing1, node *thing2); node *makeComposePolynomials(node *thing1, node *thing2); node *makeCoeff(node *thing1, node *thing2); node *makeSubpoly(node *thing1, node *thing2); node *makeRoundcoefficients(node *thing1, node *thing2); node *makeRationalapprox(node *thing1, node *thing2); node *makeAccurateInfnorm(chain *thinglist); node *makeRoundToFormat(node *thing1, node *thing2, node *thing3); node *makeEvaluate(node *thing1, node *thing2); node *makeParse(node *thing); node *makeInfnorm(chain *thinglist); node *makeSupnorm(chain *thinglist); node *makeFindZeros(node *thing1, node *thing2); node *makeFPFindZeros(node *thing1, node *thing2); node *makeDirtyInfnorm(node *thing1, node *thing2); node *makeNumberRoots(node *thing1, node *thing2); node *makeIntegral(node *thing1, node *thing2); node *makeDirtyIntegral(node *thing1, node *thing2); node *makeImplementPoly(chain *thinglist); node *makeImplementConst(chain *thinglist); node *makeNewCommand(node *thing1); node *makeCheckInfnorm(node *thing1, node *thing2, node *thing3); node *makeZeroDenominators(node *thing1, node *thing2); node *makeIsEvaluable(node *thing1, node *thing2); node *makeSearchGal(chain *thinglist); node *makeGuessDegree(chain *thinglist); node *makeDirtyFindZeros(node *thing1, node *thing2); node *makeHead(node *thing); node *makeRoundCorrectly(node *thing); node *makeReadFile(node *thing); node *makeRevert(node *thing); node *makeSort(node *thing); node *makeTail(node *thing); node *makeMantissa(node *thing); node *makeExponent(node *thing); node *makePrecision(node *thing); node *makeLength(node *thing); node *makeObjectName(node *thing); node *makePrecDeref(); node *makePointsDeref(); node *makeDiamDeref(); node *makeDisplayDeref(); node *makeVerbosityDeref(); node *makeShowMessageNumbersDeref(); node *makeCanonicalDeref(); node *makeAutoSimplifyDeref(); node *makeTaylorRecursDeref(); node *makeTimingDeref(); node *makeFullParenDeref(); node *makeMidpointDeref(); node *makeDieOnErrorDeref(); node *makeRationalModeDeref(); node *makeSuppressWarningsDeref(); node *makeHopitalRecursDeref(); node *makeAssignmentInIndexing(node *, node *, node *); node *makeFloatAssignmentInIndexing(node *, node *, node *); node *makeAssignmentInStructure(chain *, node *); node *makeFloatAssignmentInStructure(chain *, node *); node *makeProtoAssignmentInStructure(node *, node *); node *makeProtoFloatAssignmentInStructure(node *, node *); node *makeDoubleextendedSymbol(); node *makePrintXml(node *); node *makePrintXmlNewFile(node *, node *); node *makePrintXmlAppendFile(node *, node *); node *makeReadXml(node *); node *makeExecute(node *); node *makeExternalProc(char *, node *, chain *); node *makeUnit(); node *makeVariableDeclaration(chain *stringlist); node *makeProc(chain *stringlist, node *body, node *returnVal); node *makeMatchElement(node *, node *, node *); node *makeProcIllim(char *arg, node *body, node *returnVal); node *makeApply(node *thing, chain *thinglist); node *makeExternalProcedureUsage(libraryProcedure *proc); node *parseString(char *str); void computeFunctionWithProcedure(sollya_mpfi_t y, node *proc, sollya_mpfi_t x, unsigned int derivN, node *mr); void computeFunctionWithProcedureMpfr(mpfr_t rop, node *proc, mpfr_t op, unsigned int derivN); int isEqualThing(node *tree, node *tree2); int isEqualThingLibrary(node *tree, node *tree2); void fPrintThing(FILE *fd, node *thing); void printThing(node *thing); char *sPrintThing(node *thing); void freeEntryOnVoid(void *ptr); void *copyEntryOnVoid(void *ptr); int isCorrectlyTypedBaseSymbol(node *tree); int isExtendedPureTree(node *tree); int isPureTree(node *tree); int isRange(node *tree); int isMatchableList(node *tree); int isPureFinalEllipticList(node *); int isPureList(node *); int isEmptyList(node *); int isStructure(node *tree); int isProcedure(node *tree); int isExternalProcedureUsage(node *tree); int isLibraryConstant(node *tree); int isError(node *); int evaluateThingToConstant(mpfr_t result, node *tree, mpfr_t *defaultVal, int silent, int superSilent); int evaluateThingToRange(mpfr_t a, mpfr_t b, node *tree); int evaluateThingToString(char **result, node *tree); int isMatchablePrepend(node *tree); int isMatchableAppend(node *tree); int isMatchableConcat(node *tree); int isMatchableStructure(node *tree); int associationContainsDoubleEntries(chain *assoc); node *evaluateThing(node *tree); int isString(node *); int symbolNameAlreadyUsed(char *); int tryRepresentAsPolynomial(node *); int tryRepresentAsPolynomialNoConstants(node *); uint64_t hashThing(node *); uint64_t hashThingNoPolynomialHandling(node *); void freeBacktraceStack(); #endif /* ifdef EXECUTE_H*/ sollya-6.0+ds/expression.c000066400000000000000000016644101300174114700156410ustar00rootroot00000000000000/* Copyright 2006-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2) Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by CNRS, LIP6, UPMC Sorbonne Universités, UPMC Univ Paris 06, CNRS, LIP6 UMR 7606, 4 place Jussieu 75005 Paris Contributors Ch. Lauter, S. Chevillard, M. Mezzarobba christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org marc@mezzarobba.net This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include #include "mpfi-compat.h" #include #include "expression.h" #include /* fprinft, fopen, fclose, */ #include /* exit, free, mktemp */ #include #include #include "general.h" #include "double.h" #include "chain.h" #include "execute.h" #include "infnorm.h" #include "signalhandling.h" #ifdef HAVE_CONFIG_H #include "config.h" #endif #define MAXDIFFSIMPLSIZE 100 #define MAXDIFFSIMPLDEGREE 25 #define MAXDIFFPOLYSPECIALDEGREE 300 #if (!(defined(HAVE_MP_BITCNT_T) && (HAVE_MP_BITCNT_T))) typedef unsigned long int mp_bitcnt_t; #endif static inline void copyTreeAnnotations(node *new, node *old) { if (new == NULL) return; if (old == NULL) return; if (new->nodeType != MEMREF) return; if (old->nodeType != MEMREF) return; if (new == old) return; new->isCorrectlyTyped = old->isCorrectlyTyped; if ((old->derivCache != NULL) && (new->derivCache == NULL)) { new->derivCache = copyThing(old->derivCache); } if ((old->derivUnsimplCache != NULL) && (new->derivUnsimplCache == NULL)) { new->derivUnsimplCache = copyThing(old->derivUnsimplCache); } if ((old->simplifyCache != NULL) && (new->simplifyCache == NULL)) { new->simplifyCache = copyThing(old->simplifyCache); } if ((old->simplifyCacheRationalMode >= 0) && (new->simplifyCacheRationalMode < 0)) { new->simplifyCacheRationalMode = old->simplifyCacheRationalMode; } if ((old->simplifyCacheDoesNotSimplify >= 0) && (new->simplifyCacheDoesNotSimplify < 0)) { new->simplifyCacheDoesNotSimplify = old->simplifyCacheDoesNotSimplify; } addEvaluationHookFromCopy(&(new->evaluationHook), old->evaluationHook); } static inline void copyTreeAnnotationsNoSimplifications(node *new, node *old) { if (new == NULL) return; if (old == NULL) return; if (new->nodeType != MEMREF) return; if (old->nodeType != MEMREF) return; if (new == old) return; new->isCorrectlyTyped = old->isCorrectlyTyped; if ((old->derivCache != NULL) && (new->derivCache == NULL)) { new->derivCache = copyThing(old->derivCache); } if ((old->derivUnsimplCache != NULL) && (new->derivUnsimplCache == NULL)) { new->derivUnsimplCache = copyThing(old->derivUnsimplCache); } addEvaluationHookFromCopy(&(new->evaluationHook), old->evaluationHook); } void tryCopyTreeAnnotations(node *newTree, node *oldTree) { copyTreeAnnotations(newTree, oldTree); } int isSyntacticallyEqualCheap(node *tree1, node *tree2); void simplifyMpfrPrec(mpfr_t rop, mpfr_t op) { mp_prec_t prec; prec = mpfr_min_prec(op); if (prec < 12) prec = 12; mpfr_set_prec(rop, prec); mpfr_set(rop, op, GMP_RNDN); /* exact */ } void mpfr_from_mpfi(mpfr_t rop, mpfr_t op, int n, int (*mpfifun)(sollya_mpfi_t, sollya_mpfi_t, int)) { sollya_mpfi_t opI, ropI, ropItemp; sollya_mpfi_init2(opI,mpfr_get_prec(op)); sollya_mpfi_init2(ropItemp,mpfr_get_prec(rop)+2); sollya_mpfi_set_fr(opI,op); mpfifun(ropItemp,opI,n); sollya_init_and_convert_interval(ropI, ropItemp); sollya_mpfi_mid(rop,ropI); sollya_mpfi_clear(opI); sollya_mpfi_clear(ropI); sollya_mpfi_clear(ropItemp); } void mpfr_from_mpfi_data(mpfr_t rop, mpfr_t op, int n, int (*mpfifun)(sollya_mpfi_t, sollya_mpfi_t, int, void *), void *data) { sollya_mpfi_t opI, ropI, ropItemp; sollya_mpfi_init2(opI,mpfr_get_prec(op)); sollya_mpfi_init2(ropItemp,mpfr_get_prec(rop)+2); sollya_mpfi_set_fr(opI,op); mpfifun(ropItemp,opI,n,data); sollya_init_and_convert_interval(ropI, ropItemp); sollya_mpfi_mid(rop,ropI); sollya_mpfi_clear(opI); sollya_mpfi_clear(ropI); sollya_mpfi_clear(ropItemp); } void free_memory(node *tree) { if (tree == NULL) return; freeThing(tree); } void fprintHeadFunction(FILE *fd,node *tree, char *x, char *y) { int i; if (tree == NULL) return; switch (tree->nodeType) { case MEMREF: fprintHeadFunction(fd,getMemRefChild(tree), x, y); break; case VARIABLE: if (x != NULL) sollyaFprintf(fd,"%s",x); else sollyaFprintf(fd,"x"); break; case CONSTANT: fprintValue(fd,*(tree->value)); break; case ADD: sollyaFprintf(fd,"%s + %s",x,y); break; case SUB: sollyaFprintf(fd,"%s - %s",x,y); break; case MUL: sollyaFprintf(fd,"%s * %s",x,y); break; case DIV: sollyaFprintf(fd,"%s / %s",x,y); break; case SQRT: sollyaFprintf(fd,"sqrt(%s)",x); break; case EXP: sollyaFprintf(fd,"exp(%s)",x); break; case LOG: sollyaFprintf(fd,"log(%s)",x); break; case LOG_2: sollyaFprintf(fd,"log2(%s)",x); break; case LOG_10: sollyaFprintf(fd,"log10(%s)",x); break; case SIN: sollyaFprintf(fd,"sin(%s)",x); break; case COS: sollyaFprintf(fd,"cos(%s)",x); break; case TAN: sollyaFprintf(fd,"tan(%s)",x); break; case ASIN: sollyaFprintf(fd,"asin(%s)",x); break; case ACOS: sollyaFprintf(fd,"acos(%s)",x); break; case ATAN: sollyaFprintf(fd,"atan(%s)",x); break; case SINH: sollyaFprintf(fd,"sinh(%s)",x); break; case COSH: sollyaFprintf(fd,"cosh(%s)",x); break; case TANH: sollyaFprintf(fd,"tanh(%s)",x); break; case ASINH: sollyaFprintf(fd,"asinh(%s)",x); break; case ACOSH: sollyaFprintf(fd,"acosh(%s)",x); break; case ATANH: sollyaFprintf(fd,"atanh(%s)",x); break; case POW: sollyaFprintf(fd,"%s^%s",x,y); break; case NEG: sollyaFprintf(fd,"-%s",x); break; case ABS: sollyaFprintf(fd,"abs(%s)",x); break; case DOUBLE: sollyaFprintf(fd,"double(%s)",x); break; case SINGLE: sollyaFprintf(fd,"single(%s)",x); break; case QUAD: sollyaFprintf(fd,"quad(%s)",x); break; case HALFPRECISION: sollyaFprintf(fd,"halfprecision(%s)",x); break; case DOUBLEDOUBLE: sollyaFprintf(fd,"doubledouble(%s)",x); break; case TRIPLEDOUBLE: sollyaFprintf(fd,"tripledouble(%s)",x); break; case ERF: sollyaFprintf(fd,"erf(%s)",x); break; case ERFC: sollyaFprintf(fd,"erfc(%s)",x); break; case LOG_1P: sollyaFprintf(fd,"log1p(%s)",x); break; case EXP_M1: sollyaFprintf(fd,"expm1(%s)",x); break; case DOUBLEEXTENDED: sollyaFprintf(fd,"doubleextended(%s)",x); break; case LIBRARYFUNCTION: { sollyaFprintf(fd,"("); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,"diff("); } sollyaFprintf(fd,"%s",tree->libFun->functionName); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,")"); } sollyaFprintf(fd,")(%s)",x); } break; case PROCEDUREFUNCTION: { sollyaFprintf(fd,"("); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,"diff("); } sollyaFprintf(fd,"function("); fPrintThing(fd,tree->child2); sollyaFprintf(fd,")"); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,")"); } sollyaFprintf(fd,")(%s)",x); } break; case CEIL: sollyaFprintf(fd,"ceil(%s)",x); break; case FLOOR: sollyaFprintf(fd,"floor(%s)",x); break; case NEARESTINT: sollyaFprintf(fd,"nearestint(%s)",x); break; case PI_CONST: sollyaFprintf(fd,"pi"); break; case LIBRARYCONSTANT: sollyaFprintf(fd,"%s",tree->libFun->functionName); break; default: sollyaFprintf(stderr,"fprintHeadFunction: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return; } int precedence(node *tree) { switch (tree->nodeType) { case MEMREF: return precedence(getMemRefChild(tree)); break; case CONSTANT: case VARIABLE: case PI_CONST: return 1; break; case ADD: case SUB: return 2; break; case MUL: return 3; break; case DIV: return 4; break; case NEG: return 5; break; case POW: return 6; break; default: return 7; } return 0; } int isInfix(node *tree) { char *str; int res; switch(tree->nodeType) { case MEMREF: return isInfix(getMemRefChild(tree)); break; case CONSTANT: if (mpfr_sgn(*(tree->value)) < 0) return 1; if ((dyadic == 2) || (dyadic == 3)) { str = sprintValue(tree->value); res = (sollya_strchr(str,'*') != NULL); safeFree(str); return res; } break; case PI_CONST: case ADD: case SUB: case MUL: case DIV: case POW: case NEG: return 1; break; default: return 0; } return 0; } void removeTrailingZeros(char *outbuf, char *inbuf) { char *temp, *temp2, *temp3; temp = inbuf; temp2 = outbuf; temp3 = outbuf; while ((temp != NULL) && (*temp != '\0')) { *temp2 = *temp; if (*temp2 != '0') { temp3 = temp2; } temp2++; temp++; } temp3++; *temp3 = '\0'; } void printHexadecimalValue(mpfr_t x); void printValue(mpfr_t *value) { char *str; str = sprintValue(value); sollyaPrintf("%s",str); safeFree(str); } char *sprintMidpointMode(mpfr_t a, mpfr_t b) { mp_exp_t e1, e2; char *str1, *str2, *str, *str3; mpfr_t aP, bP; int sign, len1, len2, len, i; mp_prec_t prec, p; char *s1, *s2; int possibleLength; if (mpfr_sgn(a) != mpfr_sgn(b)) return NULL; if (mpfr_zero_p(a)) { str = safeCalloc(7,sizeof(char)); sprintf(str,"[0]"); return str; } prec = mpfr_get_prec(a); p = mpfr_get_prec(b); if (p > prec) prec = p; mpfr_init2(aP,prec); mpfr_init2(bP,prec); sign = mpfr_sgn(a); if (sign > 0) { mpfr_set(aP,a,GMP_RNDN); mpfr_set(bP,b,GMP_RNDN); } else { mpfr_neg(aP,b,GMP_RNDN); mpfr_neg(bP,a,GMP_RNDN); } str1 = mpfr_get_str(NULL,&e1,10,0,aP,GMP_RNDD); str2 = mpfr_get_str(NULL,&e2,10,0,bP,GMP_RNDU); str3 = safeCalloc(strlen(str1) + 1, sizeof(char)); removeTrailingZeros(str3,str1); safeFree(str1); str1 = str3; str3 = safeCalloc(strlen(str2) + 1, sizeof(char)); removeTrailingZeros(str3,str2); safeFree(str2); str2 = str3; if (e1 == e2) { if (strcmp(str1,str2) == 0) { mpfr_set(aP,a,GMP_RNDN); str3 = sprintValue(&aP); str = (char *) safeCalloc(strlen(str3) + 3, sizeof(char)); sprintf(str,"[%s]",str3); safeFree(str3); } else { if (str1[0] == str2[0]) { len1 = strlen(str1); len2 = strlen(str2); len = len1; if (len2 < len) len = len2; i = 0; while ((i < len) && (str1[i] == str2[i])) { i++; } possibleLength = i; s1 = mpfr_get_str(NULL,&e1,10,possibleLength+1,aP,GMP_RNDD); s2 = mpfr_get_str(NULL,&e2,10,possibleLength+1,bP,GMP_RNDU); if (e1 == e2) { if (s1[0] == s2[0]) { len1 = strlen(s1); len2 = strlen(s2); len = len1; if (len2 < len) len = len2; str = (char *) safeCalloc(len+6,sizeof(char)); i = 0; while ((i < len) && (s1[i] == s2[i])) { str[i] = s1[i]; i++; } str[i] = '~'; if (sign > 0) str[i+1] = s1[i]; else str[i+1] = s2[i]; str[i+2] = '/'; if (sign > 0) str[i+3] = s2[i]; else str[i+3] = s1[i]; str[i+4] = '~'; str3 = (char *) safeCalloc(strlen(str)+1,sizeof(char)); removeTrailingZeros(str3,str); safeFree(str); str = str3; str3 = (char *) safeCalloc(strlen(str)+69,sizeof(char)); if (sign < 0) { if (e1 == 0) { sprintf(str3,"-0.%s",str); } else { sprintf(str3,"-0.%se%d",str,(int)e1); } } else { if (e1 == 0) { sprintf(str3,"0.%s",str); } else { sprintf(str3,"0.%se%d",str,(int)e1); } } safeFree(str); str = str3; str3 = (char *) safeCalloc(strlen(str)+1,sizeof(char)); sprintf(str3,"%s",str); safeFree(str); str = str3; } else { str = NULL; } } else { str = NULL; } safeFree(s1); safeFree(s2); } else { str = NULL; } } } else { str = NULL; } mpfr_free_str(str1); mpfr_free_str(str2); mpfr_clear(aP); mpfr_clear(bP); return str; } char *sPrintBinary(mpfr_t x) { mpfr_t xx; int negative; mp_prec_t prec; mp_exp_t expo; char *raw, *formatted, *temp1, *temp2, *str3; char *temp3=NULL; char *resultStr; int len; prec = mpfr_get_prec(x); mpfr_init2(xx,prec); mpfr_abs(xx,x,GMP_RNDN); negative = 0; if (mpfr_sgn(x) < 0) negative = 1; raw = mpfr_get_str(NULL,&expo,2,0,xx,GMP_RNDN); if (raw == NULL) { sollyaFprintf(stderr,"Error: unable to get a string for the given number.\n"); exit(1); } else { formatted = safeCalloc(strlen(raw) + 3, sizeof(char)); temp1 = raw; temp2 = formatted; if (negative) { *temp2 = '-'; temp2++; } *temp2 = *temp1; temp2++; temp1++; if (*temp1 != '\0') { *temp2 = '.'; temp2++; } while (*temp1 != '\0') { *temp2 = *temp1; temp2++; temp1++; } str3 = (char *) safeCalloc(strlen(formatted)+2,sizeof(char)); removeTrailingZeros(str3,formatted); len = strlen(str3) - 1; if (str3[len] == '.') { str3[len] = '\0'; } if (!mpfr_zero_p(x)) { if (mpfr_number_p(x)) { temp3 = (char *) safeCalloc(strlen(str3)+74,sizeof(char)); if ((((int) expo)-1) != 0) sprintf(temp3,"%s_2 * 2^(%d)",str3,((int)expo)-1); else sprintf(temp3,"%s_2",str3); } else { temp3 = (char *) safeCalloc(strlen(raw) + 2,sizeof(char)); if (negative) sprintf(temp3,"-%s",raw); else sprintf(temp3,"%s",raw); } } else { temp3 = (char *) safeCalloc(2,sizeof(char)); sprintf(temp3,"0"); } safeFree(formatted); safeFree(str3); } mpfr_free_str(raw); mpfr_clear(xx); resultStr = (char *) safeCalloc(strlen(temp3) + 1,sizeof(char)); sprintf(resultStr,"%s",temp3); safeFree(temp3); return resultStr; } static inline int __sprintfValue_sprintf(char *str, const char *format, ...) { va_list varlist; int res; va_start(varlist, format); deferSignalHandling(); res = vsprintf(str, format, varlist); resumeSignalHandling(); va_end(varlist); return res; } char *sPrintHexadecimal(mpfr_t x) { char *res, *curr; mpfr_exp_t E; mpz_t m, n, z; int s; mp_bitcnt_t zerosRight; size_t q, w, a, i; long long int tmp; mpfr_exp_t Et; /* Display zero */ if (mpfr_zero_p(x)) { res = safeCalloc(strlen("0") + 1, sizeof(char)); strcpy(res, "0"); return res; } /* Display NaN */ if (mpfr_nan_p(x)) { res = safeCalloc(strlen("NaN") + 1, sizeof(char)); strcpy(res, "NaN"); return res; } /* Display +/- Infinity */ if (mpfr_inf_p(x)) { if (mpfr_sgn(x) < 0) { /* Display -infty */ res = safeCalloc(strlen("-infty") + 1, sizeof(char)); strcpy(res, "-infty"); } else { /* Display infty */ res = safeCalloc(strlen("infty") + 1, sizeof(char)); strcpy(res, "infty"); } return res; } /* Here, the input is neither zero, nor NaN, nor an infinity We can therefore split it into a sign, an exponent and an odd integer mantissa. */ mpz_init(m); E = mpfr_get_z_2exp(m, x); s = 0; if (mpz_sgn(m) < 0) { mpz_neg(m, m); s = 1; } zerosRight = mpz_scan1(m, 0); mpz_fdiv_q_2exp(m, m, zerosRight); E += zerosRight; /* Here, we have x = (-1)^s * 2^E * m where m = 2 * k + 1, k in N We now compute q = floor(log2(m)) and then n = m - 2^q. */ q = mpz_sizeinbase(m, 2); q--; mpz_init(n); mpz_set_si(n, 1); if (q != ((size_t) 0)) { mpz_mul_2exp(n, n, (mp_bitcnt_t) q); } mpz_sub(n, m, n); /* Now, we have to display x = (-1)^s * 2^(E + q) * (1 + n * 2^(-q)) We start by checking if n is zero. In this case m = 2^q + n is an integer power of 2. */ if (mpz_sgn(n) == 0) { /* Here, we have n = 0, so we have to display x = (-1)^s * 2^(E + q) * 1 */ E += q; res = safeCalloc(1 + 2 + 1 + 8 * sizeof(mpfr_exp_t) + 1, sizeof(char)); if (s) { res[0] = '-'; curr = res + 1; } else { curr = res; } curr[0] = '0'; curr[1] = 'x'; curr[2] = '1'; curr[3] = 'p'; curr += 4; if (sizeof(mpfr_exp_t) <= sizeof(int)) { __sprintfValue_sprintf(curr, "%d", (int) E); } else { if (sizeof(mpfr_exp_t) <= sizeof(long int)) { __sprintfValue_sprintf(curr, "%ld", (long int) E); } else { if (sizeof(mpfr_exp_t) <= sizeof(long long int)) { __sprintfValue_sprintf(curr, "%lld", (long long int) E); } else { tmp = (long long int) E; Et = (mpfr_exp_t) tmp; if (E == Et) { __sprintfValue_sprintf(curr, "%lld", tmp); } else { sollyaFprintf(stderr,"Error: sPrintHexadecimal: mpfr_exp_t variable too large to be displayed.\n"); exit(1); } } } } } else { /* Here, we have n = 0, so we have to display x = (-1)^s * 2^(E + q) * (1 + z * 2^(-w)) where w = 4 * ceil(q/4) which is an integer divisible by 4 and z = n * 2^(w-q) Hence w - q = 4 * ceil(q / 4) - q = 4 * (q / 4 + delta) - q = 4 * delta where delta is bounded by 0 <= delta < 1 Since w - q is integer, we have 0 <= w - q <= 3. Further we have 1 <= n <= 2^q - 1 and hence 1 <= z <= 2^w - 1. */ w = q >> 2; if ((q & ((size_t) 3)) != ((size_t) 0)) w++; w <<= 2; mpz_init(z); if ((w - q) != ((size_t) 0)) { mpz_mul_2exp(z, n, (mp_bitcnt_t) (w - q)); } else { mpz_set(z, n); } E += q; res = safeCalloc(1 + 2 + 1 + 1 + ((size_t) (w >> 2)) + 1 + 1 + 8 * sizeof(mpfr_exp_t) + 1, sizeof(char)); if (s) { res[0] = '-'; curr = res + 1; } else { curr = res; } curr[0] = '0'; curr[1] = 'x'; curr[2] = '1'; curr[3] = '.'; curr += 4; a = mpz_sizeinbase(z, 16); for (i=((size_t) 0);i<((size_t) ((w >> 2) - a));i++) { curr[i] = '0'; } curr += ((size_t) ((w >> 2) - a)); mpz_get_str(curr, 16, z); curr += a; curr[0] = 'p'; curr++; if (sizeof(mpfr_exp_t) <= sizeof(int)) { __sprintfValue_sprintf(curr, "%d", (int) E); } else { if (sizeof(mpfr_exp_t) <= sizeof(long int)) { __sprintfValue_sprintf(curr, "%ld", (long int) E); } else { if (sizeof(mpfr_exp_t) <= sizeof(long long int)) { __sprintfValue_sprintf(curr, "%lld", (long long int) E); } else { tmp = (long long int) E; Et = (mpfr_exp_t) tmp; if (E == Et) { __sprintfValue_sprintf(curr, "%lld", tmp); } else { sollyaFprintf(stderr,"Error: sPrintHexadecimal: mpfr_exp_t variable too large to be displayed.\n"); exit(1); } } } } mpz_clear(z); } /* Clear temporaries */ mpz_clear(n); mpz_clear(m); /* Return the result */ return res; } void printBinary(mpfr_t x) { char *str; str = sPrintBinary(x); sollyaPrintf("%s",str); safeFree(str); } void printHexadecimalValue(mpfr_t x) { char *str; str = sPrintHexadecimal(x); sollyaPrintf("%s",str); safeFree(str); } static inline void __sprintfValue_init_value(mpfr_t x, mpfr_t *valPtr) { int ternary; /* Check if input is NaN or Inf */ if (!mpfr_number_p(*valPtr)) { mpfr_init2(x, mpfr_get_prec(*valPtr)); mpfr_set(x, *valPtr, GMP_RNDN); return; } /* Here the input is a real number */ mpfr_init2(x, tools_precision); ternary = mpfr_set(x, *valPtr, GMP_RNDN); if ((ternary == 0) && (mpfr_number_p(x))) { /* The number holds on tools_precision bits */ return; } /* The number does not hold on tools_precision bits, so use its own precision */ mpfr_set_prec(x, mpfr_get_prec(*valPtr)); mpfr_set(x, *valPtr, GMP_RNDN); /* exact */ } static inline char *__sprintfValue_print_special(mpfr_t x) { char *res; /* Display zero */ if (mpfr_zero_p(x)) { res = safeCalloc(strlen("0") + 1, sizeof(char)); strcpy(res, "0"); return res; } /* Display NaN */ if (mpfr_nan_p(x)) { res = safeCalloc(strlen("NaN") + 1, sizeof(char)); strcpy(res, "NaN"); return res; } /* Display +/- Infinity */ if (mpfr_inf_p(x)) { if (mpfr_sgn(x) < 0) { /* Display -infty */ res = safeCalloc(strlen("-infty") + 1, sizeof(char)); strcpy(res, "-infty"); } else { /* Display infty */ res = safeCalloc(strlen("infty") + 1, sizeof(char)); strcpy(res, "infty"); } return res; } /* Returning NULL on purpose for unhandled cases */ return NULL; } static inline int __sprintfValue_is_small_integer(mpfr_t x) { if (!mpfr_number_p(x)) return 0; if (mpfr_zero_p(x)) return 0; if (!mpfr_integer_p(x)) return 0; return (mpfr_get_exp(x) <= 128); } static inline char *__sprintfValue_print_integer(mpfr_t x) { mpz_t z; char *res; /* Return NULL on purpose for unhandled cases */ if (!mpfr_number_p(x)) return NULL; if (!mpfr_integer_p(x)) return NULL; /* x is an integer, convert it to MPZ */ mpz_init(z); mpfr_get_z(z, x, GMP_RNDN); /* exact */ /* Allocate output memory */ res = safeCalloc(mpz_sizeinbase(z, 10) + 2 + 1, sizeof(char)); mpz_get_str(res, 10, z); /* Clear temporary */ mpz_clear(z); /* Return the result */ return res; } static inline char *__sprintfValue_print_dyadic(mpfr_t x) { mpfr_exp_t E; mpz_t m; int s; mp_bitcnt_t zerosRight; char *res; char *curr; long long int tmp; mpfr_exp_t Et; /* Return NULL on purpose for unhandled cases */ if (!mpfr_number_p(x)) return NULL; /* Handle the case of zero */ if (mpfr_zero_p(x)) { res = safeCalloc(strlen("0") + 1, sizeof(char)); strcpy(res, "0"); return res; } /* Here the input is a non-zero real number Decompose x into (-1)^s * 2^E * m */ mpz_init(m); E = mpfr_get_z_2exp(m, x); s = 0; if (mpz_sgn(m) < 0) { mpz_neg(m,m); s = 1; } zerosRight = mpz_scan1(m, 0); mpz_fdiv_q_2exp(m, m, zerosRight); E += zerosRight; /* Here, we have x = (-1)^s * 2^E * m where m = 2 * k + 1, k in Z */ if (E == ((mpfr_exp_t) 0)) { /* We have no exponent to display */ res = safeCalloc(mpz_sizeinbase(m, 10) + 2 + 1 + 1, sizeof(char)); if (s) { res[0] = '-'; curr = res + 1; } else { curr = res; } mpz_get_str(curr, 10, m); } else { /* We have the exponent to display */ res = safeCalloc(mpz_sizeinbase(m, 10) + 2 + 1 + 1 + sizeof(mpfr_exp_t) * 8 + 1 + 1, sizeof(char)); if (s) { res[0] = '-'; curr = res + 1; } else { curr = res; } mpz_get_str(curr, 10, m); curr = res + strlen(res); curr[0] = 'b'; curr++; if (sizeof(mpfr_exp_t) <= sizeof(int)) { __sprintfValue_sprintf(curr, "%d", (int) E); } else { if (sizeof(mpfr_exp_t) <= sizeof(long int)) { __sprintfValue_sprintf(curr, "%ld", (long int) E); } else { if (sizeof(mpfr_exp_t) <= sizeof(long long int)) { __sprintfValue_sprintf(curr, "%lld", (long long int) E); } else { tmp = (long long int) E; Et = (mpfr_exp_t) tmp; if (E == Et) { __sprintfValue_sprintf(curr, "%lld", tmp); } else { sollyaFprintf(stderr,"Error: __sprintfValue_print_dyadic: mpfr_exp_t variable too large to be displayed.\n"); exit(1); } } } } } /* Free temporary variable */ mpz_clear(m); /* Return the result */ return res; } static inline char *__sprintfValue_print_powers(mpfr_t x) { mpfr_exp_t E; mpz_t m; int s; mp_bitcnt_t zerosRight; char *res; char *curr; long long int tmp; mpfr_exp_t Et; /* Return NULL on purpose for unhandled cases */ if (!mpfr_number_p(x)) return NULL; /* Handle the case of zero */ if (mpfr_zero_p(x)) { res = safeCalloc(strlen("0") + 1, sizeof(char)); strcpy(res, "0"); return res; } /* Here the input is a non-zero real number Decompose x into (-1)^s * 2^E * m */ mpz_init(m); E = mpfr_get_z_2exp(m, x); s = 0; if (mpz_sgn(m) < 0) { mpz_neg(m,m); s = 1; } zerosRight = mpz_scan1(m, 0); mpz_fdiv_q_2exp(m, m, zerosRight); E += zerosRight; /* Here, we have x = (-1)^s * 2^E * m where m = 2 * k + 1, k in Z */ if (E == ((mpfr_exp_t) 0)) { /* We have no exponent to display */ res = safeCalloc(mpz_sizeinbase(m, 10) + 2 + 1 + 1, sizeof(char)); if (s) { res[0] = '-'; curr = res + 1; } else { curr = res; } mpz_get_str(curr, 10, m); } else { /* We have the exponent to display */ res = safeCalloc(mpz_sizeinbase(m, 10) + 2 + 1 + 1 + 7 + sizeof(mpfr_exp_t) * 8 + 1 + 1, sizeof(char)); if (s) { res[0] = '-'; curr = res + 1; } else { curr = res; } mpz_get_str(curr, 10, m); curr = res + strlen(res); if (sizeof(mpfr_exp_t) <= sizeof(int)) { if (E < ((mpfr_exp_t) 0)) { __sprintfValue_sprintf(curr, " * 2^(%d)", (int) E); } else { __sprintfValue_sprintf(curr, " * 2^%d", (int) E); } } else { if (sizeof(mpfr_exp_t) <= sizeof(long int)) { if (E < ((mpfr_exp_t) 0)) { __sprintfValue_sprintf(curr, " * 2^(%ld)", (long int) E); } else { __sprintfValue_sprintf(curr, " * 2^%ld", (long int) E); } } else { if (sizeof(mpfr_exp_t) <= sizeof(long long int)) { if (E < ((mpfr_exp_t) 0)) { __sprintfValue_sprintf(curr, " * 2^(%lld)", (long long int) E); } else { __sprintfValue_sprintf(curr, " * 2^%lld", (long long int) E); } } else { tmp = (long long int) E; Et = (mpfr_exp_t) tmp; if (E == Et) { if (E < ((mpfr_exp_t) 0)) { __sprintfValue_sprintf(curr, " * 2^(%lld)", tmp); } else { __sprintfValue_sprintf(curr, " * 2^%lld", tmp); } } else { sollyaFprintf(stderr,"Error: __sprintfValue_print_dyadic: mpfr_exp_t variable too large to be displayed.\n"); exit(1); } } } } } /* Free temporary variable */ mpz_clear(m); /* Return the result */ return res; } static inline mpfr_exp_t __sprintfValue_print_decimal_dec_exponent(mpfr_t x) { mp_prec_t prec; mpfr_t tmp; mpfr_exp_t F; intmax_t Fintmax; /* Return dummy value for unhandled cases */ if ((!mpfr_number_p(x)) || (mpfr_zero_p(x))) return 0; /* Initialize temporary variable */ prec = 2 * 8 * sizeof(mpfr_exp_t) + 12; if (((mp_prec_t) (2 * 8 * sizeof(intmax_t) + 12)) > prec) prec = 2 * 8 * sizeof(intmax_t) + 12; if (mpfr_get_prec(x) > prec) prec = mpfr_get_prec(x); mpfr_init2(tmp, prec); /* Compute absolute value of x */ mpfr_abs(tmp, x, GMP_RNDN); /* exact as prec >= prec(x) */ /* Compute log10(abs(x)) with rounding downwards, precision is enough to avoid double rounding */ mpfr_log10(tmp, tmp, GMP_RNDD); /* Compute floor(log(abs(x))) with rounding downwards */ mpfr_rint_floor(tmp, tmp, GMP_RNDD); /* no double rounding possible */ /* Get machine integer (intmax_t) representation of that integer */ Fintmax = mpfr_get_sj(tmp, GMP_RNDD); /* exact if not overflowing */ /* Convert to mpfr_exp_t */ F = (mpfr_exp_t) Fintmax; /* Clear temporary variable */ mpfr_clear(tmp); /* Return the result */ return F; } static inline void __sprintfValue_print_decimal_mul2(mpq_t q, mpfr_exp_t E) { mp_bitcnt_t tmp; if (E < ((mpfr_exp_t) 0)) { tmp = (mp_bitcnt_t) (-E); mpz_mul_2exp(mpq_denref(q), mpq_denref(q), tmp); } else { tmp = (mp_bitcnt_t) E; mpz_mul_2exp(mpq_numref(q), mpq_numref(q), tmp); } mpq_canonicalize(q); } static void __sprintfValue_print_decimal_pow5_fallback_pow(mpz_t z, mpz_t b, mp_bitcnt_t E) { unsigned int tmp; mp_bitcnt_t EE, H, L; mpz_t t1, t2; tmp = (unsigned int) E; EE = (mp_bitcnt_t) tmp; if (E == EE) { mpz_pow_ui(z,b,tmp); return; } /* This case should actually never happen */ H = E >> 14; L = E - (H << 14); /* Here we have E = 2^14 * H + L and hence b^E = b^(2^14 * H + L) = (b^(2^14))^H * b^L where we are sure that 2^14 and L will hold on an unsigned int. */ mpz_init(t1); mpz_init(t2); tmp = (unsigned int) (1 << 14); mpz_pow_ui(t1,b,tmp); __sprintfValue_print_decimal_pow5_fallback_pow(t1, t1, H); tmp = (unsigned int) L; mpz_pow_ui(t2,b,tmp); mpz_mul(z, t1, t2); mpz_clear(t2); mpz_clear(t1); } static inline void __sprintfValue_print_decimal_pow5_fallback(mpz_t z, mp_bitcnt_t E) { mpz_t tmp; mpz_init(tmp); mpz_set_si(tmp, 5); __sprintfValue_print_decimal_pow5_fallback_pow(z, tmp, E); mpz_clear(tmp); } static inline void __sprintfValue_print_decimal_pow5(mpz_t z, mp_bitcnt_t E) { unsigned int tmp; mp_bitcnt_t EE; tmp = (unsigned int) E; EE = (mp_bitcnt_t) tmp; if (E == EE) { mpz_ui_pow_ui(z,5,tmp); return; } /* Fall-back case that should never happen */ __sprintfValue_print_decimal_pow5_fallback(z, E); } static inline void __sprintfValue_print_decimal_mul5(mpq_t q, mpfr_exp_t E) { mpz_t f; mp_bitcnt_t tmp; mpz_init(f); if (E < ((mpfr_exp_t) 0)) { tmp = (mp_bitcnt_t) (-E); } else { tmp = (mp_bitcnt_t) E; } __sprintfValue_print_decimal_pow5(f, tmp); if (E < ((mpfr_exp_t) 0)) { mpz_mul(mpq_denref(q), mpq_denref(q), f); } else { mpz_mul(mpq_numref(q), mpq_numref(q), f); } mpz_clear(f); mpq_canonicalize(q); } void sollya_mpq_nearestint(mpq_t rop, mpq_t op) { mpz_t q, r; /* Initialize two integer variables */ mpz_init(q); mpz_init(r); /* Eucliadian division plus correction */ mpz_fdiv_qr(q, r, mpq_numref(op), mpq_denref(op)); mpz_mul_2exp(r, r, 1); /* Now we have op = q + 1/2 * r/b where b is the denominator of op. Hence nearestint(op) = q + nearestint(1/2 * r/b) We know that abs(1/2 * r/b) < 1 and that r and b have the same sign. Therefore 0 <= 1/2 * r/b < 1 and / 1 if r > b nearestint(1/2 * r/b) = | \ 0 otherwise. So, finally, / 1 if r > b nearestint(op) = q + | \ 0 otherwise. */ if (mpz_cmp(r,mpq_denref(op)) > 0) { mpz_add_ui(q, q, (unsigned long int) 1); } /* Here q = nearestint(op). Assign q to rop. */ mpq_set_z(rop, q); mpq_canonicalize(rop); /* Clear the temporaries */ mpz_clear(r); mpz_clear(q); } static inline char *__sprintfValue_print_decimal(mpfr_t x) { char *res; mpfr_exp_t E, F, G, H, Ht, K, D, Kt; mpz_t m, n; int s; mpq_t q; mp_prec_t k; int akFactor; mpq_t ak, bk, deltak, tmp, ten, nr; int mIsEven; char *curr; long long int tmpLongLongInt; size_t mantLen, d; /* Return NULL on purpose for unhandled cases */ if (!mpfr_number_p(x)) return NULL; /* Handle the case of zero */ if (mpfr_zero_p(x)) { res = safeCalloc(strlen("0") + 1, sizeof(char)); strcpy(res, "0"); return res; } /* Here the input is a non-zero real number Decompose x into (-1)^s * 2^E * m */ mpz_init(m); E = mpfr_get_z_2exp(m, x); s = 0; if (mpz_sgn(m) < 0) { mpz_neg(m,m); s = 1; } /* Compute the decimal exponent F = floor(log10(2^E * m)) = floor(log10(abs(x))) We have 1 <= 10^-F * 2^E * m < 10. */ F = __sprintfValue_print_decimal_dec_exponent(x); /* Initialize a mpq_t variable to hold q = 2^E / 10^F = 2^G / 5^F with G = E - F. */ G = E - F; mpq_init(q); mpq_set_si(q, 1, (unsigned long int) 1); mpq_canonicalize(q); __sprintfValue_print_decimal_mul2(q, G); __sprintfValue_print_decimal_mul5(q, -F); /* We know that 10^(F - k + 1) * nearestint(2^E/10^F * m * 10^(k - 1)) is the round-to-nearest decimal representation at k digits of our input x (modulo the sign). Now let alpha be defined as / -0.25 if m is an integer power of 2 alpha = | \ -0.5 otherwise and let beta = 0.5 Then 10^(F - k + 1) * nearestint(2^E/10^F * m * 10^(k - 1)) is the round-to-nearest decimal representation of 2^E * m that will round back to 2^E * m iff 2^E * (m + alpha) <(=) 10^(F - k + 1) * nearestint(2^E/10^F * m * 10^(k - 1)) <(=) 2^E * (m + beta) This is equivalent to a_k <(=) delta_k <(=) b_k (1) with a_k = alpha * 10^(k - 1) * 2^E/10^F, b_k = beta * 10^(k - 1) * 2^E/10^F and delta_k = nearestint(2^E/10^F * m * 10^(k - 1)) - 2^E/10^F * m * 10^(k - 1). It is clear that a_(k+1) = 10 * a_k b_(k+1) = 10 * b_k and it can be shown that delta_(k+1) = 10 * delta_k - nearestint(10 * delta_k). So we can start with some k, say k = 1, and test if the condition (1) above is satisfied (in which case we know that smallest decimal precision k for which the decimal rounding rounds back to binary, recovering x), or increment k and update a_k, b_k and delta_k at low cost. We shall start with k = 4 and setup a_k, b_k and delta_k. For k = 1, we have / -25/100 * 2^E/10^F if m is an integer power of 2 a_k = | \ -50/100 * 2^E/10^F otherwise and b_k = 50/100 * 2^E/10^F. */ k = 1; mpq_init(ak); mpq_init(bk); mpq_init(deltak); mpq_init(tmp); mpq_init(ten); /* Test if m > 0 is an integer power of 2 A positive integer is an integer power of 2 iff its binary representation has only one bit set to one. */ if (mpz_popcount(m) == ((mp_bitcnt_t) 1)) { akFactor = -25; } else { akFactor = -50; } mpq_set_si(tmp, akFactor, (unsigned long int) 100); mpq_canonicalize(tmp); mpq_mul(ak, q, tmp); mpq_set_si(tmp, 50, (unsigned long int) 100); mpq_canonicalize(tmp); mpq_mul(bk, q, tmp); mpq_set_si(tmp, 100, (unsigned long int) 100); mpq_canonicalize(tmp); mpq_mul(deltak, q, tmp); mpq_set_z(tmp, m); mpq_canonicalize(tmp); mpq_mul(deltak, deltak, tmp); sollya_mpq_nearestint(tmp, deltak); mpq_sub(deltak, tmp, deltak); /* Now determine if m is even or odd. If m is even, we have to test condition (1) as a_k <= delta_k <= b_k otherwise we have to test a_k < delta_k < b_k. */ mIsEven = (mpz_tstbit(m, 0) == 0); /* Initialize helper variable to 10 */ mpq_set_si(ten, 10, (unsigned long int) 1); mpq_canonicalize(ten); /* Loop to determine smallest decimal precision k */ while (!(mIsEven ? (( mpq_cmp(ak, deltak) <= 0 ) && ( mpq_cmp(deltak, bk) <= 0 ) ) : (( mpq_cmp(ak, deltak) < 0 ) && ( mpq_cmp(deltak, bk) < 0 ) ))) { mpq_mul(ak, ak, ten); mpq_mul(bk, bk, ten); mpq_mul(deltak, deltak, ten); sollya_mpq_nearestint(tmp, deltak); mpq_sub(deltak, deltak, tmp); k++; } /* Here we know the smallest decimal precision k for which the decimal rounding to nearest will round back to binary (with round-to-nearest and the original binary precision), resulting in the original value of x. Now actually compute the decimal rounding: 10^(F - k + 1) * n with n = nearestint(2^E/10^F * m * 10^(k - 1)) */ mpq_init(nr); mpz_init(n); mpq_set_z(nr, m); mpq_mul(nr, q, nr); __sprintfValue_print_decimal_mul2(nr, k - 1); __sprintfValue_print_decimal_mul5(nr, k - 1); sollya_mpq_nearestint(nr, nr); mpz_tdiv_q(n, mpq_numref(nr), mpq_denref(nr)); /* Now construct the string representation */ if (mpz_sgn(n) == 0) { /* In very rare cases 0 might be the shortest rounding. Produce 0.0 as output in this case. */ res = safeCalloc(strlen("0.0") + 1, sizeof(char)); strcpy(res, "0.0"); } else { /* Regular case We start by adjusting the exponent F: in some cases, the mantissa n exceeds 10^k - 1 because of rounding. In this case, n is divisible by 10 */ while (mpz_divisible_ui_p(n, (unsigned long int) 10)) { mpz_divexact_ui(n, n, (unsigned long int) 10); F++; } /* Now check if there is only one mantissa digit or if there are more than that */ if (mpz_cmpabs_ui(n, (unsigned long int) 10) < 0) { /* There is only one mantissa digit. Now distinguish the case when the corresponding exponent F - k + 1 is zero or not. */ if ((F - k + 1) == ((mpfr_exp_t) 0)) { /* There is only one mantissa digit and no exponent to be displayed. In order to allow for visual differentiation of this case (where there has been rounding) and an integer, we display ".0" after the mantissa digit. */ res = safeCalloc(1 + mpz_sizeinbase(n, 10) + 2 + 1 + 2 + 1, sizeof(char)); if (s) { res[0] = '-'; curr = res + 1; } else { curr = res; } mpz_get_str(curr, 10, n); curr = res + strlen(res); strcpy(curr, ".0"); } else { if ((F - k + 1) == ((mpfr_exp_t) -1)) { /* There is only one mantissa digit to be displayed and the exponent is -1. Instead of displaying Xe-1, we display 0.X */ res = safeCalloc(1 + mpz_sizeinbase(n, 10) + 2 + 1 + 2 + 1, sizeof(char)); if (s) { res[0] = '-'; curr = res + 1; } else { curr = res; } strcpy(curr, "0."); curr = res + strlen(res); mpz_get_str(curr, 10, n); } else { /* There is only one mantissa digit but an exponent to be displayed */ res = safeCalloc(1 + mpz_sizeinbase(n, 10) + 2 + 1 + 1 + sizeof(mpfr_exp_t) * 8 + 1 + 1, sizeof(char)); if (s) { res[0] = '-'; curr = res + 1; } else { curr = res; } mpz_get_str(curr, 10, n); curr = res + strlen(res); H = F - k + 1; if (sizeof(mpfr_exp_t) <= sizeof(int)) { __sprintfValue_sprintf(curr, "e%d", (int) H); } else { if (sizeof(mpfr_exp_t) <= sizeof(long int)) { __sprintfValue_sprintf(curr, "e%ld", (long int) H); } else { if (sizeof(mpfr_exp_t) <= sizeof(long long int)) { __sprintfValue_sprintf(curr, "e%lld", (long long int) H); } else { tmpLongLongInt = (long long int) H; Ht = (mpfr_exp_t) tmpLongLongInt; if (H == Ht) { __sprintfValue_sprintf(curr, "e%lld", tmpLongLongInt); } else { sollyaFprintf(stderr,"Error: __sprintfValue_print_decimal: mpfr_exp_t variable too large to be displayed.\n"); exit(1); } } } } } } } else { /* There is more than one mantissa digit to be displayed */ res = safeCalloc(1 + mpz_sizeinbase(n, 10) + 2 + 1 + 1 + 1 + 1 + 1 + 1 + sizeof(mpfr_exp_t) * 8 + 1 + 1, sizeof(char)); if (s) { res[0] = '-'; curr = res + 1; } else { curr = res; } mpz_get_str(curr, 10, n); mantLen = strlen(curr); /* Place the decimal point *into* the string of digits unless this makes the exponent field become -1, in which case we place "0." ahead of the string. */ H = F - k + 1; D = (mpfr_exp_t) (mantLen - ((size_t) 1)); K = H + D; if ((((mpfr_exp_t) 0) < K) && (K <= ((mpfr_exp_t) 4))) { K = (mpfr_exp_t) 0; } D = K - H; if (D < ((mpfr_exp_t) 1)) { D = (mpfr_exp_t) 1; } if (D > ((mpfr_exp_t) (mantLen - ((size_t) 1)))) { D = (mpfr_exp_t) (mantLen - ((size_t) 1)); } K = H + D; if (K == ((mpfr_exp_t) (-1))) { D++; K = H + D; d = (size_t) D; if (d == mantLen) { sollya_memmove((void *) (((curr + mantLen) - d) + 2), (void *) ((curr + mantLen) - d), d * sizeof(char)); ((curr + mantLen) - d)[0] = '0'; ((curr + mantLen) - d)[1] = '.'; curr += mantLen; curr += 2; } else { sollya_memmove((void *) (((curr + mantLen) - d) + 1), (void *) ((curr + mantLen) - d), d * sizeof(char)); ((curr + mantLen) - d)[0] = '.'; curr += mantLen; curr++; } } else { d = (size_t) D; sollya_memmove((void *) (((curr + mantLen) - d) + 1), (void *) ((curr + mantLen) - d), d * sizeof(char)); ((curr + mantLen) - d)[0] = '.'; curr += mantLen; curr++; } /* Now display the exponent field if it needs to be displayed */ if (K != ((mpfr_exp_t) 0)) { if (sizeof(mpfr_exp_t) <= sizeof(int)) { __sprintfValue_sprintf(curr, "e%d", (int) K); } else { if (sizeof(mpfr_exp_t) <= sizeof(long int)) { __sprintfValue_sprintf(curr, "e%ld", (long int) K); } else { if (sizeof(mpfr_exp_t) <= sizeof(long long int)) { __sprintfValue_sprintf(curr, "e%lld", (long long int) K); } else { tmpLongLongInt = (long long int) K; Kt = (mpfr_exp_t) tmpLongLongInt; if (K == Kt) { __sprintfValue_sprintf(curr, "e%lld", tmpLongLongInt); } else { sollyaFprintf(stderr,"Error: __sprintfValue_print_decimal: mpfr_exp_t variable too large to be displayed.\n"); exit(1); } } } } } } } /* Free temporary variables */ mpz_clear(m); mpq_clear(q); mpq_clear(ak); mpq_clear(bk); mpq_clear(deltak); mpq_clear(tmp); mpq_clear(ten); mpq_clear(nr); mpz_clear(n); /* Return the result */ return res; } #define __SPRINTVALUE_DYADIC_DECIMAL (0) #define __SPRINTVALUE_DYADIC_DYADIC (1) #define __SPRINTVALUE_DYADIC_POWERS (2) #define __SPRINTVALUE_DYADIC_BINARY (3) #define __SPRINTVALUE_DYADIC_HEXADECIMAL (4) char *sprintValue(mpfr_t *valPtr) { char *res; mpfr_t x; /* Initialize our representation x of the value to be displayed */ __sprintfValue_init_value(x, valPtr); /* Display NaNs, infinities and zero */ if ((!mpfr_number_p(x)) || (mpfr_zero_p(x))) { /* Use an auxiliary function */ res = __sprintfValue_print_special(x); /* Clear our representation x of the value to be displayed */ mpfr_clear(x); /* Return the result */ return res; } /* Here the input is a non-zero real number Now, if the display mode is 'binary numbers' or 'hexadecimal numbers' do not use a special code for small integers. */ if (dyadic == __SPRINTVALUE_DYADIC_BINARY) { /* Use an auxiliary function */ res = sPrintBinary(x); /* Clear our representation x of the value to be displayed */ mpfr_clear(x); /* Return the result */ return res; } if (dyadic == __SPRINTVALUE_DYADIC_HEXADECIMAL) { /* Use an auxiliary function */ res = sPrintHexadecimal(x); /* Clear our representation x of the value to be displayed */ mpfr_clear(x); /* Return the result */ return res; } /* Here the input is a non-zero real number Continue by checking if the number is an integer that holds on 128 bits. */ if (__sprintfValue_is_small_integer(x)) { /* Use an auxiliary function */ res = __sprintfValue_print_integer(x); /* Clear our representation x of the value to be displayed */ mpfr_clear(x); /* Return the result */ return res; } /* Here the input is a non-zero real number and the display mode should be taken into account */ switch (dyadic) { case __SPRINTVALUE_DYADIC_HEXADECIMAL: res = sPrintHexadecimal(x); break; case __SPRINTVALUE_DYADIC_BINARY: res = sPrintBinary(x); break; case __SPRINTVALUE_DYADIC_DYADIC: res = __sprintfValue_print_dyadic(x); break; case __SPRINTVALUE_DYADIC_POWERS: res = __sprintfValue_print_powers(x); break; case __SPRINTVALUE_DYADIC_DECIMAL: default: res = __sprintfValue_print_decimal(x); } /* Clear our representation x of the value to be displayed */ mpfr_clear(x); /* Return the result */ return res; } void printMpfr(mpfr_t x) { mpfr_t tmp; mp_prec_t prec; prec = mpfr_get_prec(x); mpfr_init2(tmp,prec); mpfr_set(tmp,x,GMP_RNDN); printValue(&tmp); sollyaPrintf("\n"); mpfr_clear(tmp); } void fprintValueWithPrintMode(FILE *fd, mpfr_t value) { char *str; mpfr_t temp; mp_prec_t p; p = mpfr_get_prec(value); mpfr_init2(temp,p); mpfr_set(temp,value,GMP_RNDN); str = sprintValue(&temp); mpfr_clear(temp); sollyaFprintf(fd,"%s",str); safeFree(str); } void fprintTreeWithPrintMode(FILE *fd, node *tree) { int pred, i; if (tree->nodeType == MEMREF) { fprintTreeWithPrintMode(fd, getMemRefChild(tree)); return; } if (fullParentheses) pred = 100; else pred = precedence(tree); switch (tree->nodeType) { case VARIABLE: if (variablename != NULL) { sollyaFprintf(fd,"%s",variablename); } else { sollyaFprintf(fd,"_x_"); } break; case CONSTANT: fprintValueWithPrintMode(fd,*(tree->value)); break; case ADD: if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (tree->child1->nodeType != CONSTANT)) sollyaFprintf(fd,"("); fprintTreeWithPrintMode(fd,tree->child1); if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (tree->child1->nodeType != CONSTANT)) sollyaFprintf(fd,")"); sollyaFprintf(fd," + "); if (isInfix(tree->child2) && (precedence(tree->child2) < pred)) sollyaFprintf(fd,"("); fprintTreeWithPrintMode(fd,tree->child2); if (isInfix(tree->child2) && (precedence(tree->child2) < pred)) sollyaFprintf(fd,")"); break; case SUB: if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (tree->child1->nodeType != CONSTANT)) sollyaFprintf(fd,"("); fprintTreeWithPrintMode(fd,tree->child1); if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (tree->child1->nodeType != CONSTANT)) sollyaFprintf(fd,")"); sollyaFprintf(fd," - "); if (isInfix(tree->child2) && (precedence(tree->child2) <= pred)) sollyaFprintf(fd,"("); fprintTreeWithPrintMode(fd,tree->child2); if (isInfix(tree->child2) && (precedence(tree->child2) <= pred)) sollyaFprintf(fd,")"); break; case MUL: if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (tree->child1->nodeType != CONSTANT)) sollyaFprintf(fd,"("); fprintTreeWithPrintMode(fd,tree->child1); if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (tree->child1->nodeType != CONSTANT)) sollyaFprintf(fd,")"); sollyaFprintf(fd," * "); if (isInfix(tree->child2) && (precedence(tree->child2) < pred)) sollyaFprintf(fd,"("); fprintTreeWithPrintMode(fd,tree->child2); if (isInfix(tree->child2) && (precedence(tree->child2) < pred)) sollyaFprintf(fd,")"); break; case DIV: if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (tree->child1->nodeType != CONSTANT)) sollyaFprintf(fd,"("); fprintTreeWithPrintMode(fd,tree->child1); if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (tree->child1->nodeType != CONSTANT)) sollyaFprintf(fd,")"); sollyaFprintf(fd," / "); if (isInfix(tree->child2) && (precedence(tree->child2) <= pred)) sollyaFprintf(fd,"("); fprintTreeWithPrintMode(fd,tree->child2); if (isInfix(tree->child2) && (precedence(tree->child2) <= pred)) sollyaFprintf(fd,")"); break; case SQRT: sollyaFprintf(fd,"sqrt("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case EXP: sollyaFprintf(fd,"exp("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case LOG: sollyaFprintf(fd,"log("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case LOG_2: sollyaFprintf(fd,"log2("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case LOG_10: sollyaFprintf(fd,"log10("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case SIN: sollyaFprintf(fd,"sin("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case COS: sollyaFprintf(fd,"cos("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case TAN: sollyaFprintf(fd,"tan("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case ASIN: sollyaFprintf(fd,"asin("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case ACOS: sollyaFprintf(fd,"acos("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case ATAN: sollyaFprintf(fd,"atan("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case SINH: sollyaFprintf(fd,"sinh("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case COSH: sollyaFprintf(fd,"cosh("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case TANH: sollyaFprintf(fd,"tanh("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case ASINH: sollyaFprintf(fd,"asinh("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case ACOSH: sollyaFprintf(fd,"acosh("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case ATANH: sollyaFprintf(fd,"atanh("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case POW: if (isInfix(tree->child1) && (precedence(tree->child1) <= pred)) sollyaFprintf(fd,"("); fprintTreeWithPrintMode(fd,tree->child1); if (isInfix(tree->child1) && (precedence(tree->child1) <= pred)) sollyaFprintf(fd,")"); sollyaFprintf(fd,"^"); if (isInfix(tree->child2) && ((precedence(tree->child2) <= pred) || ((tree->child2->nodeType == CONSTANT) && ((dyadic == 2) || (dyadic == 3))))) { sollyaFprintf(fd,"("); } fprintTreeWithPrintMode(fd,tree->child2); if (isInfix(tree->child2) && ((precedence(tree->child2) <= pred) || ((tree->child2->nodeType == CONSTANT) && ((dyadic == 2) || (dyadic == 3))))) { sollyaFprintf(fd,")"); } break; case NEG: sollyaFprintf(fd,"-"); if (isInfix(tree->child1) && (precedence(tree->child1) <= pred)) sollyaFprintf(fd,"("); fprintTreeWithPrintMode(fd,tree->child1); if (isInfix(tree->child1) && (precedence(tree->child1) <= pred)) sollyaFprintf(fd,")"); break; case ABS: sollyaFprintf(fd,"abs("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case DOUBLE: sollyaFprintf(fd,"double("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case SINGLE: sollyaFprintf(fd,"single("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case HALFPRECISION: sollyaFprintf(fd,"halfprecision("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case QUAD: sollyaFprintf(fd,"quad("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case DOUBLEDOUBLE: sollyaFprintf(fd,"doubledouble("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case TRIPLEDOUBLE: sollyaFprintf(fd,"tripledouble("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case ERF: sollyaFprintf(fd,"erf("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case ERFC: sollyaFprintf(fd,"erfc("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case LOG_1P: sollyaFprintf(fd,"log1p("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case EXP_M1: sollyaFprintf(fd,"expm1("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case DOUBLEEXTENDED: sollyaFprintf(fd,"doubleextended("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case LIBRARYFUNCTION: { if (accessThruMemRef(tree->child1)->nodeType == VARIABLE) { for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,"diff("); } sollyaFprintf(fd,"%s",tree->libFun->functionName); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,")"); } } else { if (tree->libFunDeriv == 0) { sollyaFprintf(fd,"%s(",tree->libFun->functionName); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); } else { sollyaFprintf(fd,"("); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,"diff("); } sollyaFprintf(fd,"%s",tree->libFun->functionName); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,")"); } sollyaFprintf(fd,")("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); } } } break; case PROCEDUREFUNCTION: { if (accessThruMemRef(tree->child1)->nodeType == VARIABLE) { for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,"diff("); } sollyaFprintf(fd,"function("); fPrintThing(fd,tree->child2); sollyaFprintf(fd,")"); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,")"); } } else { if (tree->libFunDeriv == 0) { sollyaFprintf(fd,"(function("); fPrintThing(fd,tree->child2); sollyaFprintf(fd,"))("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); } else { sollyaFprintf(fd,"("); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,"diff("); } sollyaFprintf(fd,"function("); fPrintThing(fd,tree->child2); sollyaFprintf(fd,")"); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,")"); } sollyaFprintf(fd,")("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); } } } break; case CEIL: sollyaFprintf(fd,"ceil("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case FLOOR: sollyaFprintf(fd,"floor("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case NEARESTINT: sollyaFprintf(fd,"nearestint("); fprintTreeWithPrintMode(fd,tree->child1); sollyaFprintf(fd,")"); break; case PI_CONST: sollyaFprintf(fd,"pi"); break; case LIBRARYCONSTANT: sollyaFprintf(fd,"%s",tree->libFun->functionName); break; default: sollyaFprintf(stderr,"Error: fprintTreeWithPrintMode: unknown identifier in the tree\n"); exit(1); } return; } void fprintValue(FILE *fd, mpfr_t value) { mpfr_t y; char *str, *str2; mp_exp_t e, expo; mp_prec_t prec; if (mpfr_zero_p(value)) { sollyaFprintf(fd,"0"); } else { prec = mpfr_get_prec(value); mpfr_init2(y,prec+10); mpfr_set(y,value,GMP_RNDN); if (mpfr_sgn(y) < 0) { sollyaFprintf(fd,"-"); mpfr_neg(y,y,GMP_RNDN); } if (!mpfr_number_p(value)) { str = mpfr_get_str(NULL,&e,10,0,y,GMP_RNDN); sollyaFprintf(fd,"%s",str); } else { expo = mpfr_get_exp(y); if (mpfr_set_exp(y,prec+10)) { printMessage(1,SOLLYA_MSG_OUT_OF_CURRENT_EXPONENT_RANGE,"\nWarning: upon printing to a file: %d is not in the current exponent range of a variable. Values printed may be wrong.\n",(int)(prec+10)); } expo -= prec+10; while (mpfr_integer_p(y)) { mpfr_div_2ui(y,y,1,GMP_RNDN); expo += 1; } expo--; if (mpfr_mul_2ui(y,y,1,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_INADVERTED_ROUNDING_WHILE_DISPLAYING,"\nWarning: upon printing to a file: rounding occurred. Values printed may be wrong.\n"); } } str = mpfr_get_str(NULL,&e,10,0,y,GMP_RNDN); str2 = (char *) safeCalloc(strlen(str)+1,sizeof(char)); strncpy(str2,str,e); sollyaFprintf(fd,"%sb%d",str2,(int)expo); safeFree(str2); } safeFree(str); mpfr_clear(y); } } void fprintValueForXml(FILE *fd, mpfr_t value) { mpfr_t y, h; char *str, *str2; mp_exp_t e, expo; mp_prec_t prec; int negate, val; if (mpfr_zero_p(value)) { sollyaFprintf(fd," 0 \n"); } else { prec = mpfr_get_prec(value); mpfr_init2(y,prec+10); mpfr_set(y,value,GMP_RNDN); val = mpfr_get_si(y,GMP_RNDN); mpfr_init2(h,prec); mpfr_set_si(h,val,GMP_RNDN); if (mpfr_number_p(y) && (mpfr_cmp(h,y) == 0)) { mpfr_clear(h); sollyaFprintf(fd," %d \n",val); } else { mpfr_clear(h); negate = 0; if (mpfr_sgn(y) < 0) { negate = 1; mpfr_neg(y,y,GMP_RNDN); } if (!mpfr_number_p(value)) { str = mpfr_get_str(NULL,&e,10,0,y,GMP_RNDN); if (!negate) sollyaFprintf(fd," %s \n",str); else sollyaFprintf(fd," -%s \n",str); } else { expo = mpfr_get_exp(y); if (mpfr_set_exp(y,prec+10)) { printMessage(1,SOLLYA_MSG_OUT_OF_CURRENT_EXPONENT_RANGE,"\nWarning: upon printing to a file: %d is not in the current exponent range of a variable. Values printed may be wrong.\n",(int)(prec+10)); } expo -= prec+10; while (mpfr_integer_p(y)) { mpfr_div_2ui(y,y,1,GMP_RNDN); expo += 1; } expo--; if (mpfr_mul_2ui(y,y,1,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_INADVERTED_ROUNDING_WHILE_DISPLAYING,"\nWarning: upon printing to a file: rounding occurred. Values printed may be wrong.\n"); } } str = mpfr_get_str(NULL,&e,10,0,y,GMP_RNDN); str2 = (char *) safeCalloc(strlen(str)+1,sizeof(char)); strncpy(str2,str,e); if (!negate) { sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd," %s \n",str2); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd," 2 \n"); sollyaFprintf(fd," %d \n",(int) expo); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); } else { sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd," -%s \n",str2); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd," 2 \n"); sollyaFprintf(fd," %d \n",(int) expo); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); } safeFree(str2); } } mpfr_clear(y); } } void printTree(node *tree) { int pred, i; if (tree->nodeType == MEMREF) { printTree(getMemRefChild(tree)); return; } if (fullParentheses) pred = 100; else pred = precedence(tree); switch (tree->nodeType) { case VARIABLE: if (variablename != NULL) { sollyaPrintf("%s",variablename); } else { sollyaPrintf("_x_"); } break; case CONSTANT: printValue(tree->value); break; case ADD: if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) sollyaPrintf("("); printTree(tree->child1); if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) sollyaPrintf(")"); sollyaPrintf(" + "); if (isInfix(tree->child2) && (precedence(tree->child2) < pred)) sollyaPrintf("("); printTree(tree->child2); if (isInfix(tree->child2) && (precedence(tree->child2) < pred)) sollyaPrintf(")"); break; case SUB: if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) sollyaPrintf("("); printTree(tree->child1); if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) sollyaPrintf(")"); sollyaPrintf(" - "); if (isInfix(tree->child2) && (precedence(tree->child2) <= pred)) sollyaPrintf("("); printTree(tree->child2); if (isInfix(tree->child2) && (precedence(tree->child2) <= pred)) sollyaPrintf(")"); break; case MUL: if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) sollyaPrintf("("); printTree(tree->child1); if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) sollyaPrintf(")"); sollyaPrintf(" * "); if (isInfix(tree->child2) && (precedence(tree->child2) < pred)) sollyaPrintf("("); printTree(tree->child2); if (isInfix(tree->child2) && (precedence(tree->child2) < pred)) sollyaPrintf(")"); break; case DIV: if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) sollyaPrintf("("); printTree(tree->child1); if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) sollyaPrintf(")"); sollyaPrintf(" / "); if (isInfix(tree->child2) && (precedence(tree->child2) <= pred)) sollyaPrintf("("); printTree(tree->child2); if (isInfix(tree->child2) && (precedence(tree->child2) <= pred)) sollyaPrintf(")"); break; case SQRT: sollyaPrintf("sqrt("); printTree(tree->child1); sollyaPrintf(")"); break; case EXP: sollyaPrintf("exp("); printTree(tree->child1); sollyaPrintf(")"); break; case LOG: sollyaPrintf("log("); printTree(tree->child1); sollyaPrintf(")"); break; case LOG_2: sollyaPrintf("log2("); printTree(tree->child1); sollyaPrintf(")"); break; case LOG_10: sollyaPrintf("log10("); printTree(tree->child1); sollyaPrintf(")"); break; case SIN: sollyaPrintf("sin("); printTree(tree->child1); sollyaPrintf(")"); break; case COS: sollyaPrintf("cos("); printTree(tree->child1); sollyaPrintf(")"); break; case TAN: sollyaPrintf("tan("); printTree(tree->child1); sollyaPrintf(")"); break; case ASIN: sollyaPrintf("asin("); printTree(tree->child1); sollyaPrintf(")"); break; case ACOS: sollyaPrintf("acos("); printTree(tree->child1); sollyaPrintf(")"); break; case ATAN: sollyaPrintf("atan("); printTree(tree->child1); sollyaPrintf(")"); break; case SINH: sollyaPrintf("sinh("); printTree(tree->child1); sollyaPrintf(")"); break; case COSH: sollyaPrintf("cosh("); printTree(tree->child1); sollyaPrintf(")"); break; case TANH: sollyaPrintf("tanh("); printTree(tree->child1); sollyaPrintf(")"); break; case ASINH: sollyaPrintf("asinh("); printTree(tree->child1); sollyaPrintf(")"); break; case ACOSH: sollyaPrintf("acosh("); printTree(tree->child1); sollyaPrintf(")"); break; case ATANH: sollyaPrintf("atanh("); printTree(tree->child1); sollyaPrintf(")"); break; case POW: if (isInfix(tree->child1) && (precedence(tree->child1) <= pred)) sollyaPrintf("("); printTree(tree->child1); if (isInfix(tree->child1) && (precedence(tree->child1) <= pred)) sollyaPrintf(")"); sollyaPrintf("^"); if (isInfix(tree->child2) && ((precedence(tree->child2) <= pred) || ((accessThruMemRef(tree->child2)->nodeType == CONSTANT) && ((dyadic == 2) || (dyadic == 3))))) { sollyaPrintf("("); } printTree(tree->child2); if (isInfix(tree->child2) && ((precedence(tree->child2) <= pred) || ((accessThruMemRef(tree->child2)->nodeType == CONSTANT) && ((dyadic == 2) || (dyadic == 3))))) { sollyaPrintf(")"); } break; case NEG: sollyaPrintf("-"); if (isInfix(tree->child1) && (precedence(tree->child1) <= pred)) sollyaPrintf("("); printTree(tree->child1); if (isInfix(tree->child1) && (precedence(tree->child1) <= pred)) sollyaPrintf(")"); break; case ABS: sollyaPrintf("abs("); printTree(tree->child1); sollyaPrintf(")"); break; case DOUBLE: sollyaPrintf("double("); printTree(tree->child1); sollyaPrintf(")"); break; case SINGLE: sollyaPrintf("single("); printTree(tree->child1); sollyaPrintf(")"); break; case HALFPRECISION: sollyaPrintf("halfprecision("); printTree(tree->child1); sollyaPrintf(")"); break; case QUAD: sollyaPrintf("quad("); printTree(tree->child1); sollyaPrintf(")"); break; case DOUBLEDOUBLE: sollyaPrintf("doubledouble("); printTree(tree->child1); sollyaPrintf(")"); break; case TRIPLEDOUBLE: sollyaPrintf("tripledouble("); printTree(tree->child1); sollyaPrintf(")"); break; case ERF: sollyaPrintf("erf("); printTree(tree->child1); sollyaPrintf(")"); break; case ERFC: sollyaPrintf("erfc("); printTree(tree->child1); sollyaPrintf(")"); break; case LOG_1P: sollyaPrintf("log1p("); printTree(tree->child1); sollyaPrintf(")"); break; case EXP_M1: sollyaPrintf("expm1("); printTree(tree->child1); sollyaPrintf(")"); break; case DOUBLEEXTENDED: sollyaPrintf("doubleextended("); printTree(tree->child1); sollyaPrintf(")"); break; case LIBRARYFUNCTION: { if (accessThruMemRef(tree->child1)->nodeType == VARIABLE) { for (i=1;i<=tree->libFunDeriv;i++) { sollyaPrintf("diff("); } sollyaPrintf("%s",tree->libFun->functionName); for (i=1;i<=tree->libFunDeriv;i++) { sollyaPrintf(")"); } } else { if (tree->libFunDeriv == 0) { sollyaPrintf("%s(",tree->libFun->functionName); printTree(tree->child1); sollyaPrintf(")"); } else { sollyaPrintf("("); for (i=1;i<=tree->libFunDeriv;i++) { sollyaPrintf("diff("); } sollyaPrintf("%s",tree->libFun->functionName); for (i=1;i<=tree->libFunDeriv;i++) { sollyaPrintf(")"); } sollyaPrintf(")("); printTree(tree->child1); sollyaPrintf(")"); } } } break; case PROCEDUREFUNCTION: { if (accessThruMemRef(tree->child1)->nodeType == VARIABLE) { for (i=1;i<=tree->libFunDeriv;i++) { sollyaPrintf("diff("); } sollyaPrintf("function("); printThing(tree->child2); sollyaPrintf(")"); for (i=1;i<=tree->libFunDeriv;i++) { sollyaPrintf(")"); } } else { if (tree->libFunDeriv == 0) { sollyaPrintf("(function("); printThing(tree->child2); sollyaPrintf("))("); printTree(tree->child1); sollyaPrintf(")"); } else { sollyaPrintf("("); for (i=1;i<=tree->libFunDeriv;i++) { sollyaPrintf("diff("); } sollyaPrintf("function("); printThing(tree->child2); sollyaPrintf(")"); for (i=1;i<=tree->libFunDeriv;i++) { sollyaPrintf(")"); } sollyaPrintf(")("); printTree(tree->child1); sollyaPrintf(")"); } } } break; case CEIL: sollyaPrintf("ceil("); printTree(tree->child1); sollyaPrintf(")"); break; case FLOOR: sollyaPrintf("floor("); printTree(tree->child1); sollyaPrintf(")"); break; case NEARESTINT: sollyaPrintf("nearestint("); printTree(tree->child1); sollyaPrintf(")"); break; case PI_CONST: sollyaPrintf("pi"); break; case LIBRARYCONSTANT: sollyaPrintf("%s",tree->libFun->functionName); break; default: sollyaFprintf(stderr,"Error: printTree: unknown identifier in the tree\n"); exit(1); } return; } char *sprintTree(node *tree) { int pred, i; char *buffer, *buffer1, *buffer2, *finalBuffer, *tempBuf; if (tree->nodeType == MEMREF) { return sprintTree(getMemRefChild(tree)); } buffer1 = NULL; buffer2 = NULL; if (fullParentheses) pred = 100; else pred = precedence(tree); switch (tree->nodeType) { case VARIABLE: if (variablename == NULL) { buffer = (char *) safeCalloc(4,sizeof(char)); sprintf(buffer,"_x_"); } else { buffer = (char *) safeCalloc(strlen(variablename)+1,sizeof(char)); sprintf(buffer,"%s",variablename); } break; case CONSTANT: buffer = sprintValue(tree->value); break; case ADD: buffer1 = sprintTree(tree->child1); buffer2 = sprintTree(tree->child2); buffer = (char *) safeCalloc(strlen(buffer1) + strlen(buffer2) + 9, sizeof(char)); tempBuf = buffer; if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) tempBuf += sprintf(tempBuf,"("); tempBuf += sprintf(tempBuf,"%s",buffer1); if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) tempBuf += sprintf(tempBuf,")"); tempBuf += sprintf(tempBuf," + "); if (isInfix(tree->child2) && (precedence(tree->child2) < pred)) tempBuf += sprintf(tempBuf,"("); tempBuf += sprintf(tempBuf,"%s",buffer2); if (isInfix(tree->child2) && (precedence(tree->child2) < pred)) tempBuf += sprintf(tempBuf,")"); break; case SUB: buffer1 = sprintTree(tree->child1); buffer2 = sprintTree(tree->child2); buffer = (char *) safeCalloc(strlen(buffer1) + strlen(buffer2) + 9, sizeof(char)); tempBuf = buffer; if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) tempBuf += sprintf(tempBuf,"("); tempBuf += sprintf(tempBuf,"%s",buffer1); if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) tempBuf += sprintf(tempBuf,")"); tempBuf += sprintf(tempBuf," - "); if (isInfix(tree->child2) && (precedence(tree->child2) <= pred)) tempBuf += sprintf(tempBuf,"("); tempBuf += sprintf(tempBuf,"%s",buffer2); if (isInfix(tree->child2) && (precedence(tree->child2) <= pred)) tempBuf += sprintf(tempBuf,")"); break; case MUL: buffer1 = sprintTree(tree->child1); buffer2 = sprintTree(tree->child2); buffer = (char *) safeCalloc(strlen(buffer1) + strlen(buffer2) + 9, sizeof(char)); tempBuf = buffer; if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) tempBuf += sprintf(tempBuf,"("); tempBuf += sprintf(tempBuf,"%s",buffer1); if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) tempBuf += sprintf(tempBuf,")"); tempBuf += sprintf(tempBuf," * "); if (isInfix(tree->child2) && (precedence(tree->child2) < pred)) tempBuf += sprintf(tempBuf,"("); tempBuf += sprintf(tempBuf,"%s",buffer2); if (isInfix(tree->child2) && (precedence(tree->child2) < pred)) tempBuf += sprintf(tempBuf,")"); break; case DIV: buffer1 = sprintTree(tree->child1); buffer2 = sprintTree(tree->child2); buffer = (char *) safeCalloc(strlen(buffer1) + strlen(buffer2) + 9, sizeof(char)); tempBuf = buffer; if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) tempBuf += sprintf(tempBuf,"("); tempBuf += sprintf(tempBuf,"%s",buffer1); if (isInfix(tree->child1) && (precedence(tree->child1) < pred) && (accessThruMemRef(tree->child1)->nodeType != CONSTANT)) tempBuf += sprintf(tempBuf,")"); tempBuf += sprintf(tempBuf," / "); if (isInfix(tree->child2) && (precedence(tree->child2) <= pred)) tempBuf += sprintf(tempBuf,"("); tempBuf += sprintf(tempBuf,"%s",buffer2); if (isInfix(tree->child2) && (precedence(tree->child2) <= pred)) tempBuf += sprintf(tempBuf,")"); break; case SQRT: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"sqrt(%s)",buffer1); break; case EXP: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"exp(%s)",buffer1); break; case LOG: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"log(%s)",buffer1); break; case LOG_2: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"log2(%s)",buffer1); break; case LOG_10: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 9, sizeof(char)); sprintf(buffer,"log10(%s)",buffer1); break; case SIN: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"sin(%s)",buffer1); break; case COS: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"cos(%s)",buffer1); break; case TAN: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"tan(%s)",buffer1); break; case ASIN: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"asin(%s)",buffer1); break; case ACOS: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"acos(%s)",buffer1); break; case ATAN: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"atan(%s)",buffer1); break; case SINH: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"sinh(%s)",buffer1); break; case COSH: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"cosh(%s)",buffer1); break; case TANH: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"tanh(%s)",buffer1); break; case ASINH: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 9, sizeof(char)); sprintf(buffer,"asinh(%s)",buffer1); break; case ACOSH: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 9, sizeof(char)); sprintf(buffer,"acosh(%s)",buffer1); break; case ATANH: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 9, sizeof(char)); sprintf(buffer,"atanh(%s)",buffer1); break; case POW: buffer1 = sprintTree(tree->child1); buffer2 = sprintTree(tree->child2); buffer = (char *) safeCalloc(strlen(buffer1) + strlen(buffer2) + 9, sizeof(char)); tempBuf = buffer; if (isInfix(tree->child1) && (precedence(tree->child1) <= pred)) tempBuf += sprintf(tempBuf,"("); tempBuf += sprintf(tempBuf,"%s",buffer1); if (isInfix(tree->child1) && (precedence(tree->child1) <= pred)) tempBuf += sprintf(tempBuf,")"); tempBuf += sprintf(tempBuf,"^"); if (isInfix(tree->child2) && ((precedence(tree->child2) <= pred) || ((accessThruMemRef(tree->child2)->nodeType == CONSTANT) && ((dyadic == 2) || (dyadic == 3))))) tempBuf += sprintf(tempBuf,"("); tempBuf += sprintf(tempBuf,"%s",buffer2); if (isInfix(tree->child2) && ((precedence(tree->child2) <= pred) || ((accessThruMemRef(tree->child2)->nodeType == CONSTANT) && ((dyadic == 2) || (dyadic == 3))))) tempBuf += sprintf(tempBuf,")"); break; case NEG: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 4, sizeof(char)); if (isInfix(tree->child1)) sprintf(buffer,"-(%s)",buffer1); else sprintf(buffer,"-%s",buffer1); break; case ABS: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"abs(%s)",buffer1); break; case DOUBLE: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 10, sizeof(char)); sprintf(buffer,"double(%s)",buffer1); break; case SINGLE: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 10, sizeof(char)); sprintf(buffer,"single(%s)",buffer1); break; case HALFPRECISION: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 17, sizeof(char)); sprintf(buffer,"halfprecision(%s)",buffer1); break; case QUAD: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"quad(%s)",buffer1); break; case DOUBLEDOUBLE: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 16, sizeof(char)); sprintf(buffer,"doubledouble(%s)",buffer1); break; case TRIPLEDOUBLE: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 16, sizeof(char)); sprintf(buffer,"tripledouble(%s)",buffer1); break; case ERF: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"erf(%s)",buffer1); break; case ERFC: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"erfc(%s)",buffer1); break; case LOG_1P: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 9, sizeof(char)); sprintf(buffer,"log1p(%s)",buffer1); break; case EXP_M1: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 9, sizeof(char)); sprintf(buffer,"expm1(%s)",buffer1); break; case DOUBLEEXTENDED: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 19, sizeof(char)); sprintf(buffer,"doubleextended(%s)",buffer1); break; case LIBRARYFUNCTION: { buffer1 = sprintTree(tree->child1); if (accessThruMemRef(tree->child1)->nodeType == VARIABLE) { buffer = (char *) safeCalloc(strlen(tree->libFun->functionName) + 6 * tree->libFunDeriv + 1, sizeof(char)); tempBuf = buffer; for (i=1;i<=tree->libFunDeriv;i++) { tempBuf += sprintf(tempBuf,"diff("); } tempBuf += sprintf(tempBuf,"%s",tree->libFun->functionName); for (i=1;i<=tree->libFunDeriv;i++) { tempBuf += sprintf(tempBuf,")"); } } else { if (tree->libFunDeriv == 0) { buffer = (char *) safeCalloc(strlen(tree->libFun->functionName) + strlen(buffer1) + 2 + 1, sizeof(char)); tempBuf = buffer; tempBuf += sprintf(tempBuf,"%s(",tree->libFun->functionName); tempBuf += sprintf(tempBuf,"%s",buffer1); tempBuf += sprintf(tempBuf,")"); } else { buffer = (char *) safeCalloc(strlen(tree->libFun->functionName) + strlen(buffer1) + 6 * tree->libFunDeriv + 4 + 1, sizeof(char)); tempBuf = buffer; tempBuf += sprintf(tempBuf,"("); for (i=1;i<=tree->libFunDeriv;i++) { tempBuf += sprintf(tempBuf,"diff("); } tempBuf += sprintf(tempBuf,"%s",tree->libFun->functionName); for (i=1;i<=tree->libFunDeriv;i++) { tempBuf += sprintf(tempBuf,")"); } tempBuf += sprintf(tempBuf,")("); tempBuf += sprintf(tempBuf,"%s",buffer1); tempBuf += sprintf(tempBuf,")"); } } } break; case PROCEDUREFUNCTION: { buffer1 = sprintTree(tree->child1); buffer2 = sPrintThing(tree->child2); if (accessThruMemRef(tree->child1)->nodeType == VARIABLE) { buffer = (char *) safeCalloc(strlen(buffer2) + 6 * tree->libFunDeriv + 10 + 1, sizeof(char)); tempBuf = buffer; for (i=1;i<=tree->libFunDeriv;i++) { tempBuf += sprintf(tempBuf,"diff("); } tempBuf += sprintf(tempBuf,"function("); tempBuf += sprintf(tempBuf,"%s",buffer2); tempBuf += sprintf(tempBuf,")"); for (i=1;i<=tree->libFunDeriv;i++) { tempBuf += sprintf(tempBuf,")"); } } else { if (tree->libFunDeriv == 0) { buffer = (char *) safeCalloc(strlen(buffer1) + strlen(buffer2) + 14 + 1, sizeof(char)); tempBuf = buffer; tempBuf += sprintf(tempBuf,"(function("); tempBuf += sprintf(tempBuf,"%s",buffer2); tempBuf += sprintf(tempBuf,"))("); tempBuf += sprintf(tempBuf,"%s",buffer1); tempBuf += sprintf(tempBuf,")"); } else { buffer = (char *) safeCalloc(strlen(buffer1) + strlen(buffer2) + 6 * tree->libFunDeriv + 14 + 1, sizeof(char)); tempBuf = buffer; tempBuf += sprintf(tempBuf,"("); for (i=1;i<=tree->libFunDeriv;i++) { tempBuf += sprintf(tempBuf,"diff("); } tempBuf += sprintf(tempBuf,"function("); tempBuf += sprintf(tempBuf,"%s",buffer2); tempBuf += sprintf(tempBuf,")"); for (i=1;i<=tree->libFunDeriv;i++) { tempBuf += sprintf(tempBuf,")"); } tempBuf += sprintf(tempBuf,")("); tempBuf += sprintf(tempBuf,"%s",buffer1); tempBuf += sprintf(tempBuf,")"); } } } break; case CEIL: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 8, sizeof(char)); sprintf(buffer,"ceil(%s)",buffer1); break; case FLOOR: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 9, sizeof(char)); sprintf(buffer,"floor(%s)",buffer1); break; case NEARESTINT: buffer1 = sprintTree(tree->child1); buffer = (char *) safeCalloc(strlen(buffer1) + 14, sizeof(char)); sprintf(buffer,"nearestint(%s)",buffer1); break; case PI_CONST: buffer = (char *) safeCalloc(3, sizeof(char)); sprintf(buffer,"pi"); break; case LIBRARYCONSTANT: buffer = (char *) safeCalloc(strlen(tree->libFun->functionName) + 1,sizeof(char)); sprintf(buffer,"%s", tree->libFun->functionName); break; default: sollyaFprintf(stderr,"Error: sprintTree: unknown identifier in the tree\n"); exit(1); } finalBuffer = (char *) safeCalloc(strlen(buffer)+1,sizeof(char)); sprintf(finalBuffer,"%s",buffer); safeFree(buffer); if (buffer1 != NULL) safeFree(buffer1); if (buffer2 != NULL) safeFree(buffer2); return finalBuffer; } void fprintTree(FILE *fd, node *tree) { int i; if (tree == NULL) return; switch (tree->nodeType) { case MEMREF: fprintTree(fd, getMemRefChild(tree)); break; case VARIABLE: if (variablename == NULL) { sollyaFprintf(fd,"_x_"); } else { sollyaFprintf(fd,"%s",variablename); } break; case CONSTANT: fprintValue(fd,*(tree->value)); break; case ADD: if (isInfix(tree->child1)) sollyaFprintf(fd,"("); fprintTree(fd,tree->child1); if (isInfix(tree->child1)) sollyaFprintf(fd,")"); sollyaFprintf(fd," + "); if (isInfix(tree->child2)) sollyaFprintf(fd,"("); fprintTree(fd,tree->child2); if (isInfix(tree->child2)) sollyaFprintf(fd,")"); break; case SUB: if (isInfix(tree->child1)) sollyaFprintf(fd,"("); fprintTree(fd,tree->child1); if (isInfix(tree->child1)) sollyaFprintf(fd,")"); sollyaFprintf(fd," - "); if (isInfix(tree->child2)) sollyaFprintf(fd,"("); fprintTree(fd,tree->child2); if (isInfix(tree->child2)) sollyaFprintf(fd,")"); break; case MUL: if (isInfix(tree->child1)) sollyaFprintf(fd,"("); fprintTree(fd,tree->child1); if (isInfix(tree->child1)) sollyaFprintf(fd,")"); sollyaFprintf(fd," * "); if (isInfix(tree->child2)) sollyaFprintf(fd,"("); fprintTree(fd,tree->child2); if (isInfix(tree->child2)) sollyaFprintf(fd,")"); break; case DIV: if (isInfix(tree->child1)) sollyaFprintf(fd,"("); fprintTree(fd,tree->child1); if (isInfix(tree->child1)) sollyaFprintf(fd,")"); sollyaFprintf(fd," / "); if (isInfix(tree->child2)) sollyaFprintf(fd,"("); fprintTree(fd,tree->child2); if (isInfix(tree->child2)) sollyaFprintf(fd,")"); break; case SQRT: sollyaFprintf(fd,"sqrt("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case EXP: sollyaFprintf(fd,"exp("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case LOG: sollyaFprintf(fd,"log("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case LOG_2: sollyaFprintf(fd,"log2("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case LOG_10: sollyaFprintf(fd,"log10("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case SIN: sollyaFprintf(fd,"sin("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case COS: sollyaFprintf(fd,"cos("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case TAN: sollyaFprintf(fd,"tan("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case ASIN: sollyaFprintf(fd,"asin("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case ACOS: sollyaFprintf(fd,"acos("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case ATAN: sollyaFprintf(fd,"atan("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case SINH: sollyaFprintf(fd,"sinh("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case COSH: sollyaFprintf(fd,"cosh("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case TANH: sollyaFprintf(fd,"tanh("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case ASINH: sollyaFprintf(fd,"asinh("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case ACOSH: sollyaFprintf(fd,"acosh("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case ATANH: sollyaFprintf(fd,"atanh("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case POW: if (isInfix(tree->child1)) sollyaFprintf(fd,"("); fprintTree(fd,tree->child1); if (isInfix(tree->child1)) sollyaFprintf(fd,")"); sollyaFprintf(fd,"^("); fprintTree(fd,tree->child2); sollyaFprintf(fd,")"); break; case NEG: sollyaFprintf(fd,"-"); if (isInfix(tree->child1)) sollyaFprintf(fd,"("); fprintTree(fd,tree->child1); if (isInfix(tree->child1)) sollyaFprintf(fd,")"); break; case ABS: sollyaFprintf(fd,"abs("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case DOUBLE: sollyaFprintf(fd,"double("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case SINGLE: sollyaFprintf(fd,"single("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case QUAD: sollyaFprintf(fd,"quad("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case HALFPRECISION: sollyaFprintf(fd,"halfprecision("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case DOUBLEDOUBLE: sollyaFprintf(fd,"doubledouble("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case TRIPLEDOUBLE: sollyaFprintf(fd,"tripledouble("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case ERF: sollyaFprintf(fd,"erf("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case ERFC: sollyaFprintf(fd,"erfc("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case LOG_1P: sollyaFprintf(fd,"log1p("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case EXP_M1: sollyaFprintf(fd,"expm1("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case DOUBLEEXTENDED: sollyaFprintf(fd,"doubleextended("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case LIBRARYFUNCTION: { if (accessThruMemRef(tree->child1)->nodeType == VARIABLE) { for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,"diff("); } sollyaFprintf(fd,"%s",tree->libFun->functionName); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,")"); } } else { if (tree->libFunDeriv == 0) { sollyaFprintf(fd,"%s(",tree->libFun->functionName); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); } else { sollyaFprintf(fd,"("); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,"diff("); } sollyaFprintf(fd,"%s",tree->libFun->functionName); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,")"); } sollyaFprintf(fd,")("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); } } } break; case PROCEDUREFUNCTION: { if (accessThruMemRef(tree->child1)->nodeType == VARIABLE) { for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,"diff("); } sollyaFprintf(fd,"function("); fPrintThing(fd,tree->child2); sollyaFprintf(fd,")"); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,")"); } } else { if (tree->libFunDeriv == 0) { sollyaFprintf(fd,"(function("); fPrintThing(fd,tree->child2); sollyaFprintf(fd,"))("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); } else { sollyaFprintf(fd,"("); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,"diff("); } sollyaFprintf(fd,"function("); fPrintThing(fd,tree->child2); sollyaFprintf(fd,")"); for (i=1;i<=tree->libFunDeriv;i++) { sollyaFprintf(fd,")"); } sollyaFprintf(fd,")("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); } } } break; case CEIL: sollyaFprintf(fd,"ceil("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case FLOOR: sollyaFprintf(fd,"floor("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case NEARESTINT: sollyaFprintf(fd,"nearestint("); fprintTree(fd,tree->child1); sollyaFprintf(fd,")"); break; case PI_CONST: sollyaFprintf(fd,"pi"); break; case LIBRARYCONSTANT: sollyaFprintf(fd,"%s",tree->libFun->functionName); break; default: sollyaFprintf(stderr,"Error: fprintTree: unknown identifier in the tree\n"); exit(1); } return; } node* copyTreeInner(node *tree); node* copyTree(node *tree) { return addMemRef(copyTreeInner(tree)); } node* copyTreeInner(node *tree) { node *copy; mpfr_t *value; mp_prec_t prec, p; mpfr_t temp; if (tree == NULL) return tree; if (tree->nodeType == MEMREF) { tree->libFunDeriv++; return tree; } switch (tree->nodeType) { case VARIABLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = VARIABLE; break; case CONSTANT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); prec = tools_precision; p = mpfr_get_prec(*(tree->value)); if (p > prec) prec = p; mpfr_init2(temp,prec); simplifyMpfrPrec(temp,*(tree->value)); mpfr_init2(*value,mpfr_get_prec(temp)); mpfr_set(*value,temp,GMP_RNDN); mpfr_clear(temp); copy->value = value; break; case ADD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ADD; copy->child1 = copyTreeInner(tree->child1); copy->child2 = copyTreeInner(tree->child2); break; case SUB: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SUB; copy->child1 = copyTreeInner(tree->child1); copy->child2 = copyTreeInner(tree->child2); break; case MUL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = copyTreeInner(tree->child1); copy->child2 = copyTreeInner(tree->child2); break; case DIV: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DIV; copy->child1 = copyTreeInner(tree->child1); copy->child2 = copyTreeInner(tree->child2); break; case SQRT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SQRT; copy->child1 = copyTreeInner(tree->child1); break; case EXP: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = EXP; copy->child1 = copyTreeInner(tree->child1); break; case LOG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG; copy->child1 = copyTreeInner(tree->child1); break; case LOG_2: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_2; copy->child1 = copyTreeInner(tree->child1); break; case LOG_10: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_10; copy->child1 = copyTreeInner(tree->child1); break; case SIN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SIN; copy->child1 = copyTreeInner(tree->child1); break; case COS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = COS; copy->child1 = copyTreeInner(tree->child1); break; case TAN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TAN; copy->child1 = copyTreeInner(tree->child1); break; case ASIN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ASIN; copy->child1 = copyTreeInner(tree->child1); break; case ACOS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ACOS; copy->child1 = copyTreeInner(tree->child1); break; case ATAN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ATAN; copy->child1 = copyTreeInner(tree->child1); break; case SINH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SINH; copy->child1 = copyTreeInner(tree->child1); break; case COSH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = COSH; copy->child1 = copyTreeInner(tree->child1); break; case TANH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TANH; copy->child1 = copyTreeInner(tree->child1); break; case ASINH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ASINH; copy->child1 = copyTreeInner(tree->child1); break; case ACOSH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ACOSH; copy->child1 = copyTreeInner(tree->child1); break; case ATANH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ATANH; copy->child1 = copyTreeInner(tree->child1); break; case POW: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = POW; copy->child1 = copyTreeInner(tree->child1); copy->child2 = copyTreeInner(tree->child2); break; case NEG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEG; copy->child1 = copyTreeInner(tree->child1); break; case ABS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ABS; copy->child1 = copyTreeInner(tree->child1); break; case DOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLE; copy->child1 = copyTreeInner(tree->child1); break; case SINGLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SINGLE; copy->child1 = copyTreeInner(tree->child1); break; case QUAD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = QUAD; copy->child1 = copyTreeInner(tree->child1); break; case HALFPRECISION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = HALFPRECISION; copy->child1 = copyTreeInner(tree->child1); break; case DOUBLEDOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLEDOUBLE; copy->child1 = copyTreeInner(tree->child1); break; case TRIPLEDOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TRIPLEDOUBLE; copy->child1 = copyTreeInner(tree->child1); break; case ERF: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ERF; copy->child1 = copyTreeInner(tree->child1); break; case ERFC: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ERFC; copy->child1 = copyTreeInner(tree->child1); break; case LOG_1P: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_1P; copy->child1 = copyTreeInner(tree->child1); break; case EXP_M1: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = EXP_M1; copy->child1 = copyTreeInner(tree->child1); break; case DOUBLEEXTENDED: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLEEXTENDED; copy->child1 = copyTreeInner(tree->child1); break; case LIBRARYFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYFUNCTION; copy->libFun = tree->libFun; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = copyTreeInner(tree->child1); break; case PROCEDUREFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PROCEDUREFUNCTION; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = copyTreeInner(tree->child1); copy->child2 = copyThing(tree->child2); break; case CEIL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CEIL; copy->child1 = copyTreeInner(tree->child1); break; case FLOOR: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = FLOOR; copy->child1 = copyTreeInner(tree->child1); break; case NEARESTINT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEARESTINT; copy->child1 = copyTreeInner(tree->child1); break; case PI_CONST: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PI_CONST; break; case LIBRARYCONSTANT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYCONSTANT; copy->libFun = tree->libFun; break; default: sollyaFprintf(stderr,"Error: copyTreeInner: unknown identifier (%d) in the tree\n", tree->nodeType); exit(1); } return copy; } int mpfr_to_mpq( mpq_t y, mpfr_t x){ mpz_t mant; mp_exp_t expo; mpq_t aux; if (mpfr_number_p(x)) { mpz_init(mant); expo = mpfr_get_z_exp(mant,x); mpq_init(aux); mpq_set_z(aux,mant); if (expo>=0) mpq_mul_2exp(y,aux,(unsigned int)expo); else mpq_div_2exp(y,aux,(unsigned int)(-expo)); mpq_clear(aux); mpz_clear(mant); return 1; } else return 0; } mp_prec_t getMpzPrecision(mpz_t x) { mp_prec_t prec; int p, dyadicValue; if (mpz_cmp_si(x, 0) == 0) { prec = 12; } else { prec = mpz_sizeinbase(x, 2); dyadicValue = mpz_scan1(x, 0); p = prec - dyadicValue; if (p < 12) prec = 12; else prec = p; } return prec; } int mpfr_to_mpz( mpz_t y, mpfr_t x){ mpz_t aux; mp_exp_t expo; int negative; mpfr_t t; mpfr_init2(t, mpfr_get_prec(x)); mpfr_floor(t, x); /* No double rounding as precision the same */ if (mpfr_number_p(t)) { negative = 0; if (mpfr_sgn(t) < 0) { negative = 1; mpfr_neg(t, t, GMP_RNDN); /* exact */ } mpz_init(aux); expo = mpfr_get_z_exp(aux,t); if (expo>=0) mpz_mul_2exp(y,aux,(unsigned int)expo); else mpz_div_2exp(y,aux,(unsigned int)(-expo)); if (negative) { mpz_neg(y, y); } mpz_clear(aux); mpfr_clear(t); return 1; } else { mpfr_clear(t); return 0; } } int tryEvaluateConstantTermToMpq(mpq_t res, node *tree) { mpq_t resA, resB, resC; int result; mpz_t num, denom; mpz_t num2, denom2; signed long int expo; size_t num2size, denom2size; if (tree == NULL) return 0; if (tree->nodeType == MEMREF) { return tryEvaluateConstantTermToMpq(res, getMemRefChild(tree)); } mpq_init(resA); mpq_init(resB); mpq_init(resC); result = 1; switch (tree->nodeType) { case CONSTANT: if (mpfr_number_p(*(tree->value))) { mpfr_to_mpq(resC,*(tree->value)); } else result = 0; break; case ADD: if (tryEvaluateConstantTermToMpq(resA, tree->child1) && tryEvaluateConstantTermToMpq(resB, tree->child2)) { mpq_add(resC,resA,resB); } else result = 0; break; case SUB: if (tryEvaluateConstantTermToMpq(resA, tree->child1) && tryEvaluateConstantTermToMpq(resB, tree->child2)) { mpq_sub(resC,resA,resB); } else result = 0; break; case MUL: if (tryEvaluateConstantTermToMpq(resA, tree->child1) && tryEvaluateConstantTermToMpq(resB, tree->child2)) { mpq_mul(resC,resA,resB); } else result = 0; break; case DIV: if (tryEvaluateConstantTermToMpq(resA, tree->child1) && tryEvaluateConstantTermToMpq(resB, tree->child2) && (mpq_sgn(resB) != 0)) { mpq_div(resC,resA,resB); } else result = 0; break; case SQRT: if (tryEvaluateConstantTermToMpq(resA, tree->child1)) { if (mpq_sgn(resA) >= 0) { mpz_init(num); mpz_init(denom); mpq_get_num(num,resA); mpq_get_den(denom,resA); if (mpz_root(num,num,2) && mpz_root(denom,denom,2)) { mpq_set_num(resC,num); mpq_set_den(resC,denom); mpq_canonicalize(resC); } else { result = 0; } mpz_clear(num); mpz_clear(denom); } else result = 0; } else result = 0; break; case POW: if (tryEvaluateConstantTermToMpq(resA, tree->child1) && tryEvaluateConstantTermToMpq(resB, tree->child2)) { mpz_init(num); mpz_init(denom); mpq_get_num(num,resB); mpq_get_den(denom,resB); if (mpz_cmp_ui(denom,1) == 0) { /* Must set resC to resA^num */ mpz_init(num2); mpz_init(denom2); if (mpz_sgn(num) < 0) { mpq_get_num(denom2,resA); mpq_get_den(num2,resA); mpz_neg(num,num); } else { mpq_get_num(num2,resA); mpq_get_den(denom2,resA); } /* Must set resC to (num2^num)/(denom2^num), num is positive */ if ((mpz_sgn(denom2) != 0) && mpz_fits_slong_p(num)) { expo = mpz_get_si(num); /* Must set resC to (num2^expo)/(denom2^expo), expo is positive */ num2size = mpz_sizeinbase(num2, 2); denom2size = mpz_sizeinbase(denom2, 2); if ((((((unsigned long long int) num2size) + 1ull) * ((unsigned long long int) expo)) < ((unsigned long long int) (INT_MAX >> 1))) && (((((unsigned long long int) denom2size) + 1ull) * ((unsigned long long int) expo)) < ((unsigned long long int) (INT_MAX >> 1)))) { mpz_pow_ui(num2, num2, (unsigned long int) expo); mpz_pow_ui(denom2, denom2, (unsigned long int) expo); mpq_set_num(resC,num2); mpq_set_den(resC,denom2); mpq_canonicalize(resC); } else result = 0; } else result = 0; mpz_clear(num2); mpz_clear(denom2); } else result = 0; mpz_clear(num); mpz_clear(denom); } else result = 0; break; case NEG: if (tryEvaluateConstantTermToMpq(resA, tree->child1)) { mpq_neg(resC,resA); } else result = 0; break; default: result = 0; } if (result) mpq_set(res,resC); mpq_clear(resA); mpq_clear(resB); mpq_clear(resC); return result; } node *dividePolynomialByPowerOfVariableUnsafe(node *tree, int alpha); int containsNotANumbers(node * tree) { int numberChilds; if (tree->nodeType == MEMREF) { return containsNotANumbers(getMemRefChild(tree)); } if (tree->nodeType == CONSTANT) { if (mpfr_nan_p(*(tree->value))) return 1; else return 0; } if (tree->nodeType == VARIABLE) { return 0; } numberChilds = arity(tree); switch (numberChilds) { case 0: return 0; break; case 1: return containsNotANumbers(tree->child1); break; case 2: return (containsNotANumbers(tree->child1) || containsNotANumbers(tree->child2)); break; default: sollyaFprintf(stderr,"Error: containsNotANumbers: unknown arity of tree node symbol.\n"); exit(1); } return 1; } int containsOnlyRealNumbers(node * tree) { int numberChilds; if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) return 1; return containsOnlyRealNumbers(getMemRefChild(tree)); } if (tree->nodeType == CONSTANT) { if (mpfr_number_p(*(tree->value))) return 1; else return 0; } if (tree->nodeType == VARIABLE) { return 1; } numberChilds = arity(tree); switch (numberChilds) { case 0: return 1; break; case 1: return containsOnlyRealNumbers(tree->child1); break; case 2: return (containsOnlyRealNumbers(tree->child1) && containsOnlyRealNumbers(tree->child2)); break; default: sollyaFprintf(stderr,"Error: containsOnlyRealNumbers: unknown arity of tree node symbol.\n"); exit(1); } return 1; } node* simplifyTreeErrorfreeInnerst(node *tree, int rec, int doRational); node* simplifyTreeErrorfreeInnerNoHookHandling(node *tree, int rec, int doRational) { node *res; if ((tree != NULL) && ((tree->nodeType == MEMREF) && (tree->simplifyCacheRationalMode >= doRational))) { if (tree->simplifyCacheDoesNotSimplify == 1) { return copyTree(tree); } else { if (tree->simplifyCache != NULL) { return copyTree(tree->simplifyCache); } } } res = addMemRef(simplifyTreeErrorfreeInnerst(tree, rec, doRational)); if ((tree != NULL) && (res != NULL) && (tree->nodeType == MEMREF)) { if (isSyntacticallyEqualCheap(tree,res)) { free_memory(res); res = copyTree(tree); tree->simplifyCacheDoesNotSimplify = 1; } else { if (((tree->nodeType == MEMREF) && (tree->evaluationHook != NULL)) && ((res->nodeType == MEMREF) && (res->evaluationHook == NULL))) { res->isCorrectlyTyped = tree->isCorrectlyTyped; addEvaluationHookFromCopy(&(res->evaluationHook), tree->evaluationHook); if ((res->derivCache == NULL) && (tree->derivCache != NULL)) { res->derivCache = copyTree(tree->derivCache); } } if (tree->simplifyCache == NULL) { if (res->nodeType == MEMREF) { tree->simplifyCache = copyTree(res); tree->simplifyCacheRationalMode = doRational; tree->simplifyCacheDoesNotSimplify = 0; } } else { if ((tree->simplifyCacheRationalMode >= 0) && (tree->simplifyCacheRationalMode < doRational)) { free_memory(tree->simplifyCache); tree->simplifyCache = copyTree(res); tree->simplifyCacheRationalMode = doRational; tree->simplifyCacheDoesNotSimplify = 0; } } if (res->nodeType == MEMREF) { if ((tree->derivCache != NULL) && (res->derivCache == NULL)) { res->derivCache = copyTree(tree->derivCache); } if ((tree->derivUnsimplCache != NULL) && (res->derivUnsimplCache == NULL)) { res->derivUnsimplCache = copyTree(tree->derivUnsimplCache); } } } } return res; } node* simplifyTreeErrorfreeInner(node *tree, int rec, int doRational) { node *res; res = simplifyTreeErrorfreeInnerNoHookHandling(tree, rec, doRational); if ((res != tree) && (tree->nodeType == MEMREF) && (res->nodeType == MEMREF) && treeContainsHooks(tree) && (!treeContainsHooks(res))) { res = rewriteThingWithMemRefReuse(res, tree); } if ((res != tree) && (tree->nodeType == MEMREF) && (res->nodeType == MEMREF)) { copyTreeAnnotationsNoSimplifications(res, tree); } return res; } /* Let f the function represented by the expression tree. If isNotUniformlyInfinite returns true, f is defined over all real numbers except maybe on a discrete set of points (by defined on a point x, we mean that f(x) can be given a value in R U {-Inf, +Inf}) and the set of points x where |f(x)| = +Inf is discrete. */ int isNotUniformlyInfinite(node *tree) { sollya_mpfi_t y, x; int res; mpfr_t yPt; /* If f evaluates over the whole real to a closed subset of the reals, we know that it is bounded. */ sollya_mpfi_init2(x, 64); sollya_mpfi_set_full_range(x); sollya_mpfi_init2(y, 64); evaluateInterval(y, tree, NULL, x); if (sollya_mpfi_has_infinity(y) || sollya_mpfi_has_nan(y)) { res = 0; } else { res = 1; } sollya_mpfi_clear(y); sollya_mpfi_clear(x); if (res) return 1; /* Consider the set R of rational expressions formed only from x and finite constants. An easy structural induction on R shows that if r \in R evaluates to a finite non-null real number at some point x, it is so for all points x but a finite number of them. */ if (isRationalFunction(tree) && containsOnlyRealNumbers(tree)) { sollya_mpfi_init2(x, 64); sollya_mpfi_set_d(x, 0.7403649888628021); sollya_mpfi_init2(y, 64); evaluateInterval(y, tree, NULL, x); if (sollya_mpfi_has_infinity(y) || sollya_mpfi_has_nan(y) || sollya_mpfi_has_zero(y)) { res = 0; } else { res = 1; } sollya_mpfi_clear(y); sollya_mpfi_clear(x); if (res) return res; } /* If f is of the form f = g +/- h and both g and h are bounded by a real, f is bounded by a real. */ switch (accessThruMemRef(tree)->nodeType) { case ADD: case SUB: case MUL: return (isNotUniformlyInfinite(accessThruMemRef(tree)->child1) && isNotUniformlyInfinite(accessThruMemRef(tree)->child2)); break; default: break; } /* If f is of the form f = g / h and both g and h are not uniformly infinite and h is not uniformly zero, f is bounded by a real. */ if (accessThruMemRef(tree)->nodeType == DIV) { return (isNotUniformlyInfinite(accessThruMemRef(tree)->child1) && isNotUniformlyZero(accessThruMemRef(tree)->child2)); } /* f is of the form f = g(h), g is defined on the whole real line and h is not uniformly infinite, so is f. */ switch (accessThruMemRef(tree)->nodeType) { case EXP: case SIN: case COS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ERF: case ERFC: case EXP_M1: case NEG: case ABS: return isNotUniformlyInfinite(accessThruMemRef(tree)->child1); break; default: break; } /* f is of the form f = g^h, g can be shown to be strictly positive and finite over the reals and h is not uniformly infinite, then f is not uniformly infinite. */ if (accessThruMemRef(tree)->nodeType == POW) { if (!isNotUniformlyInfinite(accessThruMemRef(tree)->child2)) return 0; sollya_mpfi_init2(x, 64); sollya_mpfi_set_full_range(x); sollya_mpfi_init2(y, 64); evaluateInterval(y, accessThruMemRef(tree)->child1, NULL, x); if (sollya_mpfi_has_infinity(y) || sollya_mpfi_has_nan(y) || sollya_mpfi_has_zero(y) || sollya_mpfi_has_negative_numbers(y)) { res = 0; } else { res = 1; } sollya_mpfi_clear(y); sollya_mpfi_clear(x); if (res) return res; } /* f is of the form f = g^k, g is not uniformly infinite and k is integer and non-zero then f is not uniformly infinite. */ if (accessThruMemRef(tree)->nodeType == POW) { if (!isNotUniformlyInfinite(accessThruMemRef(tree)->child1)) return 0; if (accessThruMemRef(accessThruMemRef(tree)->child2)->nodeType == CONSTANT) return (mpfr_integer_p(*(accessThruMemRef(accessThruMemRef(tree)->child2)->value)) && (mpfr_sgn(*(accessThruMemRef(accessThruMemRef(tree)->child2)->value)) >= 0)); if (!isConstant(accessThruMemRef(tree)->child2)) return 0; sollya_mpfi_init2(y, 64); evaluateConstantExpressionToInterval(y, accessThruMemRef(tree)->child2); if (sollya_mpfi_is_point_and_real(y)) { mpfr_init2(yPt, sollya_mpfi_get_prec(y)); sollya_mpfi_get_left(yPt, y); /* exact */ res = (mpfr_integer_p(yPt) && (mpfr_sgn(yPt) >= 0)); mpfr_clear(yPt); } else { res = 0; } sollya_mpfi_clear(y); return res; } /* For all other expressions, we cannot exclude that might evaluate to infinity. */ return 0; } /* Let f the function represented by the expression tree. If isNotUniformlyZero returns true, f is defined over all real numbers except maybe on a discrete set of points (in particular, f is not identically equal to NaN) and the set of its zeros is discrete. */ int isNotUniformlyZero(node *tree) { sollya_mpfi_t y, x; int res; mpfr_t yPt; /* If f evaluates over the whole real to a closed subset of the real not containing zero, we know that it is not uniformly zero. */ sollya_mpfi_init2(x, 64); sollya_mpfi_set_full_range(x); sollya_mpfi_init2(y, 64); evaluateInterval(y, tree, NULL, x); if (sollya_mpfi_has_nan(y) || sollya_mpfi_has_zero(y)) { res = 0; } else { res = 1; } sollya_mpfi_clear(y); sollya_mpfi_clear(x); if (res) return 1; /* Consider the set R of rational expressions formed only from x and finite constants. An easy structural induction on R shows that if r \in R evaluates to a finite non-null real number at some point x, it is so for all points x but a finite number of them. */ if (isRationalFunction(tree) && containsOnlyRealNumbers(tree)) { sollya_mpfi_init2(x, 64); sollya_mpfi_set_d(x, 0.7403649888628021); sollya_mpfi_init2(y, 64); evaluateInterval(y, tree, NULL, x); if (sollya_mpfi_has_infinity(y) || sollya_mpfi_has_nan(y) || sollya_mpfi_has_zero(y)) { res = 0; } else { res = 1; } sollya_mpfi_clear(y); sollya_mpfi_clear(x); return res; } /* If f is of the form f = g * h and both g and h are not uniformly zero, f is not uniformly zero. */ if (accessThruMemRef(tree)->nodeType == MUL) { return (isNotUniformlyZero(accessThruMemRef(tree)->child1) && isNotUniformlyZero(accessThruMemRef(tree)->child2)); } /* If f is of the form f = g / h, g is not uniformly zero and h stays bounded by a real number and is not uniformly zero, then f is not uniformly zero. */ if (accessThruMemRef(tree)->nodeType == DIV) { return (isNotUniformlyZero(accessThruMemRef(tree)->child1) && isNotUniformlyZero(accessThruMemRef(tree)->child2) && isNotUniformlyInfinite(accessThruMemRef(tree)->child2)); } /* f is of the form f = g(h), g is defined on the whole real line and has no zero over the reals or only has a zero at zero and h stays both bounded by a real and is not uniformly zero over any interval that is not reduced to a point, then f is not uniformly zero over any interval that is not reduced to a point. */ switch (accessThruMemRef(tree)->nodeType) { case EXP: case ERFC: return isNotUniformlyInfinite(accessThruMemRef(tree)->child1); break; case ATAN: case SINH: case COSH: case TANH: case ASINH: case ERF: case EXP_M1: case NEG: case ABS: return isNotUniformlyZero(accessThruMemRef(tree)->child1); break; default: break; } /* f is of the form f = g^h, g can be shown to be strictly positive over the reals and h stays both bounded by a real, then f is not uniformly zero over any interval that is not reduced to a point. */ if (accessThruMemRef(tree)->nodeType == POW) { if (!isNotUniformlyInfinite(accessThruMemRef(tree)->child2)) return 0; sollya_mpfi_init2(x, 64); sollya_mpfi_set_full_range(x); sollya_mpfi_init2(y, 64); evaluateInterval(y, accessThruMemRef(tree)->child1, NULL, x); if (sollya_mpfi_has_infinity(y) || sollya_mpfi_has_nan(y) || sollya_mpfi_has_zero(y) || sollya_mpfi_has_negative_numbers(y)) { res = 0; } else { res = 1; } sollya_mpfi_clear(y); sollya_mpfi_clear(x); if (res) return res; } /* f is of the form f = g^k, g is not uniformly zero over any interval and k is integer and non-zero then f is not uniformly zero over any interval that is not reduced to a point. */ if (accessThruMemRef(tree)->nodeType == POW) { if (!isNotUniformlyZero(accessThruMemRef(tree)->child1)) return 0; if (accessThruMemRef(accessThruMemRef(tree)->child2)->nodeType == CONSTANT) return (mpfr_integer_p(*(accessThruMemRef(accessThruMemRef(tree)->child2)->value)) && (mpfr_sgn(*(accessThruMemRef(accessThruMemRef(tree)->child2)->value)) >= 0)); if (!isConstant(accessThruMemRef(tree)->child2)) return 0; sollya_mpfi_init2(y, 64); evaluateConstantExpressionToInterval(y, accessThruMemRef(tree)->child2); if (sollya_mpfi_is_point_and_real(y)) { mpfr_init2(yPt, sollya_mpfi_get_prec(y)); sollya_mpfi_get_left(yPt, y); /* exact */ res = (mpfr_integer_p(yPt) && (mpfr_sgn(yPt) >= 0)); mpfr_clear(yPt); } else { res = 0; } sollya_mpfi_clear(y); return res; } /* For all other expressions, we cannot exclude that they are not uniformly zero on any interval subset of the reals that is not reduced to a point. */ return 0; } /* Let f the function represented by the expression tree. If canDoSimplificationSubtraction returns true, f-f is defined over all real numbers except maybe on a discrete set of points (in particular, f is not identically equal to NaN) and has value zero on all points where it is defined. */ int canDoSimplificationSubtraction(node *tree) { return isNotUniformlyInfinite(tree); } /* Let f the function represented by the expression tree. If canDoSimplificationDivision returns true, f/f is defined over all real numbers except maybe on a discrete set of points (in particular, f is not identically equal to NaN) and has value one on all points where it is defined. */ int canDoSimplificationDivision(node *tree) { return (isNotUniformlyInfinite(tree) && isNotUniformlyZero(tree)); } int isIntegerConstant(node *tree) { mpq_t q; int s; if (tree == NULL) return 0; if (!isConstant(tree)) return 0; if (accessThruMemRef(tree)->nodeType == CONSTANT) { return (mpfr_number_p(*(accessThruMemRef(tree)->value)) && mpfr_integer_p(*(accessThruMemRef(tree)->value))); } mpq_init(q); if (tryEvaluateConstantTermToMpq(q, tree)) { if (mpz_divisible_p(mpq_numref(q), mpq_denref(q))) { mpq_clear(q); return 1; } else { mpq_clear(q); return 0; } } mpq_clear(q); switch (tree->nodeType) { case MEMREF: return isIntegerConstant(getMemRefChild(tree)); break; case NEARESTINT: case FLOOR: case CEIL: if (isNotUniformlyInfinite(tree->child1)) { return 1; } break; case ADD: case SUB: case MUL: if (isIntegerConstant(tree->child1) && isIntegerConstant(tree->child2)) { return 1; } break; case POW: if (isIntegerConstant(tree->child1) && isIntegerConstant(tree->child2)) { if (evaluateSign(&s, tree->child2)) { return (s > 0); } } break; default: break; } return 0; } node* simplifyTreeErrorfreeInnerst(node *tree, int rec, int doRational) { node *simplChild1, *simplChild2, *simplified, *recsimplified; mpfr_t *value; mpfr_t temp; mp_prec_t prec, p, pppp; int alpha, beta; node *temp1, *temp2, *temp3, *temp4; rangetype xrange, yrange; mpq_t resMpq; mpfr_t num, denom, resDiv, resA, resB; int numberChilds; int signOkay, sign; node *res; node *kind; if (tree == NULL) return NULL; if ((tree->nodeType == MEMREF) && (tree->child1 != NULL) && (tree->polynomialRepresentation == NULL)) { kind = getMemRefChild(tree); if (accessThruMemRef(kind)->nodeType == CONSTANT) { return copyTree(tree); } } if (tree->nodeType == MEMREF) { if ((tree->arguments != NULL) && (*((mp_prec_t *) tree->arguments->value) >= 12) && sollya_mpfi_is_point_and_real(*((sollya_mpfi_t *) tree->arguments->next->value))) { mpfr_init2(temp, sollya_mpfi_get_prec(*((sollya_mpfi_t *) tree->arguments->next->value))); sollya_mpfi_get_left(temp, *((sollya_mpfi_t *) tree->arguments->next->value)); res = makeConstant(temp); mpfr_clear(temp); return addMemRef(res); } if (tree->polynomialRepresentation != NULL) { if ((tree->child1 == NULL) || tree->memRefChildFromPolynomial) return copyTree(tree); res = addMemRefEvenOnNull(NULL); if (res != NULL) { res->polynomialRepresentation = polynomialFromCopy(tree->polynomialRepresentation); copyTreeAnnotationsNoSimplifications(res, tree); return res; } } res = addMemRef(simplifyTreeErrorfreeInner(getMemRefChild(tree), rec, doRational)); copyTreeAnnotationsNoSimplifications(res, tree); return res; } if ((tree->nodeType == CONSTANT) && (mpfr_nan_p(*(tree->value)))) return copyTree(tree); if (tree->nodeType != VARIABLE) { numberChilds = arity(tree); switch (numberChilds) { case 0: break; case 1: if ((accessThruMemRef(tree->child1)->nodeType == CONSTANT) && (mpfr_nan_p(*(accessThruMemRef(tree->child1)->value)))) return copyTree(tree->child1); break; case 2: if ((accessThruMemRef(tree->child1)->nodeType == CONSTANT) && (mpfr_nan_p(*(accessThruMemRef(tree->child1)->value)))) { if (isConstant(tree)) return copyTree(tree->child1); return copyTree(tree); } if ((accessThruMemRef(tree->child2)->nodeType == CONSTANT) && (mpfr_nan_p(*(accessThruMemRef(tree->child2)->value)))) { if (isConstant(tree)) return copyTree(tree->child2); return copyTree(tree); } break; default: sollyaFprintf(stderr,"Error: simplifyTreeErrorfreeInnerst: unknown arity of tree node symbol.\n"); exit(1); } } if (doRational && isConstant(tree) && (tree->nodeType != CONSTANT)) { mpq_init(resMpq); if (tryEvaluateConstantTermToMpq(resMpq, tree)) { mpfr_init2(num,getMpzPrecision(mpq_numref(resMpq))); mpfr_init2(denom,getMpzPrecision(mpq_denref(resMpq))); mpfr_set_z(num,mpq_numref(resMpq),GMP_RNDN); /* exact */ mpfr_set_z(denom,mpq_denref(resMpq),GMP_RNDN); /* exact */ pppp = defaultprecision; if (mpfr_get_prec(num) > pppp) pppp = mpfr_get_prec(num); if (mpfr_get_prec(denom) > pppp) pppp = mpfr_get_prec(denom); mpfr_init2(resDiv,pppp); if ((mpfr_div(resDiv,num,denom,GMP_RNDN) == 0) && mpfr_number_p(resDiv)) { mpfr_init2(resA,mpfr_get_prec(resDiv)+10); mpfr_set(resA,resDiv,GMP_RNDN); /* exact */ simplifyMpfrPrec(resA, resDiv); simplified = makeConstant(resA); mpfr_clear(resA); } else { mpfr_init2(resA,mpfr_get_prec(num)+10); mpfr_set(resA,num,GMP_RNDN); /* exact */ simplifyMpfrPrec(resA, num); mpfr_init2(resB,mpfr_get_prec(denom)+10); mpfr_set(resB,denom,GMP_RNDN); /* exact */ simplifyMpfrPrec(resB, denom); simplified = makeDiv(makeConstant(resA),makeConstant(resB)); mpfr_clear(resA); mpfr_clear(resB); } mpfr_clear(num); mpfr_clear(denom); mpfr_clear(resDiv); mpq_clear(resMpq); return simplified; } mpq_clear(resMpq); } if ((tree->nodeType == DIV) && (!containsNotANumbers(tree)) && (isPolynomial(tree->child1)) && (isPolynomial(tree->child2)) && ((alpha = getMaxPowerDivider(tree->child1)) > 0) && ((beta = getMaxPowerDivider(tree->child2)) > 0)) { if (alpha == beta) { temp1 = dividePolynomialByPowerOfVariableUnsafe(tree->child1, alpha); temp2 = dividePolynomialByPowerOfVariableUnsafe(tree->child2, alpha); temp3 = (node *) safeMalloc(sizeof(node)); temp3->nodeType = DIV; temp3->child1 = temp1; temp3->child2 = temp2; temp4 = simplifyTreeErrorfreeInner(temp3,rec,doRational); free_memory(temp3); return temp4; } else { temp1 = (node *) safeMalloc(sizeof(node)); temp1->nodeType = DIV; temp1->child1 = copyTree(tree->child1); temp2 = (node *) safeMalloc(sizeof(node)); temp1->child2 = temp2; temp2->nodeType = POW; temp2->child1 = (node *) safeMalloc(sizeof(node)); temp2->child1->nodeType = VARIABLE; temp2->child2 = (node *) safeMalloc(sizeof(node)); temp2->child2->nodeType = CONSTANT; temp2->child2->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(temp2->child2->value),8 * sizeof(int) + 10); mpfr_set_si(*(temp2->child2->value),alpha,GMP_RNDN); temp3 = simplifyTreeErrorfreeInner(temp1, rec, doRational); free_memory(temp1); temp1 = (node *) safeMalloc(sizeof(node)); temp1->nodeType = DIV; temp1->child1 = copyTree(tree->child2); temp2 = (node *) safeMalloc(sizeof(node)); temp1->child2 = temp2; temp2->nodeType = POW; temp2->child1 = (node *) safeMalloc(sizeof(node)); temp2->child1->nodeType = VARIABLE; temp2->child2 = (node *) safeMalloc(sizeof(node)); temp2->child2->nodeType = CONSTANT; temp2->child2->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(temp2->child2->value),8 * sizeof(int) + 10); mpfr_set_si(*(temp2->child2->value),beta,GMP_RNDN); temp4 = simplifyTreeErrorfreeInner(temp1, rec, doRational); free_memory(temp1); temp1 = (node *) safeMalloc(sizeof(node)); temp1->nodeType = DIV; temp1->child1 = temp3; temp1->child2 = temp4; temp2 = simplifyTreeErrorfreeInner(temp1, rec, doRational); free_memory(temp1); if (alpha > beta) { temp1 = (node *) safeMalloc(sizeof(node)); temp1->nodeType = POW; temp1->child1 = (node *) safeMalloc(sizeof(node)); temp1->child1->nodeType = VARIABLE; temp1->child2 = (node *) safeMalloc(sizeof(node)); temp1->child2->nodeType = CONSTANT; temp1->child2->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(temp1->child2->value),8 * sizeof(int) + 10); mpfr_set_si(*(temp1->child2->value),alpha - beta,GMP_RNDN); } else { temp3 = (node *) safeMalloc(sizeof(node)); temp3->nodeType = POW; temp3->child1 = (node *) safeMalloc(sizeof(node)); temp3->child1->nodeType = VARIABLE; temp3->child2 = (node *) safeMalloc(sizeof(node)); temp3->child2->nodeType = CONSTANT; temp3->child2->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(temp3->child2->value),8 * sizeof(int) + 10); mpfr_set_si(*(temp3->child2->value),beta - alpha,GMP_RNDN); temp1 = (node *) safeMalloc(sizeof(node)); temp1->nodeType = DIV; temp1->child2 = temp3; temp1->child1 = (node *) safeMalloc(sizeof(node)); temp1->child1->nodeType = CONSTANT; temp1->child1->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(temp1->child1->value),12); mpfr_set_si(*(temp1->child1->value),1,GMP_RNDN); } temp4 = (node *) safeMalloc(sizeof(node)); temp4->nodeType = MUL; temp4->child1 = temp2; temp4->child2 = simplifyTreeErrorfreeInner(temp1,rec, doRational); free_memory(temp1); return temp4; } } switch (tree->nodeType) { case VARIABLE: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = VARIABLE; break; case CONSTANT: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(temp,mpfr_get_prec(*(tree->value)) + 10); simplifyMpfrPrec(temp, *(tree->value)); mpfr_init2(*value,mpfr_get_prec(temp)); mpfr_set(*value,temp,GMP_RNDN); mpfr_clear(temp); simplified->value = value; break; case ADD: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplChild2 = simplifyTreeErrorfreeInner(tree->child2,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); prec = 2 * tools_precision; p = 2 * mpfr_get_prec(*(accessThruMemRef(simplChild1)->value)); if (p > prec) prec = p; p = 2 * mpfr_get_prec(*(accessThruMemRef(simplChild2)->value)); if (p > prec) prec = p; prec += 10; if (prec > 256 * tools_precision) prec = 256 * tools_precision; mpfr_init2(*value,prec); simplified->value = value; if ((mpfr_add(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = ADD; simplified->child1 = simplChild1; simplified->child2 = simplChild2; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); free_memory(simplChild2); } } else { if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); safeFree(simplified); simplified = simplChild2; } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild2)->value)))) { free_memory(simplChild2); safeFree(simplified); simplified = simplChild1; } else { if (accessThruMemRef(simplChild1)->nodeType == NEG) { simplified->nodeType = SUB; simplified->child1 = simplChild2; simplified->child2 = copyTree(accessThruMemRef(simplChild1)->child1); free_memory(simplChild1); if (rec > 0) { recsimplified = simplifyTreeErrorfreeInner(simplified,rec-1, doRational); free_memory(simplified); simplified = recsimplified; } } else { if (accessThruMemRef(simplChild2)->nodeType == NEG) { simplified->nodeType = SUB; simplified->child1 = simplChild1; simplified->child2 = copyTree(accessThruMemRef(simplChild2)->child1); free_memory(simplChild2); if (rec > 0) { recsimplified = simplifyTreeErrorfreeInner(simplified,rec-1, doRational); free_memory(simplified); simplified = recsimplified; } } else { if (isSyntacticallyEqualCheap(simplChild1,simplChild2)) { simplified->nodeType = MUL; simplified->child1 = (node *) safeMalloc(sizeof(node)); simplified->child1->nodeType = CONSTANT; simplified->child1->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(simplified->child1->value),tools_precision); mpfr_set_d(*(simplified->child1->value),2.0,GMP_RNDN); simplified->child2 = simplChild1; free_memory(simplChild2); if (rec > 0) { recsimplified = simplifyTreeErrorfreeInner(simplified,rec-1, doRational); free_memory(simplified); simplified = recsimplified; } } else { simplified->nodeType = ADD; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } } } } break; case SUB: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplChild2 = simplifyTreeErrorfreeInner(tree->child2,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; prec = 2 * tools_precision; p = 2 * mpfr_get_prec(*(accessThruMemRef(simplChild1)->value)); if (p > prec) prec = p; p = 2 * mpfr_get_prec(*(accessThruMemRef(simplChild2)->value)); if (p > prec) prec = p; prec += 10; if (prec > 256 * tools_precision) prec = 256 * tools_precision; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,prec); simplified->value = value; if ((mpfr_sub(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = SUB; simplified->child1 = simplChild1; simplified->child2 = simplChild2; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); free_memory(simplChild2); } } else { if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); simplified->nodeType = NEG; simplified->child1 = simplChild2; } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild2)->value)))) { free_memory(simplChild2); safeFree(simplified); simplified = simplChild1; } else { if (isSyntacticallyEqualCheap(simplChild1,simplChild2) && canDoSimplificationSubtraction(simplChild1)) { free_memory(simplChild1); free_memory(simplChild2); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_set_d(*value,0.0,GMP_RNDN); } else { if (accessThruMemRef(simplChild2)->nodeType == NEG) { simplified->nodeType = ADD; simplified->child1 = simplChild1; simplified->child2 = copyTree(accessThruMemRef(simplChild2)->child1); free_memory(simplChild2); } else { if ((accessThruMemRef(simplChild1)->nodeType == EXP) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild2)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild2)->value)))) { simplified->nodeType = EXP_M1; simplified->child1 = copyTree(accessThruMemRef(simplChild1)->child1); free_memory(simplChild1); free_memory(simplChild2); } else { simplified->nodeType = SUB; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } } } } break; case MUL: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplChild2 = simplifyTreeErrorfreeInner(tree->child2,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; prec = 2 * tools_precision; p = 2 * mpfr_get_prec(*(accessThruMemRef(simplChild1)->value)); if (p > prec) prec = p; p = 2 * mpfr_get_prec(*(accessThruMemRef(simplChild2)->value)); if (p > prec) prec = p; prec += 10; if (prec > 256 * tools_precision) prec = 256 * tools_precision; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,prec); simplified->value = value; if ((mpfr_mul(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = MUL; simplified->child1 = simplChild1; simplified->child2 = simplChild2; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); free_memory(simplChild2); } } else { if ((((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild1)->value)))) || ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild2)->value))))) && (isNotUniformlyInfinite(simplChild1) && isNotUniformlyInfinite(simplChild2))) { free_memory(simplChild1); free_memory(simplChild2); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_set_d(*value,0.0,GMP_RNDN); } else { if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild1)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); safeFree(simplified); simplified = simplChild2; } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild2)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild2)->value)))) { free_memory(simplChild2); safeFree(simplified); simplified = simplChild1; } else { if ((accessThruMemRef(simplChild1)->nodeType == DIV) && (accessThruMemRef(accessThruMemRef(simplChild1)->child1)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(accessThruMemRef(simplChild1)->child1)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(accessThruMemRef(simplChild1)->child1)->value)))) { simplified->nodeType = DIV; simplified->child1 = simplChild2; simplified->child2 = copyTree(accessThruMemRef(simplChild1)->child2); free_memory(simplChild1); } else { if ((accessThruMemRef(simplChild2)->nodeType == DIV) && (accessThruMemRef(accessThruMemRef(simplChild2)->child1)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(accessThruMemRef(simplChild2)->child1)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(accessThruMemRef(simplChild2)->child1)->value)))) { simplified->nodeType = DIV; simplified->child1 = simplChild1; simplified->child2 = copyTree(accessThruMemRef(simplChild2)->child2); free_memory(simplChild2); } else { if ((accessThruMemRef(simplChild1)->nodeType == NEG) && (accessThruMemRef(simplChild2)->nodeType == NEG)) { simplified->nodeType = MUL; simplified->child1 = copyTree(accessThruMemRef(simplChild1)->child1); simplified->child2 = copyTree(accessThruMemRef(simplChild2)->child1); free_memory(simplChild1); free_memory(simplChild2); } else { if (accessThruMemRef(simplChild1)->nodeType == NEG) { simplified->nodeType = NEG; simplified->child1 = (node *) safeMalloc(sizeof(node)); simplified->child1->nodeType = MUL; simplified->child1->child1 = copyTree(accessThruMemRef(simplChild1)->child1); simplified->child1->child2 = simplChild2; free_memory(simplChild1); } else { if (accessThruMemRef(simplChild2)->nodeType == NEG) { simplified->nodeType = NEG; simplified->child1 = (node *) safeMalloc(sizeof(node)); simplified->child1->nodeType = MUL; simplified->child1->child2 = copyTree(accessThruMemRef(simplChild2)->child1); simplified->child1->child1 = simplChild1; free_memory(simplChild2); } else { if ((accessThruMemRef(simplChild1)->nodeType == MUL) && (isConstant(simplChild2)) && (isConstant(accessThruMemRef(simplChild1)->child1))) { simplified->nodeType = MUL; simplified->child1 = (node *) safeMalloc(sizeof(node)); simplified->child1->nodeType = MUL; simplified->child1->child2 = simplChild2; simplified->child1->child1 = copyTree(accessThruMemRef(simplChild1)->child1); simplified->child2 = copyTree(accessThruMemRef(simplChild1)->child2); free_memory(simplChild1); if (rec > 0) { recsimplified = simplifyTreeErrorfreeInner(simplified,rec-1, doRational); free_memory(simplified); simplified = recsimplified; } } else { if ((accessThruMemRef(simplChild1)->nodeType == MUL) && (isConstant(simplChild2)) && (isConstant(accessThruMemRef(simplChild1)->child2))) { simplified->nodeType = MUL; simplified->child1 = (node *) safeMalloc(sizeof(node)); simplified->child1->nodeType = MUL; simplified->child1->child1 = simplChild2; simplified->child1->child2 = copyTree(accessThruMemRef(simplChild1)->child2); simplified->child2 = copyTree(accessThruMemRef(simplChild1)->child1); free_memory(simplChild1); if (rec > 0) { recsimplified = simplifyTreeErrorfreeInner(simplified,rec-1, doRational); free_memory(simplified); simplified = recsimplified; } } else { if ((accessThruMemRef(simplChild2)->nodeType == MUL) && (isConstant(simplChild1)) && (isConstant(accessThruMemRef(simplChild2)->child1))) { simplified->nodeType = MUL; simplified->child2 = (node *) safeMalloc(sizeof(node)); simplified->child2->nodeType = MUL; simplified->child2->child2 = simplChild1; simplified->child2->child1 = copyTree(accessThruMemRef(simplChild2)->child1); simplified->child1 = copyTree(accessThruMemRef(simplChild2)->child2); free_memory(simplChild2); if (rec > 0) { recsimplified = simplifyTreeErrorfreeInner(simplified,rec-1, doRational); free_memory(simplified); simplified = recsimplified; } } else { if ((accessThruMemRef(simplChild2)->nodeType == MUL) && (isConstant(simplChild1)) && (isConstant(accessThruMemRef(simplChild2)->child2))) { simplified->nodeType = MUL; simplified->child2 = (node *) safeMalloc(sizeof(node)); simplified->child2->nodeType = MUL; simplified->child2->child1 = simplChild1; simplified->child2->child2 = copyTree(accessThruMemRef(simplChild2)->child2); simplified->child1 = copyTree(accessThruMemRef(simplChild2)->child1); free_memory(simplChild2); if (rec > 0) { recsimplified = simplifyTreeErrorfreeInner(simplified,rec-1, doRational); free_memory(simplified); simplified = recsimplified; } } else { if ((accessThruMemRef(simplChild2)->nodeType == DIV) && (isSyntacticallyEqualCheap(simplChild1,accessThruMemRef(simplChild2)->child2) && canDoSimplificationDivision(simplChild1))) { safeFree(simplified); free_memory(simplChild1); simplified = copyTree(accessThruMemRef(simplChild2)->child1); free_memory(simplChild2); } else { if ((accessThruMemRef(simplChild1)->nodeType == DIV) && (isSyntacticallyEqualCheap(simplChild2,accessThruMemRef(simplChild1)->child2) && canDoSimplificationDivision(simplChild2))) { safeFree(simplified); free_memory(simplChild2); simplified = copyTree(accessThruMemRef(simplChild1)->child1); free_memory(simplChild1); } else { simplified->nodeType = MUL; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } } } } } } } } } } } } } break; case DIV: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplChild2 = simplifyTreeErrorfreeInner(tree->child2,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; prec = 2 * tools_precision; p = 2 * mpfr_get_prec(*(accessThruMemRef(simplChild1)->value)); if (p > prec) prec = p; p = 2 * mpfr_get_prec(*(accessThruMemRef(simplChild2)->value)); if (p > prec) prec = p; prec += 10; if (prec > 256 * tools_precision) prec = 256 * tools_precision; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,prec); simplified->value = value; if ((mpfr_div(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = DIV; simplified->child1 = simplChild1; simplified->child2 = simplChild2; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); free_memory(simplChild2); } } else { if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild1)->value)))) { if ((!isConstant(simplChild2)) && (isNotUniformlyZero(simplChild2))) { free_memory(simplChild1); free_memory(simplChild2); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_set_d(*value,0.0,GMP_RNDN); } else { signOkay = evaluateSign(&sign, simplChild2); if (signOkay && (sign != 0)) { free_memory(simplChild1); free_memory(simplChild2); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_set_d(*value,0.0,GMP_RNDN); } else { simplified->nodeType = DIV; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild2)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild2)->value)))) { free_memory(simplChild2); safeFree(simplified); simplified = simplChild1; } else { if (isSyntacticallyEqualCheap(simplChild1,simplChild2) && canDoSimplificationDivision(simplChild1)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_set_d(*value,1.0,GMP_RNDN); free_memory(simplChild1); free_memory(simplChild2); } else { if ((accessThruMemRef(simplChild1)->nodeType == NEG) && (accessThruMemRef(simplChild2)->nodeType == NEG)) { simplified->nodeType = DIV; simplified->child1 = copyTree(accessThruMemRef(simplChild1)->child1); simplified->child2 = copyTree(accessThruMemRef(simplChild2)->child1); free_memory(simplChild1); free_memory(simplChild2); } else { if (accessThruMemRef(simplChild1)->nodeType == NEG) { simplified->nodeType = NEG; simplified->child1 = (node *) safeMalloc(sizeof(node)); simplified->child1->nodeType = DIV; simplified->child1->child1 = copyTree(accessThruMemRef(simplChild1)->child1); simplified->child1->child2 = simplChild2; free_memory(simplChild1); } else { if (accessThruMemRef(simplChild2)->nodeType == NEG) { simplified->nodeType = NEG; simplified->child1 = (node *) safeMalloc(sizeof(node)); simplified->child1->nodeType = DIV; simplified->child1->child2 = copyTree(accessThruMemRef(simplChild2)->child1); simplified->child1->child1 = simplChild1; free_memory(simplChild2); } else { if (accessThruMemRef(simplChild2)->nodeType == DIV) { simplified->nodeType = MUL; simplified->child1 = simplChild1; simplified->child2 = (node *) safeMalloc(sizeof(node)); simplified->child2->nodeType = DIV; simplified->child2->child1 = copyTree(accessThruMemRef(simplChild2)->child2); simplified->child2->child2 = copyTree(accessThruMemRef(simplChild2)->child1); free_memory(simplChild2); if (rec > 0) { recsimplified = simplifyTreeErrorfreeInner(simplified,rec, doRational); free_memory(simplified); simplified = recsimplified; } } else { if (accessThruMemRef(simplChild1)->nodeType == DIV) { simplified->nodeType = DIV; simplified->child1 = copyTree(accessThruMemRef(simplChild1)->child1); simplified->child2 = (node *) safeMalloc(sizeof(node)); simplified->child2->nodeType = MUL; simplified->child2->child1 = simplChild2; simplified->child2->child2 = copyTree(accessThruMemRef(simplChild1)->child2); free_memory(simplChild1); if (rec > 0) { recsimplified = simplifyTreeErrorfreeInner(simplified,rec, doRational); free_memory(simplified); simplified = recsimplified; } } else { if ((simplChild1->nodeType == SIN) && (simplChild2->nodeType == COS) && (isSyntacticallyEqualCheap(accessThruMemRef(simplChild1)->child1,accessThruMemRef(simplChild2)->child1))) { simplified->nodeType = TAN; simplified->child1 = copyTree(accessThruMemRef(simplChild1)->child1); free_memory(simplChild1); free_memory(simplChild2); } else { simplified->nodeType = DIV; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } } } } } } } } break; case SQRT: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); prec = tools_precision; p = mpfr_get_prec(*(accessThruMemRef(simplChild1)->value)); if (p > prec) prec = p; prec += 10; if (prec > 256 * tools_precision) prec = 256 * tools_precision; mpfr_init2(*value,prec); simplified->value = value; if ((mpfr_sqrt(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = SQRT; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if ((accessThruMemRef(simplChild1)->nodeType == POW) && (accessThruMemRef(accessThruMemRef(simplChild1)->child2)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(accessThruMemRef(simplChild1)->child2)->value),2.0) == 0.0) && (!mpfr_nan_p(*(accessThruMemRef(accessThruMemRef(simplChild1)->child2)->value)))) { simplified->nodeType = ABS; simplified->child1 = copyTree(accessThruMemRef(simplChild1)->child1); free_memory(simplChild1); } else { simplified->nodeType = SQRT; simplified->child1 = simplChild1; } } break; case EXP: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_exp(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = EXP; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = EXP; simplified->child1 = simplChild1; } break; case LOG: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_log(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = LOG; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if ((accessThruMemRef(simplChild1)->nodeType == ADD) && (accessThruMemRef(accessThruMemRef(simplChild1)->child1)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(accessThruMemRef(simplChild1)->child1)->value),1.0) == 0.0) && (!mpfr_nan_p(*(accessThruMemRef(accessThruMemRef(simplChild1)->child1)->value)))) { simplified->nodeType = LOG_1P; simplified->child1 = copyTree(accessThruMemRef(simplChild1)->child2); free_memory(simplChild1); } else { if ((accessThruMemRef(simplChild1)->nodeType == ADD) && (accessThruMemRef(accessThruMemRef(simplChild1)->child2)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(accessThruMemRef(simplChild1)->child2)->value),1.0) == 0.0) && (!mpfr_nan_p(*(accessThruMemRef(accessThruMemRef(simplChild1)->child2)->value)))) { simplified->nodeType = LOG_1P; simplified->child1 = copyTree(accessThruMemRef(simplChild1)->child1); free_memory(simplChild1); } else { if (accessThruMemRef(simplChild1)->nodeType == EXP) { safeFree(simplified); simplified = copyTree(accessThruMemRef(simplChild1)->child1); free_memory(simplChild1); } else { simplified->nodeType = LOG; simplified->child1 = simplChild1; } } } } break; case LOG_2: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_log2(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = LOG_2; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = LOG_2; simplified->child1 = simplChild1; } break; case LOG_10: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_log10(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = LOG_10; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = LOG_10; simplified->child1 = simplChild1; } break; case SIN: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_sin(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = SIN; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = SIN; simplified->child1 = simplChild1; } break; case COS: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_cos(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = COS; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = COS; simplified->child1 = simplChild1; } break; case TAN: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_tan(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = TAN; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = TAN; simplified->child1 = simplChild1; } break; case ASIN: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { mpfr_init2(temp,53); mpfr_set_ui(temp,1,GMP_RNDN); if ((mpfr_cmp(temp, *(accessThruMemRef(simplChild1)->value)) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); simplified->child2 = (node *) safeMalloc(sizeof(node)); simplified->child2->nodeType = CONSTANT; simplified->child2->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(simplified->child2->value),53); mpfr_set_si(*(simplified->child2->value),2,GMP_RNDN); simplified->nodeType = DIV; simplified->child1 = (node *) safeMalloc(sizeof(node)); simplified->child1->nodeType = PI_CONST; } else { mpfr_set_si(temp,-1,GMP_RNDN); if ((mpfr_cmp(temp, *(accessThruMemRef(simplChild1)->value)) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); simplified->child2 = (node *) safeMalloc(sizeof(node)); simplified->child2->nodeType = CONSTANT; simplified->child2->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(simplified->child2->value),53); mpfr_set_si(*(simplified->child2->value),-2,GMP_RNDN); simplified->nodeType = DIV; simplified->child1 = (node *) safeMalloc(sizeof(node)); simplified->child1->nodeType = PI_CONST; } else { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_asin(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = ASIN; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } } mpfr_clear(temp); } else { simplified->nodeType = ASIN; simplified->child1 = simplChild1; } break; case ACOS: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { mpfr_init2(temp,53); mpfr_set_si(temp,-1,GMP_RNDN); if ((mpfr_cmp(temp, *(accessThruMemRef(simplChild1)->value)) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); simplified->nodeType = PI_CONST; } else { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_acos(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = ACOS; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } mpfr_clear(temp); } else { simplified->nodeType = ACOS; simplified->child1 = simplChild1; } break; case ATAN: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { mpfr_init2(temp,53); mpfr_set_ui(temp,1,GMP_RNDN); if ((mpfr_cmp(temp, *(accessThruMemRef(simplChild1)->value)) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); simplified->child2 = (node *) safeMalloc(sizeof(node)); simplified->child2->nodeType = CONSTANT; simplified->child2->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(simplified->child2->value),53); mpfr_set_si(*(simplified->child2->value),4,GMP_RNDN); simplified->nodeType = DIV; simplified->child1 = (node *) safeMalloc(sizeof(node)); simplified->child1->nodeType = PI_CONST; } else { mpfr_set_si(temp,-1,GMP_RNDN); if ((mpfr_cmp(temp, *(accessThruMemRef(simplChild1)->value)) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); simplified->child2 = (node *) safeMalloc(sizeof(node)); simplified->child2->nodeType = CONSTANT; simplified->child2->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(simplified->child2->value),53); mpfr_set_si(*(simplified->child2->value),-4,GMP_RNDN); simplified->nodeType = DIV; simplified->child1 = (node *) safeMalloc(sizeof(node)); simplified->child1->nodeType = PI_CONST; } else { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_atan(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = ATAN; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } } mpfr_clear(temp); } else { simplified->nodeType = ATAN; simplified->child1 = simplChild1; } break; case SINH: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_sinh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = SINH; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = SINH; simplified->child1 = simplChild1; } break; case COSH: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_cosh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = COSH; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = COSH; simplified->child1 = simplChild1; } break; case TANH: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_tanh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = TANH; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = TANH; simplified->child1 = simplChild1; } break; case ASINH: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_asinh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = ASINH; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = ASINH; simplified->child1 = simplChild1; } break; case ACOSH: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_acosh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = ACOSH; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = ACOSH; simplified->child1 = simplChild1; } break; case ATANH: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_atanh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = ATANH; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = ATANH; simplified->child1 = simplChild1; } break; case POW: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplChild2 = simplifyTreeErrorfreeInner(tree->child2,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_pow(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value)) || (!mpfr_number_p(*(accessThruMemRef(simplChild1)->value)))) { simplified->nodeType = POW; simplified->child1 = simplChild1; simplified->child2 = simplChild2; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); free_memory(simplChild2); } } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild2)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild2)->value)))) { safeFree(simplified); free_memory(simplChild2); simplified = simplChild1; } else { value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (accessThruMemRef(simplChild1)->nodeType == POW) && (accessThruMemRef(accessThruMemRef(simplChild1)->child2)->nodeType == CONSTANT) && (mpfr_mul(*value,*(accessThruMemRef(simplChild2)->value),*(accessThruMemRef(accessThruMemRef(simplChild1)->child2)->value),GMP_RNDN) == 0)) { simplified->nodeType = POW; simplified->child1 = copyTree(accessThruMemRef(simplChild1)->child1); simplified->child2 = (node *) safeMalloc(sizeof(node)); simplified->child2->nodeType = CONSTANT; simplified->child2->value = value; free_memory(simplChild1); free_memory(simplChild2); } else { mpfr_clear(*value); safeFree(value); if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild2)->value),2.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild2)->value))) && (accessThruMemRef(simplChild1)->nodeType == SQRT)) { safeFree(simplified); simplified = copyTree(accessThruMemRef(simplChild1)->child1); free_memory(simplChild1); free_memory(simplChild2); } else { simplified->nodeType = POW; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } } break; case NEG: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); prec = tools_precision; p = mpfr_get_prec(*(accessThruMemRef(simplChild1)->value)); if (p > prec) prec = p; prec += 10; if (prec > 256 * tools_precision) prec = 256 * tools_precision; mpfr_init2(*value,prec); simplified->value = value; if ((mpfr_neg(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (mpfr_nan_p(*value))) { simplified->nodeType = NEG; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if (accessThruMemRef(simplChild1)->nodeType == NEG) { safeFree(simplified); simplified = copyTree(accessThruMemRef(simplChild1)->child1); free_memory(simplChild1); } else { simplified->nodeType = NEG; simplified->child1 = simplChild1; } } break; case ABS: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_abs(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = ABS; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if (accessThruMemRef(simplChild1)->nodeType == ABS) { simplified->nodeType = ABS; simplified->child1 = copyTree(accessThruMemRef(simplChild1)->child1); free_memory(simplChild1); } else { simplified->nodeType = ABS; simplified->child1 = simplChild1; } } break; case DOUBLE: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 64)? tools_precision : 64)); simplified->value = value; mpfr_round_to_double(*value, *(accessThruMemRef(simplChild1)->value)); if (!mpfr_number_p(*value)) { simplified->nodeType = DOUBLE; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if (isConstant(simplChild1)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(yrange.a),4* tools_precision); mpfr_init2(*(yrange.b),4 * tools_precision); mpfr_init2(*(xrange.a),((tools_precision > 64)? tools_precision : 64)); mpfr_init2(*(xrange.b),((tools_precision > 64)? tools_precision : 64)); mpfr_set_ui(*(xrange.a),1,GMP_RNDD); mpfr_set_ui(*(xrange.b),1,GMP_RNDU); evaluateRangeFunction(yrange, simplChild1, xrange, 8 * tools_precision); mpfr_round_to_double(*(xrange.a),*(yrange.a)); mpfr_round_to_double(*(xrange.b),*(yrange.b)); if (mpfr_number_p(*(xrange.a)) && mpfr_number_p(*(xrange.b)) && (mpfr_cmp(*(xrange.a),*(xrange.b)) == 0)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 64)? tools_precision : 64)); simplified->value = value; mpfr_set(*value,*(xrange.a),GMP_RNDN); /* Exact */ free_memory(simplChild1); } else { simplified->nodeType = DOUBLE; simplified->child1 = simplChild1; } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { simplified->nodeType = DOUBLE; simplified->child1 = simplChild1; } } break; case SINGLE: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 64)? tools_precision : 64)); simplified->value = value; mpfr_round_to_single(*value, *(accessThruMemRef(simplChild1)->value)); if (!mpfr_number_p(*value)) { simplified->nodeType = SINGLE; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if (isConstant(simplChild1)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(yrange.a),4* tools_precision); mpfr_init2(*(yrange.b),4 * tools_precision); mpfr_init2(*(xrange.a),((tools_precision > 64)? tools_precision : 64)); mpfr_init2(*(xrange.b),((tools_precision > 64)? tools_precision : 64)); mpfr_set_ui(*(xrange.a),1,GMP_RNDD); mpfr_set_ui(*(xrange.b),1,GMP_RNDU); evaluateRangeFunction(yrange, simplChild1, xrange, 8 * tools_precision); mpfr_round_to_single(*(xrange.a),*(yrange.a)); mpfr_round_to_single(*(xrange.b),*(yrange.b)); if (mpfr_number_p(*(xrange.a)) && mpfr_number_p(*(xrange.b)) && (mpfr_cmp(*(xrange.a),*(xrange.b)) == 0)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 64)? tools_precision : 64)); simplified->value = value; mpfr_set(*value,*(xrange.a),GMP_RNDN); /* Exact */ free_memory(simplChild1); } else { simplified->nodeType = SINGLE; simplified->child1 = simplChild1; } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { simplified->nodeType = SINGLE; simplified->child1 = simplChild1; } } break; case QUAD: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 128)? tools_precision : 128)); simplified->value = value; mpfr_round_to_quad(*value, *(accessThruMemRef(simplChild1)->value)); if (!mpfr_number_p(*value)) { simplified->nodeType = QUAD; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if (isConstant(simplChild1)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(yrange.a),4* tools_precision); mpfr_init2(*(yrange.b),4 * tools_precision); mpfr_init2(*(xrange.a),((tools_precision > 128)? tools_precision : 128)); mpfr_init2(*(xrange.b),((tools_precision > 128)? tools_precision : 128)); mpfr_set_ui(*(xrange.a),1,GMP_RNDD); mpfr_set_ui(*(xrange.b),1,GMP_RNDU); evaluateRangeFunction(yrange, simplChild1, xrange, 8 * tools_precision); mpfr_round_to_quad(*(xrange.a),*(yrange.a)); mpfr_round_to_quad(*(xrange.b),*(yrange.b)); if (mpfr_number_p(*(xrange.a)) && mpfr_number_p(*(xrange.b)) && (mpfr_cmp(*(xrange.a),*(xrange.b)) == 0)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 128)? tools_precision : 128)); simplified->value = value; mpfr_set(*value,*(xrange.a),GMP_RNDN); /* Exact */ free_memory(simplChild1); } else { simplified->nodeType = QUAD; simplified->child1 = simplChild1; } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { simplified->nodeType = QUAD; simplified->child1 = simplChild1; } } break; case HALFPRECISION: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 64)? tools_precision : 64)); simplified->value = value; mpfr_round_to_halfprecision(*value, *(accessThruMemRef(simplChild1)->value)); if (!mpfr_number_p(*value)) { simplified->nodeType = HALFPRECISION; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if (isConstant(simplChild1)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(yrange.a),4* tools_precision); mpfr_init2(*(yrange.b),4 * tools_precision); mpfr_init2(*(xrange.a),((tools_precision > 64)? tools_precision : 64)); mpfr_init2(*(xrange.b),((tools_precision > 64)? tools_precision : 64)); mpfr_set_ui(*(xrange.a),1,GMP_RNDD); mpfr_set_ui(*(xrange.b),1,GMP_RNDU); evaluateRangeFunction(yrange, simplChild1, xrange, 8 * tools_precision); mpfr_round_to_halfprecision(*(xrange.a),*(yrange.a)); mpfr_round_to_halfprecision(*(xrange.b),*(yrange.b)); if (mpfr_number_p(*(xrange.a)) && mpfr_number_p(*(xrange.b)) && (mpfr_cmp(*(xrange.a),*(xrange.b)) == 0)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 64)? tools_precision : 64)); simplified->value = value; mpfr_set(*value,*(xrange.a),GMP_RNDN); /* Exact */ free_memory(simplChild1); } else { simplified->nodeType = HALFPRECISION; simplified->child1 = simplChild1; } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { simplified->nodeType = HALFPRECISION; simplified->child1 = simplChild1; } } break; case DOUBLEDOUBLE: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 129)? tools_precision : 129)); simplified->value = value; mpfr_round_to_doubledouble(*value, *(accessThruMemRef(simplChild1)->value)); if (!mpfr_number_p(*value)) { simplified->nodeType = DOUBLEDOUBLE; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if (isConstant(simplChild1)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(yrange.a),4* tools_precision); mpfr_init2(*(yrange.b),4 * tools_precision); mpfr_init2(*(xrange.a),((tools_precision > 129)? tools_precision : 129)); mpfr_init2(*(xrange.b),((tools_precision > 129)? tools_precision : 129)); mpfr_set_ui(*(xrange.a),1,GMP_RNDD); mpfr_set_ui(*(xrange.b),1,GMP_RNDU); evaluateRangeFunction(yrange, simplChild1, xrange, 8 * tools_precision); mpfr_round_to_doubledouble(*(xrange.a),*(yrange.a)); mpfr_round_to_doubledouble(*(xrange.b),*(yrange.b)); if (mpfr_number_p(*(xrange.a)) && mpfr_number_p(*(xrange.b)) && (mpfr_cmp(*(xrange.a),*(xrange.b)) == 0)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 129)? tools_precision : 129)); simplified->value = value; mpfr_set(*value,*(xrange.a),GMP_RNDN); /* Exact */ free_memory(simplChild1); } else { simplified->nodeType = DOUBLEDOUBLE; simplified->child1 = simplChild1; } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { simplified->nodeType = DOUBLEDOUBLE; simplified->child1 = simplChild1; } } break; case TRIPLEDOUBLE: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 200)? tools_precision : 200)); simplified->value = value; mpfr_round_to_tripledouble(*value, *(accessThruMemRef(simplChild1)->value)); if (!mpfr_number_p(*value)) { simplified->nodeType = TRIPLEDOUBLE; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if (isConstant(simplChild1)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(yrange.a),4* tools_precision); mpfr_init2(*(yrange.b),4 * tools_precision); mpfr_init2(*(xrange.a),((tools_precision > 200)? tools_precision : 200)); mpfr_init2(*(xrange.b),((tools_precision > 200)? tools_precision : 200)); mpfr_set_ui(*(xrange.a),1,GMP_RNDD); mpfr_set_ui(*(xrange.b),1,GMP_RNDU); evaluateRangeFunction(yrange, simplChild1, xrange, 8 * tools_precision); mpfr_round_to_tripledouble(*(xrange.a),*(yrange.a)); mpfr_round_to_tripledouble(*(xrange.b),*(yrange.b)); if (mpfr_number_p(*(xrange.a)) && mpfr_number_p(*(xrange.b)) && (mpfr_cmp(*(xrange.a),*(xrange.b)) == 0)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 200)? tools_precision : 200)); simplified->value = value; mpfr_set(*value,*(xrange.a),GMP_RNDN); /* Exact */ free_memory(simplChild1); } else { simplified->nodeType = TRIPLEDOUBLE; simplified->child1 = simplChild1; } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { simplified->nodeType = TRIPLEDOUBLE; simplified->child1 = simplChild1; } } break; case ERF: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_erf(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = ERF; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = ERF; simplified->child1 = simplChild1; } break; case ERFC: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_erfc(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = ERFC; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = ERFC; simplified->child1 = simplChild1; } break; case LOG_1P: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_log1p(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = LOG_1P; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = LOG_1P; simplified->child1 = simplChild1; } break; case EXP_M1: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if ((mpfr_expm1(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { simplified->nodeType = EXP_M1; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { simplified->nodeType = EXP_M1; simplified->child1 = simplChild1; } break; case DOUBLEEXTENDED: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 128)? tools_precision : 128)); simplified->value = value; mpfr_round_to_doubleextended(*value, *(accessThruMemRef(simplChild1)->value)); if (!mpfr_number_p(*value)) { simplified->nodeType = DOUBLEEXTENDED; simplified->child1 = simplChild1; mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if (isConstant(simplChild1)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(yrange.a),4* tools_precision); mpfr_init2(*(yrange.b),4 * tools_precision); mpfr_init2(*(xrange.a),((tools_precision > 128)? tools_precision : 128)); mpfr_init2(*(xrange.b),((tools_precision > 128)? tools_precision : 128)); mpfr_set_ui(*(xrange.a),1,GMP_RNDD); mpfr_set_ui(*(xrange.b),1,GMP_RNDU); evaluateRangeFunction(yrange, simplChild1, xrange, 8 * tools_precision); mpfr_round_to_doubleextended(*(xrange.a),*(yrange.a)); mpfr_round_to_doubleextended(*(xrange.b),*(yrange.b)); if (mpfr_number_p(*(xrange.a)) && mpfr_number_p(*(xrange.b)) && (mpfr_cmp(*(xrange.a),*(xrange.b)) == 0)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 128)? tools_precision : 128)); simplified->value = value; mpfr_set(*value,*(xrange.a),GMP_RNDN); /* Exact */ free_memory(simplChild1); } else { simplified->nodeType = DOUBLEEXTENDED; simplified->child1 = simplChild1; } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { simplified->nodeType = DOUBLEEXTENDED; simplified->child1 = simplChild1; } } break; case LIBRARYFUNCTION: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = LIBRARYFUNCTION; simplified->libFun = tree->libFun; simplified->libFunDeriv = tree->libFunDeriv; simplified->child1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); break; case PROCEDUREFUNCTION: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = PROCEDUREFUNCTION; simplified->libFunDeriv = tree->libFunDeriv; simplified->child2 = copyThing(tree->child2); simplified->child1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); break; case CEIL: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,(tools_precisionvalue))?mpfr_get_prec(*(accessThruMemRef(simplChild1)->value)):tools_precision)); simplified->value = value; if ((mpfr_rint_ceil(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { if (isIntegerConstant(simplChild1)) { safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = CEIL; simplified->child1 = simplChild1; } mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if (isConstant(simplChild1)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(yrange.a),4* tools_precision); mpfr_init2(*(yrange.b),4 * tools_precision); mpfr_init2(*(xrange.a),tools_precision); mpfr_init2(*(xrange.b),tools_precision); mpfr_set_ui(*(xrange.a),1,GMP_RNDD); mpfr_set_ui(*(xrange.b),1,GMP_RNDU); evaluateRangeFunction(yrange, simplChild1, xrange, 8 * tools_precision); mpfr_rint_ceil(*(xrange.a),*(yrange.a),GMP_RNDD); mpfr_rint_ceil(*(xrange.b),*(yrange.b),GMP_RNDU); if (mpfr_number_p(*(xrange.a)) && mpfr_number_p(*(xrange.b)) && (mpfr_cmp(*(xrange.a),*(xrange.b)) == 0)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_set(*value,*(xrange.a),GMP_RNDN); /* Exact */ free_memory(simplChild1); } else { if (isIntegerConstant(simplChild1)) { safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = CEIL; simplified->child1 = simplChild1; } } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { if (isIntegerConstant(simplChild1)) { safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = CEIL; simplified->child1 = simplChild1; } } } break; case FLOOR: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,(tools_precisionvalue))?mpfr_get_prec(*(accessThruMemRef(simplChild1)->value)):tools_precision)); simplified->value = value; if ((mpfr_rint_floor(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { if (isIntegerConstant(simplChild1)) { safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = FLOOR; simplified->child1 = simplChild1; } mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if (isConstant(simplChild1)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_init2(*(xrange.a),4 * tools_precision); mpfr_init2(*(xrange.b),4 * tools_precision); mpfr_set_ui(*(xrange.a),1,GMP_RNDD); mpfr_set_ui(*(xrange.b),1,GMP_RNDU); evaluateRangeFunction(yrange, simplChild1, xrange, 8 * tools_precision); mpfr_rint_floor(*(xrange.a),*(yrange.a),GMP_RNDD); mpfr_rint_floor(*(xrange.b),*(yrange.b),GMP_RNDU); if (mpfr_number_p(*(xrange.a)) && mpfr_number_p(*(xrange.b)) && (mpfr_cmp(*(xrange.a),*(xrange.b)) == 0)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_set(*value,*(xrange.a),GMP_RNDN); /* Exact */ free_memory(simplChild1); } else { if (isIntegerConstant(simplChild1)) { safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = FLOOR; simplified->child1 = simplChild1; } } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { if (isIntegerConstant(simplChild1)) { safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = FLOOR; simplified->child1 = simplChild1; } } } break; case NEARESTINT: simplChild1 = simplifyTreeErrorfreeInner(tree->child1,rec, doRational); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,(tools_precisionvalue))?mpfr_get_prec(*(accessThruMemRef(simplChild1)->value)):tools_precision)); simplified->value = value; if ((sollya_mpfr_rint_nearestint(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN) != 0) || (!mpfr_number_p(*value))) { if (isIntegerConstant(simplChild1)) { safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = NEARESTINT; simplified->child1 = simplChild1; } mpfr_clear(*value); safeFree(value); } else { free_memory(simplChild1); } } else { if (isConstant(simplChild1)) { xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(yrange.a),tools_precision); mpfr_init2(*(yrange.b),tools_precision); mpfr_init2(*(xrange.a),4 * tools_precision); mpfr_init2(*(xrange.b),4 * tools_precision); mpfr_set_ui(*(xrange.a),1,GMP_RNDD); mpfr_set_ui(*(xrange.b),1,GMP_RNDU); evaluateRangeFunction(yrange, simplChild1, xrange, 8 * tools_precision); sollya_mpfr_rint_nearestint(*(xrange.a),*(yrange.a),GMP_RNDD); sollya_mpfr_rint_nearestint(*(xrange.b),*(yrange.b),GMP_RNDU); if (mpfr_number_p(*(xrange.a)) && mpfr_number_p(*(xrange.b)) && (mpfr_cmp(*(xrange.a),*(xrange.b)) == 0)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_set(*value,*(xrange.a),GMP_RNDN); /* Exact */ free_memory(simplChild1); } else { if (isIntegerConstant(simplChild1)) { safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = NEARESTINT; simplified->child1 = simplChild1; } } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } else { if (isIntegerConstant(simplChild1)) { safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = NEARESTINT; simplified->child1 = simplChild1; } } } break; case PI_CONST: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = PI_CONST; break; case LIBRARYCONSTANT: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = LIBRARYCONSTANT; simplified->libFun = tree->libFun; break; default: sollyaFprintf(stderr,"Error: simplifyTreeErrorfreeInnerst: unknown identifier in the tree\n"); exit(1); } return simplified; } node *simplifyRationalErrorfree(node *tree) { return simplifyTreeErrorfreeInner(tree,1,1); } node *simplifyTreeErrorfree(node *tree) { node *temp; temp = simplifyTreeErrorfreeInner(tree,1,rationalMode); if (verbosity >= 7) { if (!isSyntacticallyEqualCheap(temp,tree)) { if (verbosity < 9) { printMessage(7,SOLLYA_MSG_EXPRESSION_HAS_BEEN_SIMPLIFIED,"Information: an expression has been simplified.\n"); } else { printMessage(9,SOLLYA_MSG_EXPRESSION_HAS_BEEN_SIMPLIFIED_TO_ANOTHER_ONE,"Information: expression '%b' has been simplified to expression '%b'.\n",tree,temp); } } } return temp; } int isPolynomial(node *tree); node *differentiatePolynomialUnsafe(node *tree); node* differentiateUnsimplifiedInner(node *tree); node* differentiateUnsimplified(node *tree) { node *res; if ((tree->nodeType == MEMREF) && (tree->derivCache != NULL)) { return copyTree(tree->derivCache); } if ((tree->nodeType == MEMREF) && (tree->derivUnsimplCache != NULL)) { return copyTree(tree->derivUnsimplCache); } res = addMemRef(differentiateUnsimplifiedInner(tree)); if ((tree->nodeType == MEMREF) && (tree->derivUnsimplCache == NULL) && (res->nodeType == MEMREF)) { tree->derivUnsimplCache = copyTree(res); } return res; } int containsNonDifferentiableSubfunctions(node *tree) { /* Memory references */ if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) { return 0; /* Polynomials are always differentiable */ } return containsNonDifferentiableSubfunctions(getMemRefChild(tree)); } /* Constant expressions are always differentiable */ if (isConstant(tree)) { return 0; } /* Other cases */ switch (tree->nodeType) { case VARIABLE: return 0; break; case CONSTANT: case PI_CONST: case LIBRARYCONSTANT: return 0; break; case ADD: case SUB: case MUL: case DIV: case POW: return (containsNonDifferentiableSubfunctions(tree->child1) || containsNonDifferentiableSubfunctions(tree->child2)); break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case ERF: case ERFC: case LOG_1P: case EXP_M1: case LIBRARYFUNCTION: case PROCEDUREFUNCTION: return containsNonDifferentiableSubfunctions(tree->child1); break; case DOUBLE: case SINGLE: case QUAD: case HALFPRECISION: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case DOUBLEEXTENDED: case CEIL: case FLOOR: case NEARESTINT: return 1; break; default: sollyaFprintf(stderr,"Error: containsNonDifferentiableSubfunctions: unknown identifier (%d) in the tree\n", tree->nodeType); exit(1); } return 0; } node* differentiateUnsimplifiedInner(node *tree) { node *derivative; mpfr_t *mpfr_temp; node *temp_node, *temp_node2, *temp_node3, *f_diff, *g_diff, *f_copy, *g_copy, *g_copy2, *h_copy; node *temp_node4, *f_copy2, *temp_node5; node *temp; int deg; if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) { temp = addMemRefEvenOnNull(NULL); if (temp != NULL) { temp->polynomialRepresentation = polynomialDeriv(tree->polynomialRepresentation); return temp; } } return addMemRef(differentiateUnsimplifiedInner(getMemRefChild(tree))); } if (isConstant(tree)) { mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; } else { if (isPolynomial(tree) && ((deg = getDegreeSilent(tree)) <= MAXDIFFPOLYSPECIALDEGREE) && (deg >= 0)) { derivative = differentiatePolynomialUnsafe(tree); } else { switch (tree->nodeType) { case VARIABLE: mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; case CONSTANT: mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; case ADD: temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = ADD; temp_node->child1 = differentiateUnsimplified(tree->child1); temp_node->child2 = differentiateUnsimplified(tree->child2); derivative = temp_node; break; case SUB: temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = SUB; temp_node->child1 = differentiateUnsimplified(tree->child1); temp_node->child2 = differentiateUnsimplified(tree->child2); derivative = temp_node; break; case MUL: if (isConstant(tree->child1)) { f_diff = differentiateUnsimplified(tree->child2); g_copy = copyTree(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child1 = g_copy; temp_node->child2 = f_diff; derivative = temp_node; } else { if (isConstant(tree->child2)) { f_diff = differentiateUnsimplified(tree->child1); g_copy = copyTree(tree->child2); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_copy; temp_node->child1 = f_diff; derivative = temp_node; } else { f_copy = copyTree(tree->child1); g_copy = copyTree(tree->child2); f_diff = differentiateUnsimplified(tree->child1); g_diff = differentiateUnsimplified(tree->child2); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = ADD; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = MUL; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = MUL; temp_node->child1 = temp_node2; temp_node->child2 = temp_node3; temp_node2->child1 = f_copy; temp_node2->child2 = g_diff; temp_node3->child1 = g_copy; temp_node3->child2 = f_diff; derivative = temp_node; } } break; case DIV: f_copy = copyTree(tree->child1); g_copy = copyTree(tree->child2); f_diff = differentiateUnsimplified(tree->child1); g_diff = differentiateUnsimplified(tree->child2); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = SUB; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = MUL; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = MUL; temp_node->child1 = temp_node2; temp_node->child2 = temp_node3; temp_node2->child1 = g_copy; temp_node2->child2 = f_diff; temp_node3->child1 = f_copy; temp_node3->child2 = g_diff; g_copy = copyTree(tree->child2); temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = POW; temp_node2->child1 = g_copy; temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,2.0,GMP_RNDN); temp_node4->value = mpfr_temp; temp_node2->child2 = temp_node4; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = DIV; temp_node3->child1 = temp_node; temp_node3->child2 = temp_node2; derivative = temp_node3; break; case SQRT: h_copy = makeSqrt(copyTree(tree->child1)); g_diff = differentiateUnsimplified(tree->child1); temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,2.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = MUL; temp_node2->child1 = temp_node3; temp_node2->child2 = h_copy; temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = DIV; temp_node->child1 = g_diff; temp_node->child2 = temp_node2; derivative = temp_node; break; case EXP: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = EXP; temp_node->child1 = temp_node2; temp_node2->child1 = g_copy; derivative = temp_node; break; case LOG: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = DIV; temp_node->child1 = temp_node2; temp_node2->child2 = g_copy; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; derivative = temp_node; break; case LOG_2: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = DIV; temp_node->child1 = temp_node2; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node2->child2 = temp_node3; temp_node3->nodeType = MUL; temp_node3->child1 = g_copy; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = LOG; temp_node3->child2 = temp_node2; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,2.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; derivative = temp_node; break; case LOG_10: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = DIV; temp_node->child1 = temp_node2; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node2->child2 = temp_node3; temp_node3->nodeType = MUL; temp_node3->child1 = g_copy; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = LOG; temp_node3->child2 = temp_node2; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,10.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; derivative = temp_node; break; case SIN: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = COS; temp_node->child1 = temp_node2; temp_node2->child1 = g_copy; derivative = temp_node; break; case COS: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = SIN; temp_node2->child1 = g_copy; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = NEG; temp_node3->child1 = temp_node2; temp_node->child1 = temp_node3; derivative = temp_node; break; case TAN: g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = ADD; temp_node->child1 = temp_node2; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; h_copy = makeTan(copyTree(tree->child1)); temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,2.0,GMP_RNDN); temp_node4->value = mpfr_temp; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = POW; temp_node2->child2 = temp_node3; temp_node3->child1 = h_copy; temp_node3->child2 = temp_node4; derivative = temp_node; break; case ASIN: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = DIV; temp_node->child1 = temp_node4; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node4->child1 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = POW; temp_node3->child1 = g_copy; temp_node5 = (node*) safeMalloc(sizeof(node)); temp_node5->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,2.0,GMP_RNDN); temp_node5->value = mpfr_temp; temp_node3->child2 = temp_node5; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = SUB; temp_node2->child2 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = SQRT; temp_node3->child1 = temp_node2; temp_node4->child2 = temp_node3; derivative = temp_node; break; case ACOS: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = DIV; temp_node->child1 = temp_node4; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,-1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node4->child1 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = POW; temp_node3->child1 = g_copy; temp_node5 = (node*) safeMalloc(sizeof(node)); temp_node5->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,2.0,GMP_RNDN); temp_node5->value = mpfr_temp; temp_node3->child2 = temp_node5; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = SUB; temp_node2->child2 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = SQRT; temp_node3->child1 = temp_node2; temp_node4->child2 = temp_node3; derivative = temp_node; break; case ATAN: g_copy = copyTree(tree->child1); g_copy2 = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = MUL; temp_node2->child1 = g_copy; temp_node2->child2 = g_copy2; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = ADD; temp_node4->child1 = temp_node3; temp_node4->child2 = temp_node2; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = DIV; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; temp_node2->child2 = temp_node4; temp_node->child1 = temp_node2; derivative = temp_node; break; case SINH: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = COSH; temp_node2->child1 = g_copy; temp_node->child1 = temp_node2; derivative = temp_node; break; case COSH: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = SINH; temp_node2->child1 = g_copy; temp_node->child1 = temp_node2; derivative = temp_node; break; case TANH: g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = SUB; temp_node->child1 = temp_node2; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; h_copy = makeTanh(copyTree(tree->child1)); temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,2.0,GMP_RNDN); temp_node4->value = mpfr_temp; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = POW; temp_node2->child2 = temp_node3; temp_node3->child1 = h_copy; temp_node3->child2 = temp_node4; derivative = temp_node; break; case ASINH: g_copy = copyTree(tree->child1); g_copy2 = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = DIV; temp_node->child1 = temp_node4; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node4->child1 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = MUL; temp_node3->child1 = g_copy; temp_node3->child2 = g_copy2; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = ADD; temp_node2->child2 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = SQRT; temp_node3->child1 = temp_node2; temp_node4->child2 = temp_node3; derivative = temp_node; break; case ACOSH: g_copy = copyTree(tree->child1); g_copy2 = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = DIV; temp_node->child1 = temp_node4; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node4->child1 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = MUL; temp_node3->child1 = g_copy; temp_node3->child2 = g_copy2; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = ADD; temp_node2->child2 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,-1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = SQRT; temp_node3->child1 = temp_node2; temp_node4->child2 = temp_node3; derivative = temp_node; break; case ATANH: g_copy = copyTree(tree->child1); g_copy2 = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = MUL; temp_node2->child1 = g_copy; temp_node2->child2 = g_copy2; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = SUB; temp_node4->child1 = temp_node3; temp_node4->child2 = temp_node2; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = DIV; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; temp_node2->child2 = temp_node4; temp_node->child1 = temp_node2; derivative = temp_node; break; case POW: if (isConstant(tree->child2)) { g_copy = copyTree(tree->child2); g_copy2 = copyTree(tree->child2); f_diff = differentiateUnsimplified(tree->child1); f_copy = copyTree(tree->child1); temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = MUL; temp_node2->child1 = g_copy; temp_node2->child2 = f_diff; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = SUB; temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node4->value = mpfr_temp; temp_node3->child2 = temp_node4; temp_node3->child1 = g_copy2; temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = POW; temp_node4->child1 = f_copy; temp_node4->child2 = temp_node3; temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child1 = temp_node4; temp_node->child2 = temp_node2; derivative = temp_node; } else { h_copy = makePow(copyTree(tree->child1),copyTree(tree->child2)); f_diff = differentiateUnsimplified(tree->child1); f_copy = copyTree(tree->child1); f_copy2 = copyTree(tree->child1); g_copy = copyTree(tree->child2); g_diff = differentiateUnsimplified(tree->child2); temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = LOG; temp_node4->child1 = f_copy; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = MUL; temp_node3->child1 = g_diff; temp_node3->child2 = temp_node4; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = MUL; temp_node2->child1 = f_diff; temp_node2->child2 = g_copy; temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = DIV; temp_node->child1 = temp_node2; temp_node->child2 = f_copy2; temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = ADD; temp_node4->child1 = temp_node; temp_node4->child2 = temp_node3; temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child1 = h_copy; temp_node->child2 = temp_node4; derivative = temp_node; } break; case NEG: g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = NEG; temp_node->child1 = g_diff; derivative = temp_node; break; case ABS: g_copy = copyTree(tree->child1); h_copy = makeAbs(copyTree(tree->child1)); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = DIV; temp_node->child1 = temp_node2; temp_node2->child1 = g_copy; temp_node2->child2 = h_copy; derivative = temp_node; break; case DOUBLE: printMessage(1,SOLLYA_MSG_DOUBLE_NOT_DIFFERENTIABLE, "Warning: the double rounding operator is not differentiable.\nReplacing it by a constant function when differentiating.\n"); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; case SINGLE: printMessage(1,SOLLYA_MSG_SINGLE_NOT_DIFFERENTIABLE, "Warning: the single rounding operator is not differentiable.\nReplacing it by a constant function when differentiating.\n"); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; case QUAD: printMessage(1,SOLLYA_MSG_QUAD_NOT_DIFFERENTIABLE, "Warning: the quad rounding operator is not differentiable.\nReplacing it by a constant function when differentiating.\n"); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; case HALFPRECISION: printMessage(1,SOLLYA_MSG_HALF_NOT_DIFFERENTIABLE, "Warning: the half-precision rounding operator is not differentiable.\nReplacing it by a constant function when differentiating.\n"); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; case DOUBLEDOUBLE: printMessage(1,SOLLYA_MSG_DOUBLE_DOUBLE_NOT_DIFFERENTIABLE, "Warning: the double-double rounding operator is not differentiable.\nReplacing it by a constant function when differentiating.\n"); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; case TRIPLEDOUBLE: printMessage(1,SOLLYA_MSG_TRIPLE_DOUBLE_NOT_DIFFERENTIABLE, "Warning: the triple-double rounding operator is not differentiable.\nReplacing it by a constant function when differentiating.\n"); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; case ERF: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = DIV; temp_node3 = (node *) safeMalloc(sizeof(node)); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->nodeType = CONSTANT; temp_node3->value = mpfr_temp; temp_node4 = (node *) safeMalloc(sizeof(node)); temp_node4->nodeType = ATAN; temp_node4->child1 = temp_node3; temp_node3 = (node *) safeMalloc(sizeof(node)); temp_node3->nodeType = SQRT; temp_node3->child1 = temp_node4; temp_node2->child2 = temp_node3; temp_node3 = (node *) safeMalloc(sizeof(node)); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,2.0,GMP_RNDN); temp_node3->nodeType = CONSTANT; temp_node3->value = mpfr_temp; temp_node4 = (node *) safeMalloc(sizeof(node)); temp_node4->nodeType = POW; temp_node4->child1 = g_copy; temp_node4->child2 = temp_node3; temp_node3 = (node *) safeMalloc(sizeof(node)); temp_node3->nodeType = NEG; temp_node3->child1 = temp_node4; temp_node4 = (node *) safeMalloc(sizeof(node)); temp_node4->nodeType = EXP; temp_node4->child1 = temp_node3; temp_node2->child1 = temp_node4; temp_node->child1 = temp_node2; derivative = temp_node; break; case ERFC: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = DIV; temp_node3 = (node *) safeMalloc(sizeof(node)); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->nodeType = CONSTANT; temp_node3->value = mpfr_temp; temp_node4 = (node *) safeMalloc(sizeof(node)); temp_node4->nodeType = ATAN; temp_node4->child1 = temp_node3; temp_node3 = (node *) safeMalloc(sizeof(node)); temp_node3->nodeType = SQRT; temp_node3->child1 = temp_node4; temp_node2->child2 = temp_node3; temp_node3 = (node *) safeMalloc(sizeof(node)); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,2.0,GMP_RNDN); temp_node3->nodeType = CONSTANT; temp_node3->value = mpfr_temp; temp_node4 = (node *) safeMalloc(sizeof(node)); temp_node4->nodeType = POW; temp_node4->child1 = g_copy; temp_node4->child2 = temp_node3; temp_node3 = (node *) safeMalloc(sizeof(node)); temp_node3->nodeType = NEG; temp_node3->child1 = temp_node4; temp_node4 = (node *) safeMalloc(sizeof(node)); temp_node4->nodeType = EXP; temp_node4->child1 = temp_node3; temp_node3 = (node *) safeMalloc(sizeof(node)); temp_node3->nodeType = NEG; temp_node3->child1 = temp_node4; temp_node2->child1 = temp_node3; temp_node->child1 = temp_node2; derivative = temp_node; break; case LOG_1P: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = DIV; temp_node->child1 = temp_node2; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node4 = (node*) safeMalloc(sizeof(node)); temp_node4->nodeType = ADD; temp_node4->child1 = temp_node3; temp_node4->child2 = g_copy; temp_node2->child2 = temp_node4; temp_node3 = (node*) safeMalloc(sizeof(node)); temp_node3->nodeType = CONSTANT; mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,1.0,GMP_RNDN); temp_node3->value = mpfr_temp; temp_node2->child1 = temp_node3; derivative = temp_node; break; case EXP_M1: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = EXP; temp_node->child1 = temp_node2; temp_node2->child1 = g_copy; derivative = temp_node; break; case DOUBLEEXTENDED: printMessage(1,SOLLYA_MSG_DOUBLEEXTENDED_NOT_DIFFERENTIABLE, "Warning: the double-extended rounding operator is not differentiable.\nReplacing it by a constant function when differentiating.\n"); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; case LIBRARYFUNCTION: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = LIBRARYFUNCTION; temp_node2->libFun = tree->libFun; temp_node2->libFunDeriv = tree->libFunDeriv + 1; temp_node->child1 = temp_node2; temp_node2->child1 = g_copy; derivative = temp_node; break; case PROCEDUREFUNCTION: g_copy = copyTree(tree->child1); g_diff = differentiateUnsimplified(tree->child1); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = MUL; temp_node->child2 = g_diff; temp_node2 = (node*) safeMalloc(sizeof(node)); temp_node2->nodeType = PROCEDUREFUNCTION; temp_node2->child2 = copyThing(tree->child2); temp_node2->libFunDeriv = tree->libFunDeriv + 1; temp_node->child1 = temp_node2; temp_node2->child1 = g_copy; derivative = temp_node; break; case CEIL: printMessage(1,SOLLYA_MSG_CEIL_NOT_DIFFERENTIABLE, "Warning: the ceil operator is not differentiable.\nReplacing it by a constant function when differentiating.\n"); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; case FLOOR: printMessage(1,SOLLYA_MSG_FLOOR_NOT_DIFFERENTIABLE, "Warning: the floor operator is not differentiable.\nReplacing it by a constant function when differentiating.\n"); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; case NEARESTINT: printMessage(1,SOLLYA_MSG_NEARESTINT_NOT_DIFFERENTIABLE, "Warning: the nearestint operator is not differentiable.\nReplacing it by a constant function when differentiating.\n"); mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; case PI_CONST: case LIBRARYCONSTANT: mpfr_temp = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); temp_node = (node*) safeMalloc(sizeof(node)); temp_node->nodeType = CONSTANT; temp_node->value = mpfr_temp; derivative = temp_node; break; default: sollyaFprintf(stderr,"Error: differentiateUnsimplified: unknown identifier in the tree\n"); exit(1); } } } return addMemRef(derivative); } int isHorner(node *); int isCanonical(node *); node* differentiateInner(node *tree); node* differentiate(node *tree) { node *res; if ((tree->nodeType == MEMREF) && (tree->derivCache != NULL)) { return copyTree(tree->derivCache); } res = addMemRef(differentiateInner(tree)); if ((tree->nodeType == MEMREF) && (tree->derivCache == NULL) && (res->nodeType == MEMREF)) { tree->derivCache = copyTree(res); } return res; } node* differentiateInner(node *tree) { node *temp, *temp2, *temp3; printMessage(10,SOLLYA_MSG_FORMALLY_DIFFERENTIATING_AN_EXPRESSION,"Information: formally differentiating a function.\n"); printMessage(11,SOLLYA_MSG_FORMALLY_DIFFERENTIATING_A_PARTICULAR_EXPR,"Information: differentiating the expression '%b'\n",tree); if ((tree->nodeType == MEMREF) && (tree->polynomialRepresentation != NULL)) { temp = addMemRefEvenOnNull(NULL); if (temp != NULL) { temp->polynomialRepresentation = polynomialDeriv(tree->polynomialRepresentation); return temp; } } if (isPolynomial(tree) && (isHorner(tree) || isCanonical(tree))) { temp3 = differentiateUnsimplified(tree); temp = simplifyTreeErrorfree(temp3); free_memory(temp3); } else { if ((treeSize(tree) > MAXDIFFSIMPLSIZE) || (getDegree(tree) > MAXDIFFSIMPLDEGREE)) { printMessage(7,SOLLYA_MSG_EXPR_TOO_BIG_FOR_SIMPLIFICATION_BEFORE_DIFF,"Information: will not simplify the given expression before differentiating because it is too big.\n"); temp = differentiateUnsimplified(tree); } else { temp3 = simplifyTreeErrorfree(tree); temp2 = differentiateUnsimplified(temp3); temp = simplifyTreeErrorfree(temp2); free_memory(temp3); free_memory(temp2); } } return temp; } int evaluateConstantExpression(mpfr_t result, node *tree, mp_prec_t prec) { mpfr_t cutoff; int res; if (!isConstant(tree)) return 0; mpfr_init2(cutoff, 12); mpfr_set_si(cutoff, 0, GMP_RNDN); res = evaluateFaithfulWithCutOffFast(result, tree, NULL, cutoff, cutoff, prec); if ((res == 0) || (res == 3)) { evaluate(result, tree, cutoff, prec); } mpfr_clear(cutoff); return 1; } node* simplifyTreeInnerst(node *tree); node* simplifyTreeInner(node *tree) { node *res; res = addMemRef(simplifyTreeInnerst(tree)); if ((tree != NULL) && (res != NULL) && (tree->nodeType == MEMREF) && (!((res->nodeType == MEMREF) && (((tree->child1 != NULL) && (!tree->memRefChildFromPolynomial)) && (res->child1 == NULL)))) && isSyntacticallyEqualCheap(tree,res)) { free_memory(res); res = copyTree(tree); } return res; } node* simplifyTreeInnerst(node *tree) { node *simplChild1, *simplChild2, *simplified; mpfr_t *value; mpfr_t temp, x, y; sollya_mpfi_t tempI; int numberChilds; node *res; node *kind; if ((tree->nodeType == MEMREF) && (tree->child1 != NULL) && (tree->polynomialRepresentation == NULL)) { kind = getMemRefChild(tree); if (accessThruMemRef(kind)->nodeType == CONSTANT) { if (mpfr_get_prec(*(accessThruMemRef(kind)->value)) <= tools_precision) { return copyTree(tree); } } } if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) { if (((tree->child1 == NULL) || tree->memRefChildFromPolynomial) && polynomialCoefficientsAreDyadic(tree->polynomialRepresentation, 0)) { return copyTree(tree); } res = addMemRefEvenOnNull(NULL); if (res != NULL) { res->polynomialRepresentation = polynomialRoundDyadic(tree->polynomialRepresentation, tools_precision); return res; } } return addMemRef(simplifyTreeInner(getMemRefChild(tree))); } if ((tree->nodeType == CONSTANT) && (mpfr_nan_p(*(tree->value)))) return copyTree(tree); if (tree->nodeType != VARIABLE) { numberChilds = arity(tree); switch (numberChilds) { case 0: break; case 1: if ((accessThruMemRef(tree->child1)->nodeType == CONSTANT) && (mpfr_nan_p(*(accessThruMemRef(tree->child1)->value)))) return copyTree(tree); break; case 2: if ((accessThruMemRef(tree->child1)->nodeType == CONSTANT) && (mpfr_nan_p(*(accessThruMemRef(tree->child1)->value)))) { if (isConstant(tree)) return copyTree(tree->child1); return copyTree(tree); } if ((accessThruMemRef(tree->child2)->nodeType == CONSTANT) && (mpfr_nan_p(*(accessThruMemRef(tree->child2)->value)))) { if (isConstant(tree)) return copyTree(tree->child2); return copyTree(tree); } break; default: sollyaFprintf(stderr,"Error: simplifyTreeInner: unknown arity of tree node symbol.\n"); exit(1); } } if (isConstant(tree) && (tree->nodeType != CONSTANT)) { mpfr_init2(x, tools_precision); mpfr_init2(y, tools_precision); mpfr_set_si(x, 1, GMP_RNDN); /* exact */ if (evaluateFaithful(y, tree, x, tools_precision)) { simplified = makeConstant(y); mpfr_clear(y); mpfr_clear(x); return simplified; } mpfr_clear(y); mpfr_clear(x); } switch (tree->nodeType) { case VARIABLE: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = VARIABLE; break; case CONSTANT: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(temp,tools_precision); simplifyMpfrPrec(temp,*(tree->value)); mpfr_init2(*value,mpfr_get_prec(temp)); mpfr_set(*value,temp,GMP_RNDN); mpfr_clear(temp); simplified->value = value; break; case ADD: simplChild1 = simplifyTreeInner(tree->child1); simplChild2 = simplifyTreeInner(tree->child2); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_add(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN); free_memory(simplChild1); free_memory(simplChild2); } else { if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); safeFree(simplified); simplified = simplChild2; } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild2)->value)))) { free_memory(simplChild2); safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = ADD; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } break; case SUB: simplChild1 = simplifyTreeInner(tree->child1); simplChild2 = simplifyTreeInner(tree->child2); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_sub(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN); free_memory(simplChild1); free_memory(simplChild2); } else { if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); simplified->nodeType = NEG; simplified->child1 = simplChild2; } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild2)->value)))) { free_memory(simplChild2); safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = SUB; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } break; case MUL: simplChild1 = simplifyTreeInner(tree->child1); simplChild2 = simplifyTreeInner(tree->child2); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_mul(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN); free_memory(simplChild1); free_memory(simplChild2); } else { if (((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild1)->value)))) || ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild2)->value))))) { free_memory(simplChild1); free_memory(simplChild2); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_set_d(*value,0.0,GMP_RNDN); } else { if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild1)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); safeFree(simplified); simplified = simplChild2; } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild2)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild2)->value)))) { free_memory(simplChild2); safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = MUL; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } } break; case DIV: simplChild1 = simplifyTreeInner(tree->child1); simplChild2 = simplifyTreeInner(tree->child2); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_div(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN); free_memory(simplChild1); free_memory(simplChild2); } else { if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); free_memory(simplChild2); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_set_d(*value,0.0,GMP_RNDN); } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild2)->value),1.0) == 0)) { if (mpfr_nan_p(*(accessThruMemRef(simplChild2)->value))) { simplified->nodeType = MUL; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } else { free_memory(simplChild2); safeFree(simplified); simplified = simplChild1; } } else { simplified->nodeType = DIV; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } break; case SQRT: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_sqrt(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = SQRT; simplified->child1 = simplChild1; } break; case EXP: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_exp(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = EXP; simplified->child1 = simplChild1; } break; case LOG: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_log(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = LOG; simplified->child1 = simplChild1; } break; case LOG_2: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_log2(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = LOG_2; simplified->child1 = simplChild1; } break; case LOG_10: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_log10(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = LOG_10; simplified->child1 = simplChild1; } break; case SIN: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_sin(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = SIN; simplified->child1 = simplChild1; } break; case COS: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_cos(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = COS; simplified->child1 = simplChild1; } break; case TAN: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_tan(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = TAN; simplified->child1 = simplChild1; } break; case ASIN: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_asin(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ASIN; simplified->child1 = simplChild1; } break; case ACOS: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_acos(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ACOS; simplified->child1 = simplChild1; } break; case ATAN: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_atan(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ATAN; simplified->child1 = simplChild1; } break; case SINH: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_sinh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = SINH; simplified->child1 = simplChild1; } break; case COSH: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_cosh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = COSH; simplified->child1 = simplChild1; } break; case TANH: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_tanh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = TANH; simplified->child1 = simplChild1; } break; case ASINH: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_asinh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ASINH; simplified->child1 = simplChild1; } break; case ACOSH: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_acosh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ACOSH; simplified->child1 = simplChild1; } break; case ATANH: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_atanh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ATANH; simplified->child1 = simplChild1; } break; case POW: simplChild1 = simplifyTreeInner(tree->child1); simplChild2 = simplifyTreeInner(tree->child2); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_pow(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN); free_memory(simplChild1); free_memory(simplChild2); } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild2)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild2)->value)))) { safeFree(simplified); free_memory(simplChild2); simplified = simplChild1; } else { simplified->nodeType = POW; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } break; case NEG: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_neg(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = NEG; simplified->child1 = simplChild1; } break; case ABS: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_abs(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ABS; simplified->child1 = simplChild1; } break; case DOUBLE: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 64)? tools_precision : 64)); simplified->value = value; mpfr_round_to_double(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = DOUBLE; simplified->child1 = simplChild1; } break; case SINGLE: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 64)? tools_precision : 64)); simplified->value = value; mpfr_round_to_single(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = SINGLE; simplified->child1 = simplChild1; } break; case QUAD: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 128)? tools_precision : 128)); simplified->value = value; mpfr_round_to_quad(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = QUAD; simplified->child1 = simplChild1; } break; case HALFPRECISION: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 64)? tools_precision : 64)); simplified->value = value; mpfr_round_to_halfprecision(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = HALFPRECISION; simplified->child1 = simplChild1; } break; case DOUBLEDOUBLE: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 129)? tools_precision : 129)); simplified->value = value; mpfr_round_to_doubledouble(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = DOUBLEDOUBLE; simplified->child1 = simplChild1; } break; case TRIPLEDOUBLE: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 200)? tools_precision : 200)); simplified->value = value; mpfr_round_to_tripledouble(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = TRIPLEDOUBLE; simplified->child1 = simplChild1; } break; case ERF: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_erf(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ERF; simplified->child1 = simplChild1; } break; case ERFC: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_erfc(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ERFC; simplified->child1 = simplChild1; } break; case LOG_1P: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_log1p(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = LOG_1P; simplified->child1 = simplChild1; } break; case EXP_M1: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_expm1(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = EXP_M1; simplified->child1 = simplChild1; } break; case DOUBLEEXTENDED: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 128)? tools_precision : 128)); simplified->value = value; mpfr_round_to_doubleextended(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = DOUBLEEXTENDED; simplified->child1 = simplChild1; } break; case LIBRARYFUNCTION: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if (tree->libFun->hasData) { mpfr_from_mpfi_data(*value, *(accessThruMemRef(simplChild1)->value), tree->libFunDeriv, tree->libFun->code, tree->libFun->data); } else { mpfr_from_mpfi(*value, *(accessThruMemRef(simplChild1)->value), tree->libFunDeriv, tree->libFun->code); } free_memory(simplChild1); } else { simplified->nodeType = LIBRARYFUNCTION; simplified->child1 = simplChild1; simplified->libFun = tree->libFun; simplified->libFunDeriv = tree->libFunDeriv; } break; case PROCEDUREFUNCTION: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; computeFunctionWithProcedureMpfr(*value, tree->child2, *(accessThruMemRef(simplChild1)->value), (unsigned int) tree->libFunDeriv); free_memory(simplChild1); } else { simplified->nodeType = PROCEDUREFUNCTION; simplified->child1 = simplChild1; simplified->child2 = copyThing(tree->child2); simplified->libFunDeriv = tree->libFunDeriv; } break; case CEIL: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_ceil(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = CEIL; simplified->child1 = simplChild1; } break; case FLOOR: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_floor(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = FLOOR; simplified->child1 = simplChild1; } break; case NEARESTINT: simplChild1 = simplifyTreeInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; sollya_mpfr_rint_nearestint(*value, *(accessThruMemRef(simplChild1)->value),GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = NEARESTINT; simplified->child1 = simplChild1; } break; case PI_CONST: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_const_pi(*value,GMP_RNDN); simplified->value = value; break; case LIBRARYCONSTANT: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); sollya_mpfi_init2(tempI, tools_precision); libraryConstantToInterval(tempI, tree); sollya_mpfi_get_fr(*value, tempI); sollya_mpfi_clear(tempI); simplified->value = value; break; default: sollyaFprintf(stderr,"Error: simplifyTreeInnerst: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return simplified; } node* simplifyAllButDivisionInnerst(node *tree); node* simplifyAllButDivisionInner(node *tree) { node *res; res = addMemRef(simplifyAllButDivisionInnerst(tree)); if ((tree != NULL) && (res != NULL) && (tree->nodeType == MEMREF) && isSyntacticallyEqualCheap(tree,res)) { free_memory(res); res = copyTree(tree); } return res; } node* simplifyAllButDivisionInnerst(node *tree) { node *simplChild1, *simplChild2, *simplified; mpfr_t *value; mpfr_t temp; sollya_mpfi_t tempI; node *res; if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) { if (((tree->child1 == NULL) || tree->memRefChildFromPolynomial) && polynomialCoefficientsAreRational(tree->polynomialRepresentation, 0)) return copyTree(tree); res = addMemRefEvenOnNull(NULL); if (res != NULL) { res->polynomialRepresentation = polynomialRoundRational(tree->polynomialRepresentation, tools_precision); return res; } } return addMemRef(simplifyAllButDivisionInner(getMemRefChild(tree))); } switch (tree->nodeType) { case VARIABLE: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = VARIABLE; break; case CONSTANT: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(temp,((tools_precision > mpfr_get_prec(*(tree->value))) ? (tools_precision) : (mpfr_get_prec(*(tree->value))))); simplifyMpfrPrec(temp,*(tree->value)); mpfr_init2(*value,mpfr_get_prec(temp)); mpfr_set(*value,temp,GMP_RNDN); mpfr_clear(temp); simplified->value = value; break; case ADD: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplChild2 = simplifyAllButDivisionInner(tree->child2); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_add(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN); free_memory(simplChild1); free_memory(simplChild2); } else { if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); safeFree(simplified); simplified = simplChild2; } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild2)->value)))) { free_memory(simplChild2); safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = ADD; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } break; case SUB: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplChild2 = simplifyAllButDivisionInner(tree->child2); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_sub(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN); free_memory(simplChild1); free_memory(simplChild2); } else { if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); simplified->nodeType = NEG; simplified->child1 = simplChild2; } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild2)->value)))) { free_memory(simplChild2); safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = SUB; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } break; case MUL: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplChild2 = simplifyAllButDivisionInner(tree->child2); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_mul(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN); free_memory(simplChild1); free_memory(simplChild2); } else { if (((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild1)->value)))) || ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(simplChild2)->value))))) { free_memory(simplChild1); free_memory(simplChild2); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_set_d(*value,0.0,GMP_RNDN); } else { if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild1)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild1)->value)))) { free_memory(simplChild1); safeFree(simplified); simplified = simplChild2; } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild2)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild2)->value)))) { free_memory(simplChild2); safeFree(simplified); simplified = simplChild1; } else { simplified->nodeType = MUL; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } } } break; case DIV: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplChild2 = simplifyAllButDivisionInner(tree->child2); simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = DIV; simplified->child1 = simplChild1; simplified->child2 = simplChild2; break; case SQRT: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_sqrt(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = SQRT; simplified->child1 = simplChild1; } break; case EXP: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_exp(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = EXP; simplified->child1 = simplChild1; } break; case LOG: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_log(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = LOG; simplified->child1 = simplChild1; } break; case LOG_2: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_log2(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = LOG_2; simplified->child1 = simplChild1; } break; case LOG_10: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_log10(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = LOG_10; simplified->child1 = simplChild1; } break; case SIN: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_sin(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = SIN; simplified->child1 = simplChild1; } break; case COS: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_cos(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = COS; simplified->child1 = simplChild1; } break; case TAN: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_tan(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = TAN; simplified->child1 = simplChild1; } break; case ASIN: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_asin(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ASIN; simplified->child1 = simplChild1; } break; case ACOS: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_acos(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ACOS; simplified->child1 = simplChild1; } break; case ATAN: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_atan(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ATAN; simplified->child1 = simplChild1; } break; case SINH: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_sinh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = SINH; simplified->child1 = simplChild1; } break; case COSH: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_cosh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = COSH; simplified->child1 = simplChild1; } break; case TANH: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_tanh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = TANH; simplified->child1 = simplChild1; } break; case ASINH: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_asinh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ASINH; simplified->child1 = simplChild1; } break; case ACOSH: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_acosh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ACOSH; simplified->child1 = simplChild1; } break; case ATANH: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_atanh(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ATANH; simplified->child1 = simplChild1; } break; case POW: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplChild2 = simplifyAllButDivisionInner(tree->child2); simplified = (node*) safeMalloc(sizeof(node)); if ((accessThruMemRef(simplChild1)->nodeType == CONSTANT) && (accessThruMemRef(simplChild2)->nodeType == CONSTANT)) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_pow(*value, *(accessThruMemRef(simplChild1)->value), *(accessThruMemRef(simplChild2)->value), GMP_RNDN); free_memory(simplChild1); free_memory(simplChild2); } else { if ((accessThruMemRef(simplChild2)->nodeType == CONSTANT) && (mpfr_cmp_d(*(accessThruMemRef(simplChild2)->value),1.0) == 0) && (!mpfr_nan_p(*(accessThruMemRef(simplChild2)->value)))) { safeFree(simplified); free_memory(simplChild2); simplified = simplChild1; } else { simplified->nodeType = POW; simplified->child1 = simplChild1; simplified->child2 = simplChild2; } } break; case NEG: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_neg(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = NEG; simplified->child1 = simplChild1; } break; case ABS: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_abs(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ABS; simplified->child1 = simplChild1; } break; case DOUBLE: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 64)? tools_precision : 64)); simplified->value = value; mpfr_round_to_double(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = DOUBLE; simplified->child1 = simplChild1; } break; case SINGLE: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 64)? tools_precision : 64)); simplified->value = value; mpfr_round_to_single(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = SINGLE; simplified->child1 = simplChild1; } break; case HALFPRECISION: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 64)? tools_precision : 64)); simplified->value = value; mpfr_round_to_halfprecision(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = HALFPRECISION; simplified->child1 = simplChild1; } break; case QUAD: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 128)? tools_precision : 128)); simplified->value = value; mpfr_round_to_quad(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = QUAD; simplified->child1 = simplChild1; } break; case DOUBLEDOUBLE: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 129)? tools_precision : 129)); simplified->value = value; mpfr_round_to_doubledouble(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = DOUBLEDOUBLE; simplified->child1 = simplChild1; } break; case TRIPLEDOUBLE: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 200)? tools_precision : 200)); simplified->value = value; mpfr_round_to_tripledouble(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = TRIPLEDOUBLE; simplified->child1 = simplChild1; } break; case ERF: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_erf(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ERF; simplified->child1 = simplChild1; } break; case ERFC: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_erfc(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = ERFC; simplified->child1 = simplChild1; } break; case LOG_1P: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_log1p(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = LOG_1P; simplified->child1 = simplChild1; } break; case EXP_M1: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_expm1(*value, *(accessThruMemRef(simplChild1)->value), GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = EXP_M1; simplified->child1 = simplChild1; } break; case DOUBLEEXTENDED: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,((tools_precision > 128)? tools_precision : 128)); simplified->value = value; mpfr_round_to_doubleextended(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = DOUBLEEXTENDED; simplified->child1 = simplChild1; } break; case LIBRARYFUNCTION: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; if (tree->libFun->hasData) { mpfr_from_mpfi_data(*value, *(accessThruMemRef(simplChild1)->value), tree->libFunDeriv, tree->libFun->code, tree->libFun->data); } else { mpfr_from_mpfi(*value, *(accessThruMemRef(simplChild1)->value), tree->libFunDeriv, tree->libFun->code); } free_memory(simplChild1); } else { simplified->nodeType = LIBRARYFUNCTION; simplified->child1 = simplChild1; simplified->libFun = tree->libFun; simplified->libFunDeriv = tree->libFunDeriv; } break; case PROCEDUREFUNCTION: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; computeFunctionWithProcedureMpfr(*value, tree->child2, *(accessThruMemRef(simplChild1)->value), (unsigned int) tree->libFunDeriv); free_memory(simplChild1); } else { simplified->nodeType = PROCEDUREFUNCTION; simplified->child1 = simplChild1; simplified->child2 = copyThing(tree->child2); simplified->libFunDeriv = tree->libFunDeriv; } break; case CEIL: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_ceil(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = CEIL; simplified->child1 = simplChild1; } break; case FLOOR: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; mpfr_floor(*value, *(accessThruMemRef(simplChild1)->value)); free_memory(simplChild1); } else { simplified->nodeType = FLOOR; simplified->child1 = simplChild1; } break; case NEARESTINT: simplChild1 = simplifyAllButDivisionInner(tree->child1); simplified = (node*) safeMalloc(sizeof(node)); if (accessThruMemRef(simplChild1)->nodeType == CONSTANT) { simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); simplified->value = value; sollya_mpfr_rint_nearestint(*value, *(accessThruMemRef(simplChild1)->value),GMP_RNDN); free_memory(simplChild1); } else { simplified->nodeType = NEARESTINT; simplified->child1 = simplChild1; } break; case PI_CONST: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_const_pi(*value,GMP_RNDN); simplified->value = value; break; case LIBRARYCONSTANT: simplified = (node*) safeMalloc(sizeof(node)); simplified->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); sollya_mpfi_init2(tempI, tools_precision); libraryConstantToInterval(tempI, tree); sollya_mpfi_get_fr(*value, tempI); sollya_mpfi_clear(tempI); simplified->value = value; break; default: sollyaFprintf(stderr,"Error: simplifyAllButDivisionInnerst: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return simplified; } node *simplifyTree(node *tree) { node *temp, *temp2; temp = simplifyTreeErrorfree(tree); temp2 = simplifyTreeInner(temp); free_memory(temp); return temp2; } node *simplifyAllButDivision(node *tree) { node *temp, *temp2, *temp3, *temp4; temp = addMemRef(simplifyTreeErrorfree(tree)); temp2 = addMemRef(simplifyRationalErrorfree(temp)); temp3 = addMemRef(simplifyTreeErrorfree(temp2)); temp4 = addMemRef(simplifyAllButDivisionInner(temp3)); free_memory(temp); free_memory(temp2); free_memory(temp3); return addMemRef(temp4); } void evaluate(mpfr_t result, node *tree, mpfr_t x, mp_prec_t prec) { mpfr_t stack1, stack2, myResult; sollya_mpfi_t stackI, X, Y; if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) { polynomialEvalMpfr(result, tree->polynomialRepresentation, x); return; } if (tree->evaluationHook != NULL) { sollya_mpfi_init2(X,mpfr_get_prec(x)); sollya_mpfi_set_fr(X, x); sollya_mpfi_init2(Y,mpfr_get_prec(result)); if (evaluateWithEvaluationHook(Y, X, prec, 1, tree->evaluationHook)) { if (sollya_mpfi_has_zero(Y)) { mpfr_set_si(result, 0, GMP_RNDN); } else { sollya_mpfi_mid(result, Y); } sollya_mpfi_clear(X); sollya_mpfi_clear(Y); return; } sollya_mpfi_clear(X); sollya_mpfi_clear(Y); } evaluate(result, getMemRefChild(tree), x, prec); return; } mpfr_init2(stack1, prec); mpfr_init2(stack2, prec); switch (tree->nodeType) { case VARIABLE: mpfr_set(result, x, GMP_RNDN); break; case CONSTANT: mpfr_set(result, *(tree->value), GMP_RNDN); break; case ADD: evaluate(stack1, tree->child1, x, prec); evaluate(stack2, tree->child2, x, prec); mpfr_add(result, stack1, stack2, GMP_RNDN); break; case SUB: evaluate(stack1, tree->child1, x, prec); evaluate(stack2, tree->child2, x, prec); mpfr_sub(result, stack1, stack2, GMP_RNDN); break; case MUL: evaluate(stack1, tree->child1, x, prec); evaluate(stack2, tree->child2, x, prec); mpfr_mul(result, stack1, stack2, GMP_RNDN); break; case DIV: evaluate(stack1, tree->child1, x, prec); evaluate(stack2, tree->child2, x, prec); mpfr_div(result, stack1, stack2, GMP_RNDN); break; case SQRT: evaluate(stack1, tree->child1, x, prec); mpfr_sqrt(result, stack1, GMP_RNDN); break; case EXP: evaluate(stack1, tree->child1, x, prec); mpfr_exp(result, stack1, GMP_RNDN); break; case LOG: evaluate(stack1, tree->child1, x, prec); mpfr_log(result, stack1, GMP_RNDN); break; case LOG_2: evaluate(stack1, tree->child1, x, prec); mpfr_log2(result, stack1, GMP_RNDN); break; case LOG_10: evaluate(stack1, tree->child1, x, prec); mpfr_log10(result, stack1, GMP_RNDN); break; case SIN: evaluate(stack1, tree->child1, x, prec); mpfr_sin(result, stack1, GMP_RNDN); break; case COS: evaluate(stack1, tree->child1, x, prec); mpfr_cos(result, stack1, GMP_RNDN); break; case TAN: evaluate(stack1, tree->child1, x, prec); mpfr_tan(result, stack1, GMP_RNDN); break; case ASIN: evaluate(stack1, tree->child1, x, prec); mpfr_asin(result, stack1, GMP_RNDN); break; case ACOS: evaluate(stack1, tree->child1, x, prec); mpfr_acos(result, stack1, GMP_RNDN); break; case ATAN: evaluate(stack1, tree->child1, x, prec); mpfr_atan(result, stack1, GMP_RNDN); break; case SINH: evaluate(stack1, tree->child1, x, prec); mpfr_sinh(result, stack1, GMP_RNDN); break; case COSH: evaluate(stack1, tree->child1, x, prec); mpfr_cosh(result, stack1, GMP_RNDN); break; case TANH: evaluate(stack1, tree->child1, x, prec); mpfr_tanh(result, stack1, GMP_RNDN); break; case ASINH: evaluate(stack1, tree->child1, x, prec); mpfr_asinh(result, stack1, GMP_RNDN); break; case ACOSH: evaluate(stack1, tree->child1, x, prec); mpfr_acosh(result, stack1, GMP_RNDN); break; case ATANH: evaluate(stack1, tree->child1, x, prec); mpfr_atanh(result, stack1, GMP_RNDN); break; case POW: evaluate(stack1, tree->child1, x, prec); evaluate(stack2, tree->child2, x, prec); mpfr_pow(result, stack1, stack2, GMP_RNDN); break; case NEG: evaluate(stack1, tree->child1, x, prec); mpfr_neg(result, stack1, GMP_RNDN); break; case ABS: evaluate(stack1, tree->child1, x, prec); mpfr_abs(result, stack1, GMP_RNDN); break; case DOUBLE: evaluate(stack1, tree->child1, x, prec); mpfr_init2(myResult, ((mpfr_get_prec(result) > 64)? mpfr_get_prec(result) : 64)); mpfr_round_to_double(myResult, stack1); mpfr_set(result, myResult, GMP_RNDN); mpfr_clear(myResult); break; case SINGLE: evaluate(stack1, tree->child1, x, prec); mpfr_init2(myResult, ((mpfr_get_prec(result) > 64)? mpfr_get_prec(result) : 64)); mpfr_round_to_single(myResult, stack1); mpfr_set(result, myResult, GMP_RNDN); mpfr_clear(myResult); break; case QUAD: evaluate(stack1, tree->child1, x, prec); mpfr_init2(myResult, ((mpfr_get_prec(result) > 128)? mpfr_get_prec(result) : 128)); mpfr_round_to_single(myResult, stack1); mpfr_set(result, myResult, GMP_RNDN); mpfr_clear(myResult); break; case HALFPRECISION: evaluate(stack1, tree->child1, x, prec); mpfr_init2(myResult, ((mpfr_get_prec(result) > 64)? mpfr_get_prec(result) : 64)); mpfr_round_to_single(myResult, stack1); mpfr_set(result, myResult, GMP_RNDN); mpfr_clear(myResult); break; case DOUBLEDOUBLE: evaluate(stack1, tree->child1, x, prec); mpfr_init2(myResult, ((mpfr_get_prec(result) > 129)? mpfr_get_prec(result) : 129)); mpfr_round_to_single(myResult, stack1); mpfr_set(result, myResult, GMP_RNDN); mpfr_clear(myResult); break; case TRIPLEDOUBLE: evaluate(stack1, tree->child1, x, prec); mpfr_init2(myResult, ((mpfr_get_prec(result) > 200)? mpfr_get_prec(result) : 200)); mpfr_round_to_single(myResult, stack1); mpfr_set(result, myResult, GMP_RNDN); mpfr_clear(myResult); break; case ERF: evaluate(stack1, tree->child1, x, prec); mpfr_erf(result, stack1, GMP_RNDN); break; case ERFC: evaluate(stack1, tree->child1, x, prec); mpfr_erfc(result, stack1, GMP_RNDN); break; case LOG_1P: evaluate(stack1, tree->child1, x, prec); mpfr_log1p(result, stack1, GMP_RNDN); break; case EXP_M1: evaluate(stack1, tree->child1, x, prec); mpfr_expm1(result, stack1, GMP_RNDN); break; case DOUBLEEXTENDED: evaluate(stack1, tree->child1, x, prec); mpfr_init2(myResult, ((mpfr_get_prec(result) > 128)? mpfr_get_prec(result) : 128)); mpfr_round_to_single(myResult, stack1); mpfr_set(result, myResult, GMP_RNDN); mpfr_clear(myResult); break; case LIBRARYFUNCTION: evaluate(stack1, tree->child1, x, prec); if (tree->libFun->hasData) { mpfr_from_mpfi_data(result, stack1, tree->libFunDeriv, tree->libFun->code, tree->libFun->data); } else { mpfr_from_mpfi(result, stack1, tree->libFunDeriv, tree->libFun->code); } break; case PROCEDUREFUNCTION: evaluate(stack1, tree->child1, x, prec); computeFunctionWithProcedureMpfr(result, tree->child2, stack1, (unsigned int) tree->libFunDeriv); break; case CEIL: evaluate(stack1, tree->child1, x, prec); mpfr_ceil(result, stack1); break; case FLOOR: evaluate(stack1, tree->child1, x, prec); mpfr_floor(result, stack1); break; case NEARESTINT: evaluate(stack1, tree->child1, x, prec); sollya_mpfr_rint_nearestint(result, stack1, GMP_RNDN); break; case PI_CONST: mpfr_const_pi(result, GMP_RNDN); break; case LIBRARYCONSTANT: sollya_mpfi_init2(stackI, mpfr_get_prec(result)); libraryConstantToInterval(stackI, tree); sollya_mpfi_get_fr(result, stackI); sollya_mpfi_clear(stackI); break; default: sollyaFprintf(stderr,"Error: evaluate: unknown identifier in the tree\n"); exit(1); } mpfr_clear(stack1); mpfr_clear(stack2); return; } int arity(node *tree) { switch (tree->nodeType) { case MEMREF: return arity(getMemRefChild(tree)); break; case CONSTANT: case PI_CONST: case LIBRARYCONSTANT: return 0; break; case ADD: case SUB: case MUL: case DIV: case POW: return 2; break; case VARIABLE: case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case DOUBLE: case SINGLE: case QUAD: case HALFPRECISION: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case LIBRARYFUNCTION: case PROCEDUREFUNCTION: return 1; break; case CEIL: case FLOOR: case NEARESTINT: return 1; break; default: sollyaFprintf(stderr,"Error: arity: unknown identifier in the tree\n"); exit(1); } } int isSyntacticallyEqualCheap(node *tree1, node *tree2) { if (tree1 == tree2) return 1; if ((tree1->nodeType == MEMREF) && (tree2->nodeType == MEMREF) && (tree1->polynomialRepresentation != NULL) && (tree2->polynomialRepresentation != NULL) && (tree1->polynomialRepresentation == tree2->polynomialRepresentation)) return 1; if (tree1->nodeType == MEMREF) return isSyntacticallyEqualCheap(getMemRefChild(tree1), tree2); if (tree2->nodeType == MEMREF) return isSyntacticallyEqualCheap(tree1, getMemRefChild(tree2)); if (tree1->nodeType != tree2->nodeType) return 0; if (tree1->nodeType == PI_CONST) return 1; if ((tree1->nodeType == LIBRARYFUNCTION) && ((tree1->libFun != tree2->libFun) || (tree1->libFunDeriv != tree2->libFunDeriv))) return 0; if (tree1->nodeType == LIBRARYCONSTANT) return (tree1->libFun == tree2->libFun); if ((tree1->nodeType == PROCEDUREFUNCTION) && ((!isEqualThing(tree1->child2, tree2->child2)) || (tree1->libFunDeriv != tree2->libFunDeriv))) return 0; if (tree1->nodeType == CONSTANT) { if (mpfr_equal_p(*(tree1->value),*(tree2->value))) return 1; else return 0; } if (tree1->nodeType == VARIABLE) return 1; if (arity(tree1) == 1) { if (!isSyntacticallyEqualCheap(tree1->child1,tree2->child1)) return 0; } else { if (!isSyntacticallyEqualCheap(tree1->child1,tree2->child1)) return 0; if (!isSyntacticallyEqualCheap(tree1->child2,tree2->child2)) return 0; } return 1; } int isSyntacticallyEqual(node *tree1, node *tree2) { if ((tree1->nodeType == MEMREF) && (tree2->nodeType == MEMREF) && (tree1->polynomialRepresentation != NULL) && (tree2->polynomialRepresentation != NULL)) { return polynomialEqual(tree1->polynomialRepresentation, tree2->polynomialRepresentation, 0); } return isSyntacticallyEqualCheap(tree1, tree2); } int isConstant(node *tree); int isPolynomial(node *tree) { int res; node *temp; if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) return 1; return isPolynomial(getMemRefChild(tree)); } if (isConstant(tree)) return 1; switch (tree->nodeType) { case VARIABLE: res = 1; break; case CONSTANT: res = 1; break; case ADD: res = isPolynomial(tree->child1) && isPolynomial(tree->child2); break; case SUB: res = isPolynomial(tree->child1) && isPolynomial(tree->child2); break; case MUL: res = isPolynomial(tree->child1) && isPolynomial(tree->child2); break; case DIV: res = isPolynomial(tree->child1) && isConstant(tree->child2); break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case ABS: case DOUBLE: case SINGLE: case QUAD: case HALFPRECISION: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case LIBRARYFUNCTION: case CEIL: case FLOOR: case NEARESTINT: res = 0; break; case POW: { res = 0; if (isPolynomial(tree->child1)) { if (accessThruMemRef(tree->child2)->nodeType == CONSTANT) temp = tree->child2; else temp = simplifyTreeErrorfree(tree->child2); if (accessThruMemRef(temp)->nodeType == CONSTANT) { if (mpfr_integer_p(*(accessThruMemRef(temp)->value))) { if (mpfr_sgn(*(accessThruMemRef(temp)->value)) >= 0) { res = 1; } } } if (accessThruMemRef(tree->child2)->nodeType != CONSTANT) free_memory(temp); } } break; case NEG: res = isPolynomial(tree->child1); break; case PROCEDUREFUNCTION: res = 0; break; case PI_CONST: case LIBRARYCONSTANT: res = 1; break; default: sollyaFprintf(stderr,"Error: isPolynomial: unknown identifier in the tree\n"); exit(1); } return res; } int isRationalFunction(node *tree) { node *temp; int res; /* Handle all polynomials and constant expressions (constants, pi, library constants etc.) */ if (isPolynomial(tree)) return 1; /* Handle memory reference counting */ if (tree->nodeType == MEMREF) { return isRationalFunction(getMemRefChild(tree)); } switch (tree->nodeType) { case ADD: case SUB: case MUL: case DIV: /* Sums, productions and quotients are rational functions iff their operands are rational functions. */ return (isRationalFunction(tree->child1) && isRationalFunction(tree->child2)); break; case NEG: /* -f is a rational function iff f is a rational function */ return isRationalFunction(tree->child1); break; case POW: /* f^k is a rational function if f is a rational function and k is a constant integer */ if (!isRationalFunction(tree->child1)) return 0; res = 0; if (isPolynomial(tree->child1)) { if (accessThruMemRef(tree->child2)->nodeType == CONSTANT) temp = tree->child2; else temp = simplifyTreeErrorfree(tree->child2); if (accessThruMemRef(temp)->nodeType == CONSTANT) { if (mpfr_integer_p(*(accessThruMemRef(temp)->value))) { res = 1; } } if (accessThruMemRef(tree->child2)->nodeType != CONSTANT) free_memory(temp); } return res; break; default: break; } /* All other functions are deemed not to be rational functions */ return 0; } int isAffine(node *tree) { int res; node *temp; if (tree->nodeType == MEMREF) { return isAffine(getMemRefChild(tree)); } switch (tree->nodeType) { case VARIABLE: res = 1; break; case CONSTANT: res = 1; break; case ADD: res = isAffine(tree->child1) && isAffine(tree->child2); break; case SUB: res = isAffine(tree->child1) && isAffine(tree->child2); break; case MUL: res = isAffine(tree->child1) && isAffine(tree->child2); break; case DIV: case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case ABS: case DOUBLE: case SINGLE: case QUAD: case HALFPRECISION: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case LIBRARYFUNCTION: case CEIL: case FLOOR: case NEARESTINT: res = 0; break; case POW: { res = 0; if (isAffine(tree->child1)) { if (accessThruMemRef(tree->child2)->nodeType == CONSTANT) temp = tree->child2; else temp = simplifyTreeErrorfree(tree->child2); if (accessThruMemRef(temp)->nodeType == CONSTANT) { if (mpfr_number_p(*(accessThruMemRef(temp)->value)) && mpfr_integer_p(*(accessThruMemRef(temp)->value))) { if (mpfr_sgn(*(accessThruMemRef(temp)->value)) > 0) { res = 1; } } } if (accessThruMemRef(tree->child2)->nodeType != CONSTANT) free_memory(temp); } } break; case NEG: res = isAffine(tree->child1); break; case PROCEDUREFUNCTION: res = 0; break; case PI_CONST: case LIBRARYCONSTANT: res = 1; break; default: sollyaFprintf(stderr,"Error: isAffine: unknown identifier in the tree\n"); exit(1); } return res; } #define MAX_MACRO(a,b) (a) > (b) ? (a) : (b) #define MIN_MACRO(a,b) (a) < (b) ? (a) : (b) int getDegreeUnsafe(node *tree, int silent) { int l, r; mpfr_t temp; node *simplifiedExponent; unsigned int h; if (isConstant(tree)) return 0; if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) { return polynomialGetDegreeAsInt(tree->polynomialRepresentation); } return getDegreeUnsafe(getMemRefChild(tree), silent); } switch (tree->nodeType) { case VARIABLE: return 1; break; case CONSTANT: case PI_CONST: return 0; break; case ADD: l = getDegreeUnsafe(tree->child1, silent); r = getDegreeUnsafe(tree->child2, silent); if ((l >= 0) && (r >= 0)) return MAX_MACRO(l,r); else return -1; break; case SUB: l = getDegreeUnsafe(tree->child1, silent); r = getDegreeUnsafe(tree->child2, silent); if ((l >= 0) && (r >= 0)) return MAX_MACRO(l,r); else return -1; break; case MUL: l = getDegreeUnsafe(tree->child1, silent); r = getDegreeUnsafe(tree->child2, silent); if ((l >= 0) && (r >= 0)) return l + r; else return -1; break; case DIV: return getDegreeUnsafe(tree->child1, silent); break; case POW: { l = getDegreeUnsafe(tree->child1, silent); if (accessThruMemRef(tree->child2)->nodeType != CONSTANT) { simplifiedExponent = simplifyRationalErrorfree(tree->child2); if ((accessThruMemRef(simplifiedExponent)->nodeType == CONSTANT) && mpfr_integer_p(*(accessThruMemRef(simplifiedExponent)->value)) && (mpfr_sgn(*(accessThruMemRef(simplifiedExponent)->value)) >= 0)) { h = mpfr_get_ui(*(accessThruMemRef(simplifiedExponent)->value),GMP_RNDN); mpfr_init2(temp,mpfr_get_prec(*(accessThruMemRef(simplifiedExponent)->value)) + 10); mpfr_set_ui(temp,h,GMP_RNDN); if (mpfr_cmp(*(accessThruMemRef(simplifiedExponent)->value),temp) != 0) { if (!silent) printMessage(1, SOLLYA_MSG_DEGREE_OF_POLYNOMIAL_DOESNT_HOLD_ON_MACHINE_INT, "Warning: tried to compute polynomial degree of an expression using a power operator with an exponent which cannot be represented on an integer variable.\n"); mpfr_clear(temp); free_memory(simplifiedExponent); return -1; } mpfr_clear(temp); free_memory(simplifiedExponent); r = (int) h; if ((l >= 0) && (r >= 0)) return l * r; else return -1; } else { sollyaFprintf(stderr,"Error: getDegreeUnsafe: an error occurred. The exponent in a power operator is not constant, not integer or not non-negative.\n"); exit(1); } free_memory(simplifiedExponent); } else { if (!mpfr_integer_p(*(accessThruMemRef(tree->child2)->value))) { sollyaFprintf(stderr,"Error: getDegreeUnsafe: an error occurred. The exponent in a power operator is not integer.\n"); exit(1); } if (mpfr_sgn(*(accessThruMemRef(tree->child2)->value)) < 0) { sollyaFprintf(stderr,"Error: getDegreeUnsafe: an error occurred. The exponent in a power operator is negative.\n"); exit(1); } h = mpfr_get_ui(*(accessThruMemRef(tree->child2)->value),GMP_RNDN); mpfr_init2(temp,mpfr_get_prec(*(accessThruMemRef(tree->child2)->value)) + 10); mpfr_set_ui(temp,h,GMP_RNDN); if (mpfr_cmp(*(accessThruMemRef(tree->child2)->value),temp) != 0) { if (!silent) printMessage(1, SOLLYA_MSG_DEGREE_OF_POLYNOMIAL_DOESNT_HOLD_ON_MACHINE_INT, "Warning: tried to compute polynomial degree of an expression using a power operator with an exponent which cannot be represented on an integer variable.\n"); mpfr_clear(temp); return -1; } mpfr_clear(temp); r = (int) h; if ((l >= 0) && (r >= 0)) return l * r; else return -1; } } break; case NEG: return getDegreeUnsafe(tree->child1, silent); break; default: sollyaFprintf(stderr,"Error: getDegreeUnsafe: an error occurred on handling the expression tree\n"); exit(1); } } int getDegreeUnsafeMpz(mpz_t res, node *tree) { mpz_t left, right; int l, r; node *simplifiedExponent; if (isConstant(tree)) { mpz_set_si(res, 0); return 1; } if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) { polynomialGetDegree(res, tree->polynomialRepresentation); return 1; } return getDegreeUnsafeMpz(res, getMemRefChild(tree)); } switch (tree->nodeType) { case VARIABLE: mpz_set_si(res, 1); return 1; break; case CONSTANT: case PI_CONST: mpz_set_si(res, 1); return 1; break; case ADD: mpz_init(left); mpz_init(right); l = getDegreeUnsafeMpz(left, tree->child1); r = getDegreeUnsafeMpz(right, tree->child2); if (l && r) { if (mpz_cmp(left, right) < 0) { mpz_set(res, right); } else { mpz_set(res, left); } mpz_clear(left); mpz_clear(right); return 1; } mpz_clear(left); mpz_clear(right); break; case SUB: mpz_init(left); mpz_init(right); l = getDegreeUnsafeMpz(left, tree->child1); r = getDegreeUnsafeMpz(right, tree->child2); if (l && r) { if (mpz_cmp(left, right) < 0) { mpz_set(res, right); } else { mpz_set(res, left); } mpz_clear(left); mpz_clear(right); return 1; } mpz_clear(left); mpz_clear(right); break; case MUL: mpz_init(left); mpz_init(right); l = getDegreeUnsafeMpz(left, tree->child1); r = getDegreeUnsafeMpz(right, tree->child2); if (l && r) { mpz_add(res, left, right); mpz_clear(left); mpz_clear(right); return 1; } mpz_clear(left); mpz_clear(right); break; case DIV: return getDegreeUnsafeMpz(res, tree->child1); break; case POW: { mpz_init(left); l = getDegreeUnsafeMpz(left, tree->child1); if (accessThruMemRef(tree->child2)->nodeType != CONSTANT) { simplifiedExponent = simplifyRationalErrorfree(tree->child2); if ((accessThruMemRef(simplifiedExponent)->nodeType == CONSTANT) && mpfr_integer_p(*(accessThruMemRef(simplifiedExponent)->value)) && (mpfr_sgn(*(accessThruMemRef(simplifiedExponent)->value)) >= 0)) { mpz_init(right); mpfr_get_z(right, *(accessThruMemRef(simplifiedExponent)->value), GMP_RNDN); /* exact */ if (l) { mpz_mul(res, left, right); mpz_clear(left); mpz_clear(right); free_memory(simplifiedExponent); return 1; } mpz_init(right); } else { sollyaFprintf(stderr,"Error: getDegreeUnsafeMpz: an error occurred. The exponent in a power operator is not constant, not integer or not non-negative.\n"); exit(1); } free_memory(simplifiedExponent); } else { if (!mpfr_integer_p(*(accessThruMemRef(tree->child2)->value))) { sollyaFprintf(stderr,"Error: getDegreeUnsafe: an error occurred. The exponent in a power operator is not integer.\n"); exit(1); } if (mpfr_sgn(*(accessThruMemRef(tree->child2)->value)) < 0) { sollyaFprintf(stderr,"Error: getDegreeUnsafe: an error occurred. The exponent in a power operator is negative.\n"); exit(1); } mpz_init(right); mpfr_get_z(right, *(accessThruMemRef(tree->child2)->value), GMP_RNDN); /* exact */ if (l) { mpz_mul(res, left, right); mpz_clear(left); mpz_clear(right); return 1; } mpz_init(right); } mpz_init(left); } break; case NEG: return getDegreeUnsafeMpz(res, tree->child1); break; default: sollyaFprintf(stderr,"Error: getDegreeUnsafeMpz: an error occurred on handling the expression tree\n"); exit(1); } return 0; } int getDegree(node *tree) { if (!isPolynomial(tree)) return -1; return getDegreeUnsafe(tree, 0); } int getDegreeSilent(node *tree) { if (!isPolynomial(tree)) return -1; return getDegreeUnsafe(tree, 1); } int getDegreeMpz(mpz_t res, node *tree) { if (!isPolynomial(tree)) { mpz_set_si(res, -1); return 0; } return getDegreeUnsafeMpz(res, tree); } int getDegreeMpzVerified(mpz_t res, node *tree) { int okay, k, gottaBreak; node *tempNode; if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation == NULL) { tryRepresentAsPolynomial(tree); } if (tree->polynomialRepresentation != NULL) { polynomialGetDegree(res, tree->polynomialRepresentation); if (mpz_cmp_si(res, -1) == 0) { printMessage(1,SOLLYA_MSG_DEGREE_OF_POLYNOMIAL_LARGER_THAN_MULTIPRECISION_INT, "Warning: the degree of the given polynomial is larger than the largest multiprecision integer that can be held in memory. The polynomial's degree will be returned as -1.\n"); } return 1; } } okay = getDegreeMpz(res, tree); if (okay) { k = mpz_get_si(res); if ((mpz_cmp_si(res, k) == 0) && (k > 0)) { while (k > 0) { tempNode = getIthCoefficient(tree, k); gottaBreak = 1; if (accessThruMemRef(tempNode)->nodeType == CONSTANT) { if (mpfr_zero_p(*(accessThruMemRef(tempNode)->value))) { gottaBreak = 0; } } free_memory(tempNode); if (gottaBreak) break; k--; mpz_set_si(res, k); } } } return okay; } int isPolynomialExtraSafe(node *tree) { return (isPolynomial(tree) && (getDegreeSilent(tree) >= 0)); } int getMaxPowerDividerUnsafe(node *tree) { int l, r; mpfr_t temp; node *simplifiedNode; if (isConstant(tree)) return 0; if (tree->nodeType == MEMREF) return getMaxPowerDividerUnsafe(getMemRefChild(tree)); switch (tree->nodeType) { case VARIABLE: return 1; break; case CONSTANT: case PI_CONST: return 0; break; case ADD: l = getMaxPowerDividerUnsafe(tree->child1); r = getMaxPowerDividerUnsafe(tree->child2); return MIN_MACRO(l,r); break; case SUB: l = getMaxPowerDividerUnsafe(tree->child1); r = getMaxPowerDividerUnsafe(tree->child2); return MIN_MACRO(l,r); break; case MUL: l = getMaxPowerDividerUnsafe(tree->child1); r = getMaxPowerDividerUnsafe(tree->child2); return l + r; break; case DIV: return getMaxPowerDividerUnsafe(tree->child1); break; case POW: { l = getMaxPowerDividerUnsafe(tree->child1); if (l == 0) return 0; simplifiedNode = simplifyRationalErrorfree(tree->child2); if (accessThruMemRef(simplifiedNode)->nodeType != CONSTANT) { printMessage(1,SOLLYA_MSG_DEG_OF_MAX_POLY_DIV_IS_NOT_CONSTANT, "Warning: an attempt was made to compute the degree of the maximal polynomial divider of a polynomial in an expression using a power operator with an exponent which is not a constant but a constant expression.\n"); free_memory(simplifiedNode); return -1; } if (!mpfr_integer_p(*(accessThruMemRef(simplifiedNode)->value))) { printMessage(1,SOLLYA_MSG_DEG_OF_MAX_POLY_DIV_IS_NOT_INTEGER, "Warning: an attempt was made to compute the degree of the maximal polynomial divider of a polynomial in an expression using a power operator with an exponent which is not an integer.\n"); free_memory(simplifiedNode); return -1; } if (mpfr_sgn(*(accessThruMemRef(simplifiedNode)->value)) < 0) { printMessage(1,SOLLYA_MSG_DEG_OF_MAX_POLY_DIV_IS_NEGATIVE, "Warning: an attempt was made to compute the degree of the maximal polynomial divider of a polynomial in an expression using a power operator with an exponent which is negative.\n"); free_memory(simplifiedNode); return -1; } r = mpfr_get_si(*(accessThruMemRef(simplifiedNode)->value),GMP_RNDN); mpfr_init2(temp,mpfr_get_prec(*(accessThruMemRef(simplifiedNode)->value)) + 10); mpfr_set_si(temp,r,GMP_RNDN); if (mpfr_cmp(*(accessThruMemRef(simplifiedNode)->value),temp) != 0) { printMessage(1,SOLLYA_MSG_DEG_OF_MAX_POLY_DIV_DOESNT_HOLD_ON_MACHINE_INT, "Warning: tried to compute degree of maximal polynomial divider of a polynomial in an expression using a power operator with an exponent which cannot be represented on an integer variable.\n"); mpfr_clear(temp); free_memory(simplifiedNode); return -1; } mpfr_clear(temp); free_memory(simplifiedNode); return l * r; } break; case NEG: return getMaxPowerDividerUnsafe(tree->child1); break; default: sollyaFprintf(stderr,"Error: getMaxPowerDividerUnsafe: an error occurred on handling the expression tree\n"); exit(1); } } int getMaxPowerDivider(node *tree) { if (!isPolynomial(tree)) return -1; return getMaxPowerDividerUnsafe(tree); } node* makeBinomial(node *a, node *b, int n, int s) { node *tree, *coeff, *aPow, *bPow, *tempNode, *tempNode2; mpfr_t *coeffVal, *mpfr_temp; unsigned int i; mpz_t coeffGMP; mp_prec_t prec; tree = (node*) safeMalloc(sizeof(node)); tree->nodeType = CONSTANT; mpfr_temp = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); mpfr_set_d(*mpfr_temp,0.0,GMP_RNDN); tree->value = mpfr_temp; mpz_init(coeffGMP); for (i=0;i<=((unsigned int) n);i++) { mpz_bin_uiui(coeffGMP,(unsigned int) n,i); prec = mpz_sizeinbase (coeffGMP, 2) + 10; if (prec < tools_precision) prec = tools_precision; coeffVal = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*coeffVal,prec); if(mpfr_set_z(*coeffVal,coeffGMP,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_BINOMIAL_COEFFICIENT_COMPUTATION,"Warning: on expanding a power operator a rounding occurred when calculating a binomial coefficient.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } if ((s < 0) && (((((unsigned int) n) - i) & 1) != 0)) { /* This is a modulo 2 to determine eveness */ mpfr_neg(*coeffVal,*coeffVal,GMP_RNDN); } coeff = (node*) safeMalloc(sizeof(node)); coeff->nodeType = CONSTANT; coeff->value = coeffVal; aPow = (node*) safeMalloc(sizeof(node)); aPow->nodeType = POW; aPow->child1 = copyTree(a); tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = CONSTANT; mpfr_temp = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); if(mpfr_set_ui(*mpfr_temp,i,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_POW_EXPONENT_COMPUTATION,"Warning: on expanding a power operator a rounding occurred when calculating an exponent constant.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } tempNode->value = mpfr_temp; aPow->child2 = tempNode; bPow = (node*) safeMalloc(sizeof(node)); bPow->nodeType = POW; bPow->child1 = copyTree(b); tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = CONSTANT; mpfr_temp = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfr_temp,tools_precision); if(mpfr_set_ui(*mpfr_temp,((unsigned int) n) - i,GMP_RNDN) != 0) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_POW_EXPONENT_COMPUTATION,"Warning: on expanding a power operator a rounding occurred when calculating an exponent constant.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } tempNode->value = mpfr_temp; bPow->child2 = tempNode; tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = MUL; tempNode->child1 = coeff; tempNode->child2 = aPow; tempNode2 = (node*) safeMalloc(sizeof(node)); tempNode2->nodeType = MUL; tempNode2->child1 = tempNode; tempNode2->child2 = bPow; tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = ADD; tempNode->child1 = tree; tempNode->child2 = tempNode2; tree = tempNode; } mpz_clear(coeffGMP); return tree; } node* expandPowerInPolynomialUnsafe(node *tree) { node *copy, *left, *tempTree, *tempTree2, *tempTree3; int r, i; mpfr_t temp; mpfr_t *value; if (isConstant(tree)) return copyTree(tree); if (tree->nodeType == MEMREF) return addMemRef(expandPowerInPolynomialUnsafe(getMemRefChild(tree))); switch (tree->nodeType) { case VARIABLE: return copyTree(tree); break; case CONSTANT: case PI_CONST: return copyTree(tree); break; case ADD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ADD; copy->child1 = expandPowerInPolynomialUnsafe(tree->child1); copy->child2 = expandPowerInPolynomialUnsafe(tree->child2); return copy; break; case SUB: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SUB; copy->child1 = expandPowerInPolynomialUnsafe(tree->child1); copy->child2 = expandPowerInPolynomialUnsafe(tree->child2); return copy; break; case MUL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = expandPowerInPolynomialUnsafe(tree->child1); copy->child2 = expandPowerInPolynomialUnsafe(tree->child2); return copy; break; case DIV: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DIV; copy->child1 = expandPowerInPolynomialUnsafe(tree->child1); copy->child2 = expandPowerInPolynomialUnsafe(tree->child2); return copy; break; case POW: { left = expandPowerInPolynomialUnsafe(tree->child1); if (accessThruMemRef(tree->child2)->nodeType != CONSTANT) { sollyaFprintf(stderr,"Error: expandPowerInPolynomialUnsafe: an error occurred. The exponent in a power operator is not constant.\n"); exit(1); } if (!mpfr_integer_p(*(accessThruMemRef(tree->child2)->value))) { sollyaFprintf(stderr,"Error: expandPowerInPolynomialUnsafe: an error occurred. The exponent in a power operator is not integer.\n"); exit(1); } if (mpfr_sgn(*(accessThruMemRef(tree->child2)->value)) < 0) { sollyaFprintf(stderr,"Error: expandPowerInPolynomialUnsafe: an error occurred. The exponent in a power operator is negative.\n"); exit(1); } r = mpfr_get_si(*(accessThruMemRef(tree->child2)->value),GMP_RNDN); mpfr_init2(temp,mpfr_get_prec(*(accessThruMemRef(tree->child2)->value)) + 10); mpfr_set_si(temp,r,GMP_RNDN); if (mpfr_cmp(*(accessThruMemRef(tree->child2)->value),temp) != 0) { sollyaFprintf(stderr,"Error: expandPowerInPolynomialUnsafe: an error occurred. Tried to expand an expression using a power operator with an exponent "); sollyaFprintf(stderr,"which cannot be represented on an integer variable.\n"); mpfr_clear(temp); exit(1); } mpfr_clear(temp); if (r > 1) { switch (accessThruMemRef(left)->nodeType) { case VARIABLE: case CONSTANT: case PI_CONST: tempTree = copyTree(left); for (i=1;inodeType = MUL; tempTree2->child1 = tempTree; tempTree2->child2 = copyTree(left); tempTree = tempTree2; } break; case ADD: tempTree = makeBinomial(accessThruMemRef(left)->child1,accessThruMemRef(left)->child2,r,1); break; case SUB: tempTree = makeBinomial(accessThruMemRef(left)->child1,accessThruMemRef(left)->child2,r,-1); break; case MUL: tempTree = (node *) safeMalloc(sizeof(node)); tempTree->nodeType = MUL; tempTree2 = (node *) safeMalloc(sizeof(node)); tempTree2->nodeType = POW; tempTree2->child1 = copyTree(accessThruMemRef(left)->child1); tempTree3 = (node*) safeMalloc(sizeof(node)); tempTree3->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_si(*value,r,GMP_RNDN); tempTree3->value = value; tempTree2->child2 = tempTree3; tempTree->child1 = tempTree2; tempTree2 = (node *) safeMalloc(sizeof(node)); tempTree2->nodeType = POW; tempTree2->child1 = copyTree(accessThruMemRef(left)->child2); tempTree3 = (node*) safeMalloc(sizeof(node)); tempTree3->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_si(*value,r,GMP_RNDN); tempTree3->value = value; tempTree2->child2 = tempTree3; tempTree->child2 = tempTree2; break; case DIV: tempTree = (node *) safeMalloc(sizeof(node)); tempTree->nodeType = DIV; tempTree2 = (node *) safeMalloc(sizeof(node)); tempTree2->nodeType = POW; tempTree2->child1 = copyTree(accessThruMemRef(left)->child1); tempTree3 = (node*) safeMalloc(sizeof(node)); tempTree3->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_si(*value,r,GMP_RNDN); tempTree3->value = value; tempTree2->child2 = tempTree3; tempTree->child1 = tempTree2; tempTree2 = (node *) safeMalloc(sizeof(node)); tempTree2->nodeType = POW; tempTree2->child1 = copyTree(accessThruMemRef(left)->child2); tempTree3 = (node*) safeMalloc(sizeof(node)); tempTree3->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_si(*value,r,GMP_RNDN); tempTree3->value = value; tempTree2->child2 = tempTree3; tempTree->child2 = tempTree2; break; case NEG: if (r & 1) { /* This is a modulo 2 to determine eveness, not a logical test */ /* r is odd */ tempTree = (node *) safeMalloc(sizeof(node)); tempTree->nodeType = NEG; tempTree2 = (node *) safeMalloc(sizeof(node)); tempTree2->nodeType = POW; tempTree2->child1 = copyTree(accessThruMemRef(left)->child1); tempTree3 = (node*) safeMalloc(sizeof(node)); tempTree3->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_si(*value,r,GMP_RNDN); tempTree3->value = value; tempTree2->child2 = tempTree3; tempTree->child1 = tempTree2; } else { tempTree = (node *) safeMalloc(sizeof(node)); tempTree->nodeType = POW; tempTree->child1 = copyTree(accessThruMemRef(left)->child1); tempTree3 = (node*) safeMalloc(sizeof(node)); tempTree3->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_si(*value,r,GMP_RNDN); tempTree3->value = value; tempTree->child2 = tempTree3; } break; default: if (isConstant(left)) return copyTree(tree); sollyaFprintf(stderr,"Error: expandPowerInPolynomialUnsafe: an error occurred on handling the expanded expression subtree\n"); exit(1); } copy = expandPowerInPolynomialUnsafe(tempTree); free_memory(tempTree); } else { if (r == 1) { copy = copyTree(left); } else { copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_d(*value,1.0,GMP_RNDN); copy->value = value; } } free_memory(left); return copy; } break; case NEG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEG; copy->child1 = expandPowerInPolynomialUnsafe(tree->child1); return copy; break; default: if (isConstant(tree)) return copyTree(tree); sollyaFprintf(stderr,"Error: expandPowerInPolynomialUnsafe: an error occurred on handling the expression tree\n"); exit(1); } } node* expandPowerInPolynomial(node *tree) { if (getDegree(tree) < 0) return copyTree(tree); return expandPowerInPolynomialUnsafe(tree); } node* expandDivision(node *tree) { node *copy, *left, *right, *tempNode; mpfr_t *value; mpfr_t temp; if (tree->nodeType == MEMREF) { return addMemRef(expandDivision(getMemRefChild(tree))); } switch (tree->nodeType) { case VARIABLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = VARIABLE; break; case CONSTANT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(temp,tools_precision); simplifyMpfrPrec(temp,*(tree->value)); mpfr_init2(*value,mpfr_get_prec(temp)); mpfr_set(*value,temp,GMP_RNDN); mpfr_clear(temp); copy->value = value; break; case ADD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ADD; copy->child1 = expandDivision(tree->child1); copy->child2 = expandDivision(tree->child2); break; case SUB: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SUB; copy->child1 = expandDivision(tree->child1); copy->child2 = expandDivision(tree->child2); break; case MUL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = expandDivision(tree->child1); copy->child2 = expandDivision(tree->child2); break; case DIV: left = expandDivision(tree->child1); right = expandDivision(tree->child2); if (accessThruMemRef(right)->nodeType == DIV) { tempNode = (node *) safeMalloc(sizeof(node)); tempNode->nodeType = DIV; tempNode->child1 = copyTree(accessThruMemRef(right)->child2); tempNode->child2 = copyTree(accessThruMemRef(right)->child1); free_memory(right); copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = left; copy->child2 = tempNode; } else { copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DIV; copy->child1 = left; copy->child2 = right; } break; case SQRT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SQRT; copy->child1 = expandDivision(tree->child1); break; case EXP: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = EXP; copy->child1 = expandDivision(tree->child1); break; case LOG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG; copy->child1 = expandDivision(tree->child1); break; case LOG_2: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_2; copy->child1 = expandDivision(tree->child1); break; case LOG_10: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_10; copy->child1 = expandDivision(tree->child1); break; case SIN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SIN; copy->child1 = expandDivision(tree->child1); break; case COS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = COS; copy->child1 = expandDivision(tree->child1); break; case TAN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TAN; copy->child1 = expandDivision(tree->child1); break; case ASIN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ASIN; copy->child1 = expandDivision(tree->child1); break; case ACOS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ACOS; copy->child1 = expandDivision(tree->child1); break; case ATAN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ATAN; copy->child1 = expandDivision(tree->child1); break; case SINH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SINH; copy->child1 = expandDivision(tree->child1); break; case COSH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = COSH; copy->child1 = expandDivision(tree->child1); break; case TANH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TANH; copy->child1 = expandDivision(tree->child1); break; case ASINH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ASINH; copy->child1 = expandDivision(tree->child1); break; case ACOSH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ACOSH; copy->child1 = expandDivision(tree->child1); break; case ATANH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ATANH; copy->child1 = expandDivision(tree->child1); break; case POW: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = POW; copy->child1 = expandDivision(tree->child1); copy->child2 = expandDivision(tree->child2); break; case NEG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEG; copy->child1 = expandDivision(tree->child1); break; case ABS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ABS; copy->child1 = expandDivision(tree->child1); break; case DOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLE; copy->child1 = expandDivision(tree->child1); break; case SINGLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SINGLE; copy->child1 = expandDivision(tree->child1); break; case QUAD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = QUAD; copy->child1 = expandDivision(tree->child1); break; case HALFPRECISION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = HALFPRECISION; copy->child1 = expandDivision(tree->child1); break; case DOUBLEDOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLEDOUBLE; copy->child1 = expandDivision(tree->child1); break; case TRIPLEDOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TRIPLEDOUBLE; copy->child1 = expandDivision(tree->child1); break; case ERF: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ERF; copy->child1 = expandDivision(tree->child1); break; case ERFC: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ERFC; copy->child1 = expandDivision(tree->child1); break; case LOG_1P: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_1P; copy->child1 = expandDivision(tree->child1); break; case EXP_M1: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = EXP_M1; copy->child1 = expandDivision(tree->child1); break; case DOUBLEEXTENDED: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLEEXTENDED; copy->child1 = expandDivision(tree->child1); break; case LIBRARYFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYFUNCTION; copy->libFun = tree->libFun; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = expandDivision(tree->child1); break; case PROCEDUREFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PROCEDUREFUNCTION; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = expandDivision(tree->child1); copy->child2 = copyThing(tree->child2); break; case CEIL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CEIL; copy->child1 = expandDivision(tree->child1); break; case FLOOR: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = FLOOR; copy->child1 = expandDivision(tree->child1); break; case NEARESTINT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEARESTINT; copy->child1 = expandDivision(tree->child1); break; case PI_CONST: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PI_CONST; break; case LIBRARYCONSTANT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYCONSTANT; copy->libFun = tree->libFun; break; default: sollyaFprintf(stderr,"Error: expandDivision: unknown identifier in the tree\n"); exit(1); } return copy; } node* expandPolynomialUnsafe(node *tree) { node *left, *right, *copy, *tempNode, *tempNode2, *tempNode3, *tempNode4; mpfr_t *value; if (isConstant(tree)) return copyTree(tree); if (tree->nodeType == MEMREF) return addMemRef(expandPolynomialUnsafe(getMemRefChild(tree))); switch (tree->nodeType) { case VARIABLE: return copyTree(tree); break; case CONSTANT: case PI_CONST: return copyTree(tree); break; case ADD: left = expandPolynomialUnsafe(tree->child1); right = expandPolynomialUnsafe(tree->child2); copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ADD; copy->child1 = left; copy->child2 = right; return copy; break; case SUB: left = expandPolynomialUnsafe(tree->child1); right = expandPolynomialUnsafe(tree->child2); copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SUB; copy->child1 = left; copy->child2 = right; return copy; break; case MUL: left = expandPolynomialUnsafe(tree->child1); right = expandPolynomialUnsafe(tree->child2); switch (accessThruMemRef(left)->nodeType) { case VARIABLE: case CONSTANT: case PI_CONST: if (isConstant(right)) { copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = left; copy->child2 = right; } else { switch (accessThruMemRef(right)->nodeType) { case VARIABLE: case CONSTANT: case PI_CONST: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = left; copy->child2 = right; break; default: tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = MUL; tempNode->child1 = right; tempNode->child2 = left; copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); } } break; case MUL: switch (accessThruMemRef(right)->nodeType) { case ADD: case SUB: case NEG: case DIV: tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = MUL; tempNode->child1 = right; tempNode->child2 = left; copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); break; default: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = left; copy->child2 = right; break; } break; case ADD: tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = ADD; tempNode2 = (node*) safeMalloc(sizeof(node)); tempNode2->nodeType = MUL; tempNode3 = (node*) safeMalloc(sizeof(node)); tempNode3->nodeType = MUL; tempNode2->child1 = copyTree(accessThruMemRef(left)->child1); tempNode2->child2 = copyTree(right); tempNode3->child1 = copyTree(accessThruMemRef(left)->child2); tempNode3->child2 = right; tempNode->child1 = tempNode2; tempNode->child2 = tempNode3; free_memory(left); copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); break; case SUB: tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = SUB; tempNode2 = (node*) safeMalloc(sizeof(node)); tempNode2->nodeType = MUL; tempNode3 = (node*) safeMalloc(sizeof(node)); tempNode3->nodeType = MUL; tempNode2->child1 = copyTree(accessThruMemRef(left)->child1); tempNode2->child2 = copyTree(right); tempNode3->child1 = copyTree(accessThruMemRef(left)->child2); tempNode3->child2 = right; tempNode->child1 = tempNode2; tempNode->child2 = tempNode3; free_memory(left); copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); break; case NEG: tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = NEG; tempNode2 = (node*) safeMalloc(sizeof(node)); tempNode2->nodeType = MUL; tempNode2->child1 = copyTree(accessThruMemRef(left)->child1); tempNode2->child2 = right; tempNode->child1 = tempNode2; free_memory(left); copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); break; case DIV: if (isConstant(left)) { if (isConstant(right)) { copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = left; copy->child2 = right; } else { switch (accessThruMemRef(right)->nodeType) { case ADD: case SUB: case NEG: case DIV: tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = MUL; tempNode->child1 = right; tempNode->child2 = left; copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); break; default: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = left; copy->child2 = right; break; } } } else { tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = MUL; tempNode2 = (node*) safeMalloc(sizeof(node)); tempNode2->nodeType = MUL; tempNode3 = (node*) safeMalloc(sizeof(node)); tempNode3->nodeType = DIV; tempNode4 = (node*) safeMalloc(sizeof(node)); tempNode4->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_d(*value,1.0,GMP_RNDN); tempNode4->value = value; tempNode3->child1 = tempNode4; tempNode3->child2 = copyTree(accessThruMemRef(left)->child2); tempNode2->child1 = copyTree(accessThruMemRef(left)->child1); tempNode2->child2 = right; tempNode->child1 = tempNode3; tempNode->child2 = tempNode2; free_memory(left); copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); } break; default: if (isConstant(left)) { if (isConstant(right)) { return copyTree(tree); } else { tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = MUL; tempNode->child1 = right; tempNode->child2 = left; copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); return copy; } } else { sollyaFprintf(stderr,"Error: expandPolynomialUnsafe: an error occurred on handling the MUL left rewritten expression subtree\n"); exit(1); } } return copy; break; case DIV: left = expandPolynomialUnsafe(tree->child1); right = expandPolynomialUnsafe(tree->child2); switch (accessThruMemRef(left)->nodeType) { case CONSTANT: case PI_CONST: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DIV; copy->child1 = left; copy->child2 = right; break; case VARIABLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = DIV; tempNode->child2 = right; tempNode2 = (node*) safeMalloc(sizeof(node)); tempNode2->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_d(*value,1.0,GMP_RNDN); tempNode2->value = value; tempNode->child1 = tempNode2; copy->child2 = left; copy->child1 = tempNode; break; case ADD: tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = ADD; tempNode2 = (node*) safeMalloc(sizeof(node)); tempNode2->nodeType = DIV; tempNode3 = (node*) safeMalloc(sizeof(node)); tempNode3->nodeType = DIV; tempNode2->child1 = copyTree(accessThruMemRef(left)->child1); tempNode2->child2 = copyTree(right); tempNode3->child1 = copyTree(accessThruMemRef(left)->child2); tempNode3->child2 = right; tempNode->child1 = tempNode2; tempNode->child2 = tempNode3; free_memory(left); copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); break; case SUB: tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = SUB; tempNode2 = (node*) safeMalloc(sizeof(node)); tempNode2->nodeType = DIV; tempNode3 = (node*) safeMalloc(sizeof(node)); tempNode3->nodeType = DIV; tempNode2->child1 = copyTree(accessThruMemRef(left)->child1); tempNode2->child2 = copyTree(right); tempNode3->child1 = copyTree(accessThruMemRef(left)->child2); tempNode3->child2 = right; tempNode->child1 = tempNode2; tempNode->child2 = tempNode3; free_memory(left); copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); break; case MUL: tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = MUL; tempNode2 = (node*) safeMalloc(sizeof(node)); tempNode2->nodeType = DIV; tempNode3 = (node*) safeMalloc(sizeof(node)); tempNode3->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_d(*value,1.0,GMP_RNDN); tempNode3->value = value; tempNode4 = (node*) safeMalloc(sizeof(node)); tempNode4->nodeType = MUL; tempNode2->child1 = tempNode3; tempNode2->child2 = right; tempNode->child1 = tempNode2; tempNode->child2 = tempNode4; tempNode4->child1 = copyTree(accessThruMemRef(left)->child1); tempNode4->child2 = copyTree(accessThruMemRef(left)->child2); free_memory(left); copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); break; case DIV: tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = DIV; tempNode->child1 = copyTree(accessThruMemRef(left)->child1); tempNode2 = (node*) safeMalloc(sizeof(node)); tempNode2->nodeType = MUL; tempNode2->child1 = copyTree(accessThruMemRef(left)->child2); tempNode2->child2 = right; tempNode->child2 = tempNode2; free_memory(left); copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); break; case NEG: tempNode = (node*) safeMalloc(sizeof(node)); tempNode->nodeType = NEG; tempNode2 = (node*) safeMalloc(sizeof(node)); tempNode2->nodeType = DIV; tempNode2->child1 = copyTree(accessThruMemRef(left)->child1); tempNode2->child2 = right; tempNode->child1 = tempNode2; free_memory(left); copy = expandPolynomialUnsafe(tempNode); free_memory(tempNode); break; default: if (isConstant(left)) { return copyTree(tree); } else { sollyaFprintf(stderr,"Error: expandPolynomialUnsafe: an error occurred on handling the DIV left rewritten expression subtree\n"); exit(1); } } return copy; break; case NEG: left = expandPolynomialUnsafe(tree->child1); copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEG; copy->child1 = left; return copy; break; default: if (isConstant(tree)) { return copyTree(tree); } else { sollyaFprintf(stderr,"Error: expandPolynomialUnsafe: an error occurred on handling the expression tree\n"); exit(1); } } } node* expandPolynomial(node *tree) { node *temp, *temp2; if (getDegree(tree) < 0) return copyTree(tree); temp = expandPowerInPolynomialUnsafe(tree); temp2 = expandPolynomialUnsafe(temp); free_memory(temp); return temp2; } node* expandUnsimplified(node *tree) { node *copy; mpfr_t *value; mpfr_t temp; if (tree->nodeType == MEMREF) { return addMemRef(expandUnsimplified(getMemRefChild(tree))); } if (!isConstant(tree) && isPolynomial(tree)) return expandPolynomial(tree); switch (tree->nodeType) { case VARIABLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = VARIABLE; break; case CONSTANT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(temp,tools_precision); simplifyMpfrPrec(temp,*(tree->value)); mpfr_init2(*value,mpfr_get_prec(temp)); mpfr_set(*value,temp,GMP_RNDN); mpfr_clear(temp); copy->value = value; break; case ADD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ADD; copy->child1 = expand(tree->child1); copy->child2 = expand(tree->child2); break; case SUB: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SUB; copy->child1 = expand(tree->child1); copy->child2 = expand(tree->child2); break; case MUL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = expand(tree->child1); copy->child2 = expand(tree->child2); break; case DIV: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DIV; copy->child1 = expand(tree->child1); copy->child2 = expand(tree->child2); break; case SQRT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SQRT; copy->child1 = expand(tree->child1); break; case EXP: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = EXP; copy->child1 = expand(tree->child1); break; case LOG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG; copy->child1 = expand(tree->child1); break; case LOG_2: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_2; copy->child1 = expand(tree->child1); break; case LOG_10: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_10; copy->child1 = expand(tree->child1); break; case SIN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SIN; copy->child1 = expand(tree->child1); break; case COS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = COS; copy->child1 = expand(tree->child1); break; case TAN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TAN; copy->child1 = expand(tree->child1); break; case ASIN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ASIN; copy->child1 = expand(tree->child1); break; case ACOS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ACOS; copy->child1 = expand(tree->child1); break; case ATAN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ATAN; copy->child1 = expand(tree->child1); break; case SINH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SINH; copy->child1 = expand(tree->child1); break; case COSH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = COSH; copy->child1 = expand(tree->child1); break; case TANH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TANH; copy->child1 = expand(tree->child1); break; case ASINH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ASINH; copy->child1 = expand(tree->child1); break; case ACOSH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ACOSH; copy->child1 = expand(tree->child1); break; case ATANH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ATANH; copy->child1 = expand(tree->child1); break; case POW: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = POW; copy->child1 = expand(tree->child1); copy->child2 = expand(tree->child2); break; case NEG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEG; copy->child1 = expand(tree->child1); break; case ABS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ABS; copy->child1 = expand(tree->child1); break; case DOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLE; copy->child1 = expand(tree->child1); break; case SINGLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SINGLE; copy->child1 = expand(tree->child1); break; case HALFPRECISION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = HALFPRECISION; copy->child1 = expand(tree->child1); break; case QUAD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = QUAD; copy->child1 = expand(tree->child1); break; case DOUBLEDOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLEDOUBLE; copy->child1 = expand(tree->child1); break; case TRIPLEDOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TRIPLEDOUBLE; copy->child1 = expand(tree->child1); break; case ERF: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ERF; copy->child1 = expand(tree->child1); break; case ERFC: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ERFC; copy->child1 = expand(tree->child1); break; case LOG_1P: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_1P; copy->child1 = expand(tree->child1); break; case EXP_M1: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = EXP_M1; copy->child1 = expand(tree->child1); break; case DOUBLEEXTENDED: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLEEXTENDED; copy->child1 = expand(tree->child1); break; case LIBRARYFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYFUNCTION; copy->libFun = tree->libFun; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = expand(tree->child1); break; case PROCEDUREFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PROCEDUREFUNCTION; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = expand(tree->child1); copy->child2 = copyThing(tree->child2); break; case CEIL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CEIL; copy->child1 = expand(tree->child1); break; case FLOOR: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = FLOOR; copy->child1 = expand(tree->child1); break; case NEARESTINT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEARESTINT; copy->child1 = expand(tree->child1); break; case PI_CONST: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PI_CONST; break; case LIBRARYCONSTANT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYCONSTANT; copy->libFun = tree->libFun; break; default: sollyaFprintf(stderr,"Error: expand: unknown identifier in the tree\n"); exit(1); } return copy; } node* expand(node *tree) { node *temp, *temp2, *temp3; temp3 = expandDivision(tree); temp = expandUnsimplified(temp3); temp2 = simplifyTreeErrorfree(temp); free_memory(temp); free_memory(temp3); return temp2; } int isConstant(node *tree) { int res; switch (tree->nodeType) { case MEMREF: if (tree->arguments != NULL) return 1; if (tree->value != NULL) return 0; if (tree->polynomialRepresentation != NULL) { res = (polynomialGetDegreeAsInt(tree->polynomialRepresentation) == 0); } else { res = isConstant(getMemRefChild(tree)); } if (!res) { tree->value = (mpfr_t *) (-1); } return res; break; case VARIABLE: return 0; break; case CONSTANT: case PI_CONST: case LIBRARYCONSTANT: return 1; break; case ADD: case SUB: case MUL: case DIV: case POW: return (!(!((isConstant(tree->child1) && isConstant(tree->child2))))); break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case DOUBLE: case SINGLE: case QUAD: case HALFPRECISION: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case LIBRARYFUNCTION: case PROCEDUREFUNCTION: case CEIL: case FLOOR: case NEARESTINT: return isConstant(tree->child1); break; default: sollyaFprintf(stderr,"Error: isConstant: unknown identifier in the tree\n"); exit(1); } } int isMonomial(node *tree) { switch (tree->nodeType) { case MEMREF: return isMonomial(getMemRefChild(tree)); break; case MUL: return (isMonomial(tree->child1) && isMonomial(tree->child2)); break; case NEG: return isMonomial(tree->child1); break; case VARIABLE: return 1; break; case DIV: return (isConstant(tree->child2)) && isMonomial(tree->child1); default: return isConstant(tree); } return 0; } node* getCoefficientsInMonomialUnsafe(node *polynom) { node *leftSub, *rightSub, *coeffs; mpfr_t *value; if (isConstant(polynom)) return copyTree(polynom); if (polynom->nodeType == MEMREF) return getCoefficientsInMonomialUnsafe(getMemRefChild(polynom)); if (polynom->nodeType == VARIABLE) return NULL; if (polynom->nodeType == MUL) { leftSub = getCoefficientsInMonomialUnsafe(polynom->child1); rightSub = getCoefficientsInMonomialUnsafe(polynom->child2); if ((leftSub == NULL) && (rightSub == NULL)) return NULL; if (leftSub == NULL) return rightSub; if (rightSub == NULL) return leftSub; coeffs = (node*) safeMalloc(sizeof(node)); coeffs->nodeType = MUL; coeffs->child1 = leftSub; coeffs->child2 = rightSub; return coeffs; } if (polynom->nodeType == DIV) { leftSub = getCoefficientsInMonomialUnsafe(polynom->child1); if (leftSub == NULL) { coeffs = (node*) safeMalloc(sizeof(node)); coeffs->nodeType = DIV; coeffs->child1 = (node *) safeMalloc(sizeof(node)); coeffs->child1->nodeType = CONSTANT; coeffs->child1->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(coeffs->child1->value),10); mpfr_set_d(*(coeffs->child1->value),1.0,GMP_RNDN); coeffs->child2 = copyTree(polynom->child2); } else { coeffs = (node*) safeMalloc(sizeof(node)); coeffs->nodeType = DIV; coeffs->child1 = leftSub; coeffs->child2 = copyTree(polynom->child2); } return coeffs; } if (polynom->nodeType == NEG) { leftSub = getCoefficientsInMonomialUnsafe(polynom->child1); rightSub = (node *) safeMalloc(sizeof(node)); rightSub->nodeType = CONSTANT; value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_d(*value,-1.0,GMP_RNDN); rightSub->value = value; if (leftSub == NULL) return rightSub; coeffs = (node*) safeMalloc(sizeof(node)); coeffs->nodeType = MUL; coeffs->child1 = leftSub; coeffs->child2 = rightSub; return coeffs; } sollyaFprintf(stderr,"Error: getCoefficientsInMonomialUnsafe: an error occurred. The expression does not have the correct monomial form.\n"); exit(1); return NULL; } void getCoefficientsUnsafe(node **monomials, node *polynom, int sign) { int degree; node *temp, *coeff, *temp2; mpfr_t *value; node *simplified, *simplifiedTemp; if (polynom->nodeType == MEMREF) { getCoefficientsUnsafe(monomials, getMemRefChild(polynom), sign); return; } if (isMonomial(polynom)) { degree = getDegree(polynom); coeff = getCoefficientsInMonomialUnsafe(polynom); if (coeff == NULL) { coeff = (node *) safeMalloc(sizeof(node)); coeff->nodeType = CONSTANT; value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_d(*value,1.0,GMP_RNDN); coeff->value = value; } temp = monomials[degree]; if (temp == NULL) { if (sign < 0) { temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = NEG; temp2->child1 = coeff; coeff = temp2; } temp = coeff; } else { temp2 = (node*) safeMalloc(sizeof(node)); if (sign > 0) temp2->nodeType = ADD; else temp2->nodeType = SUB; temp2->child1 = temp; temp2->child2 = coeff; temp = temp2; } monomials[degree] = temp; return; } if (polynom->nodeType == ADD) { getCoefficientsUnsafe(monomials,polynom->child1,sign); getCoefficientsUnsafe(monomials,polynom->child2,sign); return; } if (polynom->nodeType == SUB) { getCoefficientsUnsafe(monomials,polynom->child1,sign); getCoefficientsUnsafe(monomials,polynom->child2,-sign); return; } if (polynom->nodeType == NEG) { getCoefficientsUnsafe(monomials,polynom->child1,-sign); return; } simplifiedTemp = expandPowerInPolynomialUnsafe(polynom); simplified = expandPolynomialUnsafe(simplifiedTemp); printMessage(7,SOLLYA_MSG_RECURSION_ON_POLY_COEFFICIENTS_EXTRACTION,"Warning: recursion on coefficients extraction: %b\ntransformed to\n%b\n",polynom,simplified); getCoefficientsUnsafe(monomials, simplified, sign); free_memory(simplifiedTemp); free_memory(simplified); } int isPowerOfVariable(node *); void getCoefficientsHornerUnsafe(node **coefficients, node *poly, int offset, int sign) { int deg, newSign; node *newCoeff, *temp; if (poly->nodeType == MEMREF) { getCoefficientsHornerUnsafe(coefficients, getMemRefChild(poly), offset, sign); return; } if (isConstant(poly)) { newCoeff = copyTree(poly); } else { if (poly->nodeType == SUB) newSign = -1; else newSign = 1; newCoeff = copyTree(poly->child1); if ((accessThruMemRef(poly->child2)->nodeType == MUL) && isConstant(accessThruMemRef(poly->child2)->child1) && isPowerOfVariable(accessThruMemRef(poly->child2)->child2)) { deg = getDegree(accessThruMemRef(poly->child2)->child2); getCoefficientsHornerUnsafe(coefficients,accessThruMemRef(poly->child2)->child1,offset+deg,sign*newSign); } else { if ((accessThruMemRef(poly->child2)->nodeType == MUL) && (accessThruMemRef(accessThruMemRef(poly->child2)->child1)->nodeType == MUL) && isPowerOfVariable(accessThruMemRef(accessThruMemRef(poly->child2)->child1)->child1) && isConstant(accessThruMemRef(accessThruMemRef(poly->child2)->child1)->child2) && isConstant(accessThruMemRef(poly->child2)->child2)) { deg = getDegree(accessThruMemRef(accessThruMemRef(poly->child2)->child1)->child1); temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp->child1 = copyTree(accessThruMemRef(accessThruMemRef(poly->child2)->child1)->child2); temp->child2 = copyTree(accessThruMemRef(poly->child2)->child2); getCoefficientsHornerUnsafe(coefficients,temp,offset+deg,sign*newSign); free_memory(temp); } else { if (isPowerOfVariable(poly->child2)) { deg = getDegree(poly->child2); temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = CONSTANT; temp->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(temp->value),17); mpfr_set_d(*(temp->value),1.0,GMP_RNDN); getCoefficientsHornerUnsafe(coefficients,temp,offset+deg,sign*newSign); free_memory(temp); } else { deg = getDegree(accessThruMemRef(poly->child2)->child1); getCoefficientsHornerUnsafe(coefficients,accessThruMemRef(poly->child2)->child2,offset+deg,sign*newSign); } } } } if (coefficients[offset] == NULL) { if (sign == -1) { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = NEG; temp->child1 = newCoeff; coefficients[offset] = temp; } else { coefficients[offset] = newCoeff; } } else { temp = (node *) safeMalloc(sizeof(node)); if (sign == 1) temp->nodeType = ADD; else temp->nodeType = SUB; temp->child1 = coefficients[offset]; temp->child2 = newCoeff; coefficients[offset] = temp; } } void getCoefficientsHorner(node **coefficients, node *poly) { int offset; if (poly->nodeType == MEMREF) { getCoefficientsHorner(coefficients, getMemRefChild(poly)); return; } printMessage(7,SOLLYA_MSG_POLY_COEFF_EXTRACTION_SPECIAL_ALGO_FOR_HORNER,"Information: extraction of coefficient terms from a polynomial uses a special algorithm for Horner forms.\n"); if (poly->nodeType == MUL) { offset = getDegree(poly->child1); getCoefficientsHornerUnsafe(coefficients,poly->child2,offset,1); return; } getCoefficientsHornerUnsafe(coefficients,poly,0,1); } int isPowerOfVariable(node *); int isCanonicalMonomial(node *); void getCoefficientsCanonicalUnsafe(node **coefficients, node *poly) { int deg, sign; node *newCoeff, *temp; if (poly->nodeType == MEMREF) { getCoefficientsCanonicalUnsafe(coefficients, getMemRefChild(poly)); return; } if (isConstant(poly)) { sign = 1; deg = 0; newCoeff = copyTree(poly); } else { if (isCanonicalMonomial(poly)) { deg = getDegree(poly); sign = 1; if (isPowerOfVariable(poly)) { newCoeff = (node *) safeMalloc(sizeof(node)); newCoeff->nodeType = CONSTANT; newCoeff->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(newCoeff->value),17); mpfr_set_d(*(newCoeff->value),1.0,GMP_RNDN); } else { newCoeff = copyTree(poly->child1); } } else { getCoefficientsCanonicalUnsafe(coefficients,poly->child1); if (poly->nodeType == ADD) sign = 1; else sign = -1; if (isConstant(poly->child2)) { deg = 0; newCoeff = copyTree(poly->child2); } else { deg = getDegree(poly->child2); if (isPowerOfVariable(poly->child2)) { newCoeff = (node *) safeMalloc(sizeof(node)); newCoeff->nodeType = CONSTANT; newCoeff->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(newCoeff->value),17); mpfr_set_d(*(newCoeff->value),1.0,GMP_RNDN); } else { newCoeff = copyTree(accessThruMemRef(poly->child2)->child1); } } } } if (coefficients[deg] == NULL) { if (sign == -1) { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = NEG; temp->child1 = newCoeff; coefficients[deg] = temp; } else { coefficients[deg] = newCoeff; } } else { temp = (node *) safeMalloc(sizeof(node)); if (sign == 1) temp->nodeType = ADD; else temp->nodeType = SUB; temp->child1 = coefficients[deg]; temp->child2 = newCoeff; coefficients[deg] = temp; } } void getCoefficientsCanonical(node **coefficients, node *poly) { printMessage(7,SOLLYA_MSG_POLY_COEFF_EXTRACT_SPECIAL_ALGO_FOR_CANONICAL,"Information: extraction of coefficient terms from a polynomial uses a special algorithm for canonical forms.\n"); getCoefficientsCanonicalUnsafe(coefficients, poly); } int isHorner(node *); int isCanonical(node *); node *dividePolynomialByPowerOfVariableUnsafe(node *tree, int alpha); node *makePowerOfConstant(node *constTree, int k); node *makeBinomialCoefficient(unsigned int n, unsigned int k); /* Computes the coefficients of the polynomial p^k where p is // given by the coefficients in input */ void computePowerOfPolynomialCoefficients(int *degreeRes, node ***coeffRes, node **coeffs, int degree, int k) { int i, t; node **coeffsQ; int degreeQ; node *binom; node *constPow; node *factor; node *temp; *degreeRes = k * degree; *coeffRes = (node **) safeCalloc(*degreeRes+1,sizeof(node *)); if (k == 0) { for (i=1;i<=*degreeRes;i++) { (*coeffRes)[i] = makeConstantDouble(0.0); } (*coeffRes)[0] = makeConstantDouble(1.0); return; } if (degree == 0) { for (i=1;i<=*degreeRes;i++) { (*coeffRes)[i] = makeConstantDouble(0.0); } if (coeffs[0] != NULL) { (*coeffRes)[0] = makePowerOfConstant(coeffs[0],k); } else { (*coeffRes)[0] = makeConstantDouble(0.0); } return; } if (k == 1) { for (i=0;i<=*degreeRes;i++) { if (coeffs[i] != NULL) { (*coeffRes)[i] = copyTree(coeffs[i]); } else { (*coeffRes)[i] = makeConstantDouble(0.0); } } return; } for (i=0;i<=*degreeRes;i++) { (*coeffRes)[i] = makeConstantDouble(0.0); } for (t=0;t<=k;t++) { if ((coeffs[0] != NULL) && (!((accessThruMemRef(coeffs[0])->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(coeffs[0])->value)))))) { computePowerOfPolynomialCoefficients(°reeQ, &coeffsQ, &(coeffs[1]), degree - 1, t); binom = makeBinomialCoefficient(k, t); constPow = makePowerOfConstant(coeffs[0],k-t); factor = makeMul(binom,constPow); for (i=t;i<=t+degreeQ;i++) { if (coeffsQ[i-t] != NULL) { (*coeffRes)[i] = makeAdd((*coeffRes)[i], makeMul(copyTree(factor), coeffsQ[i-t])); } } safeFree(coeffsQ); free_memory(factor); } else { if (k == t) { computePowerOfPolynomialCoefficients(°reeQ, &coeffsQ, &(coeffs[1]), degree - 1, t); factor = makeBinomialCoefficient(k, t); for (i=t;i<=t+degreeQ;i++) { if (coeffsQ[i-t] != NULL) { (*coeffRes)[i] = makeAdd((*coeffRes)[i], makeMul(copyTree(factor), coeffsQ[i-t])); } } safeFree(coeffsQ); free_memory(factor); } } } for (i=0;i<=*degreeRes;i++) { if ((*coeffRes)[i] != NULL) { temp = simplifyTreeErrorfree((*coeffRes)[i]); free_memory((*coeffRes)[i]); (*coeffRes)[i] = temp; } } } int getCoefficientsInnerAlternate(int *degree, node ***coefficients, node *poly) { polynomial_t polynomial; int deg; unsigned int myDegree, t, k; node **myCoeffs; if (poly == NULL) return 0; if (!polynomialFromExpressionOnlyRealCoeffs(&polynomial, poly)) { return 0; } if (polynomialGetCoefficients(&myCoeffs, &myDegree, polynomial)) { deg = myDegree; t = deg; if ((deg >= 0) && (t == myDegree)) { for (k=0u;k<=myDegree;k++) { if ((accessThruMemRef(myCoeffs[k])->nodeType == CONSTANT) && mpfr_zero_p(*(accessThruMemRef(myCoeffs[k])->value))) { free_memory(myCoeffs[k]); myCoeffs[k] = NULL; } } *coefficients = myCoeffs; *degree = deg; polynomialFree(polynomial); return 1; } else { for (k=0u;k<=myDegree;k++) { free_memory(myCoeffs[k]); } safeFree(myCoeffs); } } polynomialFree(polynomial); return 0; } void getCoefficientsInner(int *degree, node ***coefficients, node *poly) { node *temp, *temp2, *temp3, *temp4; int i,k,j, mpd; node **coefficients1, **coefficients2; int degree1, degree2; mpfr_t y; if (getCoefficientsInnerAlternate(degree, coefficients, poly)) { return; } if (poly->nodeType == MEMREF) { getCoefficients(degree, coefficients, getMemRefChild(poly)); return; } *degree = getDegree(poly); if (*degree < 0) { printMessage(1,SOLLYA_MSG_TRIED_TO_EXTRACT_COEFFS_OF_STH_NOT_POLYNOMIAL,"Warning: Tried to get coefficients of an expression that is not a polynomial.\n"); return; } *coefficients = (node**) safeCalloc((*degree + 1),sizeof(node*)); for (i=0;i<=*degree;i++) (*coefficients)[i] = NULL; if (isHorner(poly)) { getCoefficientsHorner(*coefficients,poly); return; } if (isCanonical(poly)) { getCoefficientsCanonical(*coefficients,poly); return; } if ((poly->nodeType == ADD) || (poly->nodeType == SUB)) { getCoefficients(°ree1, &coefficients1, poly->child1); getCoefficients(°ree2, &coefficients2, poly->child2); for (i=0;i<=degree1;i++) { (*coefficients)[i] = coefficients1[i]; } safeFree(coefficients1); for (i=0;i<=degree2;i++) { if (coefficients2[i] != NULL) { if ((*coefficients)[i] == NULL) { if (poly->nodeType == SUB) { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = NEG; temp->child1 = coefficients2[i]; (*coefficients)[i] = temp; } else { (*coefficients)[i] = coefficients2[i]; } } else { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = poly->nodeType; temp->child1 = (*coefficients)[i]; temp->child2 = coefficients2[i]; (*coefficients)[i] = temp; } } } safeFree(coefficients2); return; } if (poly->nodeType == MUL) { getCoefficients(°ree1, &coefficients1, poly->child1); getCoefficients(°ree2, &coefficients2, poly->child2); for (i=0;i<=degree1;i++) { for (k=0;k<=degree2;k++) { if ((coefficients1[i] != NULL) && (coefficients2[k] != NULL)) { j = i + k; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp->child1 = copyTree(coefficients1[i]); temp->child2 = copyTree(coefficients2[k]); if ((*coefficients)[j] == NULL) { (*coefficients)[j] = temp; } else { temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = ADD; temp2->child1 = (*coefficients)[j]; temp2->child2 = temp; (*coefficients)[j] = temp2; } } } } for (i=0;i<=degree1;i++) free_memory(coefficients1[i]); for (i=0;i<=degree2;i++) free_memory(coefficients2[i]); safeFree(coefficients1); safeFree(coefficients2); return; } if ((poly->nodeType == POW) && (accessThruMemRef(poly->child2)->nodeType == CONSTANT) && (mpfr_integer_p(*(accessThruMemRef(poly->child2)->value)))) { k = mpfr_get_si(*(accessThruMemRef(poly->child2)->value),GMP_RNDN); mpfr_init2(y,8 * sizeof(int) + 10); mpfr_set_si(y,k,GMP_RNDN); if ((mpfr_cmp(y,*(accessThruMemRef(poly->child2)->value)) == 0) && (!mpfr_nan_p(*(accessThruMemRef(poly->child2)->value))) && (k > 0)) { if ((mpd = getMaxPowerDivider(poly->child1)) > 0) { temp = dividePolynomialByPowerOfVariableUnsafe(poly->child1, mpd); temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = POW; temp2->child1 = temp; temp2->child2 = copyTree(poly->child2); getCoefficients(°ree1, &coefficients1, temp2); free_memory(temp2); for (i=0;i<=degree1;i++) (*coefficients)[i + k * mpd] = coefficients1[i]; safeFree(coefficients1); mpfr_clear(y); return; } if (k == 2) { getCoefficients(°ree1, &coefficients1, poly->child1); getCoefficients(°ree2, &coefficients2, poly->child1); for (i=0;i<=degree1;i++) { for (k=0;k<=degree2;k++) { if ((coefficients1[i] != NULL) && (coefficients2[k] != NULL)) { j = i + k; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp->child1 = copyTree(coefficients1[i]); temp->child2 = copyTree(coefficients2[k]); if ((*coefficients)[j] == NULL) { (*coefficients)[j] = temp; } else { temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = ADD; temp2->child1 = (*coefficients)[j]; temp2->child2 = temp; (*coefficients)[j] = temp2; } } } } for (i=0;i<=degree1;i++) free_memory(coefficients1[i]); for (i=0;i<=degree2;i++) free_memory(coefficients2[i]); safeFree(coefficients1); safeFree(coefficients2); mpfr_clear(y); return; } getCoefficients(°ree1, &coefficients1, poly->child1); for (i=0;i<=degree1;i++) { if (coefficients1[i] == NULL) coefficients1[i] = makeConstantDouble(0.0); } computePowerOfPolynomialCoefficients(°ree2, &coefficients2, coefficients1, degree1, k); for (i=0;i<=degree2;i++) { if (coefficients2[i] != NULL) { temp = simplifyTreeErrorfree(coefficients2[i]); free_memory(coefficients2[i]); coefficients2[i] = temp; } } for (i=0;i<=degree2;i++) { if ((coefficients2[i] != NULL) && (!((accessThruMemRef(coefficients2[i])->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(coefficients2[i])->value)))))) { (*coefficients)[i] = copyTree(coefficients2[i]); } } for (i=0;i<=degree1;i++) free_memory(coefficients1[i]); safeFree(coefficients1); for (i=0;i<=degree2;i++) free_memory(coefficients2[i]); safeFree(coefficients2); mpfr_clear(y); return; } mpfr_clear(y); } temp = simplifyTreeErrorfree(poly); temp2 = expandPowerInPolynomialUnsafe(temp); temp3 = expandPolynomialUnsafe(temp2); temp4 = simplifyTreeErrorfree(temp3); getCoefficientsUnsafe(*coefficients,temp4,1); free_memory(temp); free_memory(temp2); free_memory(temp3); free_memory(temp4); } void getCoefficients(int *degree, node ***coefficients, node *poly) { int i, deg; unsigned int myDegree, t, k; node **myCoeffs; if (poly->nodeType == MEMREF) { if (poly->polynomialRepresentation == NULL) { tryRepresentAsPolynomial(poly); } if (poly->polynomialRepresentation != NULL) { if (polynomialGetCoefficients(&myCoeffs, &myDegree, poly->polynomialRepresentation)) { deg = myDegree; t = deg; if ((deg >= 0) && (t == myDegree)) { for (k=0u;k<=myDegree;k++) { if ((accessThruMemRef(myCoeffs[k])->nodeType == CONSTANT) && mpfr_zero_p(*(accessThruMemRef(myCoeffs[k])->value))) { free_memory(myCoeffs[k]); myCoeffs[k] = NULL; } } *coefficients = myCoeffs; *degree = deg; return; } else { for (k=0u;k<=myDegree;k++) { free_memory(myCoeffs[k]); } safeFree(myCoeffs); } } } } getCoefficientsInner(degree, coefficients, poly); if (*degree >= 0) { for (i=0;i<=*degree;i++) { if ((*coefficients)[i] != NULL) (*coefficients)[i] = addMemRef((*coefficients)[i]); } } } node* hornerPolynomialUnsafe(node *tree) { node *copy, *temp, *temp2, *temp3, *temp4, *simplified; node **monomials; int degree, i, k, e; mpfr_t *value; simplified = simplifyTreeErrorfree(tree); if (isHorner(simplified)) { degree = getDegree(simplified); monomials = (node**) safeCalloc((degree + 1),sizeof(node*)); for (i=0;i<=degree;i++) monomials[i] = NULL; getCoefficientsHorner(monomials,simplified); } else { if (isCanonical(simplified)) { degree = getDegree(simplified); monomials = (node**) safeCalloc((degree + 1),sizeof(node*)); for (i=0;i<=degree;i++) monomials[i] = NULL; getCoefficientsCanonical(monomials,simplified); } else { getCoefficients(°ree,&monomials,simplified); } } while ((degree >= 0) && (monomials[degree] == NULL)) degree--; if ((degree < 0) || (monomials[degree] == NULL)) { for (i=0;i<=degree;i++) { if (monomials[i] != NULL) free_memory(monomials[i]); } safeFree(monomials); return makeConstantInt(0); } copy = copyTree(monomials[degree]); for (i=degree-1;i>=0;i--) { if (monomials[i] == NULL) { if (i == 0) { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = VARIABLE; temp->child1 = temp2; temp->child2 = copy; copy = temp; } else { for (k=i-1;((monomials[k]==NULL) && (k > 0));k--); e = (i - k) + 1; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = VARIABLE; temp3 = (node *) safeMalloc(sizeof(node)); temp3->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); if (mpfr_set_si(*value,e,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_POW_EXPONENT_COMPUTATION,"Warning: rounding occurred on representing a monomial power exponent with %d bits.\n", (int) tools_precision); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the precision.\n"); } } temp3->value = value; temp4 = (node *) safeMalloc(sizeof(node)); temp4->nodeType = POW; temp4->child1 = temp2; temp4->child2 = temp3; temp->child1 = temp4; temp->child2 = copy; copy = temp; if (monomials[k] != NULL) { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = ADD; temp->child1 = copyTree(monomials[k]); temp->child2 = copy; copy = temp; } i = k; } } else { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = VARIABLE; temp->child1 = temp2; temp->child2 = copy; copy = temp; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = ADD; temp->child1 = copyTree(monomials[i]); temp->child2 = copy; copy = temp; } } for (i=0;i<=degree;i++) { if (monomials[i] != NULL) free_memory(monomials[i]); } safeFree(monomials); free_memory(simplified); return copy; } node* dividePolynomialByPowerOfVariableUnsafe(node *tree, int alpha) { node *copy, *temp, *temp2, *temp3, *temp4, *simplified; node **monomials; int degree, i, k, e; mpfr_t *value; simplified = simplifyTreeErrorfree(tree); getCoefficients(°ree,&monomials,simplified); if (alpha > 0) { for (i=0;i= 0) && (monomials[degree] == NULL)) degree--; if ((degree < 0) || (monomials[degree] == NULL)) { for (i=0;i<=degree;i++) { if (monomials[i] != NULL) free_memory(monomials[i]); } safeFree(monomials); free_memory(simplified); return makeConstantInt(0); } copy = copyTree(monomials[degree]); for (i=degree-1;i>=0;i--) { if (monomials[i] == NULL) { if (i == 0) { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = VARIABLE; temp->child1 = temp2; temp->child2 = copy; copy = temp; } else { for (k=i-1;((monomials[k]==NULL) && (k > 0));k--); e = (i - k) + 1; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = VARIABLE; temp3 = (node *) safeMalloc(sizeof(node)); temp3->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); if (mpfr_set_si(*value,e,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_POW_EXPONENT_COMPUTATION,"Warning: rounding occurred on representing a monomial power exponent with %d bits.\n", (int) tools_precision); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the precision.\n"); } } temp3->value = value; temp4 = (node *) safeMalloc(sizeof(node)); temp4->nodeType = POW; temp4->child1 = temp2; temp4->child2 = temp3; temp->child1 = temp4; temp->child2 = copy; copy = temp; if (monomials[k] != NULL) { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = ADD; temp->child1 = copyTree(monomials[k]); temp->child2 = copy; copy = temp; } i = k; } } else { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = VARIABLE; temp->child1 = temp2; temp->child2 = copy; copy = temp; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = ADD; temp->child1 = copyTree(monomials[i]); temp->child2 = copy; copy = temp; } } for (i=0;i<=degree;i++) { if (monomials[i] != NULL) free_memory(monomials[i]); } safeFree(monomials); free_memory(simplified); return copy; } node* hornerPolynomial(node *tree) { node *temp; if (isConstant(tree)) return copyTree(tree); if (getDegree(tree) < 0) return copyTree(tree); if (isHorner(tree)) { printMessage(7,SOLLYA_MSG_EXPR_NOT_HORNERIZED_AS_ALREADY_HORNERIZED,"Information: no Horner simplification will be performed because the given tree is already in Horner form.\n"); return copyTree(tree); } temp = hornerPolynomialUnsafe(tree); return temp; } node* hornerUnsimplified(node *tree) { node *copy, *res; mpfr_t *value; mpfr_t temp; polynomial_t p; if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) { if (polynomialIsHornerized(tree->polynomialRepresentation)) return copyTree(tree); if (tree->child1 == NULL) { p = polynomialHornerize(tree->polynomialRepresentation); polynomialFree(tree->polynomialRepresentation); tree->polynomialRepresentation = p; return copyTree(tree); } res = addMemRefEvenOnNull(NULL); if (res != NULL) { res->polynomialRepresentation = polynomialHornerize(tree->polynomialRepresentation); copyTreeAnnotationsNoSimplifications(res, tree); return res; } } res = addMemRef(hornerUnsimplified(getMemRefChild(tree))); copyTreeAnnotationsNoSimplifications(res, tree); return res; } if (isPolynomial(tree)) return hornerPolynomial(tree); switch (tree->nodeType) { case VARIABLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = VARIABLE; break; case CONSTANT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(temp,tools_precision); simplifyMpfrPrec(temp,*(tree->value)); mpfr_init2(*value,mpfr_get_prec(temp)); mpfr_set(*value,temp,GMP_RNDN); mpfr_clear(temp); copy->value = value; break; case ADD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ADD; copy->child1 = horner(tree->child1); copy->child2 = horner(tree->child2); break; case SUB: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SUB; copy->child1 = horner(tree->child1); copy->child2 = horner(tree->child2); break; case MUL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = horner(tree->child1); copy->child2 = horner(tree->child2); break; case DIV: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DIV; copy->child1 = horner(tree->child1); copy->child2 = horner(tree->child2); break; case SQRT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SQRT; copy->child1 = horner(tree->child1); break; case EXP: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = EXP; copy->child1 = horner(tree->child1); break; case LOG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG; copy->child1 = horner(tree->child1); break; case LOG_2: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_2; copy->child1 = horner(tree->child1); break; case LOG_10: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_10; copy->child1 = horner(tree->child1); break; case SIN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SIN; copy->child1 = horner(tree->child1); break; case COS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = COS; copy->child1 = horner(tree->child1); break; case TAN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TAN; copy->child1 = horner(tree->child1); break; case ASIN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ASIN; copy->child1 = horner(tree->child1); break; case ACOS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ACOS; copy->child1 = horner(tree->child1); break; case ATAN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ATAN; copy->child1 = horner(tree->child1); break; case SINH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SINH; copy->child1 = horner(tree->child1); break; case COSH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = COSH; copy->child1 = horner(tree->child1); break; case TANH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TANH; copy->child1 = horner(tree->child1); break; case ASINH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ASINH; copy->child1 = horner(tree->child1); break; case ACOSH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ACOSH; copy->child1 = horner(tree->child1); break; case ATANH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ATANH; copy->child1 = horner(tree->child1); break; case POW: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = POW; copy->child1 = horner(tree->child1); copy->child2 = horner(tree->child2); break; case NEG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEG; copy->child1 = horner(tree->child1); break; case ABS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ABS; copy->child1 = horner(tree->child1); break; case DOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLE; copy->child1 = horner(tree->child1); break; case SINGLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SINGLE; copy->child1 = horner(tree->child1); break; case QUAD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = QUAD; copy->child1 = horner(tree->child1); break; case HALFPRECISION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = HALFPRECISION; copy->child1 = horner(tree->child1); break; case DOUBLEDOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLEDOUBLE; copy->child1 = horner(tree->child1); break; case TRIPLEDOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TRIPLEDOUBLE; copy->child1 = horner(tree->child1); break; case ERF: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ERF; copy->child1 = horner(tree->child1); break; case ERFC: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ERFC; copy->child1 = horner(tree->child1); break; case LOG_1P: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_1P; copy->child1 = horner(tree->child1); break; case EXP_M1: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = EXP_M1; copy->child1 = horner(tree->child1); break; case DOUBLEEXTENDED: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLEEXTENDED; copy->child1 = horner(tree->child1); break; case LIBRARYFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYFUNCTION; copy->libFun = tree->libFun; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = horner(tree->child1); break; case PROCEDUREFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PROCEDUREFUNCTION; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = horner(tree->child1); copy->child2 = copyThing(tree->child2); break; case CEIL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CEIL; copy->child1 = horner(tree->child1); break; case FLOOR: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = FLOOR; copy->child1 = horner(tree->child1); break; case NEARESTINT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEARESTINT; copy->child1 = horner(tree->child1); break; case PI_CONST: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PI_CONST; break; case LIBRARYCONSTANT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYCONSTANT; copy->libFun = tree->libFun; break; default: sollyaFprintf(stderr,"Error: horner: unknown identifier in the tree\n"); exit(1); } return copy; } int isPowerOfVariable(node *tree) { if (tree->nodeType == MEMREF) return isPowerOfVariable(getMemRefChild(tree)); if (tree->nodeType == VARIABLE) return 1; if ((tree->nodeType == POW) && (accessThruMemRef(tree->child1)->nodeType == VARIABLE) && (accessThruMemRef(tree->child2)->nodeType == CONSTANT) && mpfr_integer_p(*(accessThruMemRef(tree->child2)->value))) return 1; return 0; } int isHornerUnsafe(node *tree) { if (isConstant(tree)) return 1; if (tree->nodeType == MEMREF) return isHornerUnsafe(getMemRefChild(tree)); if (((tree->nodeType == ADD) || (tree->nodeType == SUB)) && isConstant(tree->child1) && (accessThruMemRef(tree->child2)->nodeType == MUL) && isPowerOfVariable(accessThruMemRef(tree->child2)->child1) && isHornerUnsafe(accessThruMemRef(tree->child2)->child2)) return 1; if (((tree->nodeType == ADD) || (tree->nodeType == SUB)) && isConstant(tree->child1) && isPowerOfVariable(tree->child2)) return 1; if (((tree->nodeType == ADD) || (tree->nodeType == SUB)) && isConstant(tree->child1) && (accessThruMemRef(tree->child2)->nodeType == MUL) && (accessThruMemRef(accessThruMemRef(tree->child2)->child1)->nodeType == MUL) && isPowerOfVariable(accessThruMemRef(accessThruMemRef(tree->child2)->child1)->child1) && isConstant(accessThruMemRef(accessThruMemRef(tree->child2)->child1)->child2) && isConstant(accessThruMemRef(tree->child2)->child2)) return 1; if (((tree->nodeType == ADD) || (tree->nodeType == SUB)) && isConstant(tree->child1) && (accessThruMemRef(tree->child2)->nodeType == MUL) && isConstant(accessThruMemRef(tree->child2)->child1) && isPowerOfVariable(accessThruMemRef(tree->child2)->child2)) return 1; return 0; } int isHorner(node *tree) { if (tree->nodeType == MEMREF) { if (((tree->child1 == NULL) || (tree->memRefChildFromPolynomial)) && (tree->polynomialRepresentation != NULL)) { return polynomialIsHornerized(tree->polynomialRepresentation); } return isHorner(getMemRefChild(tree)); } if ((tree->nodeType == ADD) || (tree->nodeType == SUB)) return isHornerUnsafe(tree); if (tree->nodeType == MUL) { return isPowerOfVariable(tree->child1) && isHornerUnsafe(tree->child2); } return 0; } node* hornerInner(node *); node* hornerWork(node *tree) { node *res; polynomial_t p; if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) { if (polynomialIsHornerized(tree->polynomialRepresentation)) return copyTree(tree); if (tree->child1 == NULL) { p = polynomialHornerize(tree->polynomialRepresentation); polynomialFree(tree->polynomialRepresentation); tree->polynomialRepresentation = p; return copyTree(tree); } res = addMemRefEvenOnNull(NULL); if (res != NULL) { res->polynomialRepresentation = polynomialHornerize(tree->polynomialRepresentation); copyTreeAnnotationsNoSimplifications(res, tree); return res; } } } res = addMemRef(hornerInner(tree)); if ((tree != NULL) && (res != NULL) && (tree != res) && (tree->nodeType == MEMREF) && isSyntacticallyEqualCheap(tree,res)) { free_memory(res); res = copyTree(tree); } if (((tree->nodeType == MEMREF) && (tree->evaluationHook != NULL)) && ((res->nodeType == MEMREF) && (res->evaluationHook == NULL))) { res->isCorrectlyTyped = tree->isCorrectlyTyped; addEvaluationHookFromCopy(&(res->evaluationHook), tree->evaluationHook); if ((res->derivCache == NULL) && (tree->derivCache != NULL)) { res->derivCache = copyTree(tree->derivCache); } } return res; } node* horner(node *tree) { node *res; if (tree->nodeType == MEMREF) { if (tree->hornerCache != NULL) { res = copyTree(tree->hornerCache); } else { res = hornerWork(tree); if ((tree->hornerCache != NULL) && (res->nodeType == MEMREF)) { tree->hornerCache = copyTree(res); } } } else { res = hornerWork(tree); } if (((tree->nodeType == MEMREF) && (tree->evaluationHook != NULL)) && ((res->nodeType == MEMREF) && (res->evaluationHook == NULL))) { res->isCorrectlyTyped = tree->isCorrectlyTyped; addEvaluationHookFromCopy(&(res->evaluationHook), tree->evaluationHook); if ((res->derivCache == NULL) && (tree->derivCache != NULL)) { res->derivCache = copyTree(tree->derivCache); } } return res; } node* hornerInner(node *tree) { node *temp, *temp2, *temp3; int i; if (isHorner(tree) || isPowerOfVariable(tree)) { printMessage(7,SOLLYA_MSG_EXPR_NOT_HORNERIZED_AS_ALREADY_HORNERIZED,"Information: no Horner simplification will be performed because the given tree is already in Horner form.\n"); return copyTree(tree); } temp3 = simplifyTreeErrorfree(tree); i = 0; do { temp = hornerUnsimplified(temp3); temp2 = simplifyTreeErrorfree(temp); free_memory(temp); free_memory(temp3); temp3 = temp2; i++; } while ((!(isHorner(temp3) || (!isPolynomial(temp3)))) && (i < 3)); return temp3; } node *differentiatePolynomialHornerUnsafe(node *tree) { int degree, i, k, e; node **monomials; node *temp, *temp2, *temp3, *temp4, *copy; mpfr_t *value; mp_prec_t prec; copy = NULL; getCoefficients(°ree,&monomials,tree); if (degree == 0) { for (i=0;i<=degree;i++) { free_memory(monomials[i]); } safeFree(monomials); return addMemRef(makeConstantInt(0)); } if (monomials[0] != NULL) free_memory(monomials[0]); for (i=1;i<=degree;i++) { if (monomials[i] != NULL) { if (accessThruMemRef(monomials[i])->nodeType == CONSTANT) { value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,mpfr_get_prec(*(accessThruMemRef(monomials[i])->value))+(sizeof(int)*8)); if (mpfr_mul_si(*value,*(accessThruMemRef(monomials[i])->value),i,GMP_RNDN) != 0) printMessage(1,SOLLYA_MSG_ROUNDING_UPON_DIFFERENTIATION_OF_HORNER_POLY,"Warning: rounding occurred while differentiating a polynomial in Horner form.\n"); free_memory(monomials[i]); monomials[i] = (node *) safeMalloc(sizeof(node)); monomials[i]->nodeType = CONSTANT; monomials[i]->value = value; temp = monomials[i]; } else { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp->child1 = (node *) safeMalloc(sizeof(node)); temp->child1->nodeType = CONSTANT; temp->child1->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); prec = 8 * sizeof(int) + 10; if (tools_precision > prec) prec = tools_precision; mpfr_init2(*(temp->child1->value),prec); if (mpfr_set_si(*(temp->child1->value),i,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_DIFFERENTIATION_OF_HORNER_POLY,"Warning: on differentiating a polynomial in Horner form rounding occurred while representing the degree of a monomial on a constant of the given precision\n"); } } temp->child2 = monomials[i]; } monomials[i-1] = temp; } else { monomials[i-1] = NULL; } } degree--; copy = copyTree(monomials[degree]); for (i=degree-1;i>=0;i--) { if (monomials[i] == NULL) { if (i == 0) { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = VARIABLE; temp->child1 = temp2; temp->child2 = copy; copy = temp; } else { for (k=i-1;((monomials[k]==NULL) && (k > 0));k--); e = (i - k) + 1; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = VARIABLE; temp3 = (node *) safeMalloc(sizeof(node)); temp3->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); if (mpfr_set_si(*value,e,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_POW_EXPONENT_COMPUTATION,"Warning: rounding occurred on representing a monomial power exponent with %d bits.\n", (int) tools_precision); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the precision.\n"); } } temp3->value = value; temp4 = (node *) safeMalloc(sizeof(node)); temp4->nodeType = POW; temp4->child1 = temp2; temp4->child2 = temp3; temp->child1 = temp4; temp->child2 = copy; copy = temp; if (monomials[k] != NULL) { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = ADD; temp->child1 = copyTree(monomials[k]); temp->child2 = copy; copy = temp; } i = k; } } else { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = VARIABLE; temp->child1 = temp2; temp->child2 = copy; copy = temp; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = ADD; temp->child1 = copyTree(monomials[i]); temp->child2 = copy; copy = temp; } } for (i=0;i<=degree;i++) { if (monomials[i] != NULL) free_memory(monomials[i]); } safeFree(monomials); if (copy == NULL) { copy = addMemRef(makeConstantInt(0)); } return copy; } node *differentiatePolynomialUnsafe(node *tree) { node *copy, *temp, *temp2, *temp3, *temp4, *temp5; int degree, i; node **monomials; mpfr_t *value; copy = NULL; if (isHorner(tree)) { printMessage(25,SOLLYA_MSG_DIFFERENTIATION_USES_SPECIAL_ALGO_FOR_HORNER,"Information: differentiating a polynomial in Horner form uses a special algorithm.\n"); return differentiatePolynomialHornerUnsafe(tree); } degree = getDegree(tree); if (degree == 0) { copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_d(*value,0.0,GMP_RNDN); copy->value = value; } else { getCoefficients(°ree,&monomials,tree); if (monomials[degree] == NULL) { copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); mpfr_set_d(*value,0.0,GMP_RNDN); copy->value = value; monomials[degree] = copy; } if (degree >= 2) { if (degree > 2) { temp = copyTree(monomials[degree]); temp2 = (node*) safeMalloc(sizeof(node)); temp2->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); if (mpfr_set_si(*value,degree,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_DIFFERENTIATION_OF_POLYNOMIAL,"Warning: rounding occurred on differentiating a polynomial. A constant could not be written on %d bits.\n", (int) tools_precision); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the precision.\n"); } } temp2->value = value; temp3 = (node*) safeMalloc(sizeof(node)); temp3->nodeType = MUL; temp3->child1 = temp2; temp3->child2 = temp; temp2 = (node*) safeMalloc(sizeof(node)); temp2->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); if (mpfr_set_si(*value,degree-1,GMP_RNDN) != 0) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_DIFFERENTIATION_OF_POLYNOMIAL, "Warning: rounding occurred on differentiating a polynomial. An exponent constant could not be written on %d bits.\n", (int) tools_precision); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the precision.\n"); } temp2->value = value; temp = (node*) safeMalloc(sizeof(node)); temp->nodeType = VARIABLE; temp4 = (node*) safeMalloc(sizeof(node)); temp4->nodeType = POW; temp4->child1 = temp; temp4->child2 = temp2; temp5 = (node*) safeMalloc(sizeof(node)); temp5->nodeType = MUL; temp5->child1 = temp3; temp5->child2 = temp4; copy = temp5; } else { temp = copyTree(monomials[degree]); temp2 = (node*) safeMalloc(sizeof(node)); temp2->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); if (mpfr_set_si(*value,degree,GMP_RNDN) != 0) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_DIFFERENTIATION_OF_POLYNOMIAL,"Warning: rounding occurred on differentiating a polynomial. A constant could not be written on %d bits.\n", (int) tools_precision); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the precision.\n"); } temp2->value = value; temp3 = (node*) safeMalloc(sizeof(node)); temp3->nodeType = MUL; temp3->child1 = temp2; temp3->child2 = temp; temp = (node*) safeMalloc(sizeof(node)); temp->nodeType = VARIABLE; temp4 = (node*) safeMalloc(sizeof(node)); temp4->nodeType = MUL; temp4->child1 = temp3; temp4->child2 = temp; copy = temp4; } for (i=degree-1;i>1;i--) { if (monomials[i] != NULL) { temp = copyTree(monomials[i]); temp2 = (node*) safeMalloc(sizeof(node)); temp2->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); if (mpfr_set_si(*value,i,GMP_RNDN) != 0) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_DIFFERENTIATION_OF_POLYNOMIAL,"Warning: rounding occurred on differentiating a polynomial. A constant could not be written on %d bits.\n", (int) tools_precision); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the precision.\n"); } temp2->value = value; temp3 = (node*) safeMalloc(sizeof(node)); temp3->nodeType = MUL; temp3->child1 = temp2; temp3->child2 = temp; temp2 = (node*) safeMalloc(sizeof(node)); temp2->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,tools_precision); if (mpfr_set_si(*value,i-1,GMP_RNDN) != 0) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_DIFFERENTIATION_OF_POLYNOMIAL, "Warning: rounding occurred on differentiating a polynomial. An exponent constant could not be written on %d bits.\n", (int) tools_precision); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the precision.\n"); } temp2->value = value; temp = (node*) safeMalloc(sizeof(node)); temp->nodeType = VARIABLE; temp4 = (node*) safeMalloc(sizeof(node)); temp4->nodeType = POW; temp4->child1 = temp; temp4->child2 = temp2; temp5 = (node*) safeMalloc(sizeof(node)); temp5->nodeType = MUL; temp5->child1 = temp3; temp5->child2 = temp4; temp = copy; temp2 = (node*) safeMalloc(sizeof(node)); temp2->nodeType = ADD; temp2->child1 = temp5; temp2->child2 = temp; copy = temp2; } } if (monomials[1] != NULL) { temp = copyTree(monomials[1]); temp2 = (node*) safeMalloc(sizeof(node)); temp2->nodeType = ADD; temp2->child1 = temp; temp2->child2 = copy; copy = temp2; } } else { if (degree >= 1) { copy = copyTree(monomials[1]); } else { copy = addMemRef(makeConstantInt(0)); } } for (i=0;i<=degree;i++) { if (monomials[i] != NULL) free_memory(monomials[i]); } safeFree(monomials); } if (copy == NULL) { copy = addMemRef(makeConstantInt(0)); } return copy; } int getNumeratorDenominator(node **numerator, node **denominator, node *tree) { if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) { if (polynomialGetDegreeAsInt(tree->polynomialRepresentation) != 0) { *numerator = copyTree(tree); *denominator = NULL; return 0; } } return getNumeratorDenominator(numerator, denominator, getMemRefChild(tree)); } if (tree->nodeType == DIV) { *numerator = copyTree(tree->child1); *denominator = copyTree(tree->child2); return 1; } else { *numerator = copyTree(tree); *denominator = NULL; return 0; } } node *makeBinomialCoefficient(unsigned int n, unsigned int k) { mpz_t coeffGMP; mp_prec_t prec; mpfr_t *coeffVal; node *res; mpz_init(coeffGMP); mpz_bin_uiui(coeffGMP,n,k); prec = mpz_sizeinbase(coeffGMP, 2) + 10; if (prec < tools_precision) prec = tools_precision; coeffVal = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*coeffVal,prec); if(mpfr_set_z(*coeffVal,coeffGMP,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_BINOMIAL_COEFFICIENT_COMPUTATION,"Warning: rounding occurred when calculating a binomial coefficient.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } mpz_clear(coeffGMP); res = (node *) safeMalloc(sizeof(node)); res->nodeType = CONSTANT; res->value = coeffVal; return res; } node *makePowerOfConstant(node *constTree, int k) { node *temp, *res; if (k == 1) { return copyTree(constTree); } temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = CONSTANT; temp->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(temp->value),8 * sizeof(k) + 10); mpfr_set_si(*(temp->value),k,GMP_RNDN); res = (node *) safeMalloc(sizeof(node)); res->nodeType = POW; res->child1 = copyTree(constTree); res->child2 = temp; return res; } /* polynomialShiftAndScaleAbscissaUnsafe(poly, a, b) returns // // p(a + b * x) // // for a polynomial p and a, b constant nodes // // If poly is not a polynomial the tool is terminated. // If a or b is not a constant expression, the shifting and // scaling is performed as if they were. */ node *polynomialShiftAndScaleAbscissaUnsafe(node *poly, node *a, node *b) { node *res; node **coeffs; node **coeffsRes; node *temp; int degree; int i,k; getCoefficients(°ree, &coeffs, poly); if (degree < 0) { sollyaFprintf(stderr,"Error: polynomialShiftAndScaleAbscissaUnsafe: the given expression is not a polynomial\n"); exit(1); } for (i=0;i<=degree;i++) { if (coeffs[i] == NULL) { coeffs[i] = makeConstantDouble(0.0); } } coeffsRes = (node **) safeCalloc(degree+1,sizeof(node *)); for (i=0;i<=degree;i++) { coeffsRes[i] = makeConstantDouble(0.0); } for (i=0;i<=degree;i++) { for (k=0;k<=i;k++) { temp = makeMul(copyTree(coeffs[i]), makeMul(makeBinomialCoefficient(i,k), makeMul(makePowerOfConstant(a, i-k), makePowerOfConstant(b, k)))); coeffsRes[k] = makeAdd(coeffsRes[k],temp); } } for (i=0;i<=degree;i++) { if (coeffsRes[i] != NULL) { temp = simplifyTreeErrorfree(coeffsRes[i]); free_memory(coeffsRes[i]); coeffsRes[i] = temp; } } res = makePolynomialConstantExpressions(coeffsRes, degree); for (i=0;i<=degree;i++) { if (coeffs[i] != NULL) free_memory(coeffs[i]); if (coeffsRes[i] != NULL) free_memory(coeffsRes[i]); } safeFree(coeffs); safeFree(coeffsRes); return res; } /* Returns p(q) */ node *substitutePolynomialUnsafe(node *p, node *q) { node *res; node **coeffsP, **coeffsQ, **coeffs, **coeffsQPi; int degP, degQ, deg, i, k, degQPi; node *temp; getCoefficients(°P, &coeffsP, p); if (degP < 0) { sollyaFprintf(stderr,"Error: substitutePolynomialUnsafe: the given expression is not a polynomial\n"); exit(1); } getCoefficients(°Q, &coeffsQ, q); if (degQ < 0) { sollyaFprintf(stderr,"Error: substitutePolynomialUnsafe: the given expression is not a polynomial\n"); exit(1); } for (i=0;i<=degQ;i++) { if (coeffsQ[i] == NULL) { coeffsQ[i] = makeConstantDouble(0.0); } } deg = degP * degQ; coeffs = (node **) safeCalloc(deg+1,sizeof(node *)); for (i=0;i<=deg;i++) { coeffs[i] = makeConstantDouble(0.0); } for (i=0;i<=degP;i++) { if (coeffsP[i] != NULL) { computePowerOfPolynomialCoefficients(°QPi, &coeffsQPi, coeffsQ, degQ, i); for (k=0;k<=degQPi;k++) { if (coeffsQPi[k] != NULL) { coeffs[k] = makeAdd(coeffs[k], makeMul(copyTree(coeffsP[i]), coeffsQPi[k])); } } safeFree(coeffsQPi); } } for (i=0;i<=deg;i++) { if (coeffs[i] != NULL) { temp = simplifyTreeErrorfree(coeffs[i]); free_memory(coeffs[i]); coeffs[i] = temp; } } res = makePolynomialConstantExpressions(coeffs, deg); for (i=0;i<=degP;i++) { if (coeffsP[i] != NULL) free_memory(coeffsP[i]); } safeFree(coeffsP); for (i=0;i<=degQ;i++) { if (coeffsQ[i] != NULL) free_memory(coeffsQ[i]); } safeFree(coeffsQ); for (i=0;i<=deg;i++) { if (coeffs[i] != NULL) free_memory(coeffs[i]); } safeFree(coeffs); return res; } node *substituteInner(node* tree, node *t, int doNotEvaluate, int maySimplify); node *substituteEnhanced(node* tree, node *t, int doNotEvaluate, int maySimplify) { node *res; if (maySimplify) { if ((tree->nodeType == MEMREF) && (t->nodeType == MEMREF)) { if (tree->polynomialRepresentation == NULL) { tryRepresentAsPolynomial(tree); } if ((tree->polynomialRepresentation != NULL) && (t->polynomialRepresentation == NULL)) { tryRepresentAsPolynomial(t); } if ((tree->polynomialRepresentation != NULL) && (t->polynomialRepresentation != NULL)) { res = addMemRefEvenOnNull(NULL); if (res != NULL) { res->polynomialRepresentation = polynomialCompose(tree->polynomialRepresentation, t->polynomialRepresentation); return res; } } } } return substituteInner(tree, t, doNotEvaluate, maySimplify); } node *substitute(node* tree, node *t) { return substituteEnhanced(tree, t, 0, 1); } int treeContainsHooks(node *tree) { if (tree == NULL) return 0; if (tree->nodeType == MEMREF) { if (tree->evaluationHook != NULL) return 1; if ((tree->child1 == NULL) && (tree->polynomialRepresentation != NULL)) return 0; return treeContainsHooks(getMemRefChild(tree)); } switch (tree->nodeType) { case VARIABLE: case CONSTANT: case PI_CONST: case LIBRARYCONSTANT: return 0; break; case ADD: case SUB: case MUL: case DIV: case POW: if (treeContainsHooks(tree->child1)) return 1; if (treeContainsHooks(tree->child2)) return 1; return 0; break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case DOUBLE: case SINGLE: case QUAD: case HALFPRECISION: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case LIBRARYFUNCTION: case PROCEDUREFUNCTION: case CEIL: case FLOOR: case NEARESTINT: return treeContainsHooks(tree->child1); break; default: sollyaFprintf(stderr,"Error: treeContainsHooks: unknown identifier in the tree\n"); exit(1); } return 0; } node *substituteInner(node* tree, node *t, int doNotEvaluate, int maySimplify) { node *copy; mpfr_t *value; mpfr_t temp; node **coeffs; int degree; int i; sollya_mpfi_t tEval, treeEval; mp_prec_t treeEvalPrec; mpfr_t tEl, tEr; sollya_mpfi_t aPrioriBoundForConstantExpr; int haveAPrioriBoundForConstantExpr; mp_prec_t *precPtr; sollya_mpfi_t *intervalPtr; node *tempDerivCache; // sollyaPrintf("tree = %b;\ntree->nodeType = %d;\nt = %b;\nt->nodeType = %d;\n", tree, tree->nodeType, t, t->nodeType); haveAPrioriBoundForConstantExpr = 0; if (isPolynomial(tree) && isPolynomial(t)) { if ((getDegree(t) == 1) && (getDegree(tree) >= 2)) { getCoefficients(°ree, &coeffs, t); if (degree == 1) { for (i=0;i<=degree;i++) { if (coeffs[i] == NULL) { coeffs[i] = makeConstantDouble(0.0); } } copy = polynomialShiftAndScaleAbscissaUnsafe(tree, coeffs[0], coeffs[1]); for (i=0;i<=degree;i++) { if (coeffs[i] != NULL) free_memory(coeffs[i]); } safeFree(coeffs); return copy; } for (i=0;i<=degree;i++) { if (coeffs[i] != NULL) free_memory(coeffs[i]); } safeFree(coeffs); } if ((getDegree(t) >= 2) && (getDegree(tree) >= 2)) { copy = substitutePolynomialUnsafe(tree,t); return copy; } } if (isConstant(t) && (!isConstant(tree)) && (!doNotEvaluate)) { copy = NULL; sollya_mpfi_init2(tEval, tools_precision + 10); sollya_mpfi_init2(treeEval, tools_precision + 10); evaluateConstantExpressionToInterval(tEval, t); evaluateInterval(treeEval, tree, NULL, tEval); treeEvalPrec = sollya_mpfi_get_prec(treeEval); mpfr_init2(tEl, treeEvalPrec); mpfr_init2(tEr, treeEvalPrec); sollya_mpfi_get_left(tEl, treeEval); sollya_mpfi_get_right(tEr, treeEval); if (mpfr_number_p(tEr) && mpfr_number_p(tEl)) { sollya_mpfi_init2(aPrioriBoundForConstantExpr,sollya_mpfi_get_prec(treeEval)); sollya_mpfi_set(aPrioriBoundForConstantExpr,treeEval); haveAPrioriBoundForConstantExpr = 1; if (mpfr_equal_p(tEr, tEl)) { copy = addMemRef(makeConstant(tEr)); } } mpfr_clear(tEl); mpfr_clear(tEr); sollya_mpfi_clear(tEval); sollya_mpfi_clear(treeEval); if (copy != NULL) { if (haveAPrioriBoundForConstantExpr) { sollya_mpfi_clear(aPrioriBoundForConstantExpr); } return copy; } } if (tree->nodeType == MEMREF) { copy = addMemRef(substituteInner(getMemRefChild(tree), t, 1, maySimplify)); if ((copy->nodeType == MEMREF) && (tree->evaluationHook != NULL)) { addEvaluationHookFromComposition(&(copy->evaluationHook), tree->evaluationHook, t); if (((copy->derivCache == NULL) && ((tree->derivCache != NULL) && ((tree->derivCache->nodeType == MEMREF) && (treeContainsHooks(tree->derivCache))))) && (!isConstant(copy))) { tempDerivCache = addMemRef(makeMul(addMemRef(substituteInner(tree->derivCache, t, 1, maySimplify)), addMemRef(differentiate(t)))); copy->derivCache = simplifyTreeErrorfree(tempDerivCache); free_memory(tempDerivCache); } } if (haveAPrioriBoundForConstantExpr) { if (copy->nodeType == MEMREF) { if (copy->arguments == NULL) { precPtr = (mp_prec_t *) safeMalloc(sizeof(mp_prec_t)); *precPtr = sollya_mpfi_get_prec(aPrioriBoundForConstantExpr); intervalPtr = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*intervalPtr, sollya_mpfi_get_prec(aPrioriBoundForConstantExpr)); sollya_mpfi_set(*intervalPtr, aPrioriBoundForConstantExpr); copy->arguments = addElement(addElement(NULL, intervalPtr), precPtr); } } sollya_mpfi_clear(aPrioriBoundForConstantExpr); } return copy; } switch (tree->nodeType) { case VARIABLE: copy = copyTree(t); break; case CONSTANT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(temp,mpfr_get_prec(*(tree->value))); simplifyMpfrPrec(temp,*(tree->value)); mpfr_init2(*value,mpfr_get_prec(temp)); mpfr_set(*value,temp,GMP_RNDN); mpfr_clear(temp); copy->value = value; break; case ADD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ADD; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); copy->child2 = substituteEnhanced(tree->child2,t,doNotEvaluate,maySimplify); break; case SUB: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SUB; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); copy->child2 = substituteEnhanced(tree->child2,t,doNotEvaluate,maySimplify); break; case MUL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); copy->child2 = substituteEnhanced(tree->child2,t,doNotEvaluate,maySimplify); break; case DIV: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DIV; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); copy->child2 = substituteEnhanced(tree->child2,t,doNotEvaluate,maySimplify); break; case SQRT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SQRT; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case EXP: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = EXP; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case LOG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case LOG_2: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_2; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case LOG_10: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_10; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case SIN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SIN; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case COS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = COS; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case TAN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TAN; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case ASIN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ASIN; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case ACOS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ACOS; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case ATAN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ATAN; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case SINH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SINH; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case COSH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = COSH; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case TANH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TANH; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case ASINH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ASINH; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case ACOSH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ACOSH; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case ATANH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ATANH; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case POW: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = POW; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); copy->child2 = substituteEnhanced(tree->child2,t,doNotEvaluate,maySimplify); break; case NEG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEG; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case ABS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ABS; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case DOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLE; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case SINGLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SINGLE; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case QUAD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = QUAD; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case HALFPRECISION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = HALFPRECISION; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case DOUBLEDOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLEDOUBLE; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case TRIPLEDOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TRIPLEDOUBLE; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case ERF: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ERF; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case ERFC: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ERFC; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case LOG_1P: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_1P; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case EXP_M1: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = EXP_M1; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case DOUBLEEXTENDED: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLEEXTENDED; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case LIBRARYFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYFUNCTION; copy->libFun = tree->libFun; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case PROCEDUREFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PROCEDUREFUNCTION; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); copy->child2 = copyThing(tree->child2); break; case CEIL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CEIL; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case FLOOR: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = FLOOR; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case NEARESTINT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEARESTINT; copy->child1 = substituteEnhanced(tree->child1,t,doNotEvaluate,maySimplify); break; case PI_CONST: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PI_CONST; break; case LIBRARYCONSTANT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYCONSTANT; copy->libFun = tree->libFun; break; default: sollyaFprintf(stderr,"Error: substituteInner: unknown identifier in the tree\n"); exit(1); } copy = addMemRef(copy); if (haveAPrioriBoundForConstantExpr) { if (copy->nodeType == MEMREF) { if (copy->arguments == NULL) { precPtr = (mp_prec_t *) safeMalloc(sizeof(mp_prec_t)); *precPtr = sollya_mpfi_get_prec(aPrioriBoundForConstantExpr); intervalPtr = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*intervalPtr, sollya_mpfi_get_prec(aPrioriBoundForConstantExpr)); sollya_mpfi_set(*intervalPtr, aPrioriBoundForConstantExpr); copy->arguments = addElement(addElement(NULL, intervalPtr), precPtr); } } sollya_mpfi_clear(aPrioriBoundForConstantExpr); } return copy; } void composePolynomialsInner(sollya_mpfi_t *res, int degR, sollya_mpfi_t *p, int degP, sollya_mpfi_t *q, int degQ, mp_prec_t prec) { sollya_mpfi_t *r, *s, *t; int i, j, k, l; sollya_mpfi_t temp; /* Initialize a temporary */ sollya_mpfi_init2(temp, prec); /* Allocate two scratch arrays of the length of // the result polynomial. */ r = safeCalloc(degR+1,sizeof(sollya_mpfi_t)); s = safeCalloc(degR+1,sizeof(sollya_mpfi_t)); for (i=0;i<=degR;i++) { sollya_mpfi_init2(r[i],prec); sollya_mpfi_init2(s[i],prec); sollya_mpfi_set_si(r[i],0); sollya_mpfi_set_si(s[i],0); } /* Perform a stupid Horner: // // p(q(x)) = a_0 + q(x) * (.... a_i * q(x) * pTilde(q(x)) ...) */ sollya_mpfi_set(r[0],p[degP]); for (i=degP-1;i>=0;i--) { /* Multiply pTilde(q) with q, result in s while clearing up r */ for (j=0;j<=degQ*(degP-1-i);j++) { for (k=0;k<=degQ;k++) { l = j + k; sollya_mpfi_mul(temp,r[j],q[k]); sollya_mpfi_add(s[l],s[l],temp); } sollya_mpfi_set_si(r[j],0); } /* Add in a_i */ sollya_mpfi_add(s[0],s[0],p[i]); /* Swap r and s for next step */ t = s; s = r; r = t; } /* Here, the result is in r // // Copy it into the result array res */ for (i=0;i<=degR;i++) { sollya_mpfi_set(res[i],r[i]); } /* Clear and free the scratch arrays */ for (i=0;i<=degR;i++) { sollya_mpfi_clear(r[i]); sollya_mpfi_clear(s[i]); } safeFree(r); safeFree(s); /* Clear the temporary */ sollya_mpfi_clear(temp); } void composePolynomials(node **poly, chain **radii, node *p, node *q, mp_prec_t prec) { int degP, degQ, i, degR; node **coeffsP, **coeffsQ; sollya_mpfi_t *polyP, *polyQ, *polyR; mpfr_t *coeffsR; sollya_mpfi_t **radiiArray; /* Check if both p and q are polynomials // and implement a fallback solution // for when this is not the case */ if ((!isPolynomial(p)) || (!isPolynomial(q))) { *radii = NULL; *poly = substitute(p,q); return; } /* Here, we know that p and q are polynomials // // Continue by getting all coefficients of p and q */ getCoefficients(°P, &coeffsP, p); getCoefficients(°Q, &coeffsQ, q); /* Evaluate all coefficients of p and q to // small intervals in two arrays polyP and polyQ. */ polyP = (sollya_mpfi_t *) safeCalloc(degP+1,sizeof(sollya_mpfi_t)); for (i=0;i<=degP;i++) { sollya_mpfi_init2(polyP[i],prec); if (coeffsP[i] != NULL) { evaluateConstantExpressionToSharpInterval(polyP[i], coeffsP[i]); } else { sollya_mpfi_set_si(polyP[i],0); } } polyQ = (sollya_mpfi_t *) safeCalloc(degQ+1,sizeof(sollya_mpfi_t)); for (i=0;i<=degQ;i++) { sollya_mpfi_init2(polyQ[i],prec); if (coeffsQ[i] != NULL) { evaluateConstantExpressionToSharpInterval(polyQ[i], coeffsQ[i]); } else { sollya_mpfi_set_si(polyQ[i],0); } } /* Free the arrays with the unevaluated coefficients */ for (i=0;i<=degP;i++) { if (coeffsP[i] != NULL) { free_memory(coeffsP[i]); } } safeFree(coeffsP); for (i=0;i<=degQ;i++) { if (coeffsQ[i] != NULL) { free_memory(coeffsQ[i]); } } safeFree(coeffsQ); /* Allocate and initialize an array of interval coefficients for the result // polynomial */ degR = degP * degQ; polyR = (sollya_mpfi_t *) safeCalloc(degR+1,sizeof(sollya_mpfi_t)); for (i=0;i<=degR;i++) { sollya_mpfi_init2(polyR[i],prec); } /* Have an auxiliary function do the real work of composing p and q */ composePolynomialsInner(polyR,degR,polyP,degP,polyQ,degQ,prec); /* Free the arrays with the evaluated coefficients */ for (i=0;i<=degP;i++) { sollya_mpfi_clear(polyP[i]); } safeFree(polyP); for (i=0;i<=degQ;i++) { sollya_mpfi_clear(polyQ[i]); } safeFree(polyQ); /* Allocate and compute an array of centerpoints // // Allocate also pointers to intervals and // initialize intervals that will hold the radii. // // Clear the intervals for the output coefficients // as well. */ coeffsR = (mpfr_t *) safeCalloc(degR+1,sizeof(mpfr_t)); radiiArray = (sollya_mpfi_t **) safeCalloc(degR+1,sizeof(sollya_mpfi_t *)); for (i=0;i<=degR;i++) { mpfr_init2(coeffsR[i],prec+1); sollya_mpfi_mid(coeffsR[i],polyR[i]); radiiArray[i] = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(radiiArray[i]),prec); sollya_mpfi_sub_fr(*(radiiArray[i]),polyR[i],coeffsR[i]); sollya_mpfi_clear(polyR[i]); } /* Free the array of intervals for the output coefficients */ safeFree(polyR); /* Convert the array of centerpoints to a tree. */ *poly = makePolynomial(coeffsR, degR); /* Free the arrays with the centerpoints */ for (i=0;i<=degR;i++) { mpfr_clear(coeffsR[i]); } safeFree(coeffsR); /* Convert the array of radii to a list of radii */ *radii = NULL; for (i=0;i<=degR;i++) { *radii = addElement(*radii,(void *) (radiiArray[i])); } /* Free the array holding the pointers to the // intervals of radii. */ safeFree(radiiArray); } int readHexadecimal(mpfr_t rop, char *c) { mpfr_t vrd, vru; mp_prec_t p; int res, resA, resB; char *c2; c2 = (char *) safeCalloc(strlen(c) + 2, sizeof(char)); strcpy(c2, c); if ((c2[strlen(c2) - 1] == 'p') || (c2[strlen(c2) - 1] == 'P')) c2[strlen(c2)] = '0'; p = mpfr_get_prec(rop); mpfr_init2(vrd, p); mpfr_init2(vru, p); resA = mpfr_set_str(vrd, c2, 16, GMP_RNDD); resB = mpfr_set_str(vru, c2, 16, GMP_RNDU); if (!resA && !resB) { if (mpfr_cmp(vrd,vru) == 0) { mpfr_set(rop,vrd,GMP_RNDN); res = 1; } else { resA = mpfr_set_str(vrd, c2, 16, GMP_RNDN); if (!resA) { mpfr_set(rop, vrd, GMP_RNDN); res = 0; } else { mpfr_set_nan(rop); res = 0; } } } else { mpfr_set_nan(rop); res = 0; } mpfr_clear(vrd); mpfr_clear(vru); safeFree(c2); return res; } int readDyadic(mpfr_t res, char *c) { char *mantissa, *exponent, *curr, *curr2; mpfr_t mant, expo, temp1, temp2; mp_prec_t prec; int rounding; mantissa = (char *) safeCalloc(strlen(c)+1,sizeof(char)); exponent = (char *) safeCalloc(strlen(c)+1,sizeof(char)); curr = c; curr2 = mantissa; while ((*curr != '\0') && (*curr != 'b') && (*curr != 'B')) { *curr2 = *curr; curr2++; curr++; } if (*curr != '\0') curr++; curr2 = exponent; while (*curr != '\0') { *curr2 = *curr; curr2++; curr++; } rounding = 1; prec = mpfr_get_prec(res); mpfr_init2(mant,prec); mpfr_init2(expo,prec); mpfr_init2(temp1,prec); mpfr_init2(temp2,prec); mpfr_set_str(temp1,mantissa,10,GMP_RNDU); mpfr_set_str(temp2,mantissa,10,GMP_RNDD); if (mpfr_cmp(temp1,temp2) != 0) { rounding = 0; mpfr_set_str(temp1,mantissa,10,GMP_RNDN); } if (mpfr_set(mant,temp1,GMP_RNDN) != 0) { rounding = 0; } mpfr_set_str(temp1,exponent,10,GMP_RNDU); mpfr_set_str(temp2,exponent,10,GMP_RNDD); if (mpfr_cmp(temp1,temp2) != 0) { rounding = 0; mpfr_set_str(temp1,exponent,10,GMP_RNDN); } if (mpfr_exp2(expo,temp1,GMP_RNDN) != 0) { rounding = 0; } if (mpfr_mul(res,mant,expo,GMP_RNDN) != 0) { rounding = 0; } if (!mpfr_number_p(res)) rounding = 1; mpfr_clear(mant); mpfr_clear(expo); mpfr_clear(temp1); mpfr_clear(temp2); safeFree(mantissa); safeFree(exponent); return rounding; } node *makePolynomialConstantExpressions(node **coeffs, int deg) { node *copy; int i, degree, e, k; node *temp; node *temp2; node *temp3; mpfr_t *value; node *temp4; node *res; unsigned int degU; polynomial_t p; if (deg < 0) { sollyaFprintf(stderr,"Error: makePolynomialConstantExpressions: degree of polynomial to be built is negative\n"); exit(1); } res = addMemRefEvenOnNull(NULL); if (res != NULL) { degU = deg; if (polynomialFromConstantExpressionCoefficients(&p, coeffs, degU)) { res->polynomialRepresentation = p; return res; } else { res->polynomialRepresentation = polynomialFromIntConstant(1); free_memory(res); } } degree = deg; while ((degree > 0) && ((coeffs[degree] == NULL) || ((accessThruMemRef(coeffs[degree])->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(coeffs[degree])->value)))))) degree--; if (degree == 0) { if (coeffs[0] == NULL) return makeConstantDouble(0.0); return copyTree(coeffs[0]); } copy = copyTree(coeffs[degree]); for (i=degree-1;i>=0;i--) { if ((coeffs[i] == NULL) || ((accessThruMemRef(coeffs[i])->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(coeffs[i])->value))))) { if (i == 0) { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = VARIABLE; temp->child1 = temp2; temp->child2 = copy; copy = temp; } else { for (k=i-1;(((coeffs[k] == NULL) || ((accessThruMemRef(coeffs[k])->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(coeffs[k])->value))))) && (k > 0));k--); e = (i - k) + 1; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = VARIABLE; temp3 = (node *) safeMalloc(sizeof(node)); temp3->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,(mp_prec_t) ((mp_prec_t) tools_precision > (mp_prec_t) (8 * sizeof(e) + 10) ? (mp_prec_t) tools_precision : (mp_prec_t) (8 * sizeof(e) + 10))); if (mpfr_set_si(*value,e,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_POW_EXPONENT_COMPUTATION,"Warning: rounding occurred on representing a monomial power exponent with %d bits.\n", (int) mpfr_get_prec(*value)); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the precision.\n"); } } temp3->value = value; temp4 = (node *) safeMalloc(sizeof(node)); temp4->nodeType = POW; temp4->child1 = temp2; temp4->child2 = temp3; temp->child1 = temp4; temp->child2 = copy; copy = temp; if (!((coeffs[k] == NULL) || ((accessThruMemRef(coeffs[k])->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(coeffs[k])->value)))))) { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = ADD; temp->child1 = copyTree(coeffs[k]); temp->child2 = copy; copy = temp; } i = k; } } else { temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = MUL; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = VARIABLE; temp->child1 = temp2; temp->child2 = copy; copy = temp; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = ADD; temp->child1 = copyTree(coeffs[i]); temp->child2 = copy; copy = temp; } } return addMemRef(copy); } /* Builds a polynomial expression, written in Horner form of the polynomial sum_{i=0}^degree coefficients[i]*x^i Moreover, while writting it in Horner form, it accounts for the sparsity of the polynomial. */ node *makePolynomial(mpfr_t *coefficients, int degree) { node **coeffs; int i; node *poly; /* Allocate and build an array of constant expressions representing the coefficients. Do not represent zeros. */ coeffs = (node **) safeCalloc(degree+1,sizeof(node *)); for (i=0;i<=degree;i++) { if (!mpfr_zero_p(coefficients[i])) { coeffs[i] = makeConstant(coefficients[i]); } else { /* The coefficient is zero. Do not represent it. */ coeffs[i] = NULL; } } /* Build the polynomial */ poly = makePolynomialConstantExpressions(coeffs, degree); /* Free the array of constant expressions representing the coefficients */ for (i=0;i<=degree;i++) { if (coeffs[i] != NULL) free_memory(coeffs[i]); } safeFree(coeffs); /* Return the polynomial */ return poly; } int treeSize(node *tree) { int size; if (tree == NULL) return 0; switch (tree->nodeType) { case MEMREF: if (tree->treeSizeCacheFilled) { return tree->treeSizeCache; } size = treeSize(getMemRefChild(tree)); tree->treeSizeCache = size; tree->treeSizeCacheFilled = 1; return size; break; case VARIABLE: case CONSTANT: case PI_CONST: case LIBRARYCONSTANT: return 1; break; case ADD: case SUB: case MUL: case DIV: case POW: return treeSize(tree->child1) + treeSize(tree->child2) + 1; break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case DOUBLE: case SINGLE: case QUAD: case HALFPRECISION: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case LIBRARYFUNCTION: case PROCEDUREFUNCTION: case CEIL: case FLOOR: case NEARESTINT: return treeSize(tree->child1) + 1; break; default: sollyaFprintf(stderr,"Error: treeSize: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return -1; } int highestDegreeOfPolynomialSubexpression(node *tree) { int l, r; if (tree->nodeType == MEMREF) return highestDegreeOfPolynomialSubexpression(getMemRefChild(tree)); if (isPolynomial(tree)) return getDegree(tree); switch (arity(tree)) { case 2: l = highestDegreeOfPolynomialSubexpression(tree->child1); r = highestDegreeOfPolynomialSubexpression(tree->child2); return l > r ? l : r; break; case 1: return highestDegreeOfPolynomialSubexpression(tree->child1); break; case 0: return getDegree(tree); break; default: sollyaFprintf(stderr,"Error: unknown arity of an operator.\n"); exit(1); } return -1; } node *makeAddSimplified(node *a, node *b) { if ((accessThruMemRef(a)->nodeType == CONSTANT) && mpfr_zero_p(*(accessThruMemRef(a)->value))) { free_memory(a); return b; } if ((accessThruMemRef(b)->nodeType == CONSTANT) && mpfr_zero_p(*(accessThruMemRef(b)->value))) { free_memory(b); return a; } return makeAdd(a, b); } node *makeSubSimplified(node *a, node *b) { if ((accessThruMemRef(a)->nodeType == CONSTANT) && mpfr_zero_p(*(accessThruMemRef(a)->value))) { free_memory(a); return b; } if ((accessThruMemRef(b)->nodeType == CONSTANT) && mpfr_zero_p(*(accessThruMemRef(b)->value))) { free_memory(b); return a; } return makeSub(a, b); } node *makeMulSimplified(node *a, node *b) { if ((accessThruMemRef(a)->nodeType == CONSTANT) && mpfr_zero_p(*(accessThruMemRef(a)->value))) { free_memory(b); return a; } if ((accessThruMemRef(b)->nodeType == CONSTANT) && mpfr_zero_p(*(accessThruMemRef(b)->value))) { free_memory(a); return b; } if ((accessThruMemRef(a)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(a)->value)) && (mpfr_cmp_si(*(accessThruMemRef(a)->value),1) == 0)) { free_memory(a); return b; } if ((accessThruMemRef(b)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(b)->value)) && (mpfr_cmp_si(*(accessThruMemRef(b)->value),1) == 0)) { free_memory(b); return a; } return makeMul(a, b); } int tryGetIthCoefficientSparseUnsafe(node **res, node *poly, int i) { node *resLeft, *resRight; mpfr_t iAsMpfr, tAsMpfr; mpz_t tMpz, kMpz; int t, k; resLeft = NULL; resRight = NULL; if (i < 0) return 0; if (isConstant(poly)) { if (i == 0) { *res = copyTree(poly); } else { *res = makeConstantDouble(0.0); } return 1; } switch (poly->nodeType) { case MEMREF: return tryGetIthCoefficientSparseUnsafe(res, getMemRefChild(poly), i); break; case CONSTANT: case PI_CONST: case LIBRARYCONSTANT: /* p = c */ if (i == 0) { *res = copyTree(poly); } else { *res = makeConstantDouble(0.0); } return 1; break; case VARIABLE: /* p = x */ if (i == 1) { *res = makeConstantDouble(1.0); } else { *res = makeConstantDouble(0.0); } return 1; break; case ADD: /* p = q + r */ if (tryGetIthCoefficientSparseUnsafe(&resLeft, poly->child1, i) && tryGetIthCoefficientSparseUnsafe(&resRight, poly->child2, i)) { *res = makeAddSimplified(resLeft, resRight); resLeft = NULL; resRight = NULL; return 1; } break; case SUB: /* p = q - r */ if (tryGetIthCoefficientSparseUnsafe(&resLeft, poly->child1, i) && tryGetIthCoefficientSparseUnsafe(&resRight, poly->child2, i)) { *res = makeSubSimplified(resLeft, resRight); resLeft = NULL; resRight = NULL; return 1; } break; case MUL: /* p = c * q */ if (isConstant(poly->child1)) { if (tryGetIthCoefficientSparseUnsafe(&resRight, poly->child2, i)) { *res = makeMulSimplified(copyTree(poly->child1), resRight); resRight = NULL; return 1; } } /* p = q * c */ if (isConstant(poly->child2)) { if (tryGetIthCoefficientSparseUnsafe(&resLeft, poly->child1, i)) { *res = makeMulSimplified(resLeft, copyTree(poly->child2)); resLeft = NULL; return 1; } } /* p = x * q */ if (accessThruMemRef(poly->child1)->nodeType == VARIABLE) { if (tryGetIthCoefficientSparseUnsafe(res, poly->child2, i - 1)) return 1; } /* p = q * x */ if (accessThruMemRef(poly->child2)->nodeType == VARIABLE) { if (tryGetIthCoefficientSparseUnsafe(res, poly->child1, i - 1)) return 1; } /* p = x^t * q */ if ((accessThruMemRef(poly->child1)->nodeType == POW) && (accessThruMemRef(accessThruMemRef(poly->child1)->child1)->nodeType == VARIABLE) && ((accessThruMemRef(accessThruMemRef(poly->child1)->child2)->nodeType == CONSTANT) && (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(poly->child1)->child2)->value))))) { t = mpfr_get_si(*(accessThruMemRef(accessThruMemRef(poly->child1)->child2)->value),GMP_RNDN); mpfr_init2(tAsMpfr, 8 * sizeof(int) + 10); mpfr_set_si(tAsMpfr, t, GMP_RNDN); /* exact */ if (mpfr_cmp(*(accessThruMemRef(accessThruMemRef(poly->child1)->child2)->value), tAsMpfr) == 0) { if (t <= i) { if (tryGetIthCoefficientSparseUnsafe(res, poly->child2, i - t)) { mpfr_clear(tAsMpfr); return 1; } } else { mpfr_clear(tAsMpfr); *res = makeConstantDouble(0.0); return 1; } } mpfr_clear(tAsMpfr); } /* p = q * x^t */ if ((accessThruMemRef(poly->child2)->nodeType == POW) && (accessThruMemRef(accessThruMemRef(poly->child2)->child1)->nodeType == VARIABLE) && ((accessThruMemRef(accessThruMemRef(poly->child2)->child2)->nodeType == CONSTANT) && (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(poly->child2)->child2)->value))))) { t = mpfr_get_si(*(accessThruMemRef(accessThruMemRef(poly->child2)->child2)->value),GMP_RNDN); mpfr_init2(tAsMpfr, 8 * sizeof(int) + 10); mpfr_set_si(tAsMpfr, t, GMP_RNDN); /* exact */ if (mpfr_cmp(*(accessThruMemRef(accessThruMemRef(poly->child2)->child2)->value), tAsMpfr) == 0) { if (t <= i) { if (tryGetIthCoefficientSparseUnsafe(res, poly->child1, i - t)) { mpfr_clear(tAsMpfr); return 1; } } else { mpfr_clear(tAsMpfr); *res = makeConstantDouble(0.0); return 1; } } mpfr_clear(tAsMpfr); } /* p = q * r, degree(q) = t, degree(r) = k, t * k = i */ mpz_init(tMpz); if (getDegreeMpz(tMpz, poly->child1)) { t = mpz_get_si(tMpz); if (mpz_cmp_si(tMpz, t) == 0) { mpz_init(kMpz); if (getDegreeMpz(kMpz, poly->child2)) { k = mpz_get_si(kMpz); if (mpz_cmp_si(kMpz, k) == 0) { if ((t * k == i) && (t >= 0) && (t <= i) && (k >= 0) && (k <= i) && ((((k == 0) || (t == 0)) && (i == 0)) || (t == i / k)) ) { if (tryGetIthCoefficientSparseUnsafe(&resLeft, poly->child1, t) && tryGetIthCoefficientSparseUnsafe(&resRight, poly->child2, k)) { *res = makeMulSimplified(resLeft, resRight); resLeft = NULL; resRight = NULL; return 1; } } } } mpz_clear(kMpz); } } mpz_clear(tMpz); /* Continue with other optimized ways to get the i-th coefficient of a sparse polynomial that is a product here. */ break; case DIV: /* p = q / c */ if (isConstant(poly->child2)) { if (tryGetIthCoefficientSparseUnsafe(&resLeft, poly->child1, i)) { *res = makeDiv(resLeft, copyTree(poly->child2)); resLeft = NULL; return 1; } } break; case POW: /* p = x^k */ if ((accessThruMemRef(poly->child1)->nodeType == VARIABLE) && (accessThruMemRef(poly->child2)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(poly->child2)->value))) { mpfr_init2(iAsMpfr, 8 * sizeof(int) + 10); mpfr_set_si(iAsMpfr, i, GMP_RNDN); /* exact */ if (mpfr_cmp(*(accessThruMemRef(poly->child2)->value), iAsMpfr) == 0) { *res = makeConstantDouble(1.0); mpfr_clear(iAsMpfr); return 1; } else { if (mpfr_integer_p(*(accessThruMemRef(poly->child2)->value))) { *res = makeConstantDouble(0.0); mpfr_clear(iAsMpfr); return 1; } } mpfr_clear(iAsMpfr); } /* p = q^t with degree(q) = k and k * t = i */ if ((accessThruMemRef(poly->child2)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(poly->child2)->value))) { t = mpfr_get_si(*(accessThruMemRef(poly->child2)->value),GMP_RNDN); mpfr_init2(tAsMpfr, 8 * sizeof(int) + 10); mpfr_set_si(tAsMpfr, t, GMP_RNDN); /* exact */ if (mpfr_cmp(*(accessThruMemRef(poly->child2)->value), tAsMpfr) == 0) { if ((t != 0) && (i % t == 0)) { k = getDegreeSilent(poly->child1); if ((k > 0) && (k <= t) && (k * t == i)) { if (tryGetIthCoefficientSparseUnsafe(res, poly->child1, k)) { mpfr_clear(tAsMpfr); return 1; } } } } mpfr_clear(tAsMpfr); } /* Continue with other optimized ways to get the i-th coefficient of a sparse polynomial that is a power here. */ break; default: return 0; } if (resLeft != NULL) free_memory(resLeft); if (resRight != NULL) free_memory(resRight); return 0; } int tryGetIthCoefficientSparse(node **res, node *poly, int i) { node *myres; if (!isPolynomial(poly)) return 0; myres = NULL; if (tryGetIthCoefficientSparseUnsafe(&myres, poly, i)) { if (myres == NULL) return 0; *res = simplifyTreeErrorfree(myres); free_memory(myres); return 1; } return 0; } node *getIthCoefficient(node *poly, int i) { node *tempNode; node **coefficients; int degree, k; if (poly->nodeType == MEMREF) { if (poly->polynomialRepresentation == NULL) { tryRepresentAsPolynomial(poly); } if (poly->polynomialRepresentation != NULL) { return polynomialGetIthCoefficientIntIndex(poly->polynomialRepresentation, i); } } if ((!isPolynomial(poly)) || (i < 0)) { tempNode = (node *) safeMalloc(sizeof(node)); tempNode->nodeType = CONSTANT; tempNode->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(tempNode->value),10); mpfr_set_d(*(tempNode->value),0.0,GMP_RNDN); return tempNode; } if (tryGetIthCoefficientSparse(&tempNode, poly, i)) { printMessage(8, SOLLYA_MSG_SPECIAL_ALGORITHM_USED_FOR_COEFF, "Information: a special algorithm is used to extract the i-th coefficient of an expression that is a polynomial.\n"); return tempNode; } getCoefficients(°ree, &coefficients, poly); if ((i > degree) || (coefficients[i] == NULL)) { tempNode = (node *) safeMalloc(sizeof(node)); tempNode->nodeType = CONSTANT; tempNode->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(tempNode->value),10); mpfr_set_d(*(tempNode->value),0.0,GMP_RNDN); } else { tempNode = copyTree(coefficients[i]); } for (k=0;k<=degree;k++) { if (coefficients[k] != NULL) free_memory(coefficients[k]); } safeFree(coefficients); return tempNode; } node *getSubpolynomial(node *poly, chain *monomials, int fillDegrees, mp_prec_t prec) { node *tempNode, *tempNode2, *tempNode3; node **coefficients; int degree, k, currDeg, maxDegree; chain *curr; tempNode = (node *) safeMalloc(sizeof(node)); tempNode->nodeType = CONSTANT; tempNode->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(tempNode->value),prec); mpfr_set_d(*(tempNode->value),0.0,GMP_RNDN); if (!isPolynomial(poly)) { return tempNode; } getCoefficients(°ree, &coefficients, poly); curr = monomials; maxDegree = -1; while (curr != NULL) { currDeg = *((int *) (curr->value)); if (currDeg > maxDegree) maxDegree = currDeg; if ((currDeg >= 0) && (currDeg <= degree) && (coefficients[currDeg] != NULL)) { tempNode2 = (node *) safeMalloc(sizeof(node)); tempNode2->nodeType = POW; tempNode3 = (node *) safeMalloc(sizeof(node)); tempNode3->nodeType = CONSTANT; tempNode3->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(tempNode3->value),prec); if (mpfr_set_si(*(tempNode3->value),currDeg,GMP_RNDN) != 0) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_POW_EXPONENT_COMPUTATION,"Warning: during subpolynomial extraction, the exponent of a power could not be represented exactly on with the given precision.\n"); } tempNode2->child2 = tempNode3; tempNode3 = (node *) safeMalloc(sizeof(node)); tempNode3->nodeType = VARIABLE; tempNode2->child1 = tempNode3; tempNode3 = (node *) safeMalloc(sizeof(node)); tempNode3->nodeType = MUL; tempNode3->child2 = tempNode2; tempNode3->child1 = copyTree(coefficients[currDeg]); tempNode2 = (node *) safeMalloc(sizeof(node)); tempNode2->nodeType = ADD; tempNode2->child2 = tempNode3; tempNode2->child1 = tempNode; tempNode = tempNode2; } curr = curr->next; } if (fillDegrees) { for (k=maxDegree+1;k<=degree;k++) { if (coefficients[k] != NULL) { tempNode2 = (node *) safeMalloc(sizeof(node)); tempNode2->nodeType = POW; tempNode3 = (node *) safeMalloc(sizeof(node)); tempNode3->nodeType = CONSTANT; tempNode3->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(tempNode3->value),prec); if (mpfr_set_si(*(tempNode3->value),k,GMP_RNDN) != 0) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_POW_EXPONENT_COMPUTATION,"Warning: during subpolynomial extraction, the exponent of a power could not be represented exactly on with the given precision.\n"); } tempNode2->child2 = tempNode3; tempNode3 = (node *) safeMalloc(sizeof(node)); tempNode3->nodeType = VARIABLE; tempNode2->child1 = tempNode3; tempNode3 = (node *) safeMalloc(sizeof(node)); tempNode3->nodeType = MUL; tempNode3->child2 = tempNode2; tempNode3->child1 = copyTree(coefficients[k]); tempNode2 = (node *) safeMalloc(sizeof(node)); tempNode2->nodeType = ADD; tempNode2->child2 = tempNode3; tempNode2->child1 = tempNode; tempNode = tempNode2; } } } for (k=0;k<=degree;k++) { if (coefficients[k] != NULL) free_memory(coefficients[k]); } safeFree(coefficients); tempNode2 = horner(tempNode); free_memory(tempNode); return tempNode2; } node *makeCanonicalPolyUnsafe(node *poly, mp_prec_t prec) { node **coefficients; int degree, k; node *tempNode, *tempNode2, *tempNode3; getCoefficients(°ree, &coefficients, poly); tempNode = (node *) safeMalloc(sizeof(node)); tempNode->nodeType = CONSTANT; tempNode->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(tempNode->value),prec); mpfr_set_d(*(tempNode->value),0.0,GMP_RNDN); for (k=0;k<=degree;k++) { if (coefficients[k] != NULL) { if (k == 0) { tempNode2 = (node *) safeMalloc(sizeof(node)); tempNode2->nodeType = ADD; tempNode2->child2 = coefficients[k]; tempNode2->child1 = tempNode; tempNode = tempNode2; } else { if (k == 1) { tempNode3 = (node *) safeMalloc(sizeof(node)); tempNode3->nodeType = VARIABLE; tempNode2 = (node *) safeMalloc(sizeof(node)); tempNode2->nodeType = MUL; tempNode2->child2 = tempNode3; tempNode2->child1 = coefficients[k]; tempNode3 = (node *) safeMalloc(sizeof(node)); tempNode3->nodeType = ADD; tempNode3->child2 = tempNode2; tempNode3->child1 = tempNode; tempNode = tempNode3; } else { tempNode2 = (node *) safeMalloc(sizeof(node)); tempNode2->nodeType = POW; tempNode3 = (node *) safeMalloc(sizeof(node)); tempNode3->nodeType = CONSTANT; tempNode3->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(tempNode3->value),prec); if (mpfr_set_si(*(tempNode3->value),k,GMP_RNDN) != 0) { printMessage(1,SOLLYA_MSG_ROUNDING_UPON_POW_EXPONENT_COMPUTATION,"Warning: during transformation to canonical form, the exponent of a power could not be represented exactly on with the given precision.\n"); } tempNode2->child2 = tempNode3; tempNode3 = (node *) safeMalloc(sizeof(node)); tempNode3->nodeType = VARIABLE; tempNode2->child1 = tempNode3; tempNode3 = (node *) safeMalloc(sizeof(node)); tempNode3->nodeType = MUL; tempNode3->child2 = tempNode2; tempNode3->child1 = coefficients[k]; tempNode2 = (node *) safeMalloc(sizeof(node)); tempNode2->nodeType = ADD; tempNode2->child2 = tempNode3; tempNode2->child1 = tempNode; tempNode = tempNode2; } } } } safeFree(coefficients); tempNode2 = simplifyTreeErrorfree(tempNode); free_memory(tempNode); return tempNode2; } int isCanonicalMonomial(node *tree) { if (tree->nodeType == MEMREF) return isCanonicalMonomial(getMemRefChild(tree)); if (isConstant(tree)) return 1; if (isPowerOfVariable(tree)) return 1; if ((tree->nodeType == MUL) && isConstant(tree->child1) && isPowerOfVariable(tree->child2)) return 1; return 0; } int isCanonicalUnsafe(node *tree) { int deg1, deg2; if (tree->nodeType == MEMREF) { if (((tree->child1 == NULL) || (tree->memRefChildFromPolynomial)) && (tree->polynomialRepresentation != NULL)) { return polynomialIsCanonicalized(tree->polynomialRepresentation); } return isCanonicalUnsafe(getMemRefChild(tree)); } if (isConstant(tree) || isCanonicalMonomial(tree)) return 1; if ((tree->nodeType == ADD) || (tree->nodeType == SUB)) { if (!isCanonicalUnsafe(tree->child1)) return 0; if (!isCanonicalMonomial(tree->child2)) return 0; deg1 = getDegree(tree->child1); deg2 = getDegree(tree->child2); if (deg1 >= deg2) return 0; return 1; } return 0; } int isCanonical(node *tree) { return isCanonicalUnsafe(tree); } node *makeCanonical(node *tree, mp_prec_t prec) { node *copy, *res; mpfr_t *value; mpfr_t temp; polynomial_t p; if (tree->nodeType == MEMREF) { if (tree->polynomialRepresentation != NULL) { if (polynomialIsCanonicalized(tree->polynomialRepresentation)) return copyTree(tree); if (tree->child1 == NULL) { p = polynomialCanonicalize(tree->polynomialRepresentation); polynomialFree(tree->polynomialRepresentation); tree->polynomialRepresentation = p; return copyTree(tree); } res = addMemRefEvenOnNull(NULL); if (res != NULL) { res->polynomialRepresentation = polynomialCanonicalize(tree->polynomialRepresentation); copyTreeAnnotationsNoSimplifications(res, tree); return res; } } res = addMemRef(makeCanonical(getMemRefChild(tree), prec)); copyTreeAnnotationsNoSimplifications(res, tree); return res; } if (isCanonical(tree)) { printMessage(7,SOLLYA_MSG_EXPR_NOT_CANONICALIZED_AS_ALREADY_CANONICAL,"Information: no canonical form simplification will be performed because the given tree is already canonical.\n"); return copyTree(tree); } if (isPolynomial(tree)) return makeCanonicalPolyUnsafe(tree,prec); switch (tree->nodeType) { case VARIABLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = VARIABLE; break; case CONSTANT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CONSTANT; value = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(temp,tools_precision); simplifyMpfrPrec(temp,*(tree->value)); mpfr_init2(*value,mpfr_get_prec(temp)); mpfr_set(*value,temp,GMP_RNDN); mpfr_clear(temp); copy->value = value; break; case ADD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ADD; copy->child1 = makeCanonical(tree->child1,prec); copy->child2 = makeCanonical(tree->child2,prec); break; case SUB: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SUB; copy->child1 = makeCanonical(tree->child1,prec); copy->child2 = makeCanonical(tree->child2,prec); break; case MUL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = MUL; copy->child1 = makeCanonical(tree->child1,prec); copy->child2 = makeCanonical(tree->child2,prec); break; case DIV: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DIV; copy->child1 = makeCanonical(tree->child1,prec); copy->child2 = makeCanonical(tree->child2,prec); break; case SQRT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SQRT; copy->child1 = makeCanonical(tree->child1,prec); break; case EXP: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = EXP; copy->child1 = makeCanonical(tree->child1,prec); break; case LOG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG; copy->child1 = makeCanonical(tree->child1,prec); break; case LOG_2: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_2; copy->child1 = makeCanonical(tree->child1,prec); break; case LOG_10: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_10; copy->child1 = makeCanonical(tree->child1,prec); break; case SIN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SIN; copy->child1 = makeCanonical(tree->child1,prec); break; case COS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = COS; copy->child1 = makeCanonical(tree->child1,prec); break; case TAN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TAN; copy->child1 = makeCanonical(tree->child1,prec); break; case ASIN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ASIN; copy->child1 = makeCanonical(tree->child1,prec); break; case ACOS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ACOS; copy->child1 = makeCanonical(tree->child1,prec); break; case ATAN: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ATAN; copy->child1 = makeCanonical(tree->child1,prec); break; case SINH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SINH; copy->child1 = makeCanonical(tree->child1,prec); break; case COSH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = COSH; copy->child1 = makeCanonical(tree->child1,prec); break; case TANH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TANH; copy->child1 = makeCanonical(tree->child1,prec); break; case ASINH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ASINH; copy->child1 = makeCanonical(tree->child1,prec); break; case ACOSH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ACOSH; copy->child1 = makeCanonical(tree->child1,prec); break; case ATANH: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ATANH; copy->child1 = makeCanonical(tree->child1,prec); break; case POW: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = POW; copy->child1 = makeCanonical(tree->child1,prec); copy->child2 = makeCanonical(tree->child2,prec); break; case NEG: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEG; copy->child1 = makeCanonical(tree->child1,prec); break; case ABS: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ABS; copy->child1 = makeCanonical(tree->child1,prec); break; case DOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLE; copy->child1 = makeCanonical(tree->child1,prec); break; case SINGLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = SINGLE; copy->child1 = makeCanonical(tree->child1,prec); break; case QUAD: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = QUAD; copy->child1 = makeCanonical(tree->child1,prec); break; case HALFPRECISION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = HALFPRECISION; copy->child1 = makeCanonical(tree->child1,prec); break; case DOUBLEDOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLEDOUBLE; copy->child1 = makeCanonical(tree->child1,prec); break; case TRIPLEDOUBLE: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = TRIPLEDOUBLE; copy->child1 = makeCanonical(tree->child1,prec); break; case ERF: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ERF; copy->child1 = makeCanonical(tree->child1,prec); break; case ERFC: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = ERFC; copy->child1 = makeCanonical(tree->child1,prec); break; case LOG_1P: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LOG_1P; copy->child1 = makeCanonical(tree->child1,prec); break; case EXP_M1: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = EXP_M1; copy->child1 = makeCanonical(tree->child1,prec); break; case DOUBLEEXTENDED: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = DOUBLEEXTENDED; copy->child1 = makeCanonical(tree->child1,prec); break; case LIBRARYFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYFUNCTION; copy->libFun = tree->libFun; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = makeCanonical(tree->child1,prec); break; case PROCEDUREFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PROCEDUREFUNCTION; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = makeCanonical(tree->child1,prec); copy->child2 = copyThing(tree->child2); break; case CEIL: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = CEIL; copy->child1 = makeCanonical(tree->child1,prec); break; case FLOOR: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = FLOOR; copy->child1 = makeCanonical(tree->child1,prec); break; case NEARESTINT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = NEARESTINT; copy->child1 = makeCanonical(tree->child1,prec); break; case PI_CONST: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PI_CONST; break; case LIBRARYCONSTANT: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYCONSTANT; copy->libFun = tree->libFun; break; default: sollyaFprintf(stderr,"Error: makeCanonical: unknown identifier in the tree\n"); exit(1); } return copy; } node *makeVariable() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = VARIABLE; return res; } node *makeConstantDouble(double d) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = CONSTANT; res->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(res->value),53); mpfr_set_d(*(res->value),d,GMP_RNDN); return res; } node *makeConstantInt(int a) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = CONSTANT; res->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(res->value),sizeof(int)*8); mpfr_set_si(*(res->value), a, GMP_RNDN); return res; } node *makeConstantUnsignedInt(unsigned int a) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = CONSTANT; res->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(res->value),sizeof(unsigned int)*8); mpfr_set_ui(*(res->value), a, GMP_RNDN); return res; } node *makeConstantMpz(mpz_t x) { node *res; mp_prec_t prec; res = (node *) safeMalloc(sizeof(node)); res->nodeType = CONSTANT; if (mpz_sgn(x) == 0) { prec = 12; } else { prec = (mp_prec_t) mpz_sizeinbase(x, 2); if (prec < 12) prec = 12; } res->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(res->value),prec); mpfr_set_z(*(res->value),x,GMP_RNDN); /* exact */ return res; } node *makeConstant(mpfr_t x) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = CONSTANT; res->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(res->value),mpfr_get_prec(x)); mpfr_set(*(res->value),x,GMP_RNDN); return res; } node *makeBinary(node *op1, node *op2, int opType) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = opType; res->child1 = op1; res->child2 = op2; return res; } node *makeUnary(node *op1, int opType) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = opType; res->child1 = op1; return res; } node *makeAdd(node *op1, node *op2) { return makeBinary(op1,op2,ADD); } node *makeSub(node *op1, node *op2) { return makeBinary(op1,op2,SUB); } node *makeMul(node *op1, node *op2) { return makeBinary(op1,op2,MUL); } node *makeDiv(node *op1, node *op2) { return makeBinary(op1,op2,DIV); } node *makeSqrt(node *op1) { return makeUnary(op1,SQRT); } node *makeExp(node *op1) { return makeUnary(op1,EXP); } node *makeLog(node *op1) { return makeUnary(op1,LOG); } node *makeLog2(node *op1) { return makeUnary(op1,LOG_2); } node *makeLog10(node *op1) { return makeUnary(op1,LOG_10); } node *makeSin(node *op1) { return makeUnary(op1,SIN); } node *makeCos(node *op1) { return makeUnary(op1,COS); } node *makeTan(node *op1) { return makeUnary(op1,TAN); } node *makeAsin(node *op1) { return makeUnary(op1,ASIN); } node *makeAcos(node *op1) { return makeUnary(op1,ACOS); } node *makeAtan(node *op1) { return makeUnary(op1,ATAN); } node *makePow(node *op1, node *op2) { return makeBinary(op1,op2,POW); } node *makeNeg(node *op1) { return makeUnary(op1,NEG); } node *makeAbs(node *op1) { return makeUnary(op1,ABS); } node *makeDouble(node *op1) { return makeUnary(op1,DOUBLE); } node *makeSingle(node *op1) { return makeUnary(op1,SINGLE); } node *makeQuad(node *op1) { return makeUnary(op1,QUAD); } node *makeHalfPrecision(node *op1) { return makeUnary(op1,HALFPRECISION); } node *makeDoubledouble(node *op1) { return makeUnary(op1,DOUBLEDOUBLE); } node *makeTripledouble(node *op1) { return makeUnary(op1,TRIPLEDOUBLE); } node *makeErf(node *op1 ) { return makeUnary(op1,ERF); } node *makeErfc(node *op1) { return makeUnary(op1,ERFC); } node *makeLog1p(node *op1) { return makeUnary(op1,LOG_1P); } node *makeExpm1(node *op1) { return makeUnary(op1,EXP_M1); } node *makeDoubleextended(node *op1) { return makeUnary(op1,DOUBLEEXTENDED); } node *makeCeil(node *op1) { return makeUnary(op1,CEIL); } node *makeFloor(node *op1) { return makeUnary(op1,FLOOR); } node *makeNearestInt(node *op1) { return makeUnary(op1,NEARESTINT); } node *makePi() { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PI_CONST; return res; } node *makeSinh(node *op1) { return makeUnary(op1,SINH); } node *makeCosh(node *op1) { return makeUnary(op1,COSH); } node *makeTanh(node *op1) { return makeUnary(op1,TANH); } node *makeAsinh(node *op1) { return makeUnary(op1,ASINH); } node *makeAcosh(node *op1) { return makeUnary(op1,ACOSH); } node *makeAtanh(node *op1) { return makeUnary(op1,ATANH); } int readDecimalConstant(mpfr_t result, char *str) { mpfr_t a,b; int ternary; mpfr_init2(a,tools_precision); mpfr_init2(b,tools_precision); mpfr_set_str(a,str,10,GMP_RNDD); mpfr_set_str(b,str,10,GMP_RNDU); if (mpfr_cmp(a,b) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT, "Warning: Rounding occurred when converting the constant \"%s\" to floating-point with %d bits.\n", str,(int) tools_precision); printMessage(1,SOLLYA_MSG_CONTINUATION,"If safe computation is needed, try to increase the precision.\n"); } ternary = mpfr_set_str(a,str,10,GMP_RNDN); } else { ternary = 0; } mpfr_set_prec(result, tools_precision); mpfr_set(result,a,GMP_RNDN); mpfr_clear(a); mpfr_clear(b); return ternary; } sollya-6.0+ds/expression.h000066400000000000000000000256721300174114700156460ustar00rootroot00000000000000/* Copyright 2006-2016 by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France and by LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2). Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef EXPRESSION_H #define EXPRESSION_H #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include "chain.h" #include "library.h" #include "hooks.h" #include "polynomials.h" enum __point_eval_enum_t { POINT_EVAL_FAILURE = 0, POINT_EVAL_EXACT, POINT_EVAL_CORRECTLY_ROUNDED, POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT, POINT_EVAL_FAITHFULLY_ROUNDED, POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT, POINT_EVAL_BELOW_CUTOFF }; typedef enum __point_eval_enum_t point_eval_t; #define VARIABLE 0 #define CONSTANT 1 #define ADD 2 #define SUB 3 #define MUL 4 #define DIV 5 #define SQRT 6 #define EXP 7 #define LOG 8 #define LOG_2 9 #define LOG_10 10 #define SIN 11 #define COS 12 #define TAN 13 #define ASIN 14 #define ACOS 15 #define ATAN 16 #define SINH 17 #define COSH 18 #define TANH 19 #define ASINH 20 #define ACOSH 21 #define ATANH 22 #define POW 23 #define NEG 24 #define ABS 25 #define DOUBLE 26 #define DOUBLEDOUBLE 27 #define TRIPLEDOUBLE 28 #define POLYNOMIAL 29 #define ERF 30 #define ERFC 31 #define LOG_1P 32 #define EXP_M1 33 #define DOUBLEEXTENDED 34 #define LIBRARYFUNCTION 35 #define CEIL 36 #define FLOOR 37 #define PI_CONST 38 #define SINGLE 39 #define NEARESTINT 40 #define LIBRARYCONSTANT 41 #define PROCEDUREFUNCTION 42 #define HALFPRECISION 43 #define QUAD 44 #define SOLLYA_MAX_ARG_ARRAY_ALLOC_SIZE 33554432ull typedef struct nodeStruct node; struct nodeStruct { int nodeType; mpfr_t *value; node *child1; node *child2; libraryFunction *libFun; int libFunDeriv; char *string; chain *arguments; libraryProcedure *libProc; node **argArray; int argArraySize; size_t argArrayAllocSize; sollya_mpfi_t *evalCacheX, *evalCacheY; mp_prec_t evalCachePrec; node *derivCache; node *derivUnsimplCache; int simplifyCacheDoesNotSimplify; int simplifyCacheRationalMode; node *simplifyCache; node *hornerCache; int isCorrectlyTyped; eval_hook_t *evaluationHook; polynomial_t polynomialRepresentation; int memRefChildFromPolynomial; mpfr_t *pointEvalCacheX, *pointEvalCacheY; mp_exp_t pointEvalCacheCutoff; point_eval_t pointEvalCacheResultType; uint64_t hash; int hashComputed; int treeSizeCache; int treeSizeCacheFilled; }; /* HELPER TYPE FOR THE PARSER */ typedef struct doubleNodeStruct doubleNode; struct doubleNodeStruct { node *a; node *b; }; /* END HELPER TYPE */ typedef struct rangetypeStruct rangetype; struct rangetypeStruct { mpfr_t *a; mpfr_t *b; }; /* Two static functions needed to access indirectly memory-referenced node * structs. The functions should be inlined for maximum performance. They can be static for performance as they are used only internally. */ #define MEMREF 278 void *safeMalloc (size_t); static inline node* addMemRefEvenOnNull(node *tree) { node *res; res = (node *) safeMalloc(sizeof(node)); res->nodeType = MEMREF; res->child1 = tree; res->libFunDeriv = 1; res->child2 = NULL; res->arguments = NULL; res->value = NULL; res->evalCacheX = NULL; res->evalCacheY = NULL; res->evalCachePrec = 0; res->derivCache = NULL; res->derivUnsimplCache = NULL; res->simplifyCacheDoesNotSimplify = -1; res->simplifyCacheRationalMode = -1; res->simplifyCache = NULL; res->hornerCache = NULL; res->isCorrectlyTyped = 0; res->evaluationHook = NULL; res->polynomialRepresentation = NULL; res->memRefChildFromPolynomial = 0; res->pointEvalCacheX = NULL; res->pointEvalCacheY = NULL; res->hashComputed = 0; res->treeSizeCache = -1; res->treeSizeCacheFilled = 0; return res; } static inline node* addMemRef(node *tree) { if (tree == NULL) return NULL; if (tree->nodeType == MEMREF) return tree; return addMemRefEvenOnNull(tree); } static inline node* getMemRefChild(node *tree) { if (tree->nodeType != MEMREF) return tree->child1; if (tree->child1 != NULL) return tree->child1; if (tree->polynomialRepresentation == NULL) return NULL; tree->child1 = polynomialGetExpressionExplicit(tree->polynomialRepresentation); tree->memRefChildFromPolynomial = 1; return tree->child1; } static inline node* accessThruMemRef(node *tree) { node *res; if (tree == NULL) return NULL; res = tree; while (res->nodeType == MEMREF) { res = getMemRefChild(res); } return res; } /* End of the static inline functions */ void printTree(node *tree); node* differentiate(node *tree); node* simplifyTree(node *tree); void free_memory(node *tree); int evaluateConstantExpression(mpfr_t result, node *tree, mp_prec_t prec); void evaluate(mpfr_t result, node *tree, mpfr_t x, mp_prec_t prec); void printValue(mpfr_t *value); node* copyTree(node *tree); int treeContainsHooks(node *tree); node* horner(node *tree); int getDegree(node *tree); int getDegreeSilent(node *tree); int getDegreeMpz(mpz_t res, node *tree); int getDegreeMpzVerified(mpz_t res, node *tree); int isPolynomialExtraSafe(node *tree); node* expand(node *tree); node* simplifyTreeErrorfree(node *tree); int isNotUniformlyZero(node *tree); int isNotUniformlyInfinite(node *tree); int getNumeratorDenominator(node **numerator, node **denominator, node *tree); node *substitute(node* tree, node *t); node *substituteEnhanced(node* tree, node *t, int doNotEvaluate, int maySimplify); void composePolynomials(node **, chain **, node *, node *, mp_prec_t); int readDyadic(mpfr_t res, char *c); int readHexadecimal(mpfr_t res, char *c); int isPolynomial(node *tree); int isRationalFunction(node *tree); int isAffine(node *tree); int arity(node *tree); void fprintValue(FILE *fd, mpfr_t value); void fprintTree(FILE *fd, node *tree); int isSyntacticallyEqual(node *tree1, node *tree2); void fprintHeadFunction(FILE *fd,node *tree, char *x, char *y); int isConstant(node *tree); void getCoefficients(int *degree, node ***coefficients, node *poly); node *makePolynomial(mpfr_t *coefficients, int degree); node *makePolynomialConstantExpressions(node **coeffs, int deg); int treeSize(node *tree); void printMpfr(mpfr_t x); int highestDegreeOfPolynomialSubexpression(node *tree); node *getIthCoefficient(node *poly, int i); node *getSubpolynomial(node *poly, chain *monomials, int fillDegrees, mp_prec_t prec); node *makeCanonical(node *func, mp_prec_t prec); char *sprintTree(node *tree); char *sprintValue(mpfr_t *value); char *sPrintHexadecimal(mpfr_t x); void printBinary(mpfr_t x); int isHorner(node *tree); int isCanonical(node *tree); int isPowerOfVariable(node *); char *sprintMidpointMode(mpfr_t a, mpfr_t b); void fprintValueForXml(FILE *, mpfr_t ); void fprintValueWithPrintMode(FILE *, mpfr_t ); void fprintTreeWithPrintMode(FILE *, node *); int readDecimalConstant(mpfr_t ,char *); int getMaxPowerDivider(node *tree); void simplifyMpfrPrec(mpfr_t rop, mpfr_t op); node *simplifyRationalErrorfree(node *tree); int tryEvaluateConstantTermToMpq(mpq_t res, node *tree); node *simplifyAllButDivision(node *tree); int mpfr_to_mpq( mpq_t y, mpfr_t x); int mpfr_to_mpz( mpz_t y, mpfr_t x); mp_prec_t getMpzPrecision(mpz_t x); int containsOnlyRealNumbers(node * tree); void tryCopyTreeAnnotations(node *newTree, node *oldTree); int containsNonDifferentiableSubfunctions(node *tree); node *makeVariable(); node *makeConstant(mpfr_t x); node *makeConstantDouble(double x); node *makeConstantInt(int x); node *makeConstantUnsignedInt(unsigned int x); node *makeConstantMpz(mpz_t x); node *makeAdd(node *op1, node *op2); node *makeSub(node *op1, node *op2); node *makeMul(node *op1, node *op2); node *makeDiv(node *op1, node *op2); node *makeSqrt(node *op1); node *makeExp(node *op1); node *makeLog(node *op1); node *makeLog2(node *op1); node *makeLog10(node *op1); node *makeSin(node *op1); node *makeCos(node *op1); node *makeTan(node *op1); node *makeAsin(node *op1); node *makeAcos(node *op1); node *makeAtan(node *op1); node *makePow(node *op1, node *op2); node *makeNeg(node *op1); node *makeAbs(node *op1); node *makeDouble(node *op1); node *makeSingle(node *op1); node *makeQuad(node *op1); node *makeHalfPrecision(node *op1); node *makeDoubledouble(node *op1); node *makeTripledouble(node *op1); node *makeErf(node *op1); node *makeErfc(node *op1); node *makeLog1p(node *op1); node *makeExpm1(node *op1); node *makeDoubleextended(node *op1); node *makeCeil(node *op1); node *makeFloor(node *op1); node *makeNearestInt(node *op1); node *makePi(); node *makeSinh(node *op1); node *makeCosh(node *op1); node *makeTanh(node *op1); node *makeAsinh(node *op1); node *makeAcosh(node *op1); node *makeAtanh(node *op1); node *makeUnary(node *op1, int nodeType); node *makeBinary(node *op1, node *op2, int opType); node* addMemRef(node *); node* accessThruMemRef(node *); #endif /* ifdef EXPRESSION_H*/ sollya-6.0+ds/external.c000066400000000000000000000335321300174114700152560ustar00rootroot00000000000000/* Copyright 2006-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #define _BSD_SOURCE #define _DEFAULT_SOURCE #include /* execve, fork, daemon */ #include #include #include #include #include #include #include #include #include #include #include "expression.h" #include "external.h" #include "plot.h" #include "infnorm.h" #include "general.h" #include "printf.h" #include "signalhandling.h" #ifdef HAVE_CONFIG_H #include "config.h" #endif #define READ_BUFFER_SIZE 2048 extern int fileNumber; int bashExecute(char *command) { int i; deferSignalHandling(); fflush(NULL); i = system(command); fflush(NULL); resumeSignalHandling(); return WEXITSTATUS(i); } char *evaluateStringAsBashCommand(char *command, char *input) { char *res; int okay, errorOnInput; int pipesToBash[2]; int pipesFromBash[2]; pid_t pid; int childStatus; char readBuffer[READ_BUFFER_SIZE]; int readLen; char *buf; int len; int i; if ((command == NULL) || (strlen(command) == 0)) { printMessage(1,SOLLYA_MSG_NO_COMMAND_PROVIDED,"Warning in bashevaluate: no command provided\n"); return NULL; } res = NULL; okay = 0; deferSignalHandling(); fflush(NULL); resumeSignalHandling(); /* Create two unnamed pipes */ if ((input != NULL) && (pipe(pipesToBash) == -1)) { /* Error creating the pipe */ printMessage(1,SOLLYA_MSG_ERROR_WHILE_CREATING_A_PIPE,"Warning in bashevaluate: error while creating a pipe"); } else { if (pipe(pipesFromBash) == -1) { /* Error creating the pipe */ printMessage(1, SOLLYA_MSG_ERROR_WHILE_CREATING_A_PIPE, "Warning in bashevaluate: error while creating a pipe"); } else { /* Fork // // Flush before forking */ deferSignalHandling(); fflush(NULL); parserFlushInput(); resumeSignalHandling(); if ((pid = fork()) == -1) { /* Error forking */ printMessage(1, SOLLYA_MSG_ERROR_WHILE_FORKING, "Warning in bashevaluate: error while forking"); } else { /* Fork worked */ if (pid == 0) { /* I am the child // // Close the unneeded ends of the pipes. */ if (input != NULL) close(pipesToBash[1]); close(pipesFromBash[0]); /* Connect my input and output to the pipe */ if (input != NULL) { if (sollya_dup2(pipesToBash[0],0) == -1) { _exit(1); } } if (sollya_dup2(pipesFromBash[1],1) == -1) { _exit(1); } /* Execute bash */ deferSignalHandling(); fflush(NULL); execlp("sh","sh","-c",command,(char *) NULL); fflush(NULL); resumeSignalHandling(); _exit(1); } else { /* I am the father // // Close the unneeded ends of the pipes. */ if (input != NULL) close(pipesToBash[0]); close(pipesFromBash[1]); /* Do my job */ errorOnInput = 0; if (input != NULL) { if (write(pipesToBash[1],input, strlen(input) * sizeof(char)) == -1) { printMessage(1,SOLLYA_MSG_UNABLE_TO_WRITE_TO_BASH,"Warning in bashevaluate: unable to write to bash"); errorOnInput = 1; } close(pipesToBash[1]); } deferSignalHandling(); fflush(NULL); resumeSignalHandling(); if (!errorOnInput) { do { readLen = read(pipesFromBash[0],readBuffer,READ_BUFFER_SIZE); if (readLen > 0) { if (res == NULL) { res = safeCalloc(readLen + 1, sizeof(char)); buf = res; } else { len = strlen(res); buf = safeCalloc(len + readLen + 1, sizeof(char)); strcpy(buf,res); safeFree(res); res = buf; buf += len; } for (i=0;i 0) { if (res == NULL) { res = safeCalloc(readLen + 1, sizeof(char)); buf = res; } else { len = strlen(res); buf = safeCalloc(len + readLen + 1, sizeof(char)); strcpy(buf,res); safeFree(res); res = buf; buf += len; } for (i=0;i= 1) { if (res[len-1] == '\n') res[len-1] = '\0'; } } } } } } if (!okay) { if (res != NULL) safeFree(res); res = NULL; } deferSignalHandling(); fflush(NULL); parserFlushInput(); resumeSignalHandling(); return res; } void externalPlot(char *library, mpfr_t a, mpfr_t b, mp_prec_t samplingPrecision, int random, node *func, int mode, mp_prec_t prec, char *name, int type) { void *descr; void (*myFunction)(mpfr_t, mpfr_t); char *error; mpfr_t x_h,x,y,temp,perturb,ulp,min_value; double xd, yd; FILE *file; gmp_randstate_t state; char *gplotname; char *dataname; char *outputname; int n; if(samplingPrecision > prec) { printMessage(1,SOLLYA_MSG_SAMPLING_PREC_MUST_BE_LOWER_THAN_CURR_PREC,"Error: you must use a sampling precision lower than the current precision\n"); return; } descr = dlopen(library, RTLD_NOW); if (descr==NULL) { printMessage(1,SOLLYA_MSG_EXTERNALPLOT_COULD_NOT_OPEN_A_LIBRARY, "Error: the given library (%s) is not available (%s)!\n",library,dlerror()); return; } dlerror(); /* Clear any existing error */ myFunction = (void (*)(mpfr_t, mpfr_t)) dlsym(descr, "f"); if ((error = dlerror()) != NULL) { printMessage(1, SOLLYA_MSG_EXTERNALPLOT_DID_NOT_FIND_FUNCTION_F, "Error: the function f cannot be found in library %s (%s)\n",library,error); return; } if(name==NULL) { n = sollya_snprintf(NULL, 0, "%s/%s%s-%04d", getTempDir(), PACKAGE_NAME, getUniqueId(), fileNumber); gplotname = (char *)safeCalloc(n+3, sizeof(char)); sollya_snprintf(gplotname, n+3, "%s/%s%s-%04d.p",getTempDir(), PACKAGE_NAME, getUniqueId(), fileNumber); dataname = (char *)safeCalloc(n+5, sizeof(char)); sollya_snprintf(dataname, n+5, "%s/%s%s-%04d.dat",getTempDir(),PACKAGE_NAME,getUniqueId(), fileNumber); outputname = (char *)safeCalloc(1, sizeof(char)); fileNumber++; if (fileNumber >= NUMBEROFFILES) fileNumber=0; } else { gplotname = (char *)safeCalloc(strlen(name)+3,sizeof(char)); sprintf(gplotname,"%s.p",name); dataname = (char *)safeCalloc(strlen(name)+5,sizeof(char)); sprintf(dataname,"%s.dat",name); outputname = (char *)safeCalloc(strlen(name)+5,sizeof(char)); if ((type==PLOTPOSTSCRIPT) || (type==PLOTPOSTSCRIPTFILE)) sprintf(outputname,"%s.eps",name); } /* Beginning of the interesting part of the code */ file = fopen(gplotname, "w"); if (file == NULL) { printMessage(1,SOLLYA_MSG_COULD_NOT_OPEN_PLOT_FILE,"Error: the file %s requested by plot could not be opened for writing: ",gplotname); printMessage(1,SOLLYA_MSG_CONTINUATION,"\"%s\".\n",strerror(errno)); return; } sollyaFprintf(file, "# Gnuplot script generated by %s\n",PACKAGE_NAME); if ((type==PLOTPOSTSCRIPT) || (type==PLOTPOSTSCRIPTFILE)) sollyaFprintf(file,"set terminal postscript eps color\nset out \"%s\"\n",outputname); sollyaFprintf(file, "set format x \"%%g\"\n"); sollyaFprintf(file, "set format y \"%%g\"\n"); sollyaFprintf(file, "set xrange [%1.50e:%1.50e]\n", sollya_mpfr_get_d(a, GMP_RNDD),sollya_mpfr_get_d(b, GMP_RNDU)); sollyaFprintf(file, "plot \"%s\" using 1:2 with dots t \"\"\n",dataname); fclose(file); file = fopen(dataname, "w"); if (file == NULL) { printMessage(1,SOLLYA_MSG_COULD_NOT_OPEN_PLOT_FILE,"Error: the file %s requested by plot could not be opened for writing: ",dataname); printMessage(1,SOLLYA_MSG_CONTINUATION,"\"%s\".\n",strerror(errno)); return; } gmp_randinit_default (state); mpfr_init2(x_h,samplingPrecision); mpfr_init2(perturb, prec); mpfr_init2(x,prec); mpfr_init2(y,prec); mpfr_init2(temp,prec); mpfr_init2(ulp,prec); mpfr_init2(min_value,53); mpfr_sub(min_value, b, a, GMP_RNDN); mpfr_div_2ui(min_value, min_value, 12, GMP_RNDN); mpfr_set(x_h,a,GMP_RNDD); while(mpfr_less_p(x_h,b)) { mpfr_set(x, x_h, GMP_RNDN); /* exact */ if (mpfr_zero_p(x_h)) { mpfr_set(x_h, min_value, GMP_RNDU); } else { if (mpfr_cmpabs(x_h, min_value) < 0) mpfr_set_d(x_h, 0., GMP_RNDN); else mpfr_nextabove(x_h); } if(random) { mpfr_sub(ulp, x_h, x, GMP_RNDN); mpfr_urandomb(perturb, state); mpfr_mul(perturb, perturb, ulp, GMP_RNDN); mpfr_add(x, x, perturb, GMP_RNDN); } if (mpfr_zero_p(x)) { mpfr_mul(x,x,x,GMP_RNDN); /* (+/- 0)^2 = + 0 */ } (*myFunction)(temp,x); evaluateFaithful(y, func, x,prec); mpfr_sub(temp, temp, y, GMP_RNDN); if(mode==RELATIVE) mpfr_div(temp, temp, y, GMP_RNDN); xd = sollya_mpfr_get_d(x, GMP_RNDN); if (xd >= MAX_VALUE_GNUPLOT) xd = MAX_VALUE_GNUPLOT; if (xd <= -MAX_VALUE_GNUPLOT) xd = -MAX_VALUE_GNUPLOT; sollyaFprintf(file, "%1.50e",xd); if (!mpfr_number_p(temp)) { printMessage(2,SOLLYA_MSG_A_FUNCTION_COULD_NOT_BE_PLOTTED_AT_A_POINT,"Information: function undefined or not evaluable in point %s = %v\nThis point will not be plotted.\n",((variablename == NULL) ? "_x_" : variablename),x); } yd = sollya_mpfr_get_d(temp, GMP_RNDN); if (yd >= MAX_VALUE_GNUPLOT) yd = MAX_VALUE_GNUPLOT; if (yd <= -MAX_VALUE_GNUPLOT) yd = -MAX_VALUE_GNUPLOT; sollyaFprintf(file, "\t%1.50e\n", yd); } fclose(file); /* End of the interesting part.... */ dlclose(descr); mpfr_clear(x); mpfr_clear(y); mpfr_clear(x_h); mpfr_clear(temp); mpfr_clear(perturb); mpfr_clear(ulp); mpfr_clear(min_value); deferSignalHandling(); fflush(NULL); parserFlushInput(); resumeSignalHandling(); if ((name==NULL) || (type==PLOTFILE)) { if (fork()==0) { if (daemon(1,1) == 0) { if (fork() == 0) { execlp("gnuplot", "gnuplot", "-persist", gplotname, NULL); perror("An error occurred when calling gnuplot "); exit(1); } else { wait(NULL); sleep(1); remove(gplotname); remove(dataname); sleep(1); exit(0); } } else { fprintf(stderr, "Could not create a daemon for gnuplot\n"); if (fork() == 0) { execlp("gnuplot", "gnuplot", "-persist", gplotname, NULL); perror("An error occurred when calling gnuplot "); exit(1); } else { wait(NULL); sleep(2); exit(0); } } } else { wait(NULL); sleep(1); } } else { /* Case we have an output: no daemon */ if (fork()==0) { execlp("gnuplot", "gnuplot", "-persist", gplotname, NULL); perror("An error occurred when calling gnuplot "); exit(1); } else { wait(NULL); if(type==PLOTPOSTSCRIPT) { remove(gplotname); remove(dataname); } sleep(1); } } wait(NULL); deferSignalHandling(); fflush(NULL); parserFlushInput(); resumeSignalHandling(); safeFree(gplotname); safeFree(dataname); safeFree(outputname); gmp_randclear(state); return; } sollya-6.0+ds/external.h000066400000000000000000000052541300174114700152630ustar00rootroot00000000000000/* Copyright 2006-2011 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef EXTERNAL_H #define EXTERNAL_H #include #include "expression.h" #define RELATIVE 0 #define ABSOLUTE 1 int bashExecute(char *command); void externalPlot(char *library, mpfr_t a, mpfr_t b, mp_prec_t samplingPrecision, int random, node *func, int mode, mp_prec_t prec, char *name, int type); char *evaluateStringAsBashCommand(char *, char *); #endif /* ifdef EXTERNAL_H*/ sollya-6.0+ds/externalfun.c000066400000000000000000000063311300174114700157640ustar00rootroot00000000000000/* Copyright 2007-2009 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 Contributor Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include "sollya.h" /* Example of an external functionality linked to a function symbol in sollya Compile with gcc -fPIC -Wall -c externalfun.c gcc -fPIC -shared -o externalfun externalfun.o Function foo will be linked by foo = library("./externalfun"); The C function foo is supposed to affect rop with an enclosure of the image of the n-th derivative of the function on interval op. It is supposed to be sensitive to the precision of rop. Remark that most sollya functionalities rely on the fact that at least the second derivative can be finitely enclosed. The C function may return [-inf; +inf] as an enclosure for the higher derivatives. The C function foo can use all functionalities inside sollya that have been exported in sollya.h. Some care must be taken with regard to the memory management inside the C function if sollya functionalities are used: be sure that all memory is freed before returning. The C function foo is supposed to return an integer. Its meaning is to be defined. */ int foo(mpfi_t rop, mpfi_t op, int n) { return 0; } sollya-6.0+ds/externalproc.c000066400000000000000000000155041300174114700161410ustar00rootroot00000000000000/* Copyright 2007-2012 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributor Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include /* Example of an external procedure linked to an identifier in sollya Compile with gcc -fPIC -Wall -c externalproc.c gcc -fPIC -shared -o externalproc externalproc.o Procedure foo will be linked by externalproc(foo, "./externalproc", signature); where signature is the signature of the function as type -> type or (type, type, ...) -> type where type is one of void, constant, function, range, integer, string, boolean, list of constant, list of function, list of range, list of integer, list of string, list of boolean. It is worth mentionning that the difference between the data and result type function and the type object is minimal and due to support of legacy Sollya code. Both Sollya functions and Sollya objects are transferred from and to the external procedure thru the C type sollya_obj_t. The difference is that Sollya will check that a certain object is a mathematical function when function is used as a type, and will skip this test if the object type is used. Similarly, Sollya relies on an object produced by the external procedure to be a mathematical function when function is used and will not make this assumption for object. The C function foo is supposed to return an integer indicating success. It returns its result depending on its sollya result type as follows: * void : the C function has no pointer argument for the result * constant: the first argument of the C function is of C type mpfr_t *, the result is returned by affecting the MPFR variable * function: the first argument of the C function is of C type sollya_obj_t *, the result is returned by the sollya_obj_t pointed with a new sollya_obj_t * object: the first argument of the C function is of C type sollya_obj_t *, the result is returned by the sollya_obj_t pointed with a new sollya_obj_t * range: the first argument of the C function is of C type mpfi_t *, the result is returned by affecting the MPFI variable * integer: the first argument of the C function is of C type int *, the result is returned by affecting the int variable * string: the first argument of the C function is of C type char **, the result is returned by the char * pointed with a new char * * boolean: the first argument of the C function is of C type int *, the result is returned by affecting the int variable with a boolean value * list of type: the first argument of the C function is of a C type depending on the Sollya return type. For a list of - constant: sollya_constant_list_t * - function: sollya_obj_list_t * - object: sollya_obj_list_t * - range: sollya_constant_list_t * - integer: sollya_int_list_t * - string: sollya_string_list_t * - boolean: sollya_boolean_list_t * The C function affects its possible pointer argument if and only if it succeeds. This means, if the function returns an integer indicating failure, it does not leak any memory to the encompassing environment. The C function foo receives its arguments as follows: If the sollya argument type is void, no argument array is given. Otherwise the C function receives a C void ** argument representing an array of size equal to the arity of the function where each entry (of C type void *) represents a value with a C type depending on the corresponding sollya type: * constant: the C type the void * is to be cast to mpfr_t * * function: the C type the void * is to be cast to sollya_obj_t * object: the C type the void * is to be cast to sollya_obj_t * range: the C type the void * is to be cast to mpfi_t * * integer: the C type the void * is to be cast to int * * string: the C type the void * is to be cast to char * * boolean: the C type the void * is to be cast to int * * list of type: the C type the void * is to be cast to a list of a type depending on the type of the list argument. For a list of - constant: sollya_constant_list_t - function: sollya_obj_list_t - object: sollya_obj_list_t - range: sollya_interval_list_t - integer: sollya_int_list_t - string: sollya_string_list_t - boolean: sollya_boolean_list_t. The C function is not supposed to alter the memory pointed by its array argument void **. In both directions (argument and result values), empty lists are represented by NULL pointers. */ /* Signature (integer, integer) -> integer */ int foo(int *res, void **args) { *res = *((int *) args[0]) + *((int *) args[1]); return 1; } sollya-6.0+ds/fplll_wrapper.cpp000066400000000000000000000120011300174114700166310ustar00rootroot00000000000000/* Copyright 2008-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. and by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also herefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #undef malloc #undef realloc #ifdef HAVE_SPECIAL_FPLLL_INCLUDE #if HAVE_SPECIAL_FPLLL_INCLUDE #include #else #include #endif #else #include #endif #include #define coeff(i,j,n) ((i)-1)*(n)+(j)-1 /* Considering a matrix of nbpoints+1 x dim+1 rational numbers, performs the LLL reduction of the matrix (seen as a basis of row vectors) and returns the last reduced vector (which is hence a nbpoints+1 array of mpq_t). reducedVect is supposed to point to a large enough segment of allocated and already initialized mpq_t */ #ifdef HAVE_FPLLL_OLD_API #if HAVE_FPLLL_OLD_API extern "C" void fplll_wrapper(mpq_t *reducedVect, mpq_t *exactMatrix, int dim, int nbpoints) { int i,j; ZZ_mat * FPlllMat; Z_NR zval; wrapper *LLLwrapper; mpz_t mpzval; mpz_init(mpzval); FPlllMat = new ZZ_mat(dim+1,nbpoints+1); for(j=1; j<=dim+1; j++) { for(i=1; i<=nbpoints+1; i++) { mpz_set_q(mpzval, exactMatrix[coeff(i,j,dim+1)]); /* Casts M[i,j] into a mpz_t */ zval.set(mpzval); FPlllMat->Set(j-1,i-1,zval); } } // LLL reduction LLLwrapper = new wrapper(FPlllMat); LLLwrapper->LLL(); // Converting all stuff into exact numbers for(i=1; i<=nbpoints+1; i++) { mpq_set_z(reducedVect[i-1], LLLwrapper->GetBase()->Get(dim, i-1).GetData()); } // Cleaning delete FPlllMat; delete LLLwrapper; mpz_clear(mpzval); return; } #else /* New API */ extern "C" void fplll_wrapper(mpq_t *reducedVect, mpq_t *exactMatrix, int dim, int nbpoints) { int i,j; ZZ_mat * FPlllMat; Z_NR zval; mpz_t mpzval; mpz_init(mpzval); FPlllMat = new ZZ_mat(dim+1,nbpoints+1); for(j=1; j<=dim+1; j++) { for(i=1; i<=nbpoints+1; i++) { mpz_set_q(mpzval, exactMatrix[coeff(i,j,dim+1)]); /* Casts M[i,j] into a mpz_t */ zval = mpzval; (*FPlllMat)[j-1][i-1] = zval; } } // LLL reduction lll_reduction(*FPlllMat); // Converting all stuff into exact numbers for(i=1; i<=nbpoints+1; i++) { mpq_set_z(reducedVect[i-1], (*FPlllMat)[dim][i-1].get_data()); // mpq_set_z(reducedVect[i-1], LLLwrapper->GetBase()->Get(dim, i-1).GetData()); } // Cleaning delete FPlllMat; mpz_clear(mpzval); return; } #endif /* #ifdef HAVE_FPLLL_OLD_API */ #else /* This case should not happen */ extern "C" void fplll_wrapper(mpq_t *reducedVect, mpq_t *exactMatrix, int dim, int nbpoints) { return; } #endif /* #if HAVE_FPLLL_OLD_API */ sollya-6.0+ds/fplll_wrapper.h000066400000000000000000000044311300174114700163060ustar00rootroot00000000000000/* Copyright 2016 by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributor S. Chevillard sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef FPLLL_WRAPPER_H #define FPLLL_WRAPPER_H void fplll_wrapper(mpq_t *reducedVect, mpq_t *exactMatrix, int dim, int nbpoints); #endif /* ifdef FPLLL_WRAPPER */ sollya-6.0+ds/fpminimax.c000066400000000000000000000653661300174114700154360ustar00rootroot00000000000000/* Copyright 2008-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. and by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also herefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif /* const mess */ #if defined(const) #undef const #endif /* End of the const mess */ #include #include #include #include #include "fpminimax.h" #include "expression.h" #include "remez.h" #include "chain.h" #include "execute.h" #include "fplll_wrapper.h" #define coeff(i,j,n) ((i)-1)*(n)+(j)-1 #define MAXLOOP 10 void printMpqMatrix(mpq_t *M, int p, int n) { int i,j; sollyaPrintf((const char *) "["); for(i=1;i<=p;i++) { for(j=1;j<=n;j++) { sollyaPrintf((const char *) "%r", M[coeff(i,j,n)]); if(j!=n) sollyaPrintf((const char *) ", "); } if(i!=n) sollyaPrintf((const char *) ";\n"); } sollyaPrintf((const char *) "]\n"); return; } int mpq_cmpabs(mpq_t a, mpq_t b) { mpq_t temp1, temp2; int res; mpq_init(temp1); mpq_init(temp2); mpq_abs(temp1, a); mpq_abs(temp2, b); res = mpq_cmp(temp1, temp2); mpq_clear(temp1); mpq_clear(temp2); return res; } void mpq_fma(mpq_t r, mpq_t a, mpq_t b, mpq_t c) { mpq_t temp; mpq_init(temp); mpq_mul(temp, a, b); mpq_add(r, temp, c); mpq_clear(temp); return; } /* n is the number of columns */ /* p is the number of lines (p>=n) */ /* the system is supposed to be invertible */ /* returns 1 if the system is singular */ int exact_system_solve(mpq_t *res, mpq_t *M, mpq_t *b, int p, int n) { chain *i_list=NULL; chain *j_list=NULL; chain *curri; chain *currj; int i0, j0, i, j, k; int *var; mpq_t max,lambda; int *order_i = (int *)safeMalloc(n*sizeof(int)); int *order_j = (int *)safeMalloc(n*sizeof(int)); mpq_init(max); mpq_init(lambda); for(i=1;i<=p;i++) { var = (int *)safeMalloc(sizeof(int)); *var = i; i_list = addElement(i_list, (void *)var); } for(j=1;j<=n;j++) { var = (int *)safeMalloc(sizeof(int)); *var = j; j_list = addElement(j_list, (void *)var); } // Triangulation by Gaussian elimination i0 = j0 = -1; for(k=1;k<=n;k++) { mpq_set_ui(max, 0, 1); // In this part, we search for the biggest element of the matrix curri = i_list; while(curri!=NULL) { currj = j_list; while(currj!=NULL) { i = *(int *)(curri->value); j = *(int *)(currj->value); if(mpq_cmpabs(M[coeff(i,j,n)],max)>=0) { i0 = i; j0 = j; mpq_set(max, M[coeff(i,j,n)]); } currj = currj->next; } curri = curri->next; } i_list = removeInt(i_list, i0); j_list = removeInt(j_list, j0); order_i[k-1] = i0; order_j[k-1] = j0; if(mpq_cmp_ui(M[coeff(i0,j0,n)], 0, 1)==0) { printMessage(1, SOLLYA_MSG_FPMINIMAX_SINGULAR_MATRIX, (const char *) "Error: fpminimax: singular matrix\n"); freeChain(i_list, freeIntPtr); freeChain(j_list, freeIntPtr); mpq_clear(max); mpq_clear(lambda); safeFree(order_i); safeFree(order_j); return 1; } // Here we update the matrix and the second member curri = i_list; while(curri!=NULL) { i = *(int *)(curri->value); mpq_div(lambda, M[coeff(i,j0,n)], M[coeff(i0,j0,n)]); mpq_neg(lambda, lambda); currj = j_list; while(currj!=NULL) { j = *(int *)(currj->value); mpq_fma(M[coeff(i,j,n)], lambda, M[coeff(i0,j,n)], M[coeff(i,j,n)]); currj = currj->next; } mpq_fma(b[i-1], lambda, b[i0-1], b[i-1]); mpq_set_ui(M[coeff(i,j0,n)], 0, 1); // this line is not useful strictly speaking curri = curri->next; } } /*********************************************************************/ freeChain(i_list, freeIntPtr); freeChain(j_list, freeIntPtr); // Resolution of the system itself i_list=NULL; for(i=1;i<=n;i++) { var = (int *)safeMalloc(sizeof(int)); *var = order_i[i-1]; i_list = addElement(i_list, (void *)var); } for(k=n;k>=1;k--) { i0 = order_i[k-1]; j0 = order_j[k-1]; mpq_div(res[j0-1], b[i0-1], M[coeff(i0,j0,n)]); i_list = removeInt(i_list, i0); curri = i_list; while(curri!=NULL) { i = *(int *)(curri->value); mpq_neg(M[coeff(i,j0,n)], M[coeff(i,j0,n)]); mpq_fma(b[i-1], M[coeff(i,j0,n)], res[j0-1], b[i-1]); curri=curri->next; } } safeFree(order_i); safeFree(order_j); freeChain(i_list, freeIntPtr); mpq_clear(max); mpq_clear(lambda); return 0; } chain *ChebychevPoints(mpfr_t a, mpfr_t b, int n) { chain *res=NULL; mpfr_t temp, temp2, u; mpfr_t *mpfrptr; int i; mpfr_init2(temp, tools_precision); mpfr_init2(temp2, tools_precision); mpfr_init2(u, tools_precision); mpfr_sub(u, b, a, GMP_RNDN); mpfr_div_2ui(u, u, 1, GMP_RNDN); for(i=1; i<=n; i++) { mpfrptr = (mpfr_t *)safeMalloc(sizeof(mpfr_t)); mpfr_init2(*mpfrptr, tools_precision); mpfr_set_ui(temp, 2*i-1, GMP_RNDN); mpfr_const_pi(temp2, GMP_RNDN); mpfr_mul(temp, temp, temp2, GMP_RNDN); mpfr_div_ui(temp, temp, 2*n, GMP_RNDN); mpfr_cos(temp, temp, GMP_RNDN); mpfr_add_ui(temp, temp, 1, GMP_RNDN); mpfr_mul(temp, temp, u, GMP_RNDN); mpfr_add(*mpfrptr, temp, a, GMP_RNDN); res = addElement(res, mpfrptr); } mpfr_clear(temp); mpfr_clear(temp2); mpfr_clear(u); return res; } /* Assuming that poly = sum a_i *gi(x), find a_i such that gi(x) = g(x) and store it as a constant expression in c */ /* Returns 1 in case of success and 0 in case of failure. In this case, c is unchanged */ /* Nothing is done for trying to recognize equivalent expressions: for instance, if g(x) = (x+1) and poly = 2*(1+x) the algorithm fails. The algorithm fails also if g(x) = (x+1) and poly = 2*(x+1)*3, whatever the way you put parentheses. */ int findCoeffInPseudoPolynomial(node **c, node *poly, node *g) { node *a, *b; node *temp; int r1, r2; if (poly == NULL) return 0; switch (accessThruMemRef(poly)->nodeType) { case ADD: r1 = findCoeffInPseudoPolynomial(&a, accessThruMemRef(poly)->child1, g); r2 = findCoeffInPseudoPolynomial(&b, accessThruMemRef(poly)->child2, g); if (r1) { if (r2) *c = makeAdd(a,b); else *c = a; return 1; } else { if (r2) { *c = b; return 1; } } break; case SUB: r1 = findCoeffInPseudoPolynomial(&a, accessThruMemRef(poly)->child1, g); r2 = findCoeffInPseudoPolynomial(&b, accessThruMemRef(poly)->child2, g); if (r1) { if (r2) *c = makeSub(a,b); else *c = a; return 1; } else { if (r2) { *c = makeNeg(b); return 1; } } break; case NEG: r1 = findCoeffInPseudoPolynomial(&a, accessThruMemRef(poly)->child1, g); if (r1) { *c = makeNeg(a); return 1; } break; case MUL: if ( isSyntacticallyEqual(accessThruMemRef(poly)->child2, g) && isConstant(accessThruMemRef(poly)->child1) ) { *c = copyTree(accessThruMemRef(poly)->child1); return 1; } if ( isSyntacticallyEqual(accessThruMemRef(poly)->child1, g) && isConstant(accessThruMemRef(poly)->child2) ) { *c = copyTree(accessThruMemRef(poly)->child2); return 1; } break; case DIV: if ( isSyntacticallyEqual(accessThruMemRef(poly)->child1, g) && isConstant(accessThruMemRef(poly)->child2) ) { *c = makeDiv(makeConstantDouble(1.0), copyTree(accessThruMemRef(poly)->child2)); return 1; } temp = makeDiv(makeConstantDouble(1.0), copyTree(accessThruMemRef(poly)->child2)); if ( isSyntacticallyEqual(temp, g) && isConstant(accessThruMemRef(poly)->child1) ) { *c = copyTree(poly->child1); free_memory(temp); return 1; } free_memory(temp); break; } /* Nothing worked. Maybe, poly = g, in which case, the coefficient is implicitly 1, or poly = constant and g = constant, in which case the coefficient is implicitly poly/g, or poly = 0, in which case the coefficient is implicitly 0. */ if (isSyntacticallyEqual(poly, g)) { *c = makeConstantDouble(1.0); return 1; } if ( (isConstant(poly)) && (isConstant(g)) ) { *c = makeDiv(copyTree(poly), copyTree(g)); return 1; } temp = makeConstantDouble(0.0); if (isSyntacticallyEqual(poly, temp)) { *c = temp; return 1; } /* Otherwise, we fail */ free_memory(temp); return 0; } /* Assuming that poly = sum a_i * monomials[i](x), this function computes the array of the a_i and store it in coefficients. Enough room must be available in coefficients to store them all, and the mpfr_t must already be initialized. Note that the same restrictions hold as with function findCoeffInPseudoPolynomial. Returns 1 in case of success and 0 in case of failure (in this case nothing can be said about the content of coefficients) */ int getCoefficientsInPseudoPolynomial(mpfr_t *coefficients, node *poly, chain *monomials) { chain *curr; node *coeff; int i = 0; for (curr = monomials; curr != NULL; curr = curr->next) { if (findCoeffInPseudoPolynomial(&coeff, poly, (node *)(curr->value))) { evaluateThingToConstant(coefficients[i], coeff, NULL, 1, 0); free_memory(coeff); i++; } else { return 0;} } return 1; } chain *computeExponents(chain *formats, mpfr_t* coefficients, int dim) { chain *curr; chain *res = NULL; int *intptr; chain *tempChain; int i; curr = formats; for(i=0; ivalue); } else *intptr = *(int *)(curr->value) - mpfr_get_exp(coefficients[i]); res = addElement(res, intptr); curr = curr->next; } tempChain = copyChain(res, copyIntPtrOnVoid); freeChain(res, freeIntPtr); res = tempChain; return res; } int fitInFormat(chain *formats, mpfr_t* coefficients, int dim) { chain *curr; mpfr_t val; int prec, i; int test=1; curr = formats; for(i=0; (ivalue); if (prec==1) { mpfr_init2(val, 12); mpfr_set_ui(val, 1, GMP_RNDN); mpfr_mul_2si(val, val, mpfr_get_exp(coefficients[i])-1, GMP_RNDN); if ( !mpfr_equal_p(val, coefficients[i]) ) test=0; mpfr_clear(val); } else { mpfr_init2(val, prec); if (mpfr_set(val, coefficients[i], GMP_RNDN)!=0) test=0; mpfr_clear(val); } } curr = curr->next; } return test; } node *FPminimaxMain(node *, chain *, chain *, chain *, node *); node *FPminimax(node *f, chain *monomials, chain *formats, chain *points, mpfr_t a, mpfr_t b, int fp, int absrel, node *consPart, node *minimax) { node *g, *w; node *pstar; node *err; node *tempTree; chain *pointslist; node *res; chain *correctedFormats, *newFormats; chain *curr; int i, test, count; mpfr_t zero, infinity, quality; mpfr_t *coefficients; int dim = lengthChain(monomials); newFormats = NULL; if (absrel== ABSOLUTESYM) { tempTree = makeSub(copyTree(f),copyTree(consPart)); g = simplifyTreeErrorfree(tempTree); free_memory(tempTree); w = makeConstantDouble(1.); } else { tempTree = makeSub(makeConstantDouble(1.), makeDiv(copyTree(consPart),copyTree(f))); g = simplifyTreeErrorfree(tempTree); free_memory(tempTree); tempTree = makeDiv(makeConstantDouble(1.), copyTree(f)); w = simplifyTreeErrorfree(tempTree); free_memory(tempTree); } mpfr_init2(zero, 53); mpfr_set_ui(zero, 0, GMP_RNDN); mpfr_init2(infinity, 53); mpfr_set_inf(infinity, 1); pstar = NULL; if( (fp==FLOATING) || (points==NULL) ) { if (minimax == NULL) { pushTimeCounter(); mpfr_init2(quality, 53); mpfr_set_d(quality, 0.00001, GMP_RNDN); pstar = remez(g, w, monomials, a, b, quality, zero, infinity, tools_precision); mpfr_clear(quality); popTimeCounter((char *) "FPminimax: computing minimax approximation"); } else pstar = copyTree(minimax); } if (isError(pstar)) { printMessage(1, SOLLYA_MSG_FPMINIMAX_FAILED_TO_RECOVER_COEFFS_FROM_POLY, (const char *) "Warning: fpminimax failed to recover the coefficients from the minimax pseudo-polynomial\n"); free_memory(g); free_memory(w); freeThing(pstar); mpfr_clear(zero); mpfr_clear(infinity); return NULL; } if ((pstar != NULL) && (isHorner(pstar))) { tempTree = makeCanonical(pstar, tools_precision); free_memory(pstar); pstar = tempTree; } err = NULL; if(points == NULL) { tempTree = makeSub(makeMul(copyTree(pstar), copyTree(w)), copyTree(g)); err = simplifyTreeErrorfree(tempTree); free_memory(tempTree); pushTimeCounter(); pointslist = uncertifiedFindZeros(err, a, b, defaultpoints, tools_precision); popTimeCounter((char *)"FPminimax: finding valuable interpolation points."); // Tests if there is enough points // if not, Chebychev points are used and we approximate pstar instead of f if(lengthChain(pointslist)< dim) { printMessage(2, SOLLYA_MSG_FPMINIMAX_MINIMAX_DOES_NOT_GIVE_ENOUGH_POINTS, (const char *) "Information: FPminimax: the minimax does not provide enough points.\n"); printMessage(2, SOLLYA_MSG_CONTINUATION, (const char *) "Switching to Chebyshev points.\n"); freeChain(pointslist, freeMpfrPtr); pointslist = ChebychevPoints(a,b, dim); free_memory(g); free_memory(w); if (absrel== ABSOLUTESYM) { g = copyTree(pstar); w = makeConstantDouble(1); } else { tempTree = makeSub(makeConstantDouble(1), makeDiv(copyTree(consPart), makeAdd(copyTree(pstar),copyTree(consPart)) ) ); g = simplifyTreeErrorfree(tempTree); free_memory(tempTree); tempTree = makeDiv(makeConstantDouble(1), makeAdd(copyTree(pstar),copyTree(consPart)) ); w = simplifyTreeErrorfree(tempTree); free_memory(tempTree); } } } else pointslist = copyChainWithoutReversal(points, copyMpfrPtr); curr = pointslist; printMessage(4,SOLLYA_MSG_FPMINIMAX_THE_POINTS_ARE_CERTAIN_VALUES,(const char *) "points list: [|"); while(curr != NULL) { printMessage(4, SOLLYA_MSG_CONTINUATION, (const char *) "%v", *(mpfr_t *)(curr->value)); if(curr->next != NULL) printMessage(4, SOLLYA_MSG_CONTINUATION, (const char *) ", "); curr = curr->next; } printMessage(4, SOLLYA_MSG_CONTINUATION,(const char *) "|]\n"); if (fp == FIXED) res = FPminimaxMain(g, monomials, formats, pointslist, w); else { // Floating-point coefficients: we must compute good exponents test=1; count=0; coefficients = (mpfr_t *)safeCalloc(dim, sizeof(mpfr_t)); for(i=0; ivalue)); if (curr->next != NULL) printMessage(3,SOLLYA_MSG_CONTINUATION,(const char *) ", "); curr = curr->next; } printMessage(3,SOLLYA_MSG_CONTINUATION,(const char *) "|]\n"); res = FPminimaxMain(g, monomials, correctedFormats, pointslist, w); count++; if(res==NULL) test=0; else { if (!getCoefficientsInPseudoPolynomial(coefficients, res, monomials)) { printMessage(1, SOLLYA_MSG_FPMINIMAX_FAILED_TO_RECOVER_COEFFS_FROM_POLY, (const char *) "Warning: fpminimax failed to recover the coefficients from the minimax pseudo-polynomial\n"); res = NULL; test = 0; correctedFormats = NULL; newFormats = NULL; } else newFormats = computeExponents(formats, coefficients, dim); if( isEqualChain(newFormats,correctedFormats, isEqualIntPtrOnVoid) ) test=0; else { if( (count > MAXLOOP) && (fitInFormat(formats, coefficients, dim)) ) test=0; else { if( (count > 2*MAXLOOP) ) { res=NULL; test=0; printMessage(1,SOLLYA_MSG_FPMINIMAX_DID_NOT_CONVERGE, (const char *) "Warning: fpminimax did not converge.\n"); } else { free_memory(res); freeChain(correctedFormats, freeIntPtr); correctedFormats = newFormats; } } } } } freeChain(correctedFormats, freeIntPtr); if (res!=NULL) freeChain(newFormats, freeIntPtr); for(i=0; ivalue); curr=curr->next; } x = (mpfr_t *)safeMalloc(nbpoints*sizeof(mpfr_t)); curr=points; for(i=1; i<=nbpoints; i++) { mpfr_init2(x[i-1], prec); mpfr_set(x[i-1], *(mpfr_t *)(curr->value), GMP_RNDN); curr=curr->next; } // Filling the matrix pushTimeCounter(); for (i=1; i <= nbpoints; i++) { r = evaluateFaithfulWithCutOffFast(var1, w, NULL, x[i-1], zero_mpfr, prec); if(((r==1) || (r==4) || (r==5) || (r==6) || (r==7)) && (mpfr_number_p(var1))) test=1; else test=0; for (j=1; j <= dim; j++) { if(test==1) { r = evaluateFaithfulWithCutOffFast(var2, monomials_tree[j-1], NULL, x[i-1], zero_mpfr, prec); if(((r==1) || (r==4) || (r==5) || (r==6) || (r==7)) && (mpfr_number_p(var2))) { mpfr_mul(var2, var1, var2, GMP_RNDN); mpfr_set(M[coeff(i,j,dim+1)],var2,GMP_RNDN); } } if((test==0) || (r==0) || (!mpfr_number_p(var2))) { printMessage(2,SOLLYA_MSG_FPMINIMAX_COMP_OF_MATRIX_ENTRY_USES_SLOWER_ALGO,(const char *) "Information: the construction of M[%d,%d] uses a slower algorithm\n",i,j); temp_tree = (node *)safeMalloc(sizeof(node)); temp_tree->nodeType = MUL; temp_tree->child1 = copyTree(monomials_tree[j-1]); temp_tree->child2 = copyTree(w); temp_tree2 = simplifyTreeErrorfree(temp_tree); free_memory(temp_tree); temp_tree = temp_tree2; // temp_tree = x^(monomials[j])*w(x) r = evaluateFaithfulWithCutOffFast(var3, temp_tree, NULL, x[i-1], zero_mpfr, prec); if(r==0) mpfr_set_d(var3, 0., GMP_RNDN); mpfr_set(M[coeff(i,j,dim+1)],var3,GMP_RNDN); free_memory(temp_tree); } } } for(j=1; j<=dim; j++) mpfr_set_ui(M[coeff(nbpoints+1, j, dim+1)], 0, GMP_RNDN); for(i=1; i<=nbpoints; i++) { r = evaluateFaithfulWithCutOffFast(var1, f, NULL, x[i-1], zero_mpfr, prec); if(r==0) mpfr_set_d(var1, 0., GMP_RNDN); mpfr_set(M[coeff(i,dim+1,dim+1)],var1,GMP_RNDN); } mpfr_set_ui(max, 0, GMP_RNDN); expo_min = mpfr_get_emax(); for(i=1; i<=nbpoints; i++) { for(j=1; j<=dim; j++) { mpfr_div_2si(M[coeff(i,j,dim+1)], M[coeff(i,j,dim+1)], *(int *)accessInList(formats,j-1), GMP_RNDN); if(mpfr_cmpabs(max, M[coeff(i,j,dim+1)])<0) mpfr_abs(max, M[coeff(i,j,dim+1)], GMP_RNDN); if( (!mpfr_zero_p(M[coeff(i,j,dim+1)])) && (mpfr_get_exp(M[coeff(i,j,dim+1)]) < expo_min) ) expo_min = mpfr_get_exp(M[coeff(i,j,dim+1)]); } if( (!mpfr_zero_p(M[coeff(i,dim+1,dim+1)])) && (mpfr_get_exp(M[coeff(i,dim+1,dim+1)]) < expo_min) ) expo_min = mpfr_get_exp(M[coeff(i,j,dim+1)]); } mpfr_mul_ui(M[coeff(nbpoints+1,dim+1,dim+1)], max, nbpoints, GMP_RNDN); if( (!mpfr_zero_p(M[coeff(nbpoints+1,dim+1,dim+1)])) && (mpfr_get_exp(M[coeff(nbpoints+1,dim+1,dim+1)]) < expo_min) ) expo_min = mpfr_get_exp(M[coeff(nbpoints+1,dim+1,dim+1)]); popTimeCounter((char *)"FPminimax: constructing the matrix"); pushTimeCounter(); mpfr_mul_2si(M[coeff(nbpoints+1,dim+1,dim+1)], M[coeff(nbpoints+1,dim+1,dim+1)], prec-expo_min, GMP_RNDN); for(i=1; i<=nbpoints+1; i++) { for(j=1; j<=dim+1; j++) { mpfr_mul_2si(M[coeff(i, j, dim+1)], M[coeff(i, j,dim+1)], prec-expo_min, GMP_RNDN); mpfr_get_z(mpzval, M[coeff(i,j,dim+1)], GMP_RNDN); /* Casts M[i,j] into a mpz_t */ mpq_set_z(exactMatrix[coeff(i,j,dim+1)], mpzval); /* Casts mpzval into a mpq_t */ } } popTimeCounter((char *)"FPminimax: preparing exact matrices for the call to LLL"); // LLL reduction pushTimeCounter(); fplll_wrapper(reducedVect, exactMatrix, dim, nbpoints); popTimeCounter((char *)"FPminimax: LLL call"); // Getting the coefficients pushTimeCounter(); testIfSingular = exact_system_solve(coefficients, exactMatrix, reducedVect, nbpoints+1, dim+1); popTimeCounter((char *)"FPminimax: computing the coefficients"); if(testIfSingular == 0) { /* The system has been correctly solved */ // Construction of the resulting polynomial for(j=1;j<=dim;j++) { mpfr_set_q(mpfr_coefficients[j-1], coefficients[j-1], GMP_RNDN); // We check that the precision is sufficient to represent exactly the coefficient if( (!mpfr_zero_p(mpfr_coefficients[j-1])) && (mpfr_get_exp(mpfr_coefficients[j-1]) > (int)mpfr_get_prec(mpfr_coefficients[j-1])) ) { mpfr_set_prec(mpfr_coefficients[j-1], mpfr_get_exp(mpfr_coefficients[j-1])); mpfr_set_q(mpfr_coefficients[j-1], coefficients[j-1], GMP_RNDN); } mpfr_neg(mpfr_coefficients[j-1], mpfr_coefficients[j-1], GMP_RNDN); mpfr_div_2si(mpfr_coefficients[j-1], mpfr_coefficients[j-1], *(int *)accessInList(formats,j-1), GMP_RNDN); } res = constructPolynomialFromArray(mpfr_coefficients, monomials_tree, dim); } else res = NULL; // Cleaning mpfr_clear(zero_mpfr); mpfr_clear(var1); mpfr_clear(var2); mpfr_clear(var3); mpfr_clear(max); for(i=1; i<=nbpoints+1; i++) { for(j=1; j<=dim+1; j++) { mpfr_clear(M[coeff(i,j,dim+1)]); mpq_clear(exactMatrix[coeff(i,j,dim+1)]); } } safeFree(M); safeFree(exactMatrix); for(j=1; j<=dim; j++) free_memory(monomials_tree[j-1]); safeFree(monomials_tree); for(i=1; i<=nbpoints; i++) mpfr_clear(x[i-1]); safeFree(x); for(j=1;j<=dim+1; j++) mpq_clear(coefficients[j-1]); safeFree(coefficients); for(i=1; i<=nbpoints+1; i++) mpq_clear(reducedVect[i-1]); safeFree(reducedVect); for(j=1; j<=dim; j++) mpfr_clear(mpfr_coefficients[j-1]); safeFree(mpfr_coefficients); mpz_clear(mpzval); return res; } sollya-6.0+ds/fpminimax.h000066400000000000000000000045671300174114700154370ustar00rootroot00000000000000/* Copyright 2008-2009 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 Contributor S. Chevillard sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef FPMINIMAX_H #define FPMINIMAX_H #include "expression.h" node *FPminimax(node *f, chain *monomials, chain *formats, chain *points, mpfr_t a, mpfr_t b, int fp, int absrel, node *consPart, node *minimax); #endif /* ifdef FPMINIMAX_H*/ sollya-6.0+ds/general.c000066400000000000000000002221251300174114700150470ustar00rootroot00000000000000/* Copyright 2007-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard and J. Benoit christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "signalhandling.h" #define _POSIX_SOURCE #define _POSIX_C_SOURCE 199309L #include #include #include #include /* fprintf, fopen, fclose, */ #include /* exit, free, mktemp */ #include #include #include #include #include #include #include "general.h" #include "plot.h" #include "expression.h" #include "remez.h" #include "infnorm.h" #include "assignment.h" #define YYPARSE_PARAM scanner #include "parser.h" #include #include #include #include #include "execute.h" #include "sollya-messaging.h" #include "bitfields.h" #include "printf.h" #include "assignment.h" #ifdef HAVE_CONFIG_H #include "config.h" #endif #if TIME_WITH_SYS_TIME #include #include #else #if HAVE_SYS_TIME_H #include #else #include #endif #endif #include "version.h" /* A constant for the global reused MPFI and MPFR variables */ #define GLOBAL_REUSED_VARS_MAX_ALLOC 2048 /* STATE OF THE TOOL */ int oldAutoPrint = 0; int oldVoidPrint = 0; int oldExternalProcedurePrint = 0; int printMode = PRINT_MODE_LEGACY; FILE *warnFile = NULL; char *variablename = NULL; bitfield suppressedMessages = NULL; mp_prec_t defaultprecision = DEFAULTPRECISION; mp_prec_t tools_precision = DEFAULTPRECISION; char *temporyDirectory = NULL; char *uniqueIdentifier = NULL; unsigned int globalSeed = 0; int defaultpoints = DEFAULTPOINTS; int taylorrecursions = DEFAULTTAYLORRECURSIONS; int dyadic = 0; int verbosity = 1; int activateMessageNumbers = 0; int canonical = 0; int fileNumber = 0; int autosimplify = 1; int timecounting = 0; chain *timeStack=NULL; int fullParentheses=0; int midpointMode = 0; int dieOnErrorMode = 0; int rationalMode = 0; int noRoundingWarnings = 0; int hopitalrecursions = DEFAULTHOPITALRECURSIONS; mpfr_t statediam; int eliminatePromptBackup; int libraryMode = 0; chain *readStack = NULL; chain *readStackTemp = NULL; chain *readStack2 = NULL; void *scanner = NULL; int promptToBePrinted = 0; int lastWasSyntaxError = 0; int lastCorrectlyExecuted = 0; int helpNotFinished = 0; int noColor = 0; node *parsedThing = NULL; node *parsedThingIntern = NULL; jmp_buf recoverEnvironment; int handlingCtrlC = 0; int lastHandledSignal = 0; int recoverEnvironmentReady = 0; int exitInsteadOfRecover = 1; int numberBacktrace = 1; int displayColor = -1; int oldMode = 0; int (*messageCallback)(sollya_msg_t, void *) = NULL; void *messageCallbackData = NULL; int lastMessageCallbackResult = 1; int lastMessageSuppressedResult = -1; chain *symbolTable = NULL; chain *declaredSymbolTable = NULL; chain *backtraceStack = NULL; int oldrlwrapcompatible = 0; FILE *inputFile = NULL; int inputFileOpened = 0; int flushOutput = 0; node *memRefChainStart = NULL; /* END OF STATE OF THE TOOL */ /* HELPER VARIABLES FOR THE LEXER/ PARSER */ char *newReadFilename = NULL; char *newReadFilenameTemp = NULL; FILE **tempFDPtr; FILE *temp_fd; char *constBuffer = NULL; char *constBuffer2 = NULL; char *tempString = NULL; char *tempString2 = NULL; node *tempNode = NULL; int tempInteger = 0; int *tempIntPtr = NULL; /* END OF HELPER VARIABLES */ /* HELPER VARIABLES FOR LEGACY MINIPARSER */ node * temp_node; mpfr_t *mpfr_temp; mpfr_t *mpfr_temp2; node *minitree; int miniparserCharactersRead; int miniparserSemicolonAtEnd; int miniparserEofReached; /* END OF HELPER VARIABLES */ /* GLOBAL VARIABLES FOR THE MEMORY ALLOCATION FUNCTIONS */ void *wrapSafeRealloc(void *ptr, size_t old_size, size_t new_size); void wrapSafeFree(void *ptr, size_t size); void *(*actualCalloc)(size_t, size_t) = calloc; void *(*actualMalloc)(size_t) = malloc; void (*actualFree)(void *) = free; void *(*actualRealloc)(void *, size_t) = realloc; void (*actualFreeWithSize)(void *, size_t) = wrapSafeFree; void *(*actualReallocWithSize)(void *, size_t, size_t) = wrapSafeRealloc; void *(*oldGMPMalloc)(size_t) = NULL; void *(*oldGMPRealloc)(void *, size_t, size_t) = NULL; void (*oldGMPFree)(void *, size_t) = NULL; void (*replacement_mp_set_memory_functions)(void *(*)(size_t), void *(*)(void *, size_t, size_t), void (*)(void *, size_t)) = NULL; void (*replacement_mp_get_memory_functions)(void *(**)(size_t), void *(**)(void *, size_t, size_t), void (**)(void *, size_t)) = NULL; /* END OF GLOBAL VARIABLES FOR THE MEMORY ALLOCATION FUNCTIONS */ /* HELPER VARIABLES THAT WE NEED TO MAINTAIN GLOBALLY USED FOR CERTAIN FUNCTIONS */ int __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_vars_used = 0; int __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x_initialized = 0; int __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y_initialized = 0; int __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp_initialized = 0; sollya_mpfi_t __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x; sollya_mpfi_t __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y; mpfr_t __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp; int __sparsePolynomialEvalMpfr_var_used = 0; int __sparsePolynomialEvalMpfr_scratch_initialized = 0; mpfr_t __sparsePolynomialEvalMpfr_scratch; int __sparsePolynomialEvalMpfi_var_used = 0; int __sparsePolynomialEvalMpfi_scratch_initialized = 0; sollya_mpfi_t __sparsePolynomialEvalMpfi_scratch; /* END OF HELPER VARIABLES THAT WE NEED TO MAINTAIN GLOBALLY USED FOR CERTAIN FUNCTIONS */ /* Globally reused MPFI and MPFR variables */ sollya_mpfi_t *globalReusedMPFIVars = NULL; unsigned int globalReusedMPFIVarsAllocated = 0; unsigned int globalReusedMPFIVarsUsed = 0; unsigned int globalReusedMPFIVarsInitialized = 0; unsigned int globalReusedMPFIVarsMaxAllocated = GLOBAL_REUSED_VARS_MAX_ALLOC; mpfr_t *globalReusedMPFRVars = NULL; unsigned int globalReusedMPFRVarsAllocated = 0; unsigned int globalReusedMPFRVarsUsed = 0; unsigned int globalReusedMPFRVarsInitialized = 0; unsigned int globalReusedMPFRVarsMaxAllocated = GLOBAL_REUSED_VARS_MAX_ALLOC; /* End of globally reused MPFI and MPFR variables */ /* A global variable to check if sollyaLibPrintmessage has ever been called. */ int sollyaLibPrintmessageCalled = 0; /* End of global variable to check if sollyaLibPrintmessage has ever been called. */ /* Variables for the prompt-passed arguments */ char **argsArgv = NULL; int argsArgc = 0; /* End of variables for the prompt-passed arguments */ /* Global variables for sollya_getc and sollya_fread */ int inside_sollya_getc = 0; int inside_sollya_fread = 0; int inside_sollya_feof = 0; int inside_sollya_ferror = 0; int inside_sollya_fwrite = 0; /* End of global variables for sollya_getc */ /* Global variable for the lexer/parser when the input stream needs to be rewound before/during/after a fork */ int parserAlreadyRunning = 0; /* End of global variable */ extern int yyparse(void *); extern void yylex_destroy(void *); extern int yylex_init(void **); extern int yylex(void *); extern void yyset_in(FILE *, void *); extern int parserCheckEof(); extern FILE *getCurrentLexerStream(); void freeGlobalReusedMPFIVars(); void freeGlobalReusedMPFRVars(); void freeTool(); void parserFlushInput() { if (!parserAlreadyRunning) return; fflush(getCurrentLexerStream()); } void readManipulate() { deferSignalHandling(); fflush(NULL); parserFlushInput(); resumeSignalHandling(); wait(NULL); deferSignalHandling(); fflush(NULL); parserFlushInput(); resumeSignalHandling(); } int sollya_gettime(sollya_time_t *t) { #if defined(HAVE_CLOCK_GETTIME) && HAVE_CLOCK_GETTIME struct timespec ts; #if !defined(__CYGWIN__) #if defined(HAVE_GETTIMEOFDAY) && HAVE_GETTIMEOFDAY struct timeval tv; #endif #endif int res; res = clock_gettime(CLOCK_MONOTONIC, &ts); t->seconds = (int64_t) (ts.tv_sec); t->nano_seconds = (int64_t) (ts.tv_nsec); if (res == 0) return 1; #if !defined(__CYGWIN__) #if defined(HAVE_GETTIMEOFDAY) && HAVE_GETTIMEOFDAY res = gettimeofday(&tv,NULL); t->seconds = (int64_t) (tv.tv_sec); t->nano_seconds = ((int64_t) (tv.tv_usec)) * ((int64_t) 1000); if (res == 0) return 1; #endif #endif #if defined(HAVE_TIME) && HAVE_TIME t->seconds = (int64_t) time(NULL); t->nano_seconds = (int64_t) 0; return 1; #else return 0; #endif #else #if defined(HAVE_GETTIMEOFDAY) && HAVE_GETTIMEOFDAY struct timeval tv; int res; res = gettimeofday(&tv,NULL); t->seconds = (int64_t) (tv.tv_sec); t->nano_seconds = ((int64_t) (tv.tv_usec)) * ((int64_t) 1000); if (res == 0) return 1; #if defined(HAVE_TIME) && HAVE_TIME t->seconds = (int64_t) time(NULL); t->nano_seconds = (int64_t) 0; return 1; #else return 0; #endif #else #if defined(HAVE_TIME) && HAVE_TIME t->seconds = (int64_t) time(NULL); t->nano_seconds = (int64_t) 0; return 1; #else return 0; #endif #endif #endif } size_t sollya_fwrite(const void *ptr, size_t size, size_t nmemb, FILE *fd) { size_t res; deferSignalHandling(); if (inside_sollya_fwrite) { sollyaFprintf(stderr,"Error: sollya_fwrite called from within sollya_fwrite. Bad things are happening.\n"); exit(1); } inside_sollya_fwrite = 1; res = fwrite(ptr, size, nmemb, fd); inside_sollya_fwrite = 0; resumeSignalHandling(); return res; } size_t sollya_fread(void *ptr, size_t size, size_t nmemb, FILE *fd) { size_t res; deferSignalHandling(); if (inside_sollya_fread) { sollyaFprintf(stderr,"Error: sollya_fread called from within sollya_fread. Bad things are happening.\n"); exit(1); } inside_sollya_fread = 1; res = fread(ptr, size, nmemb, fd); inside_sollya_fread = 0; resumeSignalHandling(); return res; } int sollya_getc(FILE *fd) { int res; deferSignalHandling(); if (inside_sollya_getc) { sollyaFprintf(stderr,"Error: sollya_getc called from within sollya_getc. Bad things are happening.\n"); exit(1); } inside_sollya_getc = 1; res = getc(fd); inside_sollya_getc = 0; resumeSignalHandling(); return res; } int sollya_feof(FILE *fd) { int res; deferSignalHandling(); if (inside_sollya_feof) { sollyaFprintf(stderr,"Error: sollya_feof called from within sollya_feof. Bad things are happening.\n"); exit(1); } inside_sollya_feof = 1; res = feof(fd); inside_sollya_feof = 0; resumeSignalHandling(); return res; } int sollya_ferror(FILE *fd) { int res; deferSignalHandling(); if (inside_sollya_ferror) { sollyaFprintf(stderr,"Error: sollya_ferror called from within sollya_ferror. Bad things are happening.\n"); exit(1); } inside_sollya_ferror = 1; res = ferror(fd); inside_sollya_ferror = 0; resumeSignalHandling(); return res; } void makeToolDie() { freeTool(); if (!eliminatePromptBackup) sollyaPrintf("\n"); if (inputFileOpened) { fclose(inputFile); inputFileOpened = 0; } exit(2); } void considerDyingOnError() { if (!dieOnErrorMode) return; printMessage(1,SOLLYA_MSG_TOOL_DIES_ON_ERROR_AS_PER_DIE_ON_ERROR_MODE,"Warning: some syntax, typing or side-effect error has occurred.\nAs the die-on-error mode is activated, the tool will be exited.\n"); makeToolDie(); } void normalMode() { if (displayColor == 0) return; displayColor = 0; if (noColor) return; if (eliminatePromptBackup) return; deferSignalHandling(); fflush(NULL); printf("\e[0m"); fflush(NULL); resumeSignalHandling(); } void redMode() { if (displayColor == 1) return; displayColor = 1; if (noColor) return; if (eliminatePromptBackup) return; deferSignalHandling(); fflush(NULL); printf("\e[0m\e[31m"); fflush(NULL); resumeSignalHandling(); } void blueMode() { if (displayColor == 2) return; displayColor = 2; if (eliminatePromptBackup) return; if (noColor) return; deferSignalHandling(); fflush(NULL); printf("\e[0m\e[34m"); fflush(NULL); resumeSignalHandling(); } void setDisplayColor(int i) { switch (i) { case 2: blueMode(); break; case 1: redMode(); break; default: normalMode(); break; } } int getDisplayColor() { return displayColor; } void saveMode() { oldMode = displayColor; } void changeToWarningMode() { saveMode(); warningMode(); } void restoreMode() { setDisplayColor(oldMode); } void blinkMode() { if (eliminatePromptBackup) return; deferSignalHandling(); fflush(NULL); printf("\e[5m"); fflush(NULL); resumeSignalHandling(); } void unblinkMode() { if (eliminatePromptBackup) return; deferSignalHandling(); fflush(NULL); printf("\e[25m"); fflush(NULL); resumeSignalHandling(); } void parseMode() { normalMode(); } void outputMode() { blueMode(); } void warningMode() { redMode(); } void *safeCalloc (size_t nmemb, size_t size) { void *ptr; size_t myNmemb, mySize; myNmemb = nmemb; if (myNmemb == 0) myNmemb = 1; mySize = size; if (mySize == 0) mySize = 1; deferSignalHandling(); ptr = actualCalloc(myNmemb,mySize); resumeSignalHandling(); if (ptr == NULL) { sollyaFprintf(stderr,"Error: calloc could not succeed. No more memory left.\n"); exit(1); } return ptr; } void *safeMalloc (size_t size) { void *ptr; size_t mySize; if (size == 0) mySize = 1; else mySize = size; deferSignalHandling(); ptr = actualMalloc(mySize); resumeSignalHandling(); if (ptr == NULL) { sollyaFprintf(stderr,"Error: malloc could not succeed. No more memory left.\n"); exit(1); } return ptr; } void *safeRealloc (void *ptr, size_t size) { void *newPtr; deferSignalHandling(); newPtr = actualRealloc(ptr,size); resumeSignalHandling(); if ((size != 0) && (newPtr == NULL)) { sollyaFprintf(stderr,"Error: realloc could not succeed. No more memory left.\n"); exit(1); } return newPtr; } void safeFree(void *ptr) { deferSignalHandling(); actualFree(ptr); resumeSignalHandling(); } /* The gmp signature for realloc is strange, we have to wrap our function */ void *wrapSafeRealloc(void *ptr, size_t old_size, size_t new_size) { UNUSED_PARAM(old_size); return (void *) safeRealloc(ptr,new_size); } /* Same for GMP's free */ void wrapSafeFree(void *ptr, size_t size) { UNUSED_PARAM(size); safeFree(ptr); } /* Cling-wrap the GMP functions again */ void *clingWrapSafeReallocWithSize(void *ptr, size_t old_size, size_t new_size) { void *newPtr; newPtr = actualReallocWithSize(ptr, old_size, new_size); if ((new_size != 0) && (newPtr == NULL)) { sollyaFprintf(stderr,"Error: realloc could not succeed. No more memory left.\n"); exit(1); } return newPtr; } void clingWrapSafeFreeWithSize(void *ptr, size_t size) { actualFreeWithSize(ptr, size); } /* Wrap the GMP mp_set_memory_functions and mp_get_memory_functions once in order to enable opportunities for different memory management. */ void sollya_mp_set_memory_functions(void *(*alloc_func_ptr) (size_t), void *(*realloc_func_ptr) (void *, size_t, size_t), void (*free_func_ptr) (void *, size_t)) { if (replacement_mp_set_memory_functions != NULL) { replacement_mp_set_memory_functions(alloc_func_ptr, realloc_func_ptr, free_func_ptr); return; } mp_set_memory_functions(alloc_func_ptr, realloc_func_ptr, free_func_ptr); } void sollya_mp_get_memory_functions(void *(**alloc_func_ptr) (size_t), void *(**realloc_func_ptr) (void *, size_t, size_t), void (**free_func_ptr) (void *, size_t)) { if (replacement_mp_get_memory_functions != NULL) { replacement_mp_get_memory_functions(alloc_func_ptr, realloc_func_ptr, free_func_ptr); return; } mp_get_memory_functions(alloc_func_ptr, realloc_func_ptr, free_func_ptr); } /* Wrap the sollya_mp_set_memory_functions function into one that not only installs the functions but also stores the old values into the global backup variables. Do nothing if the backup function pointers are not NULL (i.e. if they have already been set.) */ void wrap_mp_set_memory_functions(void *(*alloc_func_ptr) (size_t), void *(*realloc_func_ptr) (void *, size_t, size_t), void (*free_func_ptr) (void *, size_t)) { if ((oldGMPMalloc != NULL) || (oldGMPRealloc != NULL) || (oldGMPFree != NULL)) { return; } sollya_mp_get_memory_functions(&oldGMPMalloc,&oldGMPRealloc,&oldGMPFree); sollya_mp_set_memory_functions(alloc_func_ptr, realloc_func_ptr, free_func_ptr); } /* Provide memory management functions for the parsers These functions are wrappers that are currently provided to cope with special behavior of memory allocation in the future. */ void *parserCalloc(size_t nmemb, size_t size) { return safeCalloc(nmemb, size); } void *parserMalloc(size_t size) { return safeMalloc(size); } void *parserRealloc(void *ptr, size_t size) { return safeRealloc(ptr, size); } void parserFree(void *ptr) { safeFree(ptr); } /* Other legacy stuff */ char *maskString(char *src) { char *buf; char *res; char *curr1, *curr2; if (src == NULL) return NULL; buf = (char *) safeCalloc(strlen(src)*2+1,sizeof(char)); curr2 = buf; for (curr1=src;*curr1!='\0';curr1++) { switch (*curr1) { case '"': *curr2 = '\\'; curr2++; *curr2 = '"'; curr2++; break; case '\n': *curr2 = '\\'; curr2++; *curr2 = 'n'; curr2++; break; case '\t': *curr2 = '\\'; curr2++; *curr2 = 't'; curr2++; break; case '\a': *curr2 = '\\'; curr2++; *curr2 = 'a'; curr2++; break; case '\b': *curr2 = '\\'; curr2++; *curr2 = 'b'; curr2++; break; case '\f': *curr2 = '\\'; curr2++; *curr2 = 'f'; curr2++; break; case '\r': *curr2 = '\\'; curr2++; *curr2 = 'r'; curr2++; break; case '\v': *curr2 = '\\'; curr2++; *curr2 = 'v'; curr2++; break; default: *curr2 = *curr1; curr2++; break; } } res = (char *) safeCalloc(strlen(buf)+1,sizeof(char)); strcpy(res,buf); safeFree(buf); return res; } void demaskString(char *dest, char *src) { char *curr, *curr2; char internalBuf[4]; int i; for (i=0;i<4;i++) internalBuf[i] = '\0'; curr2 = dest; for (curr=src;*curr != '\0';curr++) { if (*curr != '\\') { *curr2++ = *curr; } else { curr++; if (*curr == '\0') break; switch (*curr) { case '\\': *curr2++ = '\\'; break; case '"': *curr2++ = '"'; break; case '?': *curr2++ = '?'; break; case '\'': *curr2++ = '\''; break; case 'n': *curr2++ = '\n'; break; case 't': *curr2++ = '\t'; break; case 'a': *curr2++ = '\a'; break; case 'b': *curr2++ = '\b'; break; case 'f': *curr2++ = '\f'; break; case 'r': *curr2++ = '\r'; break; case 'v': *curr2++ = '\v'; break; case 'x': curr++; i = 0; while ((i < 2) && (*curr != '\0') && (((*curr >= '0') && (*curr <= '9')) || ((*curr >= 'A') && (*curr <= 'F')) || ((*curr >= 'a') && (*curr <= 'f')))) { internalBuf[i] = *curr; curr++; i++; } curr--; for (i=0;i<2;i++) { if ((internalBuf[i] >= 'a') && (internalBuf[i] <= 'f')) { internalBuf[i] = (internalBuf[i] - 'a') + 'A'; } } *curr2++ = (char) sollya_strtol(internalBuf,NULL,16); break; default: i = 0; while ((i < 3) && (*curr != '\0') && (*curr >= '0') && (*curr <= '7')) { internalBuf[i] = *curr; curr++; i++; } curr--; *curr2++ = (char) sollya_strtol(internalBuf,NULL,8); } } } } int removeSpaces(char *outbuf, char *inbuf) { char *temp, *temp2; int removed; removed = 0; temp = inbuf; temp2 = outbuf; while ((temp != NULL) && (*temp != '\0')) { if (*temp != ' ') { *temp2 = *temp; temp2++; } else { removed = 1; } temp++; } return removed; } int removeMidpointMode(char *outbuf, char *inbuf) { char *temp, *temp2; int removed; removed = 0; temp = inbuf; temp2 = outbuf; while (*temp != '\0') { if (*temp != '~') { *temp2 = *temp; temp2++; temp++; } else { temp++; while ((*temp != '\0') && (*temp != '~')) temp++; if (*temp != '\0') temp++; removed = 1; } } return removed; } void cutMidpointStringIntoTwo(char *str1, char *str2, char *str) { char *temp1, *temp2, *temp; temp1 = str1; temp2 = str2; temp = str; while (*temp != '\0') { if (*temp != '~') { *temp1 = *temp; *temp2 = *temp; temp++; temp1++; temp2++; } else { temp++; while (*temp != '\0') { if (*temp != '/') { *temp1 = *temp; temp++; temp1++; } else { temp++; while (*temp != '\0') { if (*temp != '~') { *temp2 = *temp; temp++; temp2++; } else { temp++; break; } } break; } } } } } void newReadFileStarted() { } void carriageReturnLexed() { if (helpNotFinished) { outputMode(); sollyaPrintf("This is %s. Having typed 'help', you have got to a special prompt.\nType now a semicolon (';') for an introduction on the %s help system.\nType now 'help;' for getting a list of available commands.\nType now a command name followed by a semicolon (';') for help on this command.\n>> ",PACKAGE_NAME,PACKAGE_NAME); } if (promptToBePrinted) printPrompt(); } void newTokenLexed() { helpNotFinished = 0; promptToBePrinted = 0; lastCorrectlyExecuted = 0; } /* Precondition: fd can only be one of stdout and stderr */ int sollyaVfprintfSpecial(FILE *fd, const char *format, va_list varlist) { int res; if (printMode == PRINT_MODE_LEGACY) return sollyaInternalVfprintf(fd,format,varlist); if ((printMode == PRINT_MODE_WARNING_TO_STDERR) && (displayColor == 1)) return sollyaInternalVfprintf(stderr,format,varlist); if ((printMode == PRINT_MODE_WARNING_TO_FILE) && (displayColor == 1) && (warnFile != NULL)) { res = sollyaInternalVfprintf(warnFile,format,varlist); return res; } return sollyaInternalVfprintf(fd,format,varlist); } int sollyaVfprintf(FILE *fd, const char *format, va_list varlist) { if ((fd == stdout) || (fd == stderr)) return sollyaVfprintfSpecial(fd,format,varlist); return sollyaInternalVfprintf(fd,format,varlist); } int installMessageCallback(int (*msgHandler) (sollya_msg_t, void *), void *data) { messageCallback = msgHandler; messageCallbackData = data; lastMessageCallbackResult = 1; return 1; } void getMessageCallback(int (**fptr)(sollya_msg_t, void *), void **data) { if (fptr != NULL) { *fptr = messageCallback; } if (data != NULL) { if (messageCallback != NULL) { *data = messageCallbackData; } else { *data = NULL; } } } int uninstallMessageCallback() { messageCallback = NULL; messageCallbackData = NULL; lastMessageCallbackResult = 1; return 1; } int messageHasEnoughVerbosityAndIsNotSuppressed(int verb, int msgNum) { int suppressed; if ((verb >= 0) && (verbosity < verb)) return 0; /* Check if message suppression is activated for that message */ suppressed = 0; if ((suppressedMessages != NULL) && (verb >= 0) && (msgNum != SOLLYA_MSG_NO_MSG)) { if (msgNum != SOLLYA_MSG_CONTINUATION) { suppressed = getBitInBitfield(suppressedMessages, msgNum); } else { if (lastMessageSuppressedResult == -1) { suppressed = 0; } else { suppressed = lastMessageSuppressedResult; } } } if ((verb >= 0) && suppressed && (msgNum != SOLLYA_MSG_NO_MSG)) return 0; return 1; } int printMessageInner(int verb, int msgNum, const char *format, va_list varlist) { int oldColor; int res, suppressed; const char *myFormat; const char *tempStr; sollya_msg_decl_t myMsg; if ((verb >= 0) && (verbosity < verb)) return 0; /* Check if message suppression is activated for that message */ suppressed = 0; if ((suppressedMessages != NULL) && (verb >= 0) && (msgNum != SOLLYA_MSG_NO_MSG)) { if (msgNum != SOLLYA_MSG_CONTINUATION) { suppressed = getBitInBitfield(suppressedMessages, msgNum); } else { if (lastMessageSuppressedResult == -1) { suppressed = 0; } else { suppressed = lastMessageSuppressedResult; } } } lastMessageSuppressedResult = suppressed; if ((verb >= 0) && suppressed && (msgNum != SOLLYA_MSG_NO_MSG)) return 0; /* If there is a message callback installed, call it. If it says no message is to be displayed, just bail out. Do not call the message callback handler for no messages and continuation messages. In the case of a continuation message, take the last "display/don't display" value instead of what the handler would return. */ if ((msgNum != SOLLYA_MSG_CONTINUATION) || (messageCallback == NULL)) lastMessageCallbackResult = 1; if ((msgNum != SOLLYA_MSG_NO_MSG) && (msgNum != SOLLYA_MSG_CONTINUATION) && (messageCallback != NULL)) { myMsg.msg_id = msgNum; lastMessageCallbackResult = messageCallback(&myMsg, messageCallbackData); } if (!lastMessageCallbackResult) return 0; oldColor = displayColor; if ((verb >= 1) || (verb < 0)) warningMode(); else outputMode(); if (activateMessageNumbers && (msgNum != SOLLYA_MSG_CONTINUATION) && (msgNum != SOLLYA_MSG_NO_MSG)) { myFormat = format; res = 0; if (((tempStr = sollya_strstr(format,"Warning")) != NULL) && (tempStr == format)) { if (verb >= 0) { res += sollyaFprintf(stdout,"Warning (%d)",msgNum); } else { res += sollyaFprintf(stderr,"Warning (%d)",msgNum); } myFormat = tempStr + strlen("Warning"); } else { if (((tempStr = sollya_strstr(format,"Error")) != NULL) && (tempStr == format)) { if (verb >= 0) { res += sollyaFprintf(stdout,"Error (%d)",msgNum); } else { res += sollyaFprintf(stderr,"Error (%d)",msgNum); } myFormat = tempStr + strlen("Error"); } else { if (((tempStr = sollya_strstr(format,"Information")) != NULL) && (tempStr == format)) { if (verb >= 0) { res += sollyaFprintf(stdout,"Information (%d)",msgNum); } else { res += sollyaFprintf(stderr,"Information (%d)",msgNum); } myFormat = tempStr + strlen("Information"); } else { if (verb >= 0) { res += sollyaFprintf(stdout,"Message (%d): ",msgNum); } else { res += sollyaFprintf(stderr,"Message (%d): ",msgNum); } } } } if (verb >= 0) { res += sollyaVfprintf(stdout,myFormat,varlist); } else { res += sollyaVfprintf(stderr,myFormat,varlist); } } else { if (verb >= 0) { res = sollyaVfprintf(stdout,format,varlist); } else { res = sollyaVfprintf(stderr,format,varlist); } } setDisplayColor(oldColor); return res; } int printMessage(int verb, int msgNum, const char *format, ...) { int res; va_list varlist; va_start(varlist,format); res = printMessageInner(verb, msgNum, format, varlist); va_end(varlist); return res; } int sollyaLibPrintmessage(int verb, int cont, const char *format, ...) { va_list varlist; int res; va_start(varlist,format); if (cont) { if (sollyaLibPrintmessageCalled) { sollyaLibPrintmessageCalled = 1; res = printMessageInner(verb, SOLLYA_MSG_CONTINUATION, format, varlist); } else { sollyaLibPrintmessageCalled = 1; res = printMessageInner(verb, SOLLYA_MSG_GENERIC_SOLLYA_LIBRARY_MSG, format, varlist); } } else { sollyaLibPrintmessageCalled = 1; res = printMessageInner(verb, SOLLYA_MSG_GENERIC_SOLLYA_LIBRARY_MSG, format, varlist); } va_end(varlist); return res; } int sollyaPrintf(const char *format, ...) { va_list varlist; int res; va_start(varlist,format); res = sollyaVfprintf(stdout,format,varlist); va_end(varlist); return res; } int sollyaFprintf(FILE *fd, const char *format, ...) { va_list varlist; int res; va_start(varlist,format); res = sollyaVfprintf(fd,format,varlist); va_end(varlist); return res; } /* Returns a string representing x written in binary, such that it can be read back by mpfr_set_str. x must be a valid number. If x is an Inf or NaN, NULL is returned. Note: the string must be freed afterwards, of course. */ char *mpfr_to_binary_str(mpfr_t x) { char *s; char *ptr; mp_exp_t e; mp_prec_t prec = mpfr_get_prec(x); if (!mpfr_number_p(x)) return NULL; if (mpfr_zero_p(x)) { s = calloc(5, sizeof(char)); s[0] = '0'; s[1] = 'p'; s[2] = '+'; s[3] = '0'; return s; } /* The documentation of mpfr_get_str explains that it needs max ( mpfr_get_prec(x)+2, 7 ). This is achieved by mpfr_get_prec(x)+7. We must add 4 chars for "0." and "p+". Finally, 20 extra bits are sufficient to write a 64-bit exponent in base 10 */ s = (char *)calloc(prec+7+4+20, sizeof(char)); mpfr_get_str(s+2, &e, 2, 0, x, GMP_RNDN); if ( s[2] == '-' ) { s[0] = '-'; ptr = s+1; } else ptr = s; ptr[0] = '0'; ptr[1] = '.'; ptr[prec+2] = 'p'; if (e>=0) { ptr[prec+3] = '+'; ptr = ptr + prec + 4; } else ptr = ptr + prec + 3; sollya_snprintf(ptr, prec+7+4+20, "%ld", (long)e); return s; } void freeCounter(void) { freeChain(timeStack, safeFree); timeStack=NULL; return; } void pushTimeCounter(void) { sollya_time_t *buf; if(timecounting==1) { buf = safeMalloc(sizeof(sollya_time_t)); if(!sollya_gettime(buf)) sollyaFprintf(stderr, "Error: unable to use the timer. Measures may be untrustable\n"); timeStack = addElement(timeStack, buf); } return; } void popTimeCounter(char *s) { sollya_time_t *buf_init; sollya_time_t *buf_final; long long int days, hours, minutes, seconds, milliseconds, nanoseconds; chain *prev; if((timecounting==1)&&(timeStack!=NULL)) { buf_final = safeMalloc(sizeof(sollya_time_t)); if(!sollya_gettime(buf_final)) sollyaFprintf(stderr, "Error: unable to use the timer. Measures may be untrustable\n"); buf_init = timeStack->value; seconds = (long long int)(buf_final->seconds) - (long long int)(buf_init->seconds); nanoseconds = (long long int)(buf_final->nano_seconds) - (long long int)(buf_init->nano_seconds); if (nanoseconds < 0) { nanoseconds += 1000000000ll; seconds--; } milliseconds = nanoseconds / 1000000ll; if((milliseconds>0)||(seconds>0)) { changeToWarningMode(); sollyaPrintf("Information: %s spent ", s); if(seconds!=0) { minutes = seconds / 60; seconds = seconds % 60; hours = minutes / 60; minutes = minutes % 60; days = hours / 24; hours = hours % 24; if(days!=0) sollyaPrintf("%ld days, ", days); if(hours!=0) sollyaPrintf("%ld hours, ", hours); if(minutes!=0) sollyaPrintf("%ld minutes, ", minutes); if(seconds!=0) sollyaPrintf("%ld seconds, ", seconds); } sollyaPrintf("%ld ms\n", milliseconds); restoreMode(); } prev = timeStack; timeStack = timeStack->next; safeFree(prev); safeFree(buf_init); safeFree(buf_final); } return; } void printPrompt(void) { if (eliminatePromptBackup) return; if (readStack != NULL) return; parseMode(); if (oldrlwrapcompatible && (!noColor)) { deferSignalHandling(); printf("\e[1A\n"); fflush(NULL); resumeSignalHandling(); } sollyaPrintf("> "); } void freeFunctionSpecialVariables() { __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_vars_used = 0; if (__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x_initialized) { sollya_mpfi_clear(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x); __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x_initialized = 0; } if (__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y_initialized) { sollya_mpfi_clear(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y); __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y_initialized = 0; } if (__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp_initialized) { mpfr_clear(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp); __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp_initialized = 0; } __sparsePolynomialEvalMpfr_var_used = 0; if (__sparsePolynomialEvalMpfr_scratch_initialized) { mpfr_clear(__sparsePolynomialEvalMpfr_scratch); __sparsePolynomialEvalMpfr_scratch_initialized = 0; } __sparsePolynomialEvalMpfi_var_used = 0; if (__sparsePolynomialEvalMpfi_scratch_initialized) { sollya_mpfi_clear(__sparsePolynomialEvalMpfi_scratch); __sparsePolynomialEvalMpfi_scratch_initialized = 0; } } void freeTool() { if(variablename != NULL) safeFree(variablename); if(newReadFilename != NULL) safeFree(newReadFilename); if(suppressedMessages != NULL) freeBitfield(suppressedMessages); if (!(eliminatePromptBackup == 1)) { removePlotFiles(); } while ((readStack != NULL) && (readStack2 != NULL)) { temp_fd = *((FILE **) (readStack2->value)); fclose(temp_fd); safeFree(readStack2->value); readStackTemp = readStack2->next; safeFree(readStack2); readStack2 = readStackTemp; safeFree(readStack->value); readStackTemp = readStack->next; safeFree(readStack); readStack = readStackTemp; } parserAlreadyRunning = 0; yylex_destroy(scanner); freeFunctionLibraries(); freeConstantLibraries(); freeProcLibraries(); freeCounter(); freeSymbolTable(symbolTable, freeThingOnVoid); symbolTable = NULL; freeDeclaredSymbolTable(declaredSymbolTable, freeThingOnVoid); freeBacktraceStack(); freeFunctionSpecialVariables(); freeGlobalReusedMPFIVars(); freeGlobalReusedMPFRVars(); polynomialFreeCaches(); declaredSymbolTable = NULL; backtraceStack = NULL; mpfr_clear(statediam); safeFree(temporyDirectory); temporyDirectory = NULL; safeFree(uniqueIdentifier); uniqueIdentifier = NULL; mpfr_free_cache(); normalMode(); } void initToolDefaults() { int k; node *tempNode; chain *tempList; char *pidStr, *uniqueStr; unsigned int mySeed; char *c; if(variablename != NULL) safeFree(variablename); variablename = NULL; if(suppressedMessages != NULL) freeBitfield(suppressedMessages); suppressedMessages = NULL; defaultprecision = DEFAULTPRECISION; tools_precision = DEFAULTPRECISION; defaultpoints = DEFAULTPOINTS; taylorrecursions = DEFAULTTAYLORRECURSIONS; memRefChainStart = NULL; dyadic = 0; verbosity = 1; activateMessageNumbers = 0; canonical = 0; fileNumber = 0; autosimplify = 1; rationalMode = 0; timecounting = 0; if (timeStack != NULL) freeCounter(); timeStack=NULL; fullParentheses=0; midpointMode = 0; noRoundingWarnings = eliminatePromptBackup; hopitalrecursions = DEFAULTHOPITALRECURSIONS; symbolTable = NULL; declaredSymbolTable = NULL; backtraceStack = NULL; mpfr_init2(statediam,10); mpfr_set_d(statediam,DEFAULTDIAM,GMP_RNDN); __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_vars_used = 0; __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x_initialized = 0; __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y_initialized = 0; __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp_initialized = 0; __sparsePolynomialEvalMpfr_var_used = 0; __sparsePolynomialEvalMpfr_scratch_initialized = 0; __sparsePolynomialEvalMpfi_var_used = 0; __sparsePolynomialEvalMpfi_scratch_initialized = 0; globalReusedMPFIVars = NULL; globalReusedMPFIVarsAllocated = 0; globalReusedMPFIVarsUsed = 0; globalReusedMPFIVarsInitialized = 0; globalReusedMPFIVarsMaxAllocated = GLOBAL_REUSED_VARS_MAX_ALLOC; globalReusedMPFRVars = NULL; globalReusedMPFRVarsAllocated = 0; globalReusedMPFRVarsUsed = 0; globalReusedMPFRVarsInitialized = 0; globalReusedMPFRVarsMaxAllocated = GLOBAL_REUSED_VARS_MAX_ALLOC; polynomialInitializeCaches(); sollyaLibPrintmessageCalled = 0; if ((argsArgc < 1) || (argsArgv == NULL)) { tempNode = makeEmptyList(); } else { tempList = NULL; for (k=argsArgc-1;k>=0;k--) { tempList = addElement(tempList, makeString(argsArgv[k])); } tempNode = makeList(tempList); } tempNode = addMemRef(tempNode); symbolTable = addEntry(symbolTable, "__argv", tempNode, copyThingOnVoid); freeThing(tempNode); pidStr = getUniqueId(); uniqueStr = (char *) safeCalloc(4 + strlen(PACKAGE_STRING) + 1 + strlen(pidStr) + 1 + 8 * sizeof(int) + 1, sizeof(char)); mySeed = (unsigned int) ((unsigned int) time(NULL)) + ((unsigned int) globalSeed); srand(mySeed); globalSeed = rand(); sollya_snprintf(uniqueStr, 4 + strlen(PACKAGE_STRING) + 1 + strlen(pidStr) + 1 + 8 * sizeof(int) + 1, "_id_%s_%s_%08d", PACKAGE_STRING, pidStr, (mySeed = rand())); for (c=uniqueStr;*c!='\0';c++) { if ((*c == ' ') || (*c == '\t') || (*c == '\n') || (*c == '.') || (*c == '/')) { *c = '_'; } } for (c=uniqueStr;*c!='\0';c++) { if (!((('A' <= *c) && (*c <= 'Z')) || (('a' <= *c) && (*c <= 'z')) || (('0' <= *c) && (*c <= '9')) || (*c == '_'))) { *c = '_'; } } tempNode = makeString(uniqueStr); symbolTable = addEntry(symbolTable, "__unique_id", tempNode, copyThingOnVoid); freeThing(tempNode); safeFree(uniqueStr); parseMode(); } void restartTool() { mpfr_clear(statediam); freeSymbolTable(symbolTable, freeThingOnVoid); symbolTable = NULL; freeDeclaredSymbolTable(declaredSymbolTable, freeThingOnVoid); freeBacktraceStack(); freeFunctionSpecialVariables(); freeGlobalReusedMPFIVars(); freeGlobalReusedMPFRVars(); polynomialFreeCaches(); declaredSymbolTable = NULL; backtraceStack = NULL; freeFunctionLibraries(); freeConstantLibraries(); freeProcLibraries(); mpfr_free_cache(); initToolDefaults(); parseMode(); } char *getNameOfVariable() { char *str; if (variablename == NULL) return NULL; str = (char *) safeCalloc(strlen(variablename)+1,sizeof(char)); strcpy(str,variablename); return str; } int setNameOfVariable(char *str) { if (variablename != NULL) return 0; variablename = (char *) safeCalloc(strlen(str)+1,sizeof(char)); strcpy(variablename,str); return 1; } char *initTempDir() { char *res; char *staticRes; size_t len; staticRes = getenv("TMPDIR"); if ((staticRes != NULL) && ((len = strlen(staticRes)) != 0)) { res = safeCalloc(len + 1, sizeof(char)); strcpy(res, staticRes); } else { staticRes = getenv("%TEMP%"); if ((staticRes != NULL) && ((len = strlen(staticRes)) != 0)) { res = safeCalloc(len + 1, sizeof(char)); strcpy(res, staticRes); } else { staticRes = getenv("%TMP%"); if ((staticRes != NULL) && ((len = strlen(staticRes)) != 0)) { res = safeCalloc(len + 1, sizeof(char)); strcpy(res, staticRes); } else { staticRes = "/tmp"; len = strlen(staticRes); res = safeCalloc(len + 1, sizeof(char)); strcpy(res, staticRes); } } } return res; } char *initUniqueId() { char *res, *str; pid_t pid; size_t size; size = 8 * sizeof(signed long long int) + 10; pid = getpid(); str = safeCalloc(size + 1, sizeof(char)); sollya_snprintf(str, size, "%lld", (signed long long int) pid); res = safeCalloc(strlen(str) + 1, sizeof(char)); strcpy(res, str); safeFree(str); return res; } char *getTempDir() { if (temporyDirectory == NULL) { temporyDirectory = initTempDir(); } return temporyDirectory; } char *getUniqueId() { if (uniqueIdentifier == NULL) { uniqueIdentifier = initUniqueId(); } return uniqueIdentifier; } mp_prec_t getToolPrecision() { return tools_precision; } void setToolPrecision(mp_prec_t prec) { tools_precision = prec; defaultprecision = prec; } int getToolPoints() { return defaultpoints; } void setToolPoints(int p) { if (p < 12) defaultpoints = 12; else defaultpoints = p; } int getToolTaylorRecursions() { return taylorrecursions; } void setToolTaylorRecursions(int i) { if (i < 0) taylorrecursions = 0; else taylorrecursions = i; } int getToolHopitalRecursions() { return hopitalrecursions; } void setToolHopitalRecursions(int i) { if (i < 0) hopitalrecursions = 0; else hopitalrecursions = i; } int getToolDiameter(mpfr_t rop) { return mpfr_set(rop,statediam,GMP_RNDN); } void setToolDiameter(mpfr_t op) { mpfr_set_prec(statediam,mpfr_get_prec(op)); mpfr_set(statediam,op,GMP_RNDN); } int getDisplayMode() { return dyadic; } int setDisplayMode(int newMode) { if ((0 <= newMode) && (newMode <= 4)) { dyadic = newMode; return 1; } else { dyadic = 0; return 0; } } int getVerbosity() { return verbosity; } int setVerbosity(int newVerbosity) { if (newVerbosity >= 0) { verbosity = newVerbosity; return 1; } else { verbosity = 0; return 0; } } int getCanonical() { return canonical; } void setCanonical(int newCanonical) { canonical = (!(!newCanonical)); } int getAutosimplify() { return autosimplify; } void setAutosimplify(int newAutosimplify) { autosimplify = (!(!newAutosimplify)); } int getFullParentheses() { return fullParentheses; } void setFullParentheses(int newFullParentheses) { fullParentheses = (!(!newFullParentheses)); } int getMidpointMode() { return midpointMode; } void setMidpointMode(int newMidpointMode) { midpointMode = (!(!newMidpointMode)); } int getDieOnErrorMode() { return dieOnErrorMode; } void setDieOnErrorMode(int newDieOnErrorMode) { dieOnErrorMode = (!(!newDieOnErrorMode)); } int getTimecounting() { return timecounting; } void setTimecounting(int newTimecounting) { timecounting = (!(!newTimecounting)); } int getRoundingWarnings() { return (!noRoundingWarnings); } void setRoundingWarnings(int newRoundingWarnings) { noRoundingWarnings = (!newRoundingWarnings); } int getRationalMode() { return rationalMode; } void setRationalMode(int newRationalMode) { rationalMode = (!(!newRationalMode)); } void setRecoverEnvironment(jmp_buf *env) { sollya_memmove(&recoverEnvironment,env,sizeof(recoverEnvironment)); exitInsteadOfRecover = 0; } void invalidateRecoverEnvironment() { exitInsteadOfRecover = 1; } int initializeLibraryMode(void *(*myActualMalloc)(size_t), void *(*myActualCalloc)(size_t, size_t), void *(*myActualRealloc)(void *, size_t), void (*myActualFree)(void*), void *(*myActualReallocWithSize)(void *, size_t, size_t), void (*myActualFreeWithSize)(void *, size_t), int argc, char **argv, void (*my_mp_set_func)(void *(*)(size_t), void *(*)(void *, size_t, size_t), void (*)(void *, size_t)), void (*my_mp_get_func)(void *(**)(size_t), void *(**)(void *, size_t, size_t), void (**)(void *, size_t))) { void *ptr; int k, allArgsOkay; libraryMode = 1; oldGMPMalloc = NULL; oldGMPRealloc = NULL; oldGMPFree = NULL; replacement_mp_set_memory_functions = NULL; replacement_mp_get_memory_functions = NULL; actualCalloc = calloc; actualMalloc = malloc; actualFree = free; actualRealloc = realloc; actualFreeWithSize = wrapSafeFree; actualReallocWithSize = wrapSafeRealloc; if (my_mp_set_func != NULL) replacement_mp_set_memory_functions = my_mp_set_func; if (my_mp_get_func != NULL) replacement_mp_get_memory_functions = my_mp_get_func; if (myActualMalloc != NULL) actualMalloc = myActualMalloc; if (myActualCalloc != NULL) actualCalloc = myActualCalloc; if (myActualRealloc != NULL) actualRealloc = myActualRealloc; if (myActualFree != NULL) actualFree = myActualFree; if (myActualReallocWithSize != NULL) actualReallocWithSize = myActualReallocWithSize; if (myActualFreeWithSize != NULL) actualFreeWithSize = myActualFreeWithSize; messageCallback = NULL; lastMessageCallbackResult = 1; lastMessageSuppressedResult = -1; inputFileOpened = 0; flushOutput = 0; oldAutoPrint = 0; oldExternalProcedurePrint = 0; printMode = PRINT_MODE_LEGACY; warnFile = NULL; eliminatePromptBackup = 1; wrap_mp_set_memory_functions(safeMalloc,clingWrapSafeReallocWithSize,clingWrapSafeFreeWithSize); if ((argc >= 1) && (argv != NULL)) { for (k=0,allArgsOkay = 1;(kvalue)); fclose(temp_fd); safeFree(readStack2->value); readStackTemp = readStack2->next; safeFree(readStack2); readStack2 = readStackTemp; safeFree(readStack->value); readStackTemp = readStack->next; safeFree(readStack); readStack = readStackTemp; } freeFunctionLibraries(); freeConstantLibraries(); freeProcLibraries(); freeCounter(); freeSymbolTable(symbolTable, freeThingOnVoid); symbolTable = NULL; freeDeclaredSymbolTable(declaredSymbolTable, freeThingOnVoid); freeBacktraceStack(); freeFunctionSpecialVariables(); freeGlobalReusedMPFIVars(); freeGlobalReusedMPFRVars(); polynomialFreeCaches(); declaredSymbolTable = NULL; backtraceStack = NULL; mpfr_clear(statediam); safeFree(temporyDirectory); temporyDirectory = NULL; safeFree(uniqueIdentifier); uniqueIdentifier = NULL; mpfr_free_cache(); uninstallMessageCallback(); sollya_mp_set_memory_functions(oldGMPMalloc,oldGMPRealloc,oldGMPFree); actualCalloc = calloc; actualMalloc = malloc; actualFree = free; actualRealloc = realloc; actualFreeWithSize = wrapSafeFree; actualReallocWithSize = wrapSafeRealloc; replacement_mp_set_memory_functions = NULL; replacement_mp_get_memory_functions = NULL; oldGMPMalloc = NULL; oldGMPRealloc = NULL; oldGMPFree = NULL; libraryMode = 0; return 1; } double sollya_mpfr_get_d(mpfr_t op, mpfr_rnd_t rnd) { union { uint64_t i; double d; } xdb; /* Handle NaNs on our own */ if (mpfr_nan_p(op)) { xdb.i = 0x7ff800007ff80000ull; return xdb.d; } return mpfr_get_d(op, rnd); } void allocateReusedGlobalMPFIVars() { if (globalReusedMPFIVars != NULL) return; if (globalReusedMPFIVarsAllocated != 0) return; globalReusedMPFIVars = (sollya_mpfi_t *) safeCalloc(globalReusedMPFIVarsMaxAllocated, sizeof(sollya_mpfi_t)); globalReusedMPFIVarsAllocated = globalReusedMPFIVarsMaxAllocated; globalReusedMPFIVarsUsed = 0; globalReusedMPFIVarsInitialized = 0; } void allocateReusedGlobalMPFRVars() { if (globalReusedMPFRVars != NULL) return; if (globalReusedMPFRVarsAllocated != 0) return; globalReusedMPFRVars = (mpfr_t *) safeCalloc(globalReusedMPFRVarsMaxAllocated, sizeof(mpfr_t)); globalReusedMPFRVarsAllocated = globalReusedMPFRVarsMaxAllocated; globalReusedMPFRVarsUsed = 0; globalReusedMPFRVarsInitialized = 0; } sollya_mpfi_t *getReusedGlobalMPFIVars(unsigned int n, mp_prec_t prec) { sollya_mpfi_t *ptr; unsigned int i; if (n == 0) return NULL; if ((globalReusedMPFIVars == NULL) || (globalReusedMPFIVarsAllocated == 0)) allocateReusedGlobalMPFIVars(); if ((globalReusedMPFIVarsAllocated - globalReusedMPFIVarsUsed) < n) return NULL; ptr = &(globalReusedMPFIVars[globalReusedMPFIVarsUsed]); globalReusedMPFIVarsUsed += n; for (i=globalReusedMPFIVarsInitialized;i globalReusedMPFIVarsInitialized) { globalReusedMPFIVarsInitialized = globalReusedMPFIVarsUsed; } for (i=0;i globalReusedMPFRVarsInitialized) { globalReusedMPFRVarsInitialized = globalReusedMPFRVarsUsed; } for (i=0;i globalReusedMPFIVarsUsed) { globalReusedMPFIVarsUsed = 0; } else { globalReusedMPFIVarsUsed -= n; } } void returnReusedGlobalMPFRVars(unsigned int n) { if (n == 0) return; if (n > globalReusedMPFRVarsUsed) { globalReusedMPFRVarsUsed = 0; } else { globalReusedMPFRVarsUsed -= n; } } void freeGlobalReusedMPFIVars() { unsigned int i; if (globalReusedMPFIVars == NULL) return; if (globalReusedMPFIVarsAllocated == 0) return; for (i=0;i=s;curr--) { if (*curr == b) return curr; } return NULL; } static inline int __sollya_strtol_impl_aux(uint64_t *v, char c, int b) { uint64_t t; if (b < 2) return 0; if (b > 36) return 0; if ((c >= '0') && (c <= '9')) { t = (uint64_t) (c - '0'); if (t >= ((uint64_t) b)) return 0; *v = t; return 1; } if ((c >= 'A') && (c <= 'Z')) { t = ((uint64_t) (c - 'A')) + ((uint64_t) 10); if (t >= ((uint64_t) b)) return 0; *v = t; return 1; } if ((c >= 'a') && (c <= 'z')) { t = ((uint64_t) (c - 'z')) + ((uint64_t) 10); if (t >= ((uint64_t) b)) return 0; *v = t; return 1; } return 0; } long int sollya_strtol_impl(const char *nptr, char **endptr, int base) { int b; char *curr; int sign; uint64_t v, c; long int value; b = base; sign = 1; for (curr = ((char *) nptr);*curr!='\0';curr++) { if (!((*curr == ' ') || (*curr == '\f') || (*curr == '\n') || (*curr == '\r') || (*curr == '\t') || (*curr == '\v'))) break; } if (*curr == '+') { curr++; } else { if (*curr == '-') { sign = -1; curr++; } } if (base == 0) { if ((*curr == '0') && (*(curr + 1) == 'x')) { b = 16; curr += 2; } else { if (*curr == '0') { b = 8; curr++; } else { b = 10; } } } else { if (base == 16) { if ((*curr == '0') && (*(curr + 1) == 'x')) { curr += 2; } } } if ((b < 2) || (b > 36)) { if (endptr != NULL) { *endptr = curr; } return 0; } v = (uint64_t) 0; value = (long int) 0; for (;*curr!='\0';curr++) { if (!__sollya_strtol_impl_aux(&c, *curr, b)) break; v = v * ((uint64_t) b) + c; if (sign > 0) { if (v > ((uint64_t) LONG_MAX)) { value = LONG_MAX; break; } else { value = (long int) v; } } else { if (v > (((uint64_t) (-(LONG_MIN + ((long int) 16)))) + ((uint64_t) 16))) { value = LONG_MIN; break; } else { value = (long int) v; } } } if (endptr != NULL) { *endptr = curr; } return value; } #define __SOLLYA_DUP2_IMPL_BUF_SIZE 512 /* This is a lazy reimplementation of dup2 that will not work all the time */ int sollya_dup2_impl(int oldfd, int newfd) { int extraFDs[__SOLLYA_DUP2_IMPL_BUF_SIZE]; int extraFDsCount; int tmp; int i; int gotIt; int closingExtraOkay; /* Handle stupid input */ if (oldfd == newfd) return newfd; /* Initialize index extraFDsCount of extra file descriptors */ extraFDsCount = 0; /* Get a copy of oldfd, to see if it is a valid file descriptor */ tmp = dup(oldfd); if (tmp == -1) { /* The oldfd file descriptor does not seem to be valid */ return -1; } extraFDs[extraFDsCount] = tmp; extraFDsCount++; /* Try to get a copy of the newfd file descriptor. Hence we can handle closing errors on newfd. The call may fail, which is not necessarily an issue as the newfd file descriptor may also not be open. */ tmp = dup(newfd); if (tmp != -1) { extraFDs[extraFDsCount] = tmp; extraFDsCount++; } /* Close the newfd file descriptor. The call may fail, which is not necessarily an issue as the newfd file descriptor may also not be open. */ close(newfd); /* Try several times to get the right newfd copy of oldfd. */ gotIt = 0; for (i=0;i<__SOLLYA_DUP2_IMPL_BUF_SIZE-2;i++) { tmp = dup(oldfd); if (tmp != -1) { if (tmp == newfd) { gotIt = 1; break; } else { extraFDs[extraFDsCount] = tmp; extraFDsCount++; } } } /* Close the extra file descriptors */ closingExtraOkay = 1; for (i=0;i 1) { for (k=0;k print warning messages into a file instead on the standard output\n"); sollyaPrintf(" --warnonstderr print warning messages on error output instead on the standard output\n"); sollyaPrintf("\nFor help on %s commands type \"help;\" on the %s prompt.\n",PACKAGE_NAME,PACKAGE_NAME); sollyaPrintf("A complete documentation on %s is available on the %s website .\n",PACKAGE_NAME,PACKAGE_NAME); sollyaPrintf("\nReport bugs to <%s>\n",PACKAGE_BUGREPORT); } else { /* argv[i] is "--version" */ if (!printBanner) sollyaPrintf("%s\n\n",PACKAGE_STRING); /* For help2man to recognize the name of the tool */ sollyaPrintf(VERSION_COPYRIGHT_TEXT); if (printBuiltInfo) { sollyaPrintf("\nSend bug reports to <%s>\n\n", PACKAGE_BUGREPORT); sollyaPrintf("This build of %s is based on GMP %s, MPFR %s and MPFI %s.\n",PACKAGE_STRING,gmp_version,mpfr_get_version(),sollya_mpfi_get_version()); #if defined(HAVE_FPLLL_VERSION_STRING) sollyaPrintf("It uses FPLLL as: \"%s\"\n",HAVE_FPLLL_VERSION_STRING); #endif } sollyaPrintf("\n"); } return 1; } else if (strcmp(argv[i],"--args") == 0) argsArgRead = 1; else if (strcmp(argv[i],"--nocolor") == 0) noColor = 1; else if (strcmp(argv[i],"--noprompt") == 0) eliminatePromptBackup = 1; else if (strcmp(argv[i],"--oldrlwrapcompatible") == 0) oldrlwrapcompatible = 1; else if (strcmp(argv[i],"--flush") == 0) flushOutput = 1; else if (strcmp(argv[i],"--oldautoprint") == 0) oldAutoPrint = 1; else if (strcmp(argv[i],"--oldexternalprocprint") == 0) oldExternalProcedurePrint = 1; else if (strcmp(argv[i],"--warnonstderr") == 0) { if (printMode != PRINT_MODE_WARNING_TO_FILE) { printMode = PRINT_MODE_WARNING_TO_STDERR; } else { sollyaPrintf("Error: only one of the --warnonstderr or --warninfile options can be given.\n"); return 1; } } else if ((strcmp(argv[i],"--warninfile") == 0) || (strcmp(argv[i],"--warninfileappend") == 0)){ if (printMode != PRINT_MODE_WARNING_TO_STDERR) { if (i+1 1) { for (k=0;k #include "expression.h" #include "chain.h" #include "library.h" #include #include #include #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "sollya-messaging.h" #include "bitfields.h" #define DEFAULTPOINTS 501 #define DEFAULTPRECISION 165 #define DEFAULTDIAM 1e-4 #define DEFAULTDIAM2 2e-3 #define DEFAULTTAYLORRECURSIONS 0 #define DEFAULTHOPITALRECURSIONS 2 #define MAXHORNERTREESIZE 5000 #define MAXHORNERDEGREE 5000 #define MAXAUTOSIMPLSIZE 5500 #define CHEAPSIMPLIFYSIZE 4000 #define PARIMEMSIZE 300000000 #define UNUSED_PARAM(_unused_param_x) ((void)(_unused_param_x)) #define PRINT_MODE_LEGACY 0 #define PRINT_MODE_WARNING_TO_STDERR 1 #define PRINT_MODE_WARNING_TO_FILE 2 extern int oldAutoPrint; extern int oldVoidPrint; extern int oldExternalProcedurePrint; extern int printMode; extern FILE *warnFile; extern char *variablename; extern bitfield suppressedMessages; extern mp_prec_t defaultprecision; extern mp_prec_t tools_precision; extern int defaultpoints; extern int taylorrecursions; extern int dyadic; extern int verbosity; extern int activateMessageNumbers; extern int canonical; extern int fileNumber; extern int autosimplify; extern int timecounting; extern chain *timeStack; extern int fullParentheses; extern int midpointMode; extern int dieOnErrorMode; extern int rationalMode; extern int noRoundingWarnings; extern int hopitalrecursions; extern int eliminatePromptBackup; extern int libraryMode; extern chain *readStack; extern chain *readStackTemp; extern chain *readStack2; extern void *scanner; extern char *newReadFilename; extern char *newReadFilenameTemp; extern FILE **tempFDPtr; extern FILE *temp_fd; extern node *temp_node; extern mpfr_t *mpfr_temp; extern mpfr_t *mpfr_temp2; extern node *minitree; extern int miniparserCharactersRead; extern int miniparserSemicolonAtEnd; extern int miniparserEofReached; extern char *constBuffer; extern char *constBuffer2; extern node* parsedThing; extern int promptToBePrinted; extern int lastWasSyntaxError; extern int lastCorrectlyExecuted; extern int helpNotFinished; extern char *tempString; extern char *tempString2; extern node *tempNode; extern int tempInteger; extern chain *symbolTable; extern chain *declaredSymbolTable; extern chain *backtraceStack; extern mpfr_t statediam; extern node *parsedThingIntern; extern int *tempIntPtr; extern FILE *inputFile; extern int inputFileOpened; extern int flushOutput; extern node *memRefChainStart; extern void *rpl_malloc(size_t n); extern void *rpl_realloc(void *, size_t n); extern int __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_vars_used; extern int __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x_initialized; extern int __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y_initialized; extern int __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp_initialized; extern sollya_mpfi_t __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x; extern sollya_mpfi_t __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y; extern mpfr_t __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp; extern int __sparsePolynomialEvalMpfr_var_used; extern int __sparsePolynomialEvalMpfr_scratch_initialized; extern mpfr_t __sparsePolynomialEvalMpfr_scratch; extern int __sparsePolynomialEvalMpfi_var_used; extern int __sparsePolynomialEvalMpfi_scratch_initialized; extern sollya_mpfi_t __sparsePolynomialEvalMpfi_scratch; struct __sollya_time_struct_t { int64_t seconds; int64_t nano_seconds; }; typedef struct __sollya_time_struct_t sollya_time_t; void printPrompt(void); void recoverFromError(void); void demaskString(char*, char*); char *maskString(char *); void *safeCalloc (size_t nmemb, size_t size); void *safeMalloc (size_t size); void *safeRealloc (void *ptr, size_t size); void safeFree(void *ptr); int printMessage(int verb, int msgNum, const char *format, ...); int messageHasEnoughVerbosityAndIsNotSuppressed(int verb, int msgNum); int sollyaVfprintf(FILE *fd, const char *format, va_list varlist); int sollyaPrintf(const char *format, ...); int sollyaFprintf(FILE *fd, const char *format, ...); char *mpfr_to_binary_str(mpfr_t x); int removeSpaces(char *outbuf, char *inbuf); int removeMidpointMode(char *outbuf, char *inbuf); void cutMidpointStringIntoTwo(char *str1, char *str2, char *str); void freeCounter(void); void pushTimeCounter(void); void popTimeCounter(char *s); void newReadFileStarted(); void carriageReturnLexed(); void newTokenLexed(); void considerDyingOnError(); void restartTool(); void normalMode(); void redMode(); void blueMode(); void blinkMode(); void unblinkMode(); void parseMode(); void outputMode(); void warningMode(); void saveMode(); void restoreMode(); void changeToWarningMode(); int getDisplayColor(); void setDisplayColor(int); int installMessageCallback(int (*msgHandler) (sollya_msg_t, void *), void *); int uninstallMessageCallback(); void getMessageCallback(int (**)(sollya_msg_t, void *), void **); int initializeLibraryMode(void *(*)(size_t), void *(*)(size_t, size_t), void *(*)(void *, size_t), void (*)(void*), void *(*)(void *, size_t, size_t), void (*)(void *, size_t), int, char **, void (*)(void *(*)(size_t), void *(*)(void *, size_t, size_t), void (*)(void *, size_t)), void (*)(void *(**)(size_t), void *(**)(void *, size_t, size_t), void (**)(void *, size_t))); int finalizeLibraryMode(); mp_prec_t getToolPrecision(); void setToolPrecision(mp_prec_t prec); int getToolPoints(); void setToolPoints(int p); int getToolTaylorRecursions(); void setToolTaylorRecursions(int i); int getToolHopitalRecursions(); void setToolHopitalRecursions(int i); int getToolDiameter(mpfr_t rop); void setToolDiameter(mpfr_t op); char *getTempDir(); char *getUniqueId(); int getDisplayMode(); int setDisplayMode(int); int getVerbosity(); int setVerbosity(int); int getCanonical(); void setCanonical(int); int getAutosimplify(); void setAutosimplify(int); int getFullParentheses(); void setFullParentheses(int); int getMidpointMode(); void setMidpointMode(int); int getDieOnErrorMode(); void setDieOnErrorMode(int); int getTimecounting(); void setTimecounting(int); int getRoundingWarnings(); void setRoundingWarnings(int); int getRationalMode(); void setRationalMode(int); double sollya_mpfr_get_d(mpfr_t, mpfr_rnd_t); sollya_mpfi_t *getReusedGlobalMPFIVars(unsigned int, mp_prec_t); void returnReusedGlobalMPIVars(unsigned int); mpfr_t *getReusedGlobalMPFRVars(unsigned int, mp_prec_t); void returnReusedGlobalMPFRVars(unsigned int); int sollyaLibPrintmessage(int, int, const char *, ...); int sollya_getc(FILE *); int sollya_feof(FILE *); int sollya_ferror(FILE *); size_t sollya_fread(void *, size_t, size_t, FILE *); size_t sollya_fwrite(const void *, size_t, size_t, FILE *); int sollya_gettime(sollya_time_t *); void readManipulate(); void parserFlushInput(); /* Compatibility macros */ #if defined(HAVE_MEMMOVE) && HAVE_MEMMOVE #define sollya_memmove(dest, src, n) memmove((dest),(src),(n)) #else void *sollya_memmove_impl(void *, const void *, size_t); #define sollya_memmove(dest, src, n) sollya_memmove_impl((dest),(src),(n)) #endif #if defined(HAVE_MEMSET) && HAVE_MEMSET #define sollya_memset(s, c, n) memset((s),(c),(n)) #else void *sollya_memset_impl(void *, int, size_t); #define sollya_memset(s, c, n) sollya_memset_impl((s),(c),(n)) #endif #if defined(HAVE_STRCHR) && HAVE_STRCHR #define sollya_strchr(s, c) strchr((s),(c)) #else char *sollya_strchr_impl(const char *, int); #define sollya_strchr(s, c) sollya_strchr_impl((s),(c)) #endif #if defined(HAVE_STRRCHR) && HAVE_STRRCHR #define sollya_strrchr(s, c) strrchr((s),(c)) #else char *sollya_strrchr_impl(const char *, int); #define sollya_strrchr(s, c) sollya_strrchr_impl((s),(c)) #endif #if defined(HAVE_STRTOL) && HAVE_STRTOL #define sollya_strtol(nptr, endptr, base) strtol((nptr),(endptr),(base)) #else long int sollya_strtol_impl(const char *, char **, int); #define sollya_strtol(nptr, endptr, base) sollya_strtol_impl((nptr),(endptr),(base)) #endif #if defined(HAVE_DUP2) && HAVE_DUP2 #define sollya_dup2(oldfd, newfd) dup2((oldfd), (newfd)) #else int sollya_dup2_impl(int, int); #define sollya_dup2(oldfd, newfd) sollya_dup2_impl((oldfd), (newfd)) #endif #if defined(HAVE_STRSTR) && HAVE_STRSTR #define sollya_strstr(haystack, needle) strstr((haystack),(needle)) #else char *sollya_strstr_impl(const char *, const char *); #define sollya_strstr(haystack, needle) sollya_strstr_impl((haystack),(needle)) #endif #endif /* ifdef GENERAL_H*/ sollya-6.0+ds/hash.c000066400000000000000000000221101300174114700143450ustar00rootroot00000000000000/* Copyright 2015-2016 by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributor Ch. Lauter christoph.lauter@lip6.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include "hash.h" static inline uint64_t __rotateLeft(uint64_t x, unsigned int k) { unsigned int s, r; uint64_t tmp1, tmp2, tmp3; s = k & ((unsigned int) 63); if (s == ((unsigned int) 0)) return x; r = 64 - s; tmp1 = x; tmp1 <<= s; tmp2 = x; tmp2 >>= r; tmp3 = tmp1 | tmp2; return tmp3; } static inline uint64_t __hashCombine_internal(uint64_t h1, uint64_t h2) { uint64_t tmp1, tmp2; tmp1 = h1 ^ h2; tmp2 = __rotateLeft(tmp1, 17); return tmp2; } static inline uint64_t __hashUint64_internal(uint64_t x) { uint64_t tmp1, tmp2; tmp1 = x ^ UINT64_C(0xcafebabedeadbeef); tmp2 = __rotateLeft(tmp1, 13); return tmp2; } static inline uint64_t __hashUint8_internal(uint8_t x) { uint64_t tmp1, tmp2; tmp1 = (uint64_t) x; tmp2 = tmp1; tmp1 <<= 8; tmp2 |= tmp1; tmp1 <<= 8; tmp2 |= tmp1; tmp1 <<= 8; tmp2 |= tmp1; tmp1 <<= 8; tmp2 |= tmp1; tmp1 <<= 8; tmp2 |= tmp1; tmp1 <<= 8; tmp2 |= tmp1; tmp1 <<= 8; tmp2 |= tmp1; return __hashUint64_internal(tmp2); } static inline uint64_t __hashUint16_internal(uint16_t x) { uint64_t tmp1, tmp2; tmp1 = (uint64_t) x; tmp2 = tmp1; tmp1 <<= 16; tmp2 |= tmp1; tmp1 <<= 16; tmp2 |= tmp1; tmp1 <<= 16; tmp2 |= tmp1; return __hashUint64_internal(tmp2); } static inline uint64_t __hashUint32_internal(uint32_t x) { uint64_t tmp1, tmp2; tmp1 = (uint64_t) x; tmp2 = tmp1; tmp1 <<= 32; tmp2 |= tmp1; return __hashUint64_internal(tmp2); } static inline uint64_t __hashUnsignedChar_internal(unsigned char x) { uint8_t tmp1; uint16_t tmp2; uint32_t tmp3; uint64_t tmp4; if (sizeof(uint8_t) >= sizeof(unsigned char)) { tmp1 = (uint8_t) x; return __hashUint8_internal(tmp1); } if (sizeof(uint16_t) >= sizeof(unsigned char)) { tmp2 = (uint16_t) x; return __hashUint16_internal(tmp2); } if (sizeof(uint32_t) >= sizeof(unsigned char)) { tmp3 = (uint32_t) x; return __hashUint32_internal(tmp3); } tmp4 = (uint64_t) x; return __hashUint64_internal(tmp4); } static inline uint64_t __hashUnsignedInt_internal(unsigned int x) { uint8_t tmp1; uint16_t tmp2; uint32_t tmp3; uint64_t tmp4; if (sizeof(uint8_t) >= sizeof(unsigned int)) { tmp1 = (uint8_t) x; return __hashUint8_internal(tmp1); } if (sizeof(uint16_t) >= sizeof(unsigned int)) { tmp2 = (uint16_t) x; return __hashUint16_internal(tmp2); } if (sizeof(uint32_t) >= sizeof(unsigned int)) { tmp3 = (uint32_t) x; return __hashUint32_internal(tmp3); } tmp4 = (uint64_t) x; return __hashUint64_internal(tmp4); } static inline uint64_t __hashUnsignedLong_internal(unsigned long x) { uint8_t tmp1; uint16_t tmp2; uint32_t tmp3; uint64_t tmp4; if (sizeof(uint8_t) >= sizeof(unsigned long)) { tmp1 = (uint8_t) x; return __hashUint8_internal(tmp1); } if (sizeof(uint16_t) >= sizeof(unsigned long)) { tmp2 = (uint16_t) x; return __hashUint16_internal(tmp2); } if (sizeof(uint32_t) >= sizeof(unsigned long)) { tmp3 = (uint32_t) x; return __hashUint32_internal(tmp3); } tmp4 = (uint64_t) x; return __hashUint64_internal(tmp4); } static inline uint64_t __hashPointer_internal(void *x) { uintptr_t X; uint8_t tmp1; uint16_t tmp2; uint32_t tmp3; uint64_t tmp4; X = (uintptr_t) x; if (sizeof(uint8_t) >= sizeof(uintptr_t)) { tmp1 = (uint8_t) X; return __hashUint8_internal(tmp1); } if (sizeof(uint16_t) >= sizeof(uintptr_t)) { tmp2 = (uint16_t) X; return __hashUint16_internal(tmp2); } if (sizeof(uint32_t) >= sizeof(uintptr_t)) { tmp3 = (uint32_t) X; return __hashUint32_internal(tmp3); } tmp4 = (uint64_t) X; return __hashUint64_internal(tmp4); } static inline uint64_t __hashChar_internal(char x) { char xx; unsigned char tmp; xx = x; tmp = *((unsigned char *) &xx); return __hashUnsignedChar_internal(tmp); } static inline uint64_t __hashInt_internal(int x) { int xx; unsigned int tmp; xx = x; tmp = *((unsigned int *) &xx); return __hashUnsignedInt_internal(tmp); } static inline uint64_t __hashInt64_internal(int64_t x) { int64_t xx; uint64_t tmp; xx = x; tmp = *((uint64_t *) &xx); return __hashUint64_internal(tmp); } static inline uint64_t __hashLong_internal(long x) { long xx; unsigned long tmp; xx = x; tmp = *((unsigned long *) &xx); return __hashUnsignedLong_internal(tmp); } typedef union { uint64_t l; double d; } binary64_caster; static inline uint64_t __hashDouble_internal(double x) { double xx; uint64_t tmp; binary64_caster caster; xx = x; caster.d = xx; tmp = caster.l; return __hashUint64_internal(tmp); } static inline uint64_t __hashMpfr_internal(mpfr_t x) { long exp; double mant; uint64_t tmp1, tmp2; exp = (long) 0; mant = mpfr_get_d_2exp(&exp, x, GMP_RNDN); tmp1 = __hashLong_internal(exp); tmp2 = __hashDouble_internal(mant); return __hashCombine_internal(tmp1, tmp2); } static inline uint64_t __hashMpfi_internal(sollya_mpfi_t x) { uint64_t tmp1, tmp2; /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ tmp1 = __hashMpfr_internal(&(x->left)); tmp2 = __hashMpfr_internal(&(x->right)); return __hashCombine_internal(tmp1, tmp2); } static inline uint64_t __hashMpz_internal(mpz_t x) { long exp; double mant; uint64_t tmp1, tmp2; exp = (long) 0; mant = mpz_get_d_2exp(&exp, x); tmp1 = __hashLong_internal(exp); tmp2 = __hashDouble_internal(mant); return __hashCombine_internal(tmp1, tmp2); } static inline uint64_t __hashMpq_internal(mpq_t x) { uint64_t tmp1, tmp2; mpq_canonicalize(x); tmp1 = __hashMpz_internal(mpq_numref(x)); tmp2 = __hashMpz_internal(mpq_denref(x)); return __hashCombine_internal(tmp1, tmp2); } static inline uint64_t __hashString_internal(char *x) { uint64_t tmp; char *curr; tmp = UINT64_C(0); for (curr=x;*curr!='\0';curr++) { tmp = __hashCombine_internal(tmp, __hashChar_internal(*curr)); } return tmp; } uint64_t hashCombine(uint64_t h1, uint64_t h2) { uint64_t res; res = __hashCombine_internal(h1, h2); return res; } uint64_t hashMpfr(mpfr_t x) { uint64_t res; res = __hashMpfr_internal(x); return res; } uint64_t hashMpfi(sollya_mpfi_t x) { uint64_t res; res = __hashMpfi_internal(x); return res; } uint64_t hashMpq(mpq_t x) { uint64_t res; res = __hashMpq_internal(x); return res; } uint64_t hashString(char *x) { uint64_t res; res = __hashString_internal(x); return res; } uint64_t hashChar(char x) { uint64_t res; res = __hashChar_internal(x); return res; } uint64_t hashInt(int x) { uint64_t res; res = __hashInt_internal(x); return res; } uint64_t hashUnsignedInt(unsigned int x) { uint64_t res; res = __hashUnsignedInt_internal(x); return res; } uint64_t hashInt64(int64_t x) { uint64_t res; res = __hashInt64_internal(x); return res; } uint64_t hashPointer(void *x) { uint64_t res; res = __hashPointer_internal(x); return res; } sollya-6.0+ds/hash.h000066400000000000000000000050711300174114700143610ustar00rootroot00000000000000/* Copyright 2015 by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France Contributor Ch. Lauter christoph.lauter@lip6.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef HASH_H #define HASH_H #include #include #include #include "mpfi-compat.h" uint64_t hashChar(char); uint64_t hashInt(int); uint64_t hashUnsignedInt(unsigned int); uint64_t hashMpfr(mpfr_t); uint64_t hashMpfi(sollya_mpfi_t); uint64_t hashMpq(mpq_t); uint64_t hashString(char *); uint64_t hashPointer(void *); uint64_t hashInt64(int64_t); uint64_t hashCombine(uint64_t, uint64_t); #endif /* ifdef HASH_H*/ sollya-6.0+ds/help.h000066400000000000000000013010141300174114700143630ustar00rootroot00000000000000/* Copyright 2007-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard, M. Joldes christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org joldes@laas.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef HELP_H #define HELP_H #define HELP_PRINTFLOAT_TEXT "Name: printsingle\n==> prints a constant value as a hexadecimal single precision number\n\nUsage: \n printsingle({constant}) : constant -> void\n\nParameters: \n {constant} represents a constant\n\nDescription: \n * Prints a constant value as a hexadecimal number on 8 hexadecimal\n digits. The hexadecimal number represents the integer equivalent to\n the 32 bit memory representation of the constant considered as a\n single precision number.\n \n If the constant value does not hold on a single precision number, it\n is first rounded to the nearest single precision number before it is\n displayed. A warning is displayed in this case.\n\nExample 1: \n > printsingle(3);\n 0x40400000\n\nExample 2: \n > prec=100!;\n > verbosity = 1!;\n > printsingle(exp(5));\n Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used.\n Warning: rounding down occurred before printing a value as a simple.\n 0x431469c5\n\nSee also: printdouble, single\n" #define HELP_PRINTHEXA_TEXT "Name: printdouble\n==> prints a constant value as a hexadecimal double precision number\n\nUsage: \n printdouble({constant}) : constant -> void\n\nParameters: \n {constant} represents a constant\n\nDescription: \n * Prints a constant value as a hexadecimal number on 16 hexadecimal\n digits. The hexadecimal number represents the integer equivalent to\n the 64 bit memory representation of the constant considered as a\n double precision number.\n \n If the constant value does not hold on a double precision number, it\n is first rounded to the nearest double precision number before\n displayed. A warning is displayed in this case.\n\nExample 1: \n > printdouble(3);\n 0x4008000000000000\n\nExample 2: \n > prec=100!;\n > verbosity = 1!;\n > printdouble(exp(5));\n Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used.\n Warning: rounding down occurred before printing a value as a double.\n 0x40628d389970338f\n\nSee also: printsingle, printexpansion, double\n" #define HELP_ABS_TEXT "Name: abs\n==> the absolute value.\n\nLibrary names:\n sollya_obj_t sollya_lib_abs(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_abs(sollya_obj_t)\n #define SOLLYA_ABS(x) sollya_lib_build_function_abs(x)\n\nDescription: \n * abs is the absolute value function. abs(x)=x if x>0 and -x otherwise.\n\n" #define HELP_ABSOLUTE_TEXT "Name: absolute\n==> indicates an absolute error for externalplot, fpminimax or supnorm\n\nLibrary names:\n sollya_obj_t sollya_lib_absolute()\n int sollya_lib_is_absolute(sollya_obj_t)\n\nUsage: \n absolute : absolute|relative\n\nDescription: \n * The use of absolute in the command externalplot indicates that during\n plotting in externalplot an absolute error is to be considered.\n \n See externalplot for details.\n\n * Used with fpminimax, absolute indicates that fpminimax must try to minimize\n the absolute error.\n \n See fpminimax for details.\n\n * When given in argument to supnorm, absolute indicates that an absolute error\n is to be considered for supremum norm computation.\n \n See supnorm for details.\n\nExample 1: \n > bashexecute(\"gcc -fPIC -c externalplotexample.c\");\n > bashexecute(\"gcc -shared -o externalplotexample externalplotexample.o -lgmp -lmpfr\");\n > externalplot(\"./externalplotexample\",absolute,exp(x),[-1/2;1/2],12,perturb);\n\nSee also: externalplot, fpminimax, relative, bashexecute, supnorm\n" #define HELP_ACCURATEINFNORM_TEXT "Name: accurateinfnorm\n==> computes a faithful rounding of the infinity norm of a function \n\nUsage: \n accurateinfnorm({function},{range},{constant}) : (function, range, constant) -> constant\n accurateinfnorm({function},{range},{constant},{exclusion range 1},...,{exclusion range n}) : (function, range, constant, range, ..., range) -> constant\n\nParameters: \n {function} represents the function whose infinity norm is to be computed\n {range} represents the infinity norm is to be considered on\n {constant} represents the number of bits in the significant of the result\n {exclusion range 1} through {exclusion range n} represent ranges to be excluded \n\nDescription: \n * The command accurateinfnorm computes an upper bound to the infinity norm of\n function {function} in {range}. This upper bound is the least\n floating-point number greater than the value of the infinity norm that\n lies in the set of dyadic floating point numbers having {constant}\n significant mantissa bits. This means the value accurateinfnorm evaluates to\n is at the time an upper bound and a faithful rounding to {constant}\n bits of the infinity norm of function {function} on range {range}.\n \n If given, the fourth and further arguments of the command accurateinfnorm,\n {exclusion range 1} through {exclusion range n} the infinity norm of\n the function {function} is not to be considered on.\n\n * The command accurateinfnorm is now considered DEPRECATED in Sollya.\n Users should be aware about the fact that the algorithm behind\n accurateinfnorm is highly inefficient and that other, better suited\n algorithms, such as supnorm, are available inside Sollya. As a\n matter of fact, while accurateinfnorm is maintained for compatibility reasons\n with legacy Sollya codes, users are advised to avoid using accurateinfnorm\n in new Sollya scripts and to replace it, where possible, by the\n supnorm command.\n\nExample 1: \n > p = remez(exp(x), 5, [-1;1]);\n > accurateinfnorm(p - exp(x), [-1;1], 20);\n 4.52055246569216251373291015625e-5\n > accurateinfnorm(p - exp(x), [-1;1], 30);\n 4.5205513970358879305422306060791015625e-5\n > accurateinfnorm(p - exp(x), [-1;1], 40);\n 4.520551396713923253400935209356248378753662109375e-5\n\nExample 2: \n > p = remez(exp(x), 5, [-1;1]);\n > midpointmode = on!;\n > infnorm(p - exp(x), [-1;1]);\n 0.45205~5/7~e-4\n > accurateinfnorm(p - exp(x), [-1;1], 40);\n 4.520551396713923253400935209356248378753662109375e-5\n\nSee also: infnorm, dirtyinfnorm, supnorm, checkinfnorm, remez, diam\n" #define HELP_ACOS_TEXT "Name: acos\n==> the arccosine function.\n\nLibrary names:\n sollya_obj_t sollya_lib_acos(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_acos(sollya_obj_t)\n #define SOLLYA_ACOS(x) sollya_lib_build_function_acos(x)\n\nDescription: \n * acos is the inverse of the function cos: acos(y) is the unique number \n x in [0; Pi] such that cos(x)=y.\n\n * It is defined only for y in [-1; 1].\n\nSee also: cos\n" #define HELP_ACOSH_TEXT "Name: acosh\n==> the arg-hyperbolic cosine function.\n\nLibrary names:\n sollya_obj_t sollya_lib_acosh(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_acosh(sollya_obj_t)\n #define SOLLYA_ACOSH(x) sollya_lib_build_function_acosh(x)\n\nDescription: \n * acosh is the inverse of the function cosh: acosh(y) is the unique number \n x in [0; +Inf] such that cosh(x)=y.\n\n * It is defined only for y in [0; +Inf].\n\nSee also: cosh\n" #define HELP_AND_TEXT "Name: &&\n==> boolean AND operator\n\nLibrary name:\n sollya_obj_t sollya_lib_and(sollya_obj_t, sollya_obj_t)\n\nUsage: \n {expr1} && {expr2} : (boolean, boolean) -> boolean\n\nParameters: \n {expr1} and {expr2} represent boolean expressions\n\nDescription: \n * && evaluates to the boolean AND of the two\n boolean expressions {expr1} and {expr2}. && evaluates to \n true iff both {expr1} and {expr2} evaluate to true.\n\nExample 1: \n > true && false;\n false\n\nExample 2: \n > (1 == exp(0)) && (0 == log(1));\n true\n\nSee also: ||, !\n" #define HELP_ANNOTATEFUNCTION_TEXT "Name: annotatefunction\n==> Annotates a Sollya function object with an approximation that is faster to evaluate\n\nLibrary names:\n sollya_obj_t sollya_lib_annotatefunction(sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t, ...);\n sollya_obj_t sollya_lib_v_annotatefunction(sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t,\n va_list);\n\nUsage: \n annotatefunction({f}, {g}, {I}, {d}) : (function, function, range, range) -> function\n annotatefunction({f}, {g}, {I}, {d}, {x0}) : (function, function, range, range, constant) -> function\n\nParameters: \n {f} is a function.\n {g} is a function, in most cases a polynomial.\n {I} is an interval.\n {d} is an interval.\n {x0} is a constant (default value is 0 when not provided).\n\nDescription: \n * When a given function {f} is to be evaluated at several points of a given\n interval {I} to a given precision, it might be useful to precompute a good\n approximant {g} of {f} and further evaluate it instead of {f} when the\n approximation is good enough to provide the desire precision. If {f} is a\n complicated expression, whereas {g} is, e.g., a polynomial of low degree,\n the cost of precomputing {g} can be well compensated by the gain of time in\n each subsequent evaluation. The purpose of annotatefunction is to provide\n such a mechanism to the user.\n\n * When using annotatefunction({f}, {g}, {I}, {d}, {x0}),\n resp. annotatefunction({f}, {g}, {I}, {d}) (where {x0} is assumed to be\n zero), it is assumed that\n \n forall x in I, f(x) - g(x - x0) in d.\n \n It is the user responsibility to ensure this property. Otherwise, any\n subsequent use of {f} on points of {I} might lead to incorrect values.\n\n * A call to annotatefunction({f}, {g}, {I}, {d}, {x0}) annotates the given\n Sollya function object {f} with the approximation {g}. In further use, when\n asked to evaluate {f} on a point x of {I}, Sollya will first evaluate {g}\n on x-x0 and check if the result is accurate enough in the given context\n (accounting for the fact that the error of approximation between the true\n value and g(x-x0) belongs to {d}). If not (and only in this case), an\n evaluation of the expression of {f} on x is performed.\n\n * The approximation {g} can be any Sollya function but particular\n performance is expected when {g} is a polynomial. Upon annotation with a\n polynomial, precomputations are performed to analyze certain properties of\n the given approximation polynomial.\n\n * annotatefunction updates the internal representation of {f} so as to\n persistently keep this information attached with the Sollya object\n representing {f}. In particular, the annotation is persistent through copy\n or use of {f} as a subexpression to build up bigger expressions. Notice\n however, that there is no way of deducing an annotation for the derivative\n of {f} from an annotation of {f}. So, in general, it should not be expected\n that diff({f}) will be automatically annotated (notice, however that {f}\n might be a subexpression of its derivative, e.g., for {f}=exp or {f}=tan, in\n which case the corresponding subexpressions of the derivative could inherit\n the annotations from {f}. It is currently not specified whether Sollya does\n this automatically or not).\n\n * annotatefunction really is an imperative statement that modifies the\n internal representation of {f}. However, for convenience annotatefunction\n returns {f} itself.\n\n * Sollya function objects can be annotated more than once with different\n approximations on different domains, that do not need to be disjoint. Upon\n evaluation of the annotated function object, Sollya chooses an\n approximation annotation (if any) that provides for sufficient accuracy at\n the evaluation point. It is not specified in which order Sollya tries\n different possible annotations when several are available for a given\n point {x}.\n\nExample 1: \n > verbosity=1!;\n > procedure EXP(X,n,p) {\n var res, oldPrec;\n oldPrec = prec;\n prec = p!;\n \"Using procedure function exponential with X=\" @ X @ \", n=\" @ n @ \", and p=\" @ p;\n res = exp(X);\n prec = oldPrec!;\n return res;\n };\n > g = function(EXP);\n > p = 46768052394588893382516870161332864698044514954899b-165 + x * (23384026197294446691258465802074096632225783601255b-164 + x * (5846006549323611672948426613035653821819225877423b-163 + x * (3897337699549074448627696490806815137319821946501b-164 + x * (7794675399098148717422744621371434831048848817417b-167 + x * (24942961277114075921122941174178849425809856036737b-171 + x * (8314320425704876115613838900105097456456371179471b-172 + x * (19004160973039701371579356991645932289422670402995b-176 + x * (19004160972669324148912122254449912156003926801563b-179 + x * (33785175062542597526738679493857229456702396042255b-183 + x * (6757035113643674378393625988264926886191860669891b-184 + x * (9828414707511252769908089206114262766633532289937b-188 + x * (26208861108003813314724515233584738706961162212965b-193 + x * (32257064253325954315953742396999456577223350602741b-197 + x * (578429089657689569703509185903214676926704485495b-195 + x * 2467888542176675658523627105540996778984959471957b-201))))))))))))));\n > h = annotatefunction(g, p, [-1/2;1/2], [-475294848522543b-124;475294848522543b-124]);\n > h == g;\n true\n > prec = 24;\n The precision has been set to 24 bits.\n > h(0.25);\n Warning: rounding has happened. The value displayed is a faithful rounding to 24 bits of the true result.\n 1.2840254\n > prec = 165;\n The precision has been set to 165 bits.\n > h(0.25);\n Using procedure function exponential with X=[0.25;0.25], n=0, and p=185\n Warning: rounding has happened. The value displayed is a faithful rounding to 165 bits of the true result.\n 1.28402541668774148407342056806243645833628086528147\n\nSee also: chebyshevform, taylorform, remez, supnorm, infnorm\n" #define HELP_APPEND_TEXT "Name: :.\n==> add an element at the end of a list.\n\nLibrary name:\n sollya_obj_t sollya_lib_append(sollya_obj_t, sollya_obj_t)\n\nUsage: \n {L}:.{x} : (list, any type) -> list\n\nParameters: \n {L} is a list (possibly empty).\n {x} is an object of any type.\n\nDescription: \n * :. adds the element {x} at the end of the list {L}.\n\n * Note that since {x} may be of any type, it can in particular be a list.\n\nExample 1: \n > [|2,3,4|]:.5;\n [|2, 3, 4, 5|]\n\nExample 2: \n > [|1,2,3|]:.[|4,5,6|];\n [|1, 2, 3, [|4, 5, 6|]|]\n\nExample 3: \n > [||]:.1;\n [|1|]\n\nSee also: .:, @\n" #define HELP_APPROX_TEXT "Name: ~\n==> floating-point evaluation of a constant expression\n\nLibrary name:\n sollya_obj_t sollya_lib_approx(sollya_obj_t)\n\nUsage: \n ~ {expression} : function -> constant\n ~ {something} : any type -> any type\n\nParameters: \n {expression} stands for an expression that is a constant\n {something} stands for some language element that is not a constant expression\n\nDescription: \n * ~ {expression} evaluates the {expression} that is a constant\n term to a floating-point constant. The evaluation may involve a\n rounding. If {expression} is not a constant, the evaluated constant is\n a faithful rounding of {expression} with precision bits, unless the\n {expression} is exactly 0 as a result of cancellation. In the\n latter case, a floating-point approximation of some (unknown) accuracy\n is returned.\n\n * ~ does not do anything on all language elements that are not a\n constant expression. In other words, it behaves like the identity\n function on any type that is not a constant expression. It can hence\n be used in any place where one wants to be sure that expressions are\n simplified using floating-point computations to constants of a known\n precision, regardless of the type of actual language elements.\n\n * ~ error evaluates to error and provokes a warning.\n\n * ~ is a prefix operator not requiring parentheses. Its\n precedence is the same as for the unary + and -\n operators. It cannot be repeatedly used without brackets.\n\nExample 1: \n > print(exp(5));\n exp(5)\n > print(~ exp(5));\n 148.41315910257660342111558004055227962348766759388\n\nExample 2: \n > autosimplify = off!;\n\nExample 3: \n > print(~sin(5 * pi));\n 0\n\nExample 4: \n > print(~exp(x));\n exp(x)\n > print(~ \"Hello\");\n Hello\n\nExample 5: \n > print(~exp(x*5*Pi));\n exp((pi) * 5 * x)\n > print(exp(x* ~(5*Pi)));\n exp(x * 15.7079632679489661923132169163975144209858469968757)\n\nExample 6: \n > print(~exp(5)*x);\n 148.41315910257660342111558004055227962348766759388 * x\n > print( (~exp(5))*x);\n 148.41315910257660342111558004055227962348766759388 * x\n > print(~(exp(5)*x));\n exp(5) * x\n\nSee also: evaluate, prec, error\n" #define HELP_ASCIIPLOT_TEXT "Name: asciiplot\n==> plots a function in a range using ASCII characters\n\nLibrary name:\n void sollya_lib_asciiplot(sollya_obj_t, sollya_obj_t)\n\nUsage: \n asciiplot({function}, {range}) : (function, range) -> void\n\nParameters: \n {function} represents a function to be plotted\n {range} represents a range the function is to be plotted in \n\nDescription: \n * asciiplot plots the function {function} in range {range} using ASCII\n characters. On systems that provide the necessary \n TIOCGWINSZ ioctl, Sollya determines the size of the\n terminal for the plot size if connected to a terminal. If it is not\n connected to a terminal or if the test is not possible, the plot is of\n fixed size 77x25 characters. The function is\n evaluated on a number of points equal to the number of columns\n available. Its value is rounded to the next integer in the range of\n lines available. A letter \"x\" is written at this place. If zero is in\n the hull of the image domain of the function, an x-axis is\n displayed. If zero is in range, a y-axis is displayed. If the\n function is constant or if the range is reduced to one point, the\n function is evaluated to a constant and the constant is displayed\n instead of a plot.\n\nExample 1: \n > asciiplot(exp(x),[1;2]);\n xx\n xx \n xx \n xx \n xx \n xxx \n xx \n xxx \n xx \n xxx \n xxx \n xxx \n xxx \n xxx \n xxxx \n xxx \n xxxx \n xxxx \n xxxx \n xxxx \n xxxxx \n xxxxx \n xxxxx \n xxx \n\nExample 2: \n > asciiplot(expm1(x),[-1;2]);\n | x\n | x \n | x \n | x \n | xx \n | x \n | x \n | xx \n | x \n | xx \n | xx \n | xx \n | xx \n | xx \n | xx \n | xxx \n | xxx \n | xxxx \n | xxxx \n | xxxx \n | xxxxxx \n ---------------------xxxxxxxx-----------------------------------------------\n xxxxxxxxxxxx | \n xxxxxxxxx | \n\nExample 3: \n > asciiplot(5,[-1;1]);\n 5\n\nExample 4: \n > asciiplot(exp(x),[1;1]);\n 2.7182818284590452353602874713526624977572470937\n\nSee also: plot, externalplot\n" #define HELP_ASIN_TEXT "Name: asin\n==> the arcsine function.\n\nLibrary names:\n sollya_obj_t sollya_lib_asin(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_asin(sollya_obj_t)\n #define SOLLYA_ASIN(x) sollya_lib_build_function_asin(x)\n\nDescription: \n * asin is the inverse of the function sin: asin(y) is the unique number \n x in [-Pi/2; Pi/2] such that sin(x)=y.\n\n * It is defined only for y in [-1; 1].\n\nSee also: sin\n" #define HELP_ASINH_TEXT "Name: asinh\n==> the arg-hyperbolic sine function.\n\nLibrary names:\n sollya_obj_t sollya_lib_asinh(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_asinh(sollya_obj_t)\n #define SOLLYA_ASINH(x) sollya_lib_build_function_asinh(x)\n\nDescription: \n * asinh is the inverse of the function sinh: asinh(y) is the unique number \n x in [-Inf; +Inf] such that sinh(x)=y.\n\n * It is defined for every real number y.\n\nSee also: sinh\n" #define HELP_ATAN_TEXT "Name: atan\n==> the arctangent function.\n\nLibrary names:\n sollya_obj_t sollya_lib_atan(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_atan(sollya_obj_t)\n #define SOLLYA_ATAN(x) sollya_lib_build_function_atan(x)\n\nDescription: \n * atan is the inverse of the function tan: atan(y) is the unique number \n x in [-Pi/2; Pi/2] such that tan(x)=y.\n\n * It is defined for every real number y.\n\nSee also: tan\n" #define HELP_ATANH_TEXT "Name: atanh\n==> the hyperbolic arctangent function.\n\nLibrary names:\n sollya_obj_t sollya_lib_atanh(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_atanh(sollya_obj_t)\n #define SOLLYA_ATANH(x) sollya_lib_build_function_atanh(x)\n\nDescription: \n * atanh is the inverse of the function tanh: atanh(y) is the unique number \n x in [-Inf; +Inf] such that tanh(x)=y.\n\n * It is defined only for y in [-1; 1].\n\nSee also: tanh\n" #define HELP_AUTODIFF_TEXT "Name: autodiff\n==> Computes the first n derivatives of a function at a point or over an interval.\n\nLibrary name:\n sollya_obj_t sollya_lib_autodiff(sollya_obj_t, sollya_obj_t, sollya_obj_t)\n\nUsage: \n autodiff({f}, {n}, {x0}) : (function, integer, constant) -> list\n autodiff({f}, {n}, {I}) : (function, integer, range) -> list\n\nParameters: \n {f} is the function to be differentiated.\n {n} is the order of differentiation.\n {x0} is the point at which the function is differentiated.\n {I} is the interval over which the function is differentiated.\n\nDescription: \n * autodiff computes the first n derivatives of f at point x0. The computation\n is performed numerically, without symbolically differentiating the expression\n of f. Yet, the computation is safe since small interval enclosures are\n produced. More precisely, autodiff returns a list [f_0, ..., f_n] such that,\n for each i, f_i is a small interval enclosing the exact value of f^(i)(x0).\n\n * Since it does not perform any symbolic differentiation, autodiff is much \n more efficient than diff and should be preferred when only numerical values\n are necessary.\n\n * If an interval I is provided instead of a point x0, the list returned by\n autodiff satisfies: for each i, f^(i)(I) is included in f_i. A particular use\n is when one wants to know the successive derivatives of a function at a non\n representable point such as pi. In this case, it suffices to call autodiff\n with the (almost) point interval I = [pi].\n\n * When I is almost a point interval, the returned enclosures f_i are also\n almost point intervals. However, when the interval I begins to be fairly\n large, the enclosures can be deeply overestimated due to the dependency\n phenomenon present with interval arithmetic.\n\n * As a particular case, f_0 is an enclosure of the image of f over I.\n However, since the algorithm is not specially designed for this purpose it is\n not very efficient for this particular task. In particular, it is not able to\n return a finite enclosure for functions with removable singularities\n (e.g. sin(x)/x at 0). The command evaluate is much more efficient for\n computing an accurate enclosure of the image of a function over an interval.\n\nExample 1: \n > L = autodiff(exp(cos(x))+sin(exp(x)), 5, 0);\n > midpointmode = on!;\n > for f_i in L do f_i;\n 0.3559752813266941742012789792982961497379810154498~2/4~e1\n 0.5403023058681397174009366074429766037323104206179~0/3~\n -0.3019450507398802024611853185539984893647499733880~6/2~e1\n -0.252441295442368951995750696489089699886768918239~6/4~e1\n 0.31227898756481033145214529184139729746320579069~1/3~e1\n -0.16634307959006696033484053579339956883955954978~3/1~e2\n\nExample 2: \n > f = log(cos(x)+x);\n > L = autodiff(log(cos(x)+x), 5, [2,4]);\n > L[0];\n [0;1.27643852425465597132446653114905059102580436018893]\n > evaluate(f, [2,4]);\n [0.45986058925497069206106494332976097408234056912429;1.20787210589964169595901037621103012113048821362855]\n > fprime = diff(f);\n > L[1];\n [2.53086745013099407167484456656211083053393118778677e-2;1.7568024953079282513726390945118290941359128873365]\n > evaluate(fprime,[2,4]);\n [2.71048755415961996452136364304380881763456815673085e-2;1.1091953066394329083739722578862353140555843127995]\n\nExample 3: \n > L = autodiff(sin(x)/x, 0, [-1,1]);\n > L[0];\n [-infty;infty]\n > evaluate(sin(x)/x, [-1,1]);\n [0.5403023058681397174009366074429766037323104206179;1]\n\nSee also: diff, evaluate\n" #define HELP_AUTOSIMPLIFY_TEXT "Name: autosimplify\n==> activates, deactivates or inspects the value of the automatic simplification state variable\n\nLibrary names:\n void sollya_lib_set_autosimplify_and_print(sollya_obj_t)\n void sollya_lib_set_autosimplify(sollya_obj_t)\n sollya_obj_t sollya_lib_get_autosimplify()\n\nUsage: \n autosimplify = {activation value} : on|off -> void\n autosimplify = {activation value} ! : on|off -> void\n autosimplify : on|off\n\nParameters: \n {activation value} represents on or off, i.e. activation or deactivation\n\nDescription: \n * An assignment autosimplify = {activation value}, where {activation value}\n is one of on or off, activates respectively deactivates the\n automatic safe simplification of expressions of functions generated by\n the evaluation of commands or in argument of other commands.\n \n Sollya commands like remez, taylor or rationalapprox sometimes\n produce expressions that can be simplified. Constant subexpressions\n can be evaluated to dyadic floating-point numbers, monomials with\n coefficients 0 can be eliminated. Further, expressions\n indicated by the user perform better in many commands when simplified\n before being passed in argument to a command. When the automatic\n simplification of expressions is activated, Sollya automatically\n performs a safe (not value changing) simplification process on such\n expressions.\n \n The automatic generation of subexpressions can be annoying, in\n particular if it takes too much time for not enough benefit. Further the\n user might want to inspect the structure of the expression tree\n returned by a command. In this case, the automatic simplification\n should be deactivated.\n \n If the assignment autosimplify = {activation value} is followed by an\n exclamation mark, no message indicating the new state is\n displayed. Otherwise the user is informed of the new state of the\n global mode by an indication.\n\nExample 1: \n > autosimplify = on !;\n > print(x - x);\n 0\n > autosimplify = off ;\n Automatic pure tree simplification has been deactivated.\n > print(x - x);\n x - x\n\nExample 2: \n > autosimplify = on !; \n > print(rationalapprox(sin(pi/5.9),7));\n 33 / 65\n > autosimplify = off !; \n > print(rationalapprox(sin(pi/5.9),7));\n 33 / 65\n\nSee also: print, ==, !=, prec, points, diam, display, verbosity, canonical, taylorrecursions, timing, fullparentheses, midpointmode, hopitalrecursions, remez, rationalapprox, taylor\n" #define HELP_BASHEVALUATE_TEXT "Name: bashevaluate\n==> executes a shell command and returns its output as a string\n\nLibrary names:\n sollya_obj_t sollya_lib_bashevaluate(sollya_obj_t, ...)\n sollya_obj_t sollya_lib_v_bashevaluate(sollya_obj_t, va_list)\n\nUsage: \n bashevaluate({command}) : string -> string\n bashevaluate({command},{input}) : (string, string) -> string\n\nParameters: \n {command} is a command to be interpreted by the shell.\n {input} is an optional character sequence to be fed to the command.\n\nDescription: \n * bashevaluate({command}) will execute the shell command {command} in a shell.\n All output on the command's standard output is collected and returned \n as a character sequence.\n\n * If an additional argument {input} is given in a call to\n bashevaluate({command},{input}), this character sequence is written to the\n standard input of the command {command} that gets executed.\n\n * All characters output by {command} are included in the character\n sequence to which bashevaluate evaluates but two exceptions. Every NULL\n character ('\\0') in the output is replaced with\n '?' as Sollya is unable to handle character sequences containing that\n character. Additionally, if the output ends in a newline character\n ('\\n'), this character is stripped off. Other\n newline characters which are not at the end of the output are left as\n such.\n\nExample 1: \n > bashevaluate(\"LANG=C date\");\n Mon Oct 17 09:33:25 CEST 2016\n\nExample 2: \n > [| bashevaluate(\"echo Hello\") |];\n [|\"Hello\"|]\n\nExample 3: \n > a = bashevaluate(\"sed -e 's/a/e/g;'\", \"Hallo\");\n > a;\n Hello\n\nSee also: bashexecute\n" #define HELP_BASHEXECUTE_TEXT "Name: bashexecute\n==> executes a shell command.\n\nLibrary name:\n void sollya_lib_bashexecute(sollya_obj_t)\n\nUsage: \n bashexecute({command}) : string -> void\n\nParameters: \n {command} is a command to be interpreted by the shell.\n\nDescription: \n * bashexecute({command}) lets the shell interpret {command}. It is useful to execute\n some external code within Sollya.\n\n * bashexecute does not return anything. It just executes its argument. However, if\n {command} produces an output in a file, this result can be imported in Sollya\n with help of commands like execute, readfile and parse.\n\nExample 1: \n > bashexecute(\"LANG=C date\");\n Mon Oct 17 09:33:27 CEST 2016\n\nSee also: execute, readfile, parse, bashevaluate\n" #define HELP_BINARY_TEXT "Name: binary\n==> special value for global state display\n\nLibrary names:\n sollya_obj_t sollya_lib_binary()\n int sollya_lib_is_binary(sollya_obj_t)\n\nDescription: \n * binary is a special value used for the global state display. If\n the global state display is equal to binary, all data will be\n output in binary notation.\n \n As any value it can be affected to a variable and stored in lists.\n\nSee also: decimal, dyadic, powers, hexadecimal, display\n" #define HELP_BIND_TEXT "Name: bind\n==> partially applies a procedure to an argument, returning a procedure with one argument less\n\nUsage: \n bind({proc}, {ident}, {obj}) : (procedure, identifier type, any type) -> procedure\n\nParameters: \n {proc} is a procedure to be partially applied to an argument\n {ident} is one of the formal arguments of {proc}\n {obj} is any Sollya object {ident} is to be bound to\n\nDescription: \n * bind allows a formal parameter {ident} of a procedure {proc} to \n be bound to an object {obj}, hence {proc} to be partially applied.\n The result of this curryfied application, returned by bind, is \n a procedure with one argument less. This way, bind permits \n specialization of a generic procedure, parameterized e.g. by a function\n or range.\n\n * In the case when {proc} does not have a formal parameter named \n {ident}, bind prints a warning and returns the procedure \n {proc} unmodified. \n\n * bind always returns a procedure, even if {proc} only has one \n argument, which gets bound to {ident}. In this case, bind\n returns a procedure which does not take any argument. Hence \n evaluation, which might provoke side effects, is only performed\n once the procedure gets used.\n\n * bind does not work on procedures with an arbitrary number\n of arguments.\n\nExample 1: \n > procedure add(X,Y) { return X + Y; };\n > succ = bind(add,X,1);\n > succ(5);\n 6\n > succ;\n proc(Y)\n {\n nop;\n return (proc(X, Y)\n {\n nop;\n return (X) + (Y);\n })(1, Y);\n }\n\nExample 2: \n > procedure add(X,Y) { return X + Y; };\n > succ = bind(add,X,1);\n > five = bind(succ,Y,4);\n > five();\n 5\n > five;\n proc()\n {\n nop;\n return (proc(Y)\n {\n nop;\n return (proc(X, Y)\n {\n nop;\n return (X) + (Y);\n })(1, Y);\n })(4);\n }\n\nExample 3: \n > verbosity = 1!;\n > procedure add(X,Y) { return X + Y; };\n > foo = bind(add,R,1);\n Warning: the given procedure has no argument named \"R\". The procedure is returned unchanged.\n > foo;\n proc(X, Y)\n {\n nop;\n return (X) + (Y);\n }\n\nSee also: procedure, proc, function, @\n" #define HELP_BOOLEAN_TEXT "Name: boolean\n==> keyword representing a boolean type \n\nLibrary name:\n SOLLYA_EXTERNALPROC_TYPE_BOOLEAN\n\nUsage: \n boolean : type type\n\nDescription: \n * boolean represents the boolean type for declarations\n of external procedures by means of externalproc.\n \n Remark that in contrast to other indicators, type indicators like\n boolean cannot be handled outside the externalproc context. In\n particular, they cannot be assigned to variables.\n\nSee also: externalproc, constant, function, integer, list of, range, string, object\n" #define HELP_CANONICAL_TEXT "Name: canonical\n==> brings all polynomial subexpressions of an expression to canonical form or activates, deactivates or checks canonical form printing\n\nLibrary names:\n void sollya_lib_set_canonical_and_print(sollya_obj_t)\n void sollya_lib_set_canonical(sollya_obj_t)\n sollya_obj_t sollya_lib_canonical(sollya_obj_t)\n sollya_obj_t sollya_lib_get_canonical()\n\nUsage: \n canonical({function}) : function -> function\n canonical = {activation value} : on|off -> void\n canonical = {activation value} ! : on|off -> void\n\nParameters: \n {function} represents the expression to be rewritten in canonical form\n {activation value} represents on or off, i.e. activation or deactivation\n\nDescription: \n * The command canonical rewrites the expression representing the function\n {function} in a way such that all polynomial subexpressions (or the\n whole expression itself, if it is a polynomial) are written in\n canonical form, i.e. as a sum of monomials in the canonical base. The\n canonical base is the base of the integer powers of the global free\n variable. The command canonical does not endanger the safety of\n computations even in Sollya's floating-point environment: the\n function returned is mathematically equal to the function {function}.\n\n * An assignment canonical = {activation value}, where {activation value}\n is one of on or off, activates respectively deactivates the\n automatic printing of polynomial expressions in canonical form,\n i.e. as a sum of monomials in the canonical base. If automatic\n printing in canonical form is deactivated, automatic printing yields to\n displaying polynomial subexpressions in Horner form.\n \n If the assignment canonical = {activation value} is followed by an\n exclamation mark, no message indicating the new state is\n displayed. Otherwise the user is informed of the new state of the\n global mode by an indication.\n\nExample 1: \n > print(canonical(1 + x * (x + 3 * x^2)));\n 1 + x^2 + 3 * x^3\n > print(canonical((x + 1)^7));\n 1 + 7 * x + 21 * x^2 + 35 * x^3 + 35 * x^4 + 21 * x^5 + 7 * x^6 + x^7\n\nExample 2: \n > print(canonical(exp((x + 1)^5) - log(asin(((x + 2) + x)^4 * (x + 1)) + x)));\n exp(1 + 5 * x + 10 * x^2 + 10 * x^3 + 5 * x^4 + x^5) - log(asin(16 + 80 * x + 160 * x^2 + 160 * x^3 + 80 * x^4 + 16 * x^5) + x)\n\nExample 3: \n > canonical;\n off\n > (x + 2)^9;\n 512 + x * (2304 + x * (4608 + x * (5376 + x * (4032 + x * (2016 + x * (672 + x * (144 + x * (18 + x))))))))\n > canonical = on;\n Canonical automatic printing output has been activated.\n > (x + 2)^9;\n 512 + 2304 * x + 4608 * x^2 + 5376 * x^3 + 4032 * x^4 + 2016 * x^5 + 672 * x^6 + 144 * x^7 + 18 * x^8 + x^9\n > canonical;\n on\n > canonical = off!;\n > (x + 2)^9;\n 512 + x * (2304 + x * (4608 + x * (5376 + x * (4032 + x * (2016 + x * (672 + x * (144 + x * (18 + x))))))))\n\nSee also: horner, print, autosimplify\n" #define HELP_CEIL_TEXT "Name: ceil\n==> the usual function ceil.\n\nLibrary names:\n sollya_obj_t sollya_lib_ceil(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_ceil(sollya_obj_t)\n #define SOLLYA_CEIL(x) sollya_lib_build_function_ceil(x)\n\nDescription: \n * ceil is defined as usual: ceil(x) is the smallest integer y such that y >= x.\n\n * It is defined for every real number x.\n\nSee also: floor, nearestint, round, RU\n" #define HELP_CHEBYSHEVFORM_TEXT "Name: chebyshevform\n==> computes a rigorous polynomial approximation\n\nLibrary name:\n sollya_obj_t sollya_lib_chebyshevform(sollya_obj_t, sollya_obj_t,\n sollya_obj_t);\n\nUsage: \n chebyshevform({f}, {n}, {I}) : (function, integer, range) -> list\n\nParameters: \n {f} is the function to be approximated.\n {n} is the degree of the polynomial that must approximate {f}.\n {I} is the interval over which the function is to be approximated. This interval cannot be a point interval, i.e. its endpoints have to be different.\n\nDescription: \n * WARNING: chebyshevform is a certified command, not difficult to use but not\n completely straightforward to use either. In order to be sure to use it\n correctly, the reader is invited to carefully read this documentation\n entirely.\n\n * chebyshevform computes an approximation polynomial and an interval error\n bound for a given function f.\n \n More precisely, it returns a list L=[p, coeffErrors, Delta, chebCoeffs]\n where: \n - p is an approximation polynomial of degree n which is roughly speaking a\n numerical Chebyshev interpolation polynomial of f over I represented in\n monomial basis.\n - coeffsErrors is a list of n+1 intervals. Each interval coeffsErrors[i]\n contains an enclosure of all the errors accumulated when computing the i-th\n coefficient of p.\n - Delta is an interval that provides a bound for the approximation error\n between p and f. See details below.\n - chebCoeffs is a list of n+1 intervals. These are the interval\n coefficients obtained for the representation of interpolation polynomial\n considered in Chebyshev basis. See details below. \n\n * The polynomial p and the bound Delta are obtained using Chebyshev Models\n principles.\n\n * More formally, the mathematical property ensured by the algorithm may be\n stated as follows:\n \n Using monomial basis representation given by p: there exist (small) values\n eps[i] in coeffsErrors[i] such that:\n for all x in I, there exists delta in Delta such that\n f(x) - p(x) = sum{i=0...n} eps[i]*x^i + delta.\n \n Using Chebyshev basis representation given by chebCoeffs: there exist values\n alpha[i] in chebCoeffs[i] such that:\n for all x in I, there exists delta in Delta such that\n f(x) - sum{i=0...n} alpha[i]*T_i(y) = delta,\n where [a,b]=I, y=(2*x-b-a)/(b-a) and T_i(y) is the i-th Chebyshev polynomial\n over [-1,1].\n\n * The algorithm does not guarantee that by increasing the degree of the\n approximation, the remainder bound will become smaller. Moreover, it may even\n become larger due to the dependency phenomenon present with interval\n arithmetic. In order to reduce this phenomenon, a possible solution is to\n split the definition domain I into several smaller intervals.\n\nExample 1: \n > TL=chebyshevform(exp(x), 10, [-1,1]);\n > p=TL[0];\n > Delta=TL[2];\n > p; Delta;\n 1.00000000000000000000000000000000000000000000000017 + x * (1.0000000002738981919773953471453626764777115166417 + x * (0.50000000002276754368023326882542097365411870042312 + x * (0.166666661190450656168988993421371510533693281444003 + x * (4.1666666211440433973188799509591566161569698904644e-2 + x * (8.3333639749825520034240517636254576844423981913793e-3 + x * (1.38889143636148090706862105537216777944219976325265e-3 + x * (1.98342776066472142284727329700227389403558111865906e-4 + x * (2.47957727598277888282218067965324267955768146489014e-5 + x * (2.8254033440982477266316370012542019511804700836066e-6 + x * 2.8136983333718843135828091163040197490633045592362e-7)))))))))\n [-2.71406412827174505775085010461449926572460824320373e-11;2.71406412827174505775085010461449926572460824320373e-11]\n\nSee also: taylorform, diff, autodiff, taylor, remez\n" #define HELP_CHECKINFNORM_TEXT "Name: checkinfnorm\n==> checks whether the infinity norm of a function is bounded by a value\n\nLibrary name:\n sollya_obj_t sollya_lib_checkinfnorm(sollya_obj_t, sollya_obj_t,\n sollya_obj_t)\n\nUsage: \n checkinfnorm({function},{range},{constant}) : (function, range, constant) -> boolean\n\nParameters: \n {function} represents the function whose infinity norm is to be checked\n {range} represents the infinity norm is to be considered on\n {constant} represents the upper bound the infinity norm is to be checked to\n\nDescription: \n * The command checkinfnorm checks whether the infinity norm of the given\n function {function} in the range {range} can be proven (by Sollya) to\n be less than the given bound {bound}. This means, if checkinfnorm\n evaluates to true, the infinity norm has been proven (by Sollya's\n interval arithmetic) to be less than the bound. If checkinfnorm evaluates\n to false, there are two possibilities: either the bound is less than\n or equal to the infinity norm of the function or the bound is greater\n than the infinity norm but Sollya could not conclude using its\n internal interval arithmetic.\n \n checkinfnorm is sensitive to the global variable diam. The smaller diam,\n the more time Sollya will spend on the evaluation of checkinfnorm in\n order to prove the bound before returning false although the infinity\n norm is bounded by the bound. If diam is equal to 0, Sollya will\n eventually spend infinite time on instances where the given bound\n {bound} is less or equal to the infinity norm of the function\n {function} in range {range}. In contrast, with diam being zero,\n checkinfnorm evaluates to true iff the infinity norm of the function in\n the range is bounded by the given bound.\n\nExample 1: \n > checkinfnorm(sin(x),[0;1.75], 1);\n true\n > checkinfnorm(sin(x),[0;1.75], 1/2); checkinfnorm(sin(x),[0;20/39],1/2);\n false\n true\n\nExample 2: \n > p = remez(exp(x), 5, [-1;1]);\n > b = dirtyinfnorm(p - exp(x), [-1;1]);\n > checkinfnorm(p - exp(x), [-1;1], b);\n false\n > b1 = round(b, 15, RU);\n > checkinfnorm(p - exp(x), [-1;1], b1);\n true\n > b2 = round(b, 25, RU);\n > checkinfnorm(p - exp(x), [-1;1], b2);\n false\n > diam = 1b-20!;\n > checkinfnorm(p - exp(x), [-1;1], b2);\n true\n\nSee also: infnorm, dirtyinfnorm, supnorm, accurateinfnorm, remez, diam\n" #define HELP_COEFF_TEXT "Name: coeff\n==> gives the coefficient of degree n of a polynomial\n\nLibrary name:\n sollya_obj_t sollya_lib_coeff(sollya_obj_t, sollya_obj_t)\n\nUsage: \n coeff({f},{n}) : (function, integer) -> constant\n\nParameters: \n {f} is a function (usually a polynomial).\n {n} is an integer\n\nDescription: \n * If {f} is a polynomial, coeff({f}, {n}) returns the coefficient of\n degree {n} in {f}.\n\n * If {f} is a function that is not a polynomial, coeff({f}, {n}) returns 0.\n\nExample 1: \n > coeff((1+x)^5,3);\n 10\n\nExample 2: \n > coeff(sin(x),0);\n 0\n\nSee also: degree, roundcoefficients, subpoly\n" #define HELP_COMPOSEPOLYNOMIALS_TEXT "Name: composepolynomials\n==> computes an approximation to the composition of two polynomials and bounds the error\n\nLibrary name:\n sollya_obj_t sollya_lib_composepolynomials(sollya_obj_t, sollya_obj_t)\n\nUsage: \n composepolynomials({p},{q}) : (function, function) -> structure\n\nParameters: \n {p} and {q} are polynomials\n\nDescription: \n * Given two polynomials p and q, composepolynomials({p}, {q}) computes an \n approximation r to the polynomial (p o q) and bounds the\n error polynomial r - (p o q) using interval arithmetic.\n\n * composepolynomials always returns a structure containing two elements,\n poly and radii. The element\n poly is contains the approximate composed polynomial\n r. The element radii contains a list of n + 1 \n intervals ai bounding the coefficients of the\n error polynomial, which is of the same degree n as is the\n composed polynomial (p o q). This is, there exist\n alphai in ai such that \n sum_i alphai * x^i = r(x) - (p o q)(x).\n\n * In the case when either of p or q is not a polynomial, composepolynomials\n behaves like substitute used in a literate structure. The list of intervals\n bounding the coefficients of the error polynomial is returned empty.\n\nExample 1: \n > composepolynomials(1 + 2 * x + 3 * x^2 + 4 * x^3, 5 + 6 * x + 7 * x^2);\n { .radii = [|[0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0]|], .poly = 586 + x * (1992 + x * (4592 + x * (6156 + x * (6111 + x * (3528 + x * 1372))))) }\n\nExample 2: \n > print(composepolynomials(1/5 * x + exp(17) + log(2) * x^2, x^4 + 1/3 * x^2));\n { .radii = [|[-3.5873240686715317015647477332221852960774705712039e-43;3.5873240686715317015647477332221852960774705712039e-43], [0;0], [-2.67276471009219564614053646715148187881519688010505e-51;2.67276471009219564614053646715148187881519688010505e-51], [0;0], [-1.06910588403687825845621458686059275152607875204202e-50;1.06910588403687825845621458686059275152607875204202e-50], [0;0], [-2.13821176807375651691242917372118550305215750408404e-50;2.13821176807375651691242917372118550305215750408404e-50], [0;0], [-1.06910588403687825845621458686059275152607875204202e-50;1.06910588403687825845621458686059275152607875204202e-50]|], .poly = 2.41549527535752982147754351803858238798675673527228e7 + x^2 * (6.6666666666666666666666666666666666666666666666666e-2 + x^2 * (0.2770163533955494788241369023842418408972777927067 + x^2 * (0.46209812037329687294482141430545104538366675624017 + x^2 * 0.69314718055994530941723212145817656807550013436026))) }\n\nExample 3: \n > composepolynomials(sin(x),x + x^2);\n { .radii = [| |], .poly = sin(x * (1 + x)) }\n\nSee also: substitute\n" #define HELP_CONCAT_TEXT "Name: @\n==> concatenates two lists or strings or applies a list as arguments to a procedure\n\nLibrary name:\n sollya_obj_t sollya_lib_concat(sollya_obj_t, sollya_obj_t)\n\nUsage: \n {L1}@{L2} : (list, list) -> list\n {string1}@{string2} : (string, string) -> string\n {proc}@{L1} : (procedure, list) -> any type\n\nParameters: \n {L1} and {L2} are two lists.\n {string1} and {string2} are two strings.\n {proc} is a procedure or an external procedure.\n\nDescription: \n * In its first usage form, @ concatenates two lists or strings.\n\n * In its second usage form, @ applies the elements of a list as\n arguments to a procedure or an external procedure. In the case when {proc} is\n a procedure or external procedure with a fixed number of arguments, a check\n is done if the number of elements in the list corresponds to the number of\n formal parameters of {proc}. An empty list can therefore be applied only to a\n procedure that does not take any argument. In the case when {proc} accepts an\n arbitrary number of arguments, no such check is performed.\n\nExample 1: \n > [|1,...,3|]@[|7,8,9|];\n [|1, 2, 3, 7, 8, 9|]\n\nExample 2: \n > \"Hello \"@\"World!\";\n Hello World!\n\nExample 3: \n > procedure cool(a,b,c) { \n write(a,\", \", b,\" and \",c,\" are cool guys.\\n\");\n };\n > cool @ [| \"Christoph\", \"Mioara\", \"Sylvain\" |];\n Christoph, Mioara and Sylvain are cool guys.\n\nExample 4: \n > procedure sayhello() { \n \"Hello! how are you?\";\n };\n > sayhello();\n Hello! how are you?\n > sayhello @ [||];\n Hello! how are you?\n\nExample 5: \n > bashexecute(\"gcc -fPIC -Wall -c externalprocexample.c\");\n > bashexecute(\"gcc -fPIC -shared -o externalprocexample externalprocexample.o\");\n > externalproc(foo, \"./externalprocexample\", (integer, integer) -> integer);\n > foo;\n foo\n > foo @ [|5, 6|];\n 11\n\nExample 6: \n > procedure add(L = ...) {\n var acc, i;\n acc = 0;\n for i in L do acc = i + acc;\n return acc;\n };\n > add(1,2);\n 3\n > add(1,2,3);\n 6\n > add @ [|1, 2|];\n 3\n > add @ [|1, 2, 3|];\n 6\n > add @ [||];\n 0\n\nSee also: .:, :., procedure, externalproc, proc, bind, getbacktrace\n" #define HELP_CONSTANT_TEXT "Name: constant\n==> keyword representing a constant type \n\nLibrary name:\n SOLLYA_EXTERNALPROC_TYPE_CONSTANT\n\nUsage: \n constant : type type\n\nDescription: \n * constant represents the constant type for declarations\n of external procedures externalproc.\n \n Remark that in contrast to other indicators, type indicators like\n constant cannot be handled outside the externalproc context. In\n particular, they cannot be assigned to variables.\n\nSee also: externalproc, boolean, function, integer, list of, range, string, object\n" #define HELP_COS_TEXT "Name: cos\n==> the cosine function.\n\nLibrary names:\n sollya_obj_t sollya_lib_cos(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_cos(sollya_obj_t)\n #define SOLLYA_COS(x) sollya_lib_build_function_cos(x)\n\nDescription: \n * cos is the usual cosine function.\n\n * It is defined for every real number x.\n\nSee also: acos, sin, tan\n" #define HELP_COSH_TEXT "Name: cosh\n==> the hyperbolic cosine function.\n\nLibrary names:\n sollya_obj_t sollya_lib_cosh(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_cosh(sollya_obj_t)\n #define SOLLYA_COSH(x) sollya_lib_build_function_cosh(x)\n\nDescription: \n * cosh is the usual hyperbolic function: cosh(x) = (exp(x)+exp(-x))/2.\n\n * It is defined for every real number x.\n\nSee also: acosh, sinh, tanh, exp\n" #define HELP_D_TEXT "Name: D\n==> short form for double\n\nSee also: double\n" #define HELP_DD_TEXT "Name: DD\n==> short form for doubledouble\n\nSee also: doubledouble\n" #define HELP_DE_TEXT "Name: DE\n==> short form for doubleextended\n\nSee also: doubleextended\n" #define HELP_DECIMAL_TEXT "Name: decimal\n==> special value for global state display\n\nLibrary names:\n sollya_obj_t sollya_lib_decimal()\n int sollya_lib_is_decimal(sollya_obj_t)\n\nDescription: \n * decimal is a special value used for the global state display.\n If the global state display is equal to decimal, all data will\n be output in decimal notation.\n \n As any value it can be affected to a variable and stored in lists.\n\nSee also: dyadic, powers, hexadecimal, binary, display\n" #define HELP_DEFAULT_TEXT "Name: default\n==> default value for some commands.\n\nLibrary names:\n sollya_obj_t sollya_lib_default()\n int sollya_lib_is_default(sollya_obj_t)\n\nDescription: \n * default is a special value and is replaced by something depending on the \n context where it is used. It can often be used as a joker, when you want to \n specify one of the optional parameters of a command and not the others: set \n the value of uninteresting parameters to default.\n\n * Global variables can be reset by affecting them the special value default.\n\nExample 1: \n > p = remez(exp(x),5,[0;1],default,1e-5);\n > q = remez(exp(x),5,[0;1],1,1e-5);\n > p==q;\n true\n\nExample 2: \n > prec;\n 165\n > prec=200;\n The precision has been set to 200 bits.\n\n" #define HELP_DEGREE_TEXT "Name: degree\n==> gives the degree of a polynomial.\n\nLibrary name:\n sollya_obj_t sollya_lib_degree(sollya_obj_t)\n\nUsage: \n degree({f}) : function -> integer\n\nParameters: \n {f} is a function (usually a polynomial).\n\nDescription: \n * If {f} is a polynomial, degree({f}) returns the degree of {f}.\n\n * Contrary to the usage, Sollya considers that the degree of the null polynomial\n is 0.\n\n * If {f} is a function that is not a polynomial, degree({f}) returns -1.\n\nExample 1: \n > degree((1+x)*(2+5*x^2));\n 3\n > degree(0);\n 0\n\nExample 2: \n > degree(sin(x));\n -1\n\nSee also: coeff, subpoly, roundcoefficients\n" #define HELP_DENOMINATOR_TEXT "Name: denominator\n==> gives the denominator of an expression\n\nLibrary name:\n sollya_obj_t sollya_lib_denominator(sollya_obj_t)\n\nUsage: \n denominator({expr}) : function -> function\n\nParameters: \n {expr} represents an expression\n\nDescription: \n * If {expr} represents a fraction {expr1}/{expr2}, denominator({expr})\n returns the denominator of this fraction, i.e. {expr2}.\n \n If {expr} represents something else, denominator({expr}) \n returns 1.\n \n Note that for all expressions {expr}, numerator({expr}) / denominator({expr})\n is equal to {expr}.\n\nExample 1: \n > denominator(5/3);\n 3\n\nExample 2: \n > denominator(exp(x));\n 1\n\nExample 3: \n > a = 5/3;\n > b = numerator(a)/denominator(a);\n > print(a);\n 5 / 3\n > print(b);\n 5 / 3\n\nExample 4: \n > a = exp(x/3);\n > b = numerator(a)/denominator(a);\n > print(a);\n exp(x / 3)\n > print(b);\n exp(x / 3)\n\nSee also: numerator, rationalmode\n" #define HELP_DIAM_TEXT "Name: diam\n==> parameter used in safe algorithms of Sollya and controlling the maximal length of the involved intervals.\n\nLibrary names:\n void sollya_lib_set_diam_and_print(sollya_obj_t)\n void sollya_lib_set_diam(sollya_obj_t)\n sollya_obj_t sollya_lib_get_diam()\n\nUsage: \n diam = {width} : constant -> void\n diam = {width} ! : constant -> void\n diam : constant\n\nParameters: \n {width} represents the maximal relative width of the intervals used\n\nDescription: \n * diam is a global variable. Its value represents the maximal width allowed\n for intervals involved in safe algorithms of Sollya (namely infnorm,\n checkinfnorm, accurateinfnorm, integral, findzeros, supnorm).\n\n * More precisely, diam is relative to the width of the input interval of\n the command. For instance, suppose that diam=1e-5: if infnorm is called\n on interval [0;1], the maximal width of an interval will be 1e-5. But if it\n is called on interval [0;1e-3], the maximal width will be 1e-8.\n\nSee also: infnorm, checkinfnorm, accurateinfnorm, integral, findzeros, supnorm\n" #define HELP_DIEONERRORMODE_TEXT "Name: dieonerrormode\n==> global variable controlling if Sollya is exited on an error or not.\n\nLibrary names:\n void sollya_lib_set_dieonerrormode_and_print(sollya_obj_t)\n void sollya_lib_set_dieonerrormode(sollya_obj_t)\n sollya_obj_t sollya_lib_get_dieonerrormode()\n\nUsage: \n dieonerrormode = {activation value} : on|off -> void\n dieonerrormode = {activation value} ! : on|off -> void\n dieonerrormode : on|off\n\nParameters: \n {activation value} controls if Sollya is exited on an error or not.\n\nDescription: \n * dieonerrormode is a global variable. When its value is off, which is the default,\n Sollya will not exit on any syntax, typing, side-effect errors. These\n errors will be caught by the tool, even if a memory might be leaked at \n that point. On evaluation, the error special value will be produced.\n\n * When the value of the dieonerrormode variable is on, Sollya will exit\n on any syntax, typing, side-effect errors. A warning message will\n be printed in these cases at appropriate verbosity levels. \n\nExample 1: \n > verbosity = 1!;\n > dieonerrormode = off;\n Die-on-error mode has been deactivated.\n > for i from true to false do i + \"Salut\";\n Warning: one of the arguments of the for loop does not evaluate to a constant.\n The for loop will not be executed.\n > exp(17);\n Warning: rounding has happened. The value displayed is a faithful rounding to 165 bits of the true result.\n 2.41549527535752982147754351803858238798675673527224e7\n\nExample 2: \n > verbosity = 1!;\n > dieonerrormode = off!;\n > 5 */ 4;\n Warning: syntax error, unexpected /.\n The last symbol read has been \"/\".\n Will skip input until next semicolon after the unexpected token. May leak memory.\n exp(17);\n Warning: rounding has happened. The value displayed is a faithful rounding to 165 bits of the true result.\n 2.41549527535752982147754351803858238798675673527224e7\n\nExample 3: \n > verbosity = 1!;\n > dieonerrormode;\n off\n > dieonerrormode = on!;\n > dieonerrormode;\n on\n > for i from true to false do i + \"Salut\";\n Warning: one of the arguments of the for loop does not evaluate to a constant.\n The for loop will not be executed.\n Warning: some syntax, typing or side-effect error has occurred.\n As the die-on-error mode is activated, the tool will be exited.\n\nExample 4: \n > verbosity = 1!;\n > dieonerrormode = on!;\n > 5 */ 4;\n Warning: syntax error, unexpected /.\n The last symbol read has been \"/\".\n Will skip input until next semicolon after the unexpected token. May leak memory.\n Warning: some syntax, typing or side-effect error has occurred.\n As the die-on-error mode is activated, the tool will be exited.\n\nExample 5: \n > verbosity = 0!;\n > dieonerrormode = on!;\n > 5 */ 4;\n\nSee also: on, off, verbosity, error\n" #define HELP_DIFF_TEXT "Name: diff\n==> differentiation operator\n\nLibrary name:\n sollya_obj_t sollya_lib_diff(sollya_obj_t)\n\nUsage: \n diff({function}) : function -> function\n\nParameters: \n {function} represents a function\n\nDescription: \n * diff({function}) returns the symbolic derivative of the function\n {function} by the global free variable.\n \n If {function} represents a function symbol that is externally bound\n to some code by library, the derivative is performed as a symbolic\n annotation to the returned expression tree.\n\nExample 1: \n > diff(sin(x));\n cos(x)\n\nExample 2: \n > diff(x);\n 1\n\nExample 3: \n > diff(x^x);\n x^x * (1 + log(x))\n\nSee also: library, autodiff, taylor, taylorform\n" #define HELP_DIRTYFINDZEROS_TEXT "Name: dirtyfindzeros\n==> gives a list of numerical values listing the zeros of a function on an interval.\n\nLibrary name:\n sollya_obj_t sollya_lib_dirtyfindzeros(sollya_obj_t, sollya_obj_t)\n\nUsage: \n dirtyfindzeros({f},{I}) : (function, range) -> list\n\nParameters: \n {f} is a function.\n {I} is an interval.\n\nDescription: \n * dirtyfindzeros({f},{I}) returns a list containing some zeros of {f} in the\n interval {I}. The values in the list are numerical approximation of the exact\n zeros. The precision of these approximations is approximately the precision\n stored in prec. If {f} does not have two zeros very close to each other, it \n can be expected that all zeros are listed. However, some zeros may be\n forgotten. This command should be considered as a numerical algorithm and\n should not be used if safety is critical.\n\n * More precisely, the algorithm relies on global variables prec and points and it performs the following steps: \n let n be the value of variable points and t be the value\n of variable prec.\n \n - Evaluate |f| at n evenly distributed points in the interval I.\n The working precision to be used is automatically chosen in order to ensure that the sign\n is correct.\n - Whenever f changes its sign for two consecutive points,\n find an approximation x of its zero with precision t using\n Newton's algorithm. The number of steps in Newton's iteration depends on t:\n the precision of the approximation is supposed to be doubled at each step.\n - Add this value to the list.\n \n\n * The user should be aware that the list returned by dirtyfindzeros may\n contain a certain floating-point number twice. These repetitions\n reflect the existence of different zeros of the function the value of\n which rounds to the same floating-point number in the current working\n precision. In this case, increasing the working precision will end up\n making the two zeros distinguishable even in rounded floating-point\n arithmetic.\n\nExample 1: \n > dirtyfindzeros(sin(x),[-5;5]);\n [|-3.1415926535897932384626433832795028841971693993751, 0, 3.1415926535897932384626433832795028841971693993751|]\n\nExample 2: \n > L1=dirtyfindzeros(x^2*sin(1/x),[0;1]);\n > points=1000!;\n > L2=dirtyfindzeros(x^2*sin(1/x),[0;1]);\n > length(L1); length(L2);\n 18\n 25\n\nSee also: prec, points, findzeros, dirtyinfnorm, numberroots\n" #define HELP_DIRTYINFNORM_TEXT "Name: dirtyinfnorm\n==> computes a numerical approximation of the infinity norm of a function on an interval.\n\nLibrary name:\n sollya_obj_t sollya_lib_dirtyinfnorm(sollya_obj_t, sollya_obj_t)\n\nUsage: \n dirtyinfnorm({f},{I}) : (function, range) -> constant\n\nParameters: \n {f} is a function.\n {I} is an interval.\n\nDescription: \n * dirtyinfnorm({f},{I}) computes an approximation of the infinity norm of the \n given function f on the interval I, e.g. max {|f(x)|, x in I}.\n\n * The interval must be bound. If the interval contains one of -Inf or +Inf, the \n result of dirtyinfnorm is NaN.\n\n * The result of this command depends on the global variables prec and points.\n Therefore, the returned result is generally a good approximation of the exact\n infinity norm, with precision prec. However, the result is generally \n underestimated and should not be used when safety is critical.\n Use infnorm instead.\n\n * The following algorithm is used: let n be the value of variable points\n and t be the value of variable prec.\n \n - Evaluate |f| at n evenly distributed points in the\n interval I. The evaluation are faithful roundings of the exact\n results at precision t.\n - Whenever the derivative of f changes its sign for two consecutive \n points, find an approximation x of its zero with precision t.\n Then compute a faithful rounding of |f(x)| at precision t.\n - Return the maximum of all computed values.\n \n\nExample 1: \n > dirtyinfnorm(sin(x),[-10;10]);\n 1\n\nExample 2: \n > prec=15!;\n > dirtyinfnorm(exp(cos(x))*sin(x),[0;5]);\n 1.45856\n > prec=40!;\n > dirtyinfnorm(exp(cos(x))*sin(x),[0;5]);\n 1.458528537136\n > prec=100!;\n > dirtyinfnorm(exp(cos(x))*sin(x),[0;5]);\n 1.458528537136237644438147455025\n > prec=200!;\n > dirtyinfnorm(exp(cos(x))*sin(x),[0;5]);\n 1.458528537136237644438147455023841718299214087993682374094153\n\nExample 3: \n > dirtyinfnorm(x^2, [log(0);log(1)]);\n NaN\n\nSee also: prec, points, infnorm, checkinfnorm, supnorm\n" #define HELP_DIRTYINTEGRAL_TEXT "Name: dirtyintegral\n==> computes a numerical approximation of the integral of a function on an interval.\n\nLibrary name:\n sollya_obj_t sollya_lib_dirtyintegral(sollya_obj_t, sollya_obj_t)\n\nUsage: \n dirtyintegral({f},{I}) : (function, range) -> constant\n\nParameters: \n {f} is a function.\n {I} is an interval.\n\nDescription: \n * dirtyintegral({f},{I}) computes an approximation of the integral of {f} on {I}.\n\n * The interval must be bound. If the interval contains one of -Inf or +Inf, the \n result of dirtyintegral is NaN, even if the integral has a meaning.\n\n * The result of this command depends on the global variables prec and points.\n The method used is the trapezium rule applied at n evenly distributed\n points in the interval, where n is the value of global variable points.\n\n * This command computes a numerical approximation of the exact value of the \n integral. It should not be used if safety is critical. In this case, use\n command integral instead.\n\n * Warning: this command is currently known to be unsatisfactory. If you really\n need to compute integrals, think of using another tool or report a feature\n request to sylvain.chevillard@ens-lyon.org.\n\nExample 1: \n > sin(10);\n -0.54402111088936981340474766185137728168364301291622\n > dirtyintegral(cos(x),[0;10]);\n -0.54400304905152629822448058882475382036536298356282\n > points=2000!;\n > dirtyintegral(cos(x),[0;10]);\n -0.54401997751158321972222697312583199035995837926893\n\nSee also: prec, points, integral\n" #define HELP_DIRTYSIMPLIFY_TEXT "Name: dirtysimplify\n==> simplifies an expression representing a function\n\nLibrary name:\n sollya_obj_t sollya_lib_dirtysimplify(sollya_obj_t)\n\nUsage: \n dirtysimplify({function}) : function -> function\n\nParameters: \n {function} represents the expression to be simplified\n\nDescription: \n * The command dirtysimplify simplifies constant subexpressions of the\n expression given in argument representing the function\n {function}. Those constant subexpressions are evaluated using\n floating-point arithmetic with the global precision prec.\n\nExample 1: \n > print(dirtysimplify(sin(pi * x)));\n sin(3.1415926535897932384626433832795028841971693993751 * x)\n > print(dirtysimplify(erf(exp(3) + x * log(4))));\n erf(20.0855369231876677409285296545817178969879078385544 + x * 1.3862943611198906188344642429163531361510002687205)\n\nExample 2: \n > prec = 20!;\n > t = erf(0.5);\n > s = dirtysimplify(erf(0.5));\n > prec = 200!;\n > t;\n 0.520499877813046537682746653891964528736451575757963700058806\n > s;\n 0.52050018310546875\n\nSee also: simplify, autosimplify, prec, evaluate, horner, rationalmode\n" #define HELP_DISPLAY_TEXT "Name: display\n==> sets or inspects the global variable specifying number notation\n\nLibrary names:\n void sollya_lib_set_display_and_print(sollya_obj_t)\n void sollya_lib_set_display(sollya_obj_t)\n sollya_obj_t sollya_lib_get_display()\n\nUsage: \n display = {notation value} : decimal|binary|dyadic|powers|hexadecimal -> void\n display = {notation value} ! : decimal|binary|dyadic|powers|hexadecimal -> void\n display : decimal|binary|dyadic|powers|hexadecimal\n\nParameters: \n {notation value} represents a variable of type decimal|binary|dyadic|powers|hexadecimal\n\nDescription: \n * An assignment display = {notation value}, where {notation value} is\n one of decimal, dyadic, powers, binary or hexadecimal, activates\n the corresponding notation for output of values in print, write or\n at the Sollya prompt.\n \n If the global notation variable display is decimal, all numbers will\n be output in scientific decimal notation. If the global notation\n variable display is dyadic, all numbers will be output as dyadic\n numbers with Gappa notation. If the global notation variable display\n is powers, all numbers will be output as dyadic numbers with a\n notation compatible with Maple and PARI/GP. If the global notation\n variable display is binary, all numbers will be output in binary\n notation. If the global notation variable display is hexadecimal,\n all numbers will be output in C99/ IEEE754-2008 notation. All output\n notations can be parsed back by Sollya, inducing no error if the input\n and output precisions are the same (see prec).\n \n If the assignment display = {notation value} is followed by an\n exclamation mark, no message indicating the new state is\n displayed. Otherwise the user is informed of the new state of the\n global mode by an indication.\n\nExample 1: \n > display = decimal;\n Display mode is decimal numbers.\n > a = evaluate(sin(pi * x), 0.25);\n > a;\n 0.70710678118654752440084436210484903928483593768847\n > display = binary;\n Display mode is binary numbers.\n > a;\n 1.01101010000010011110011001100111111100111011110011001001000010001011001011111011000100110110011011101010100101010111110100111110001110101101111011000001011101010001_2 * 2^(-1)\n > display = hexadecimal;\n Display mode is hexadecimal numbers.\n > a;\n 0x1.6a09e667f3bcc908b2fb1366ea957d3e3adec1751p-1\n > display = dyadic;\n Display mode is dyadic numbers.\n > a;\n 33070006991101558613323983488220944360067107133265b-165\n > display = powers;\n Display mode is dyadic numbers in integer-power-of-2 notation.\n > a;\n 33070006991101558613323983488220944360067107133265 * 2^(-165)\n\nSee also: print, write, decimal, dyadic, powers, binary, hexadecimal, prec\n" #define HELP_DIVIDE_TEXT "Name: /\n==> division function\n\nLibrary names:\n sollya_obj_t sollya_lib_div(sollya_obj_t, sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_div(sollya_obj_t, sollya_obj_t)\n #define SOLLYA_DIV(x,y) sollya_lib_build_function_div((x), (y))\n\nUsage: \n {function1} / {function2} : (function, function) -> function\n {interval1} / {interval2} : (range, range) -> range\n {interval1} / {constant} : (range, constant) -> range\n {interval1} / {constant} : (constant, range) -> range\n\nParameters: \n {function1} and {function2} represent functions\n {interval1} and {interval2} represent intervals (ranges)\n {constant} represents a constant or constant expression\n\nDescription: \n * / represents the division (function) on reals. \n The expression {function1} / {function2} stands for\n the function composed of the division function and the two\n functions {function1} and {function2}, where {function1} is\n the numerator and {function2} the denominator.\n\n * / can be used for interval arithmetic on intervals\n (ranges). / will evaluate to an interval that safely\n encompasses all images of the division function with arguments\n varying in the given intervals. If the intervals given contain points\n where the division function is not defined, infinities and NaNs will be\n produced in the output interval. Any combination of intervals with\n intervals or constants (resp. constant expressions) is\n supported. However, it is not possible to represent families of\n functions using an interval as one argument and a function (varying in\n the free variable) as the other one.\n\nExample 1: \n > 5 / 2;\n 2.5\n\nExample 2: \n > x / 2;\n x * 0.5\n\nExample 3: \n > x / x;\n 1\n\nExample 4: \n > 3 / 0;\n NaN\n\nExample 5: \n > diff(sin(x) / exp(x));\n (exp(x) * cos(x) - sin(x) * exp(x)) / exp(x)^2\n\nExample 6: \n > [1;2] / [3;4];\n [0.25;0.66666666666666666666666666666666666666666666666668]\n > [1;2] / 17;\n [5.8823529411764705882352941176470588235294117647059e-2;0.11764705882352941176470588235294117647058823529412]\n > -13 / [4;17];\n [-3.25;-0.76470588235294117647058823529411764705882352941175]\n\nSee also: +, -, *, ^\n" #define HELP_DOUBLE_TEXT "Names: double, D\n==> rounding to the nearest IEEE 754 double (binary64).\n\nLibrary names:\n sollya_obj_t sollya_lib_double(sollya_obj_t)\n sollya_obj_t sollya_lib_double_obj()\n int sollya_lib_is_double_obj(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_double(sollya_obj_t)\n #define SOLLYA_D(x) sollya_lib_build_function_double(x)\n\nDescription: \n * double is both a function and a constant.\n\n * As a function, it rounds its argument to the nearest IEEE 754 double precision (i.e. IEEE754-2008 binary64) number.\n Subnormal numbers are supported as well as standard numbers: it is the real\n rounding described in the standard.\n\n * As a constant, it symbolizes the double precision format. It is used in \n contexts when a precision format is necessary, e.g. in the commands \n round, roundcoefficients and implementpoly.\n See the corresponding help pages for examples.\n\nExample 1: \n > display=binary!;\n > D(0.1);\n 1.100110011001100110011001100110011001100110011001101_2 * 2^(-4)\n > D(4.17);\n 1.000010101110000101000111101011100001010001111010111_2 * 2^(2)\n > D(1.011_2 * 2^(-1073));\n 1.1_2 * 2^(-1073)\n\nSee also: halfprecision, single, doubleextended, doubledouble, quad, tripledouble, roundcoefficients, implementpoly, round, printdouble\n" #define HELP_DOUBLEDOUBLE_TEXT "Names: doubledouble, DD\n==> represents a number as the sum of two IEEE doubles.\n\nLibrary names:\n sollya_obj_t sollya_lib_double_double(sollya_obj_t)\n sollya_obj_t sollya_lib_double_double_obj()\n int sollya_lib_is_double_double_obj(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_double_double(sollya_obj_t)\n #define SOLLYA_DD(x) sollya_lib_build_function_double_double(x)\n\nDescription: \n * doubledouble is both a function and a constant.\n\n * As a function, it rounds its argument to the nearest number that can be written\n as the sum of two double precision numbers.\n\n * The algorithm used to compute doubledouble(x) is the following: let xh = double(x)\n and let xl = double(x - xh). Return the number xh + xl. Note that if the current \n precision is not sufficient to exactly represent xh + xl, a rounding will occur\n and the result of doubledouble(x) will be useless.\n\n * As a constant, it symbolizes the double-double precision format. It is used in \n contexts when a precision format is necessary, e.g. in the commands \n round, roundcoefficients and implementpoly.\n See the corresponding help pages for examples.\n\nExample 1: \n > verbosity=1!;\n > a = 1+ 2^(-100);\n > DD(a);\n 1.0000000000000000000000000000007888609052210118054\n > prec=50!;\n > DD(a);\n 1.000000000000000000000000000000788860905\n\nSee also: halfprecision, single, double, doubleextended, quad, tripledouble, roundcoefficients, implementpoly, round\n" #define HELP_DOUBLEEXTENDED_TEXT "Names: doubleextended, DE\n==> computes the nearest number with 64 bits of mantissa.\n\nLibrary names:\n sollya_obj_t sollya_lib_doubleextended(sollya_obj_t)\n sollya_obj_t sollya_lib_doubleextended_obj()\n int sollya_lib_is_doubleextended_obj(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_doubleextended(sollya_obj_t)\n #define SOLLYA_DE(x) sollya_lib_build_function_doubleextended(x)\n\nDescription: \n * doubleextended is a function that computes the nearest floating-point number with\n 64 bits of mantissa to a given number. Since it is a function, it can be\n composed with other Sollya functions such as exp, sin, etc.\n\n * doubleextended now does handle subnormal numbers for a presumed exponent width\n of the double-extended format of 15 bits. This means, with respect to \n rounding, doubleextended behaves as a IEEE 754-2008 binary79 with a 64 bit \n significand (with a hidden bit normal range), one sign bit and a \n 15 bit exponent field would behave. This behavior may be different\n from the one observed on Intel-based IA32/Intel64 processors (or compatible\n versions from other vendors). However it is the one seen on HP/Intel \n Itanium when the precision specifier is double-extended and pseudo-denormals\n are activated.\n\n * Since it is a function and not a command, its behavior is a bit different from \n the behavior of round(x,64,RN) even if the result is exactly the same.\n round(x,64,RN) is immediately evaluated whereas doubleextended(x) can be composed \n with other functions (and thus be plotted and so on).\n\nExample 1: \n > display=binary!;\n > DE(0.1);\n 1.100110011001100110011001100110011001100110011001100110011001101_2 * 2^(-4)\n > round(0.1,64,RN);\n 1.100110011001100110011001100110011001100110011001100110011001101_2 * 2^(-4)\n\nExample 2: \n > D(2^(-2000));\n 0\n > DE(2^(-20000));\n 0\n\nExample 3: \n > verbosity=1!;\n > f = sin(DE(x));\n > f(pi);\n Warning: rounding has happened. The value displayed is a faithful rounding to 165 bits of the true result.\n -5.016557612668332023557327080330757013831561670255e-20\n > g = sin(round(x,64,RN));\n Warning: at least one of the given expressions or a subexpression is not correctly typed\n or its evaluation has failed because of some error on a side-effect.\n\nSee also: roundcoefficients, halfprecision, single, double, doubledouble, quad, tripledouble, round\n" #define HELP_DYADIC_TEXT "Name: dyadic\n==> special value for global state display\n\nLibrary names:\n sollya_obj_t sollya_lib_dyadic()\n int sollya_lib_is_dyadic(sollya_obj_t)\n\nDescription: \n * dyadic is a special value used for the global state display.\n If the global state display is equal to dyadic, all data will\n be output in dyadic notation with numbers displayed in Gappa format.\n \n As any value it can be affected to a variable and stored in lists.\n\nSee also: decimal, powers, hexadecimal, binary, display\n" #define HELP_EQUAL_TEXT "Name: ==\n==> equality test operator\n\nLibrary name:\n sollya_obj_t sollya_lib_cmp_equal(sollya_obj_t, sollya_obj_t)\n\nUsage: \n {expr1} == {expr2} : (any type, any type) -> boolean\n\nParameters: \n {expr1} and {expr2} represent expressions\n\nDescription: \n * The test {expr1} == {expr2} returns true when {expr1} and {expr2} are\n syntactically equal and different from error and @NaN@. Conversely if {expr1}\n and {expr2} are objects that are mathematically different and Sollya manages\n to figure it out, the test returns false. In between these two cases, there\n is the grey zone of expressions that are not syntactically equal but are\n mathematically equal. In such a case, Sollya normally tries to determine if\n the expressions are mathematically equal and if it manages to prove it, it\n returns true, without a warning. In the case when {expr1} and {expr2} are\n two constant expressions, Sollya will in particular try to evaluate their\n difference: in the case when the difference is 0 or is so small that Sollya\n does not manage to obtain a faithful rounding of the real value, it will\n return true (with a warning if it has not been possible to actually prove\n that the real value is 0). In any other case, when both expressions are not\n syntactically equal and Sollya has not been able to prove that they are\n mathematically equal, it returns false.\n\n * The level of simplifications performed by Sollya to determine if\n expressions are mathematically equal depends on the value of autosimplify.\n If it is off, no formal simplification is performed, hence expression trees\n as simple as x+1 and 1+x will be considered not equal. Conversely, if\n autosimplify is set to on, polynomial subexpressions that are mathematically\n equal will in general be recognized as being equal.\n\n * The user should always keep in mind that a litteral constant written in\n decimal arithmetic (such as 0.1 for instance) is not considered as an exact\n constant by Sollya (unless it is exactly representable in binary without\n requiring too much precision) and is first correctly rounded at precision\n prec, prior to any other operation. Of course, this leads to a rounding\n warning, but it is important to remember that this is done before the\n expression trees are compared, possibly leading to two expressions comparing\n equal, while they are obviously mathematically different, just because they\n contain different constants that have been rounded to the same value at\n precision prec. As a general rule, to avoid this behavior, the user should\n represent constants in an exact format such as hexadecimal or represent\n decimal constants as integer fractions (e.g., 0.1 represented by the constant\n expression 1/10).\n\n * Notice that @NaN@ and error share the property that they both compare equal\n and different to anything, i.e., if the variable {a} contains @NaN@ or error\n and whatever the content of variable {b} is, the tests {a} == {b} and\n {a} != {b} both return false. The standard way of testing if {a} contains\n @NaN@ or error is indeed to check if {a} == {a} returns false. In such a\n case, it is however impossible to determine what is the actual value of {a}\n amongst both possibilities using only == or !=. The standard way to\n discriminate this situation is to use the match ... with ... construct.\n\nExample 1: \n > \"Hello\" == \"Hello\";\n true\n > \"Hello\" == \"Salut\";\n false\n > \"Hello\" == 5;\n false\n > 5 + x == 5 + x;\n true\n\nExample 2: \n > verbosity = 1!;\n > asin(1) * 2 == pi;\n true\n > cos(3)^2 == 1 - sin(3)^2;\n Warning: the tool is unable to decide an equality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n true\n > exp(5) == log(4);\n false\n\nExample 3: \n > autosimplify=off;\n Automatic pure tree simplification has been deactivated.\n > exp(1+x) == exp(x+1);\n false\n > autosimplify=on;\n Automatic pure tree simplification has been activated.\n > exp(1+x) == exp(x+1);\n false\n > (1/3+x)^2 == x^2 + 1/9 + (5-3)*x/3;\n true\n > log(x)/log(10) == log10(x);\n false\n\nExample 4: \n > prec = 12;\n The precision has been set to 12 bits.\n > verbosity = 1!;\n > 16384.1 == 16385.1;\n Warning: Rounding occurred when converting the constant \"16384.1\" to floating-point with 12 bits.\n If safe computation is needed, try to increase the precision.\n Warning: Rounding occurred when converting the constant \"16385.1\" to floating-point with 12 bits.\n If safe computation is needed, try to increase the precision.\n true\n > 16384 == 16384.25;\n false\n > 0.1 == 1/10;\n Warning: Rounding occurred when converting the constant \"0.1\" to floating-point with 12 bits.\n If safe computation is needed, try to increase the precision.\n false\n > 0.1 == round(1/10, prec, RN);\n Warning: Rounding occurred when converting the constant \"0.1\" to floating-point with 12 bits.\n If safe computation is needed, try to increase the precision.\n true\n\nExample 5: \n > error == error;\n false\n > error != error;\n false\n > @NaN@ == @NaN@;\n false\n > @NaN@ != @NaN@;\n false\n > error == @NaN@;\n false\n > error != @NaN@;\n false\n > a = error;\n > match a with\n @NaN@ : (\"a contains @NaN@\")\n default:(\"a contains something else\");\n error\n > a = @NaN@;\n > match a with\n @NaN@ : (\"a contains @NaN@\")\n default:(\"a contains something else\");\n a contains @NaN@\n\nSee also: !=, >, >=, <=, <, in, !, &&, ||, error, prec, autosimplify\n" #define HELP_ERF_TEXT "Name: erf\n==> the error function.\n\nLibrary names:\n sollya_obj_t sollya_lib_erf(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_erf(sollya_obj_t)\n #define SOLLYA_ERF(x) sollya_lib_build_function_erf(x)\n\nDescription: \n * erf is the error function defined by:\n erf(x) = (2/sqrt(Pi)) * integral(exp(-t^2), [0;x])\n\n * It is defined for every real number x.\n\nSee also: erfc, exp\n" #define HELP_ERFC_TEXT "Name: erfc\n==> the complementary error function.\n\nLibrary names:\n sollya_obj_t sollya_lib_erfc(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_erfc(sollya_obj_t)\n #define SOLLYA_ERFC(x) sollya_lib_build_function_erfc(x)\n\nDescription: \n * erfc is the complementary error function defined by erfc(x) = 1 - erf(x).\n\n * It is defined for every real number x.\n\nSee also: erf\n" #define HELP_ERROR_TEXT "Name: error\n==> expression representing an input that is wrongly typed or that cannot be executed\n\nLibrary names:\n sollya_obj_t sollya_lib_error()\n int sollya_lib_obj_is_error(sollya_obj_t)\n\nUsage: \n error : error\n\nDescription: \n * The variable error represents an input during the evaluation of\n which a type or execution error has been detected or is to be\n detected. Inputs that are syntactically correct but wrongly typed\n evaluate to error at some stage. Inputs that are correctly typed\n but containing commands that depend on side-effects that cannot be\n performed or inputs that are wrongly typed at meta-level (cf. parse),\n evaluate to error.\n \n Remark that in contrast to all other elements of the Sollya language,\n error compares neither equal nor unequal to itself. This provides a\n means of detecting syntax errors inside the Sollya language itself\n without introducing issues of two different wrongly typed inputs being\n equal.\n\nExample 1: \n > print(5 + \"foo\");\n error\n\nExample 2: \n > error;\n error\n\nExample 3: \n > error == error;\n false\n > error != error;\n false\n\nExample 4: \n > correct = 5 + 6;\n > incorrect = 5 + \"foo\";\n > correct == correct;\n true\n > incorrect == incorrect;\n false\n > errorhappened = !(incorrect == incorrect);\n > errorhappened;\n true\n\nSee also: void, parse, ==, !=\n" #define HELP_EVALUATE_TEXT "Name: evaluate\n==> evaluates a function at a constant point or in a range\n\nLibrary name:\n sollya_obj_t sollya_lib_evaluate(sollya_obj_t, sollya_obj_t)\n\nUsage: \n evaluate({function}, {constant}) : (function, constant) -> constant | range\n evaluate({function}, {range}) : (function, range) -> range\n evaluate({function}, {function2}) : (function, function) -> function\n\nParameters: \n {function} represents a function\n {constant} represents a constant point\n {range} represents a range\n {function2} represents a function that is not constant\n\nDescription: \n * If its second argument is a constant {constant}, evaluate evaluates\n its first argument {function} at the point indicated by\n {constant}. This evaluation is performed in a way that the result is a\n faithful rounding of the real value of the {function} at {constant} to\n the current global precision. If such a faithful rounding is not\n possible, evaluate returns a range surely encompassing the real value\n of the function {function} at {constant}. If even interval evaluation\n is not possible because the expression is undefined or numerically\n unstable, NaN will be produced.\n\n * If its second argument is a range {range}, evaluate evaluates its\n first argument {function} by interval evaluation on this range\n {range}. This ensures that the image domain of the function {function}\n on the preimage domain {range} is surely enclosed in the returned\n range.\n\n * In the case when the second argument is a range that is reduced to a\n single point (such that [1;1] for instance), the evaluation\n is performed in the same way as when the second argument is a constant but\n it produces a range as a result: evaluate automatically adjusts the precision\n of the intern computations and returns a range that contains at most three floating-point\n consecutive numbers in precision prec. This corresponds to the same accuracy\n as a faithful rounding of the actual result. If such a faithful rounding\n is not possible, evaluate has the same behavior as in the case when the\n second argument is a constant.\n\n * If its second argument is a function {function2} that is not a\n constant, evaluate replaces all occurrences of the free variable in\n function {function} by function {function2}.\n\nExample 1: \n > midpointmode=on!;\n > print(evaluate(sin(pi * x), 2.25));\n 0.70710678118654752440084436210484903928483593768847\n > print(evaluate(sin(pi * x), [2.25; 2.25]));\n 0.707106781186547524400844362104849039284835937688~4/5~\n\nExample 2: \n > print(evaluate(sin(pi * x), 2));\n [-1.7298645251438126951650861503109812954283676799168e-12715;7.5941198201187963145069564314525661706039084390068e-12716]\n\nExample 3: \n > print(evaluate(sin(pi * x), [2, 2.25]));\n [-5.143390272677254630046998919961912407349224165421e-50;0.70710678118654752440084436210484903928483593768866]\n\nExample 4: \n > print(evaluate(sin(pi * x), 2 + 0.25 * x));\n sin((pi) * 2 + x * (pi) * 0.25)\n\nExample 5: \n > print(evaluate(sin(pi * 1/x), 0));\n [-1;1]\n\nSee also: isevaluable\n" #define HELP_EXECUTE_TEXT "Name: execute\n==> executes the content of a file\n\nLibrary name:\n void sollya_lib_execute(sollya_obj_t)\n\nUsage: \n execute({filename}) : string -> void\n\nParameters: \n {filename} is a string representing a file name\n\nDescription: \n * execute opens the file indicated by {filename}, and executes the sequence of \n commands it contains. This command is evaluated at execution time: this way you\n can modify the file {filename} (for instance using bashexecute) and execute it\n just after.\n\n * If {filename} contains a command execute, it will be executed recursively.\n\n * If {filename} contains a call to restart, it will be neglected.\n\n * If {filename} contains a call to quit, the commands following quit\n in {filename} will be neglected.\n\nExample 1: \n > a=2;\n > a;\n 2\n > print(\"a=1;\") > \"example.sollya\";\n > execute(\"example.sollya\"); \n > a;\n 1\n\nExample 2: \n > verbosity=1!;\n > print(\"a=1; restart; a=2;\") > \"example.sollya\";\n > execute(\"example.sollya\"); \n Warning: a restart command has been used in a file read into another.\n This restart command will be neglected.\n > a;\n 2\n\nExample 3: \n > verbosity=1!;\n > print(\"a=1; quit; a=2;\") > \"example.sollya\";\n > execute(\"example.sollya\"); \n Warning: the execution of a file read by execute demanded stopping the interpretation but it is not stopped.\n > a;\n 1\n\nSee also: parse, readfile, write, print, bashexecute, quit, restart\n" #define HELP_EXP_TEXT "Name: exp\n==> the exponential function.\n\nLibrary names:\n sollya_obj_t sollya_lib_exp(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_exp(sollya_obj_t)\n #define SOLLYA_EXP(x) sollya_lib_build_function_exp(x)\n\nDescription: \n * exp is the usual exponential function defined as the solution of the\n ordinary differential equation y' = y with y(0)=1.\n\n * exp(x) is defined for every real number x.\n\nSee also: exp, log\n" #define HELP_EXPAND_TEXT "Name: expand\n==> expands polynomial subexpressions\n\nLibrary name:\n sollya_obj_t sollya_lib_expand(sollya_obj_t)\n\nUsage: \n expand({function}) : function -> function\n\nParameters: \n {function} represents a function\n\nDescription: \n * expand({function}) expands all polynomial subexpressions in function\n {function} as far as possible. Factors of sums are multiplied out,\n power operators with constant positive integer exponents are replaced\n by multiplications.\n\nExample 1: \n > print(expand(x^3));\n x * x * x\n\nExample 2: \n > print(expand((x + 2)^3 + 2 * x));\n 8 + 12 * x + 6 * x * x + x * x * x + 2 * x\n\nExample 3: \n > print(expand(exp((x + (x + 3))^5)));\n exp(243 + 405 * x + 270 * x * x + 90 * x * x * x + 15 * x * x * x * x + x * x * x * x * x + x * 405 + 108 * x * 5 * x + 54 * x * x * 5 * x + 12 * x * x * x * 5 * x + x * x * x * x * 5 * x + x * x * 270 + 27 * x * x * x * 10 + 9 * x * x * x * x * 10 + x * x * x * x * x * 10 + x * x * x * 90 + 6 * x * x * x * x * 10 + x * x * x * x * x * 10 + x * x * x * x * 5 * x + 15 * x * x * x * x + x * x * x * x * x)\n\nSee also: dirtysimplify, simplify, horner, coeff, degree\n" #define HELP_EXPM1_TEXT "Name: expm1\n==> shifted exponential function.\n\nLibrary names:\n sollya_obj_t sollya_lib_expm1(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_expm1(sollya_obj_t)\n #define SOLLYA_EXPM1(x) sollya_lib_build_function_expm1(x)\n\nDescription: \n * expm1 is defined by expm1(x) = exp(x)-1.\n\n * It is defined for every real number x.\n\nSee also: exp\n" #define HELP_EXPONENT_TEXT "Name: exponent\n==> returns the scaled binary exponent of a number.\n\nLibrary name:\n sollya_obj_t sollya_lib_exponent(sollya_obj_t)\n\nUsage: \n exponent({x}) : constant -> integer\n\nParameters: \n {x} is a dyadic number.\n\nDescription: \n * exponent(x) is by definition 0 if x is one of 0, NaN, or Inf.\n\n * If {x} is not zero, it can be uniquely written as x = m*2^e where\n m is an odd integer and e is an integer. exponent(x) returns e. \n\nExample 1: \n > a=round(Pi,20,RN);\n > e=exponent(a);\n > e;\n -17\n > m=mantissa(a);\n > a-m*2^e;\n 0\n\nSee also: mantissa, precision\n" #define HELP_EXTERNALPLOT_TEXT "Name: externalplot\n==> plots the error of an external code with regard to a function\n\nLibrary names:\n void sollya_lib_externalplot(sollya_obj_t, sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t, ...)\n void sollya_lib_v_externalplot(sollya_obj_t, sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t, va_list)\n\nUsage: \n externalplot({filename}, {mode}, {function}, {range}, {precision}) : (string, absolute|relative, function, range, integer) -> void\n externalplot({filename}, {mode}, {function}, {range}, {precision}, {perturb}) : (string, absolute|relative, function, range, integer, perturb) -> void\n externalplot({filename}, {mode}, {function}, {range}, {precision}, {plot mode}, {result filename}) : (string, absolute|relative, function, range, integer, file|postscript|postscriptfile, string) -> void\n externalplot({filename}, {mode}, {function}, {range}, {precision}, {perturb}, {plot mode}, {result filename}) : (string, absolute|relative, function, range, integer, perturb, file|postscript|postscriptfile, string) -> void\n\nDescription: \n * The command externalplot plots the error of an external function\n evaluation code sequence implemented in the object file named\n {filename} with regard to the function {function}. If {mode}\n evaluates to {absolute}, the difference of both functions is\n considered as an error function; if {mode} evaluates to {relative},\n the difference is divided by the function {function}. The resulting\n error function is plotted on all floating-point numbers with\n {precision} significant mantissa bits in the range {range}. \n \n If the sixth argument of the command externalplot is given and evaluates to\n perturb, each of the floating-point numbers the function is evaluated at gets perturbed by a\n random value that is uniformly distributed in +/-1 ulp\n around the original {precision} bit floating-point variable.\n \n If a sixth and seventh argument, respectively a seventh and eighth\n argument in the presence of perturb as a sixth argument, are given\n that evaluate to a variable of type file|postscript|postscriptfile respectively to a\n character sequence of type string, externalplot will plot\n (additionally) to a file in the same way as the command plot\n does. See plot for details.\n \n The external function evaluation code given in the object file name\n {filename} is supposed to define a function name f as\n follows (here in C syntax): void f(mpfr_t rop, mpfr_t op). \n This function is supposed to evaluate op with an accuracy corresponding\n to the precision of rop and assign this value to\n rop.\n\nExample 1: \n > bashexecute(\"gcc -fPIC -c externalplotexample.c\");\n > bashexecute(\"gcc -shared -o externalplotexample externalplotexample.o -lgmp -lmpfr\");\n > externalplot(\"./externalplotexample\",relative,exp(x),[-1/2;1/2],12,perturb);\n\nSee also: plot, asciiplot, perturb, absolute, relative, file, postscript, postscriptfile, bashexecute, externalproc, library\n" #define HELP_EXTERNALPROC_TEXT "Name: externalproc\n==> binds an external code to a Sollya procedure\n\nLibrary names:\n sollya_obj_t sollya_lib_externalprocedure(sollya_externalprocedure_type_t, \n sollya_externalprocedure_type_t *,\n int, char *, void *);\n sollya_obj_t sollya_lib_externalprocedure_with_data(\n sollya_externalprocedure_type_t, \n sollya_externalprocedure_type_t *,\n int, char *, void *, void *,\n void (*)(void *));\n\nUsage: \n externalproc({identifier}, {filename}, {argumenttype} -> {resulttype}) : (identifier type, string, type type, type type) -> void\n\nParameters: \n {identifier} represents the identifier the code is to be bound to\n {filename} of type string represents the name of the object file where the code of procedure can be found\n {argumenttype} represents a definition of the types of the arguments of the Sollya procedure and the external code\n {resulttype} represents a definition of the result type of the external code\n\nDescription: \n * externalproc allows for binding the Sollya identifier {identifier} to an\n external code. After this binding, when Sollya encounters {identifier}\n applied to a list of actual parameters, it will evaluate these parameters and\n call the external code with these parameters. If the external code indicated\n success, it will receive the result produced by the external code, transform\n it to Sollya's internal representation and return it.\n \n In order to allow correct evaluation and typing of the data in parameter and\n in result to be passed to and received from the external code, externalproc\n has a third parameter {argumenttype} -> {resulttype}. Both {argumenttype} and\n {resulttype} are one of void, constant, function, object, range, integer,\n string, boolean, list of constant, list of function, list of object,\n list of range, list of integer, list of string, list of boolean.\n \n It is worth mentionning that the difference between the data and\n result type function and the type object is minimal and due to\n support of legacy Sollya code. Both Sollya functions and Sollya\n objects are transferred from and to the external procedure thru the C\n type sollya_obj_t. The difference is that\n Sollya will check that a certain object is a mathematical function\n when function is used as a type, and will skip this test if the\n object type is used. Similarly, Sollya relies on an object produced\n by the external procedure to be a mathematical function when function\n is used and will not make this assumption for object.\n \n If upon a usage of a procedure bound to an external procedure the type of the\n actual parameters given or its number is not correct, Sollya produces a type\n error. An external function not applied to arguments represents itself and\n prints out with its argument and result types.\n \n The external function is supposed to return an integer indicating success. It\n returns its result depending on its Sollya result type as follows. Here, the\n external procedure is assumed to be implemented as a C function. \n - If the Sollya result type is void, the C function has no pointer\n argument for the result.\n - If the Sollya result type is constant, the first argument of the\n C function is of C type mpfr_t *, the result is returned by affecting\n the MPFR variable.\n - If the Sollya result type is function, the first argument of the\n C function is of C type sollya_obj_t *, the result is returned by\n affecting the sollya_obj_t variable.\n - If the Sollya result type is object, the first argument of the\n C function is of C type sollya_obj_t *, the result is returned by\n affecting the sollya_obj_t variable.\n - If the Sollya result type is range, the first argument of the C function\n is of C type mpfi_t *, the result is returned by affecting the MPFI\n variable.\n - If the Sollya result type is integer, the first argument of the\n C function is of C type int *, the result is returned by affecting the\n int variable.\n - If the Sollya result type is string, the first argument of the\n C function is of C type char **, the result is returned by the char *\n pointed with a new char *.\n - If the Sollya result type is boolean, the first argument of the\n C function is of C type int *, the result is returned by affecting the\n int variable with a boolean value.\n - If the Sollya result type is list of type, the first argument of the\n C function is of a C type depending on the Sollya return type: \n - For a list of constant: sollya_constant_list_t *\n - For a list of function: sollya_obj_list_t *\n - For a list of object: sollya_obj_list_t *\n - For a list of range: sollya_constant_list_t *\n - For a list of integer: sollya_int_list_t *\n - For a list of string: sollya_string_list_t *\n - For a list of boolean: sollya_boolean_list_t * \n \n The external procedure affects its possible pointer argument if and only if\n it succeeds. This means, if the function returns an integer indicating\n failure, it does not leak any memory to the encompassing environment.\n \n The external procedure receives its arguments as follows: If the Sollya\n argument type is void, no argument array is given. Otherwise the C function\n receives a C void ** argument representing an array of size equal to the\n arity of the function where each entry (of C type void *) represents a value\n with a C type depending on the corresponding Sollya type. \n - If the Sollya type is constant, the void * is to be cast to mpfr_t *.\n - If the Sollya type is function, the void * is to be cast to\n sollya_obj_t.\n - If the Sollya type is object, the void * is to be cast to sollya_obj_t.\n - If the Sollya type is range, the void * is to be cast to mpfi_t *.\n - If the Sollya type is integer, the void * is to be cast to int *.\n - If the Sollya type is string, the void * is to be cast to char *.\n - If the Sollya type is boolean, the void * is to be cast to int *.\n - If the Sollya type is list of type, the void * is to be cast to a list\n of a type depending on the type of the list argument: \n - For a list of constant: sollya_constant_list_t\n - For a list of function: sollya_obj_list_t\n - For a list of object: sollya_obj_list_t\n - For a list of range: sollya_interval_list_t\n - For a list of integer: sollya_int_list_t\n - For a list of string: sollya_string_list_t\n - For a list of boolean: sollya_boolean_list_t \n \n The external procedure is not supposed to alter the memory pointed by its\n array argument void **.\n \n In both directions (argument and result values), empty lists are represented\n by NULL pointers.\n \n Similarly to internal procedures, externally bounded procedures can be\n considered to be objects inside Sollya that can be assigned to other\n variables, stored in list etc.\n\n * The user should be aware that they may use the Sollya library in external\n codes to be dynamically bound to Sollya using externalproc. On most systems,\n it suffices to include the header of the Sollya library into the source code\n of the external procedure. Linking with the actual Sollya library is not\n necessary on most systems; as the interactive Sollya executable contains a\n superset of the Sollya library functions. On some systems, linking with the\n Sollya library or some of its dependencies may be necessary.\n \n In particular, the Sollya library -- and, of course, its header file --\n contain a certain set of functions to manipulate lists with elements of\n certain types, such as sollya_constant_list_t, sollya_obj_list_t and so on.\n As explained above, these types are passed in argument to (and received back\n thru a reference from) an external procedure. These list manipulation\n functions are not strictly necessary to the use of the Sollya library in\n free-standing applications that do not use the functionality provided with\n externalproc. They are therefore provided as-is without any further\n documentation, besides the comments given in the Sollya library header file.\n\n * The dynamic object file whose name is given to externalproc for binding of\n an external procedure may also define a destructor function\n int sollya_external_lib_close(void). If Sollya finds such a destructor\n function in the dynamic object file, it will call that function when closing\n the dynamic object file again. This happens when Sollya is terminated or when\n the current Sollya session is restarted using restart. The purpose of the\n destructor function is to allow the dynamically bound code to free any memory\n that it might have allocated before Sollya is terminated or restarted.\n \n The dynamic object file is not necessarily needed to define a destructor\n function. This ensure backward compatibility with older Sollya external\n library function object files.\n \n When defined, the destructor function is supposed to return an integer\n value indicating if an error has happened. Upon success, the destructor\n functions is to return a zero value, upon error a non-zero value.\n\nExample 1: \n > bashexecute(\"gcc -fPIC -Wall -c externalprocexample.c\");\n > bashexecute(\"gcc -fPIC -shared -o externalprocexample externalprocexample.o\");\n > externalproc(foo, \"./externalprocexample\", (integer, integer) -> integer);\n > foo;\n foo\n > foo(5, 6);\n 11\n > verbosity = 1!;\n > foo();\n Warning: at least one of the given expressions or a subexpression is not correctly typed\n or its evaluation has failed because of some error on a side-effect.\n error\n > a = foo;\n > a(5,6);\n 11\n\nSee also: library, libraryconstant, externalplot, bashexecute, void, constant, function, range, integer, string, boolean, list of, object\n" #define HELP_FALSE_TEXT "Name: false\n==> the boolean value representing the false.\n\nLibrary names:\n sollya_obj_t sollya_lib_false()\n int sollya_lib_is_false(sollya_obj_t)\n\nDescription: \n * false is the usual boolean value.\n\nExample 1: \n > true && false;\n false\n > 2<1;\n false\n\nSee also: true, &&, ||\n" #define HELP_FILE_TEXT "Name: file\n==> special value for commands plot and externalplot\n\nLibrary names:\n sollya_obj_t sollya_lib_file()\n int sollya_lib_is_file(sollya_obj_t)\n\nDescription: \n * file is a special value used in commands plot and externalplot to save\n the result of the command in a data file.\n\n * As any value it can be affected to a variable and stored in lists.\n\nExample 1: \n > savemode=file;\n > name=\"plotSinCos\";\n > plot(sin(x),0,cos(x),[-Pi,Pi],savemode, name);\n\nSee also: externalplot, plot, postscript, postscriptfile\n" #define HELP_FINDZEROS_TEXT "Name: findzeros\n==> gives a list of intervals containing all zeros of a function on an interval.\n\nLibrary name:\n sollya_obj_t sollya_lib_findzeros(sollya_obj_t, sollya_obj_t)\n\nUsage: \n findzeros({f},{I}) : (function, range) -> list\n\nParameters: \n {f} is a function.\n {I} is an interval.\n\nDescription: \n * findzeros({f},{I}) returns a list of intervals {I1}, ... ,{In} such that, for \n every zero z of f, there exists some k such that z is in Ik.\n\n * The list may contain intervals {Ik} that do not contain any zero of {f}.\n An interval {Ik} may contain many zeros of {f}.\n\n * This command is meant for cases when safety is critical. If you want to be sure\n not to forget any zero, use findzeros. However, if you just want to know \n numerical values for the zeros of {f}, dirtyfindzeros should be quite \n satisfactory and a lot faster.\n\n * If d denotes the value of global variable diam, the algorithm ensures\n that for each k, |Ik| < d*|I|.\n\n * The algorithm used is basically a bisection algorithm. It is the same algorithm\n that the one used for infnorm. See the help page of this command for more \n details. In short, the behavior of the algorithm depends on global variables\n prec, diam, taylorrecursions and hopitalrecursions.\n\nExample 1: \n > findzeros(sin(x),[-5;5]);\n [|[-3.14208984375;-3.140869140625], [-1.220703125e-3;1.220703125e-3], [3.140869140625;3.14208984375]|]\n > diam=1e-10!;\n > findzeros(sin(x),[-5;5]);\n [|[-3.14159265370108187198638916015625;-3.141592652536928653717041015625], [-1.16415321826934814453125e-9;1.16415321826934814453125e-9], [3.141592652536928653717041015625;3.14159265370108187198638916015625]|]\n\nSee also: dirtyfindzeros, infnorm, prec, diam, taylorrecursions, hopitalrecursions, numberroots\n" #define HELP_FIXED_TEXT "Name: fixed\n==> indicates that fixed-point formats should be used for fpminimax\n\nLibrary names:\n sollya_obj_t sollya_lib_fixed()\n int sollya_lib_is_fixed(sollya_obj_t)\n\nUsage: \n fixed : fixed|floating\n\nDescription: \n * The use of fixed in the command fpminimax indicates that the list of\n formats given as argument is to be considered to be a list of fixed-point\n formats.\n See fpminimax for details.\n\nExample 1: \n > fpminimax(cos(x),6,[|32,32,32,32,32,32,32|],[-1;1],fixed);\n 0.9999997480772435665130615234375 + x^2 * (-0.4999928693287074565887451171875 + x^2 * (4.163351492024958133697509765625e-2 + x^2 * (-1.338223926723003387451171875e-3)))\n\nSee also: fpminimax, floating\n" #define HELP_FLOATING_TEXT "Name: floating\n==> indicates that floating-point formats should be used for fpminimax\n\nLibrary names:\n sollya_obj_t sollya_lib_floating()\n int sollya_lib_is_floating(sollya_obj_t)\n\nUsage: \n floating : fixed|floating\n\nDescription: \n * The use of floating in the command fpminimax indicates that the list of\n formats given as argument is to be considered to be a list of floating-point\n formats.\n See fpminimax for details.\n\nExample 1: \n > fpminimax(cos(x),6,[|D...|],[-1;1],floating);\n 0.99999974816012215939053930924274027347564697265625 + x * (-2.795931796958502334440230695107655659202089892465e-15 + x * (-0.49999286980201401719980935922649223357439041137695 + x * (4.0484539189054105169841244454207387920433372507922e-14 + x * (4.1633515528919168291466235132247675210237503051758e-2 + x * (-4.015858818743733758578949218474363725507386355118e-14 + x * (-1.3382240885483781024645200119493892998434603214264e-3))))))\n\nSee also: fpminimax, fixed\n" #define HELP_FLOOR_TEXT "Name: floor\n==> the usual function floor.\n\nLibrary names:\n sollya_obj_t sollya_lib_floor(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_floor(sollya_obj_t)\n #define SOLLYA_FLOOR(x) sollya_lib_build_function_floor(x)\n\nDescription: \n * floor is defined as usual: floor(x) is the greatest integer y such that y <= x.\n\n * It is defined for every real number x.\n\nSee also: ceil, nearestint, round, RD\n" #define HELP_FPMINIMAX_TEXT "Name: fpminimax\n==> computes a good polynomial approximation with fixed-point or floating-point coefficients\n\nLibrary names:\n sollya_obj_t sollya_lib_fpminimax(sollya_obj_t, sollya_obj_t, sollya_obj_t,\n sollya_obj_t, ...)\n sollya_obj_t sollya_lib_v_fpminimax(sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t, va_list)\n\nUsage: \n fpminimax({f}, {n}, {formats}, {range}, {indic1}, {indic2}, {indic3}, {P}) : (function, integer, list, range, absolute|relative | fixed|floating | function, absolute|relative | fixed|floating | function, absolute|relative | fixed|floating | function, function) -> function\n fpminimax({f}, {monomials}, {formats}, {range}, {indic1}, {indic2}, {indic3}, {P}) : (function, list, list, range, absolute|relative | fixed|floating | function, absolute|relative | fixed|floating | function, absolute|relative | fixed|floating | function, function) -> function\n fpminimax({f}, {n}, {formats}, {L}, {indic1}, {indic2}, {indic3}, {P}) : (function, integer, list, list, absolute|relative | fixed|floating | function, absolute|relative | fixed|floating | function, absolute|relative | fixed|floating | function, function) -> function\n fpminimax({f}, {monomials}, {formats}, {L}, {indic1}, {indic2}, {indic3}, {P}) : (function, list, list, list, absolute|relative | fixed|floating | function, absolute|relative | fixed|floating | function, absolute|relative | fixed|floating | function, function) -> function\n\nParameters: \n {f} is the function to be approximated\n {n} is the degree of the polynomial that must approximate {f}\n {monomials} is a list of integers or a list of function. It indicates the basis for the approximation of {f}\n {formats} is a list indicating the formats that the coefficients of the polynomial must have\n {range} is the interval where the function must be approximated\n {L} is a list of interpolation points used by the method\n {indic1} (optional) is one of the optional indication parameters. See the detailed description below.\n {indic2} (optional) is one of the optional indication parameters. See the detailed description below.\n {indic3} (optional) is one of the optional indication parameters. See the detailed description below.\n {P} (optional) is the minimax polynomial to be considered for solving the problem.\n\nDescription: \n * fpminimax uses a heuristic (but practically efficient) method to find a\n good polynomial approximation of a function {f} on an interval {range}. It\n implements the method published in the article: \n Efficient polynomial L^\\infty - approximations\n Nicolas Brisebarre and Sylvain Chevillard \n Proceedings of the 18th IEEE Symposium on Computer Arithmetic (ARITH 18) \n pp. 169-176\n\n * The basic usage of this command is fpminimax({f}, {n}, {formats}, {range}).\n It computes a polynomial approximation of f with degree at most n\n on the interval {range}. {formats} is a list of integers or format types\n (such as double, doubledouble, etc.). The polynomial returned by the\n command has its coefficients that fit the formats indications. For\n instance, if formats[0] is 35, the coefficient of degree 0 of the\n polynomial will fit a floating-point format of 35 bits. If formats[1]\n is D, the coefficient of degree 1 will be representable by a floating-point\n number with a precision of 53 bits (which is not necessarily an IEEE 754\n double precision number. See the remark below), etc.\n\n * The second argument may be either an integer, a list of integers or a list\n of functions. An integer indicates the degree of the desired polynomial\n approximation. A list of integers indicates the list of desired monomials.\n For instance, the list [|0,2,4,6|] indicates that the polynomial must be\n even and of degree at most 6. Giving an integer n as second argument is\n equivalent as giving [|0,...,n|].\n Finally, a list of function g_k indicates that the desired approximation\n must be a linear combination of the g_k. \n The list of formats is interpreted with respect to the list of monomials. For\n instance, if the list of monomials is [|0,2,4,6|] and the list\n of formats is [|161,107,53,24|], the coefficients of degree 0 is\n searched as a floating-point number with precision 161, the coefficient of\n degree 2 is searched as a number of precision 107, and so on.\n\n * The list of formats may contain either integers or format types\n (halfprecision, single, double, doubledouble, tripledouble, doubleextended\n and quad). The list may be too large or even infinite. Only the first\n indications will be considered. For instance, for a degree n polynomial,\n formats[n+1] and above will be discarded. This lets one use elliptical\n indications for the last coefficients.\n\n * The floating-point coefficients considered by fpminimax do not have an\n exponent range. In particular, in the format list, double is an exact synonym\n for 53. Currently, fpminimax only ensures that the corresponding coefficient\n has at most 53 bits of mantissa. It does not imply that it is an\n IEEE-754 double.\n\n * By default, the list of formats is interpreted as a list of floating-point\n formats. This may be changed by passing fixed as an optional argument (see\n below). Let us take an example: fpminimax(f, 2, [|107, DD, 53|], [0;1]).\n Here the optional argument is missing (we could have set it to floating).\n Thus, fpminimax will search for a polynomial of degree 2 with a constant\n coefficient that is a 107 bits floating-point number, etc. \n Currently, doubledouble is just a synonym for 107 and tripledouble a\n synonym for 161. This behavior may change in the future (taking into\n account the fact that some double-doubles are not representable with\n 107 bits). \n Second example: fpminimax(f, 2, [|25, 18, 30|], [0;1], fixed).\n In this case, fpminimax will search for a polynomial of degree 2 with a\n constant coefficient of the form m/2^25 where m is an\n integer. In other words, it is a fixed-point number with 25 bits after\n the point. Note that even with argument fixed, the formats list is\n allowed to contain halfprecision, single, double, doubleextended,\n doubledouble, quad or tripledouble. In this this case, it is just\n a synonym for 11, 24, 53, 64, 107, 113 or 161. This is deprecated and\n may change in the future.\n\n * The fourth argument may be a range or a list. Lists are for advanced users\n that know what they are doing. The core of the method is a kind of\n approximated interpolation. The list given here is a list of points that\n must be considered for the interpolation. It must contain at least as\n many points as unknown coefficients. If you give a list, it is also\n recommended that you provide the minimax polynomial as last argument.\n If you give a range, the list of points will be automatically computed.\n\n * The fifth, sixth and seventh arguments are optional. By default, fpminimax\n will approximate f while optimizing the relative error, and interpreting\n the list of formats as a list of floating-point formats. \n This default behavior may be changed with these optional arguments. You\n may provide zero, one, two or three of the arguments in any order.\n This lets the user indicate only the non-default arguments. \n The three possible arguments are: \n - relative or absolute: the error to be optimized;\n - floating or fixed: formats of the coefficients;\n - a constrained part q.\n \n The constrained part lets the user assign in advance some of the\n coefficients. For instance, for approximating exp(x), it may\n be interesting to search for a polynomial p of the form\n p = 1 + x + x^2/2 + a3 x^3 + a4 x^4.\n Thus, there is a constrained part q = 1 + x + x^2/2 and the unknown\n polynomial should be considered in the monomial basis [|3, 4|].\n Calling fpminimax with monomial basis [|3,4|] and constrained\n part q, will return a polynomial with the right form.\n\n * The last argument is for advanced users. It is the minimax polynomial that\n approximates the function f in the given basis. If it is not given\n this polynomial will be automatically computed by fpminimax.\n \n This minimax polynomial is used to compute the list of interpolation\n points required by the method. It is also used, when floating-point\n coefficients are desired, to give an initial assumption for the\n exponents of the coeffcients. In general, you do not have to provide this\n argument. But if you want to obtain several polynomials of the same degree\n that approximate the same function on the same range, just changing the\n formats, you should probably consider computing only once the minimax\n polynomial and the list of points instead of letting fpminimax recompute\n them each time.\n \n Note that in the case when a constrained part is given, the minimax\n polynomial must take that into account. For instance, in the previous\n example, the minimax would be obtained by the following command:\n P = remez(1-(1+x+x^2/2)/exp(x), [|3,4|], range, 1/exp(x));\n Note that the constrained part is not to be added to P.\n \n In the case when the second argument is an integer or a list of integers,\n there is no restriction for P, as long as it is a polynomial.\n However, when the second argument is a list of functions, and even if these\n functions are all polynomials, P must be expanded in the given basis.\n For instance, if the second argument is 2 or [|0, 1, 2|], P can be given\n in Horner form. However, if the second argument is [|1, x, x^2|], P must\n be written as a linear combination of 1, x and x^2, otherwise, the algorithm\n will fail to recover the coefficients of P and will fail with an error\n message.\n \n Please also note that recovering the coefficients of P in an arbitrary\n basis is performed heuristically and no verification is performed to check\n that P does not contain other functions than the functions of the basis.\n\n * Note that fpminimax internally computes a minimax polynomial (using\n the same algorithm as remez command). Thus fpminimax may encounter\n the same problems as remez. In particular, it may be very slow\n when Haar condition is not fulfilled. Another consequence is that\n currently fpminimax has to be run with a sufficiently high working precision.\n\nExample 1: \n > P = fpminimax(cos(x),6,[|DD, DD, D...|],[-1b-5;1b-5]);\n > printexpansion(P);\n (0x3ff0000000000000 + 0xbc09fda15e029b00) + x * ((0x3af9eb57163024a8 + 0x37942c2f3f3e3839) + x * (0xbfdfffffffffff98 + x * (0xbbd1693f9c028849 + x * (0x3fa5555555145337 + x * (0x3c7a25f610ad9ebc + x * 0xbf56c138142da5b0)))))\n\nExample 2: \n > P = fpminimax(sin(x),6,[|32...|],[-1b-5;1b-5], fixed, absolute);\n > display = powers!;\n > P;\n x * (1 + x^2 * (-357913941 * 2^(-31) + x^2 * (35789873 * 2^(-32))))\n\nExample 3: \n > P = fpminimax(exp(x), [|3,4|], [|D,24|], [-1/256; 1/246], 1+x+x^2/2);\n > display = powers!;\n > P;\n 1 + x * (1 + x * (1 * 2^(-1) + x * (375300225001191 * 2^(-51) + x * (5592621 * 2^(-27)))))\n\nExample 4: \n > f = cos(exp(x));\n > pstar = remez(f, 5, [-1b-7;1b-7]);\n > listpoints = dirtyfindzeros(f-pstar, [-1b-7; 1b-7]);\n > P1 = fpminimax(f, 5, [|DD...|], listpoints, absolute, default, default, pstar);\n > P2 = fpminimax(f, 5, [|D...|], listpoints, absolute, default, default, pstar);\n > P3 = fpminimax(f, 5, [|D, D, D, 24...|], listpoints, absolute, default, default, pstar);\n > print(\"Error of pstar: \", dirtyinfnorm(f-pstar, [-1b-7; 1b-7]));\n Error of pstar: 7.9048441259903026332577436001060063099817726177425e-16\n > print(\"Error of P1: \", dirtyinfnorm(f-P1, [-1b-7; 1b-7]));\n Error of P1: 7.9048441259903026580081299123420463921479618202064e-16\n > print(\"Error of P2: \", dirtyinfnorm(f-P2, [-1b-7; 1b-7]));\n Error of P2: 8.2477144579950871737109573536791331686347620955985e-16\n > print(\"Error of P3: \", dirtyinfnorm(f-P3, [-1b-7; 1b-7]));\n Error of P3: 1.08454277156993282593701156841863009789063333951055e-15\n\nExample 5: \n > L = [|exp(x), sin(x), cos(x)-1, sin(x^3)|];\n > g = (2^x-1)/x;\n > p = fpminimax(g, L, [|D...|], [-1/16;1/16],absolute);\n > display = powers!;\n > p;\n -3267884797436153 * 2^(-54) * sin(x^3) + 5247089102535885 * 2^(-53) * (cos(x) - 1) + -8159095033730771 * 2^(-54) * sin(x) + 6243315658446641 * 2^(-53) * exp(x)\n\nExample 6: \n > n = 9;\n > T = [|1, x|];\n > for i from 2 to n do T[i] = canonical(2*x*T[i-1]-T[i-2]);\n > g = (2^x-1)/x;\n > PCheb = fpminimax(g, T, [|DD,DE...|], [-1/16;1/16],absolute);\n > display = dyadic!;\n > print(PCheb);\n 8733930098894247371b-98 * (9 * x + -120 * x^3 + 432 * x^5 + -576 * x^7 + 256 * x^9) + 15750497046710770365b-94 * (1 + -32 * x^2 + 160 * x^4 + -256 * x^6 + 128 * x^8) + 6467380330985872933b-88 * (-7 * x + 56 * x^3 + -112 * x^5 + 64 * x^7) + 9342762606926218927b-84 * (-1 + 18 * x^2 + -48 * x^4 + 32 * x^6) + 11814521367456461131b-80 * (5 * x + -20 * x^3 + 16 * x^5) + 6405479474328570593b-75 * (1 + -8 * x^2 + 8 * x^4) + 11584457324781949889b-72 * (-3 * x + 4 * x^3) + 16779705312447201161b-69 * (-1 + 2 * x^2) + 18265014280997359319b-66 * x + 117054497448175143902009975397253b-107\n\nSee also: remez, dirtyfindzeros, absolute, relative, fixed, floating, default, halfprecision, single, double, doubleextended, doubledouble, quad, tripledouble, implementpoly, coeff, degree, roundcoefficients, guessdegree\n" #define HELP_FULLPARENTHESES_TEXT "Name: fullparentheses\n==> activates, deactivates or inspects the state variable controlling output with full parenthesising\n\nLibrary names:\n void sollya_lib_set_fullparentheses_and_print(sollya_obj_t);\n void sollya_lib_set_fullparentheses(sollya_obj_t);\n sollya_obj_t sollya_lib_get_fullparentheses();\n\nUsage: \n fullparentheses = {activation value} : on|off -> void\n fullparentheses = {activation value} ! : on|off -> void\n\nParameters: \n {activation value} represents on or off, i.e. activation or deactivation\n\nDescription: \n * An assignment fullparentheses = {activation value}, where {activation value}\n is one of on or off, activates respectively deactivates the output\n of expressions with full parenthesising. In full parenthesising mode,\n Sollya commands like print, write and the implicit command when an\n expression is given at the prompt will output expressions with\n parenthesising at all places where it is necessary for expressions\n containing infix operators to be parsed back with the same\n result. Otherwise parentheses around associative operators are\n omitted.\n \n If the assignment fullparentheses = {activation value} is followed by an\n exclamation mark, no message indicating the new state is\n displayed. Otherwise the user is informed of the new state of the\n global mode by an indication.\n\nExample 1: \n > autosimplify = off!;\n > fullparentheses = off;\n Full parentheses mode has been deactivated.\n > print(1 + 2 + 3);\n 1 + 2 + 3\n > fullparentheses = on;\n Full parentheses mode has been activated.\n > print(1 + 2 + 3);\n (1 + 2) + 3\n\nSee also: print, write, autosimplify\n" #define HELP_FUNCTION_TEXT "Name: function\n==> keyword for declaring a procedure-based function or a keyword representing a function type \n\nLibrary names:\n sollya_obj_t sollya_lib_procedurefunction(sollya_obj_t, sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_procedurefunction(sollya_obj_t,\n sollya_obj_t)\n SOLLYA_EXTERNALPROC_TYPE_FUNCTION\n\nUsage: \n function({procedure}) : procedure -> function\n function : type type\n\nParameters: \n {procedure} is a procedure of type (range, integer, integer) -> range\n\nDescription: \n * For the sake of safety and mathematical consistency, Sollya\n distinguishes clearly between functions, seen in the mathematical\n sense of the term, i.e. mappings, and procedures, seen in the sense\n Computer Science gives to functions, i.e. pieces of code that compute\n results for arguments following an algorithm. In some cases however,\n it is interesting to use such Computer Science procedures as\n realisations of mathematical functions, e.g. in order to plot them or\n even to perform polynomial approximation on them. The function keyword\n allows for such a transformation of a Sollya procedure into a Sollya\n function. \n\n * The procedure to be used as a function through function({procedure})\n must be of type (range, integer, integer)\n -> range. This means it must take in argument\n an interval X, a degree of differentiation n and a\n working precision p. It must return in result an interval\n Y encompassing the image f^(n)(X) of the\n n-th derivative of the implemented function f,\n i.e. f^(n)(X) c Y. In order to allow\n Sollya's algorithms to work properly, the procedure must ensure that,\n whenever (p, diam(X)) tends to (infinity, 0),\n the computed over-estimated bounding Y tends to the actual image f^(n)(X).\n\n * The user must be aware that they are responsible of the correctness\n of the procedure. If, for some n and X, {procedure} returns an interval Y\n such that f^n(X) is not included in Y, function will successfully\n return a function without any complain, but this function might behave\n inconsistently in further computations.\n\n * For cases when the procedure does not have the correct signature or\n does not return a finite interval as a result function({procedure})\n evaluates to Not-A-Number (resp. to an interval of Not-A-Numbers for\n interval evaluation).\n\n * function also represents the function type for declarations\n of external procedures by means of externalproc.\n \n Remark that in contrast to other indicators, type indicators like\n function cannot be handled outside the externalproc context. In\n particular, they cannot be assigned to variables.\n\nExample 1: \n > procedure EXP(X,n,p) {\n \t var res, oldPrec;\n \t oldPrec = prec;\n \t prec = p!;\n \t \n \t res = exp(X);\n \t \n \t prec = oldPrec!;\n \t return res;\n };\n > f = function(EXP);\n > f(1);\n 2.7182818284590452353602874713526624977572470937\n > exp(1);\n 2.7182818284590452353602874713526624977572470937\n > f(x + 3);\n (function(proc(X, n, p)\n {\n var res, oldPrec;\n oldPrec = prec;\n prec = p!;\n res = exp(X);\n prec = oldPrec!;\n return res;\n }))(3 + x)\n > diff(f);\n diff(function(proc(X, n, p)\n {\n var res, oldPrec;\n oldPrec = prec;\n prec = p!;\n res = exp(X);\n prec = oldPrec!;\n return res;\n }))\n > (diff(f))(0);\n 1\n > g = f(sin(x));\n > g(17);\n 0.38235816999386683402690554641655641359573458342088\n > diff(g);\n (diff(function(proc(X, n, p)\n {\n var res, oldPrec;\n oldPrec = prec;\n prec = p!;\n res = exp(X);\n prec = oldPrec!;\n return res;\n })))(sin(x)) * cos(x)\n > (diff(g))(1);\n 1.25338076749344683697237458088447611474812675164344\n > p = remez(f,3,[-1/2;1/2]);\n > p;\n 0.99967120901420646830315493949039176881764871951833 + x * (0.99973702983571140134762682913614052309208076875596 + x * (0.510497293602826249216227216546435103583073053437 + x * 0.169814324607133287588897694747370380479108785868016))\n\nSee also: proc, library, procedure, externalproc, boolean, constant, integer, list of, range, string, object\n" #define HELP_GE_TEXT "Name: >=\n==> greater-than-or-equal-to operator\n\nLibrary name:\n sollya_obj_t sollya_lib_cmp_greater_equal(sollya_obj_t, sollya_obj_t)\n\nUsage: \n {expr1} >= {expr2} : (constant, constant) -> boolean\n\nParameters: \n {expr1} and {expr2} represent constant expressions\n\nDescription: \n * The operator >= evaluates to true iff its operands {expr1} and\n {expr2} evaluate to two floating-point numbers a1\n respectively a2 with the global precision prec and\n a1 is greater than or equal to a2. The user should\n be aware of the fact that because of floating-point evaluation, the\n operator >= is not exactly the same as the mathematical\n operation \"greater-than-or-equal-to\".\n\nExample 1: \n > 5 >= 4;\n true\n > 5 >= 5;\n true\n > 5 >= 6;\n false\n > exp(2) >= exp(1);\n true\n > log(1) >= exp(2);\n false\n\nExample 2: \n > prec = 12;\n The precision has been set to 12 bits.\n > 16384.1 >= 16385.1;\n true\n\nSee also: ==, !=, >, <=, <, in, !, &&, ||, prec, max, min\n" #define HELP_GETBACKTRACE_TEXT "Name: getbacktrace\n==> returns the list of Sollya procedures currently run\n\nLibrary name:\n sollya_obj_t sollya_lib_getbacktrace();\n\nUsage: \n getbacktrace() : void -> list\n\nDescription: \n * The getbacktrace command allows the stack of Sollya procedures that are\n currently run to be inspected. When called, getbacktrace returns an\n ordered list of structures, each of which contains an element\n passed_args and an element called_proc. The element called_proc\n contains the Sollya object representing the procedure being run. The\n element passed_args contains an ordered list of all effective\n arguments passed to the procedure when it was called. The procedure called\n last (i.e., on top of the stack) comes first in the list returned\n by getbacktrace. When any of the procedure called takes no arguments, the\n passed_arg element of the corresponding structure evaluates to an empty\n list.\n\n * When called from outside any procedure (at toplevel), getbacktrace returns\n an empty list.\n\n * When called for a stack containing a call to a variadic procedure that was\n called with an infinite number of effective arguments, the corresponding\n passed_args element evaluates to an end-elliptic list.\n\nExample 1: \n > procedure testA() {\n \t \"Current backtrace:\";\n \t getbacktrace();\n };\n > procedure testB(X) {\n \t \"X = \", X;\n \t testA();\n };\n > procedure testC(X, Y) {\n \t \"X = \", X, \", Y = \", Y;\n \t testB(Y);\n };\n > testC(17, 42);\n X = 17, Y = 42\n X = 42\n Current backtrace:\n [|{ .passed_args = [| |], .called_proc = proc()\n {\n \"Current backtrace:\";\n getbacktrace();\n return void;\n } }, { .passed_args = [|42|], .called_proc = proc(X)\n {\n \"X = \", X;\n testA();\n return void;\n } }, { .passed_args = [|17, 42|], .called_proc = proc(X, Y)\n {\n \"X = \", X, \", Y = \", Y;\n testB(Y);\n return void;\n } }|]\n\nExample 2: \n > getbacktrace();\n [| |]\n\nExample 3: \n > procedure printnumargs(X) {\n \t var L, t;\n \t \"number of arguments: \", X;\n \t L = getbacktrace();\n \t \"Backtrace:\";\n \t for t in L do {\n \t \" \" @ objectname(t.called_proc) @ \", \", t.passed_args;\n \t };\n };\n > procedure numargs(l = ...) {\n \t \"l[17] = \", l[17];\n \t printnumargs(length(l));\n };\n > procedure test() {\n \t numargs @ [|25, 26, 27 ...|];\n };\n > test();\n l[17] = 42\n number of arguments: infty\n Backtrace:\n printnumargs, [|infty|]\n numargs, [|25, 26, 27...|]\n test, [| |]\n\nSee also: proc, procedure, objectname, bind, @\n" #define HELP_GETSUPPRESSEDMESSAGES_TEXT "Name: getsuppressedmessages\n==> returns a list of numbers of messages that have been suppressed from message output\n\nLibrary name:\n sollya_obj_t sollya_lib_getsuppressedmessages();\n\nUsage: \n getsuppressedmessages() : void -> list\n\nDescription: \n * The getsuppressedmessages command allows the user to inspect the state of warning\n and information message suppression. When called, getsuppressedmessages returns a\n list of integers numbers that stand for the warning and information\n messages that have been suppressed. If no message is suppressed,\n getsuppressedmessages returns an empty list.\n\n * Every Sollya warning or information message (that is not fatal to the\n tool's execution) has a message number. By default, these numbers are\n not displayed when a message is output. When message number displaying\n is activated using showmessagenumbers, the message numbers are\n displayed together with the message. This allows the user to match the\n numbers returned in a list by getsuppressedmessages with the actual warning and\n information messages.\n\n * The list of message numbers returned by getsuppressedmessages is suitable to be fed\n into the unsuppressmessage command. This way, the user may unsuppress\n all warning and information messages that have been suppressed.\n\nExample 1: \n > verbosity = 1;\n The verbosity level has been set to 1.\n > 0.1;\n Warning: Rounding occurred when converting the constant \"0.1\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n 0.1\n > suppressmessage(174);\n > 0.1;\n 0.1\n > suppressmessage(407);\n > 0.1;\n 0.1\n > getsuppressedmessages();\n [|174, 407|]\n > suppressmessage(207, 196);\n > getsuppressedmessages();\n [|174, 196, 207, 407|]\n\nExample 2: \n > suppressmessage(174, 209, 13, 24, 196);\n > suppressmessage([| 16, 17 |]);\n > suppressmessage(19);\n > unsuppressmessage([| 13, 17 |]);\n > getsuppressedmessages();\n [|16, 19, 24, 174, 196, 209|]\n > unsuppressmessage(getsuppressedmessages());\n > getsuppressedmessages();\n [| |]\n\nExample 3: \n > verbosity = 12;\n The verbosity level has been set to 12.\n > suppressmessage(174);\n > exp(x * 0.1);\n Information: no Horner simplification will be performed because the given tree is already in Horner form.\n exp(x * 0.1)\n > getsuppressedmessages();\n [|174|]\n > verbosity = 0;\n The verbosity level has been set to 0.\n > exp(x * 0.1);\n exp(x * 0.1)\n > getsuppressedmessages();\n [|174|]\n\nSee also: getsuppressedmessages, suppressmessage, unsuppressmessage, verbosity, roundingwarnings\n" #define HELP_GT_TEXT "Name: >\n==> greater-than operator\n\nLibrary name:\n sollya_obj_t sollya_lib_cmp_greater(sollya_obj_t, sollya_obj_t)\n\nUsage: \n {expr1} > {expr2} : (constant, constant) -> boolean\n\nParameters: \n {expr1} and {expr2} represent constant expressions\n\nDescription: \n * The operator > evaluates to true iff its operands {expr1} and\n {expr2} evaluate to two floating-point numbers a1\n respectively a2 with the global precision prec and\n a1 is greater than a2. The user should\n be aware of the fact that because of floating-point evaluation, the\n operator > is not exactly the same as the mathematical\n operation \"greater-than\".\n\nExample 1: \n > 5 > 4;\n true\n > 5 > 5;\n false\n > 5 > 6;\n false\n > exp(2) > exp(1);\n true\n > log(1) > exp(2);\n false\n\nExample 2: \n > prec = 12;\n The precision has been set to 12 bits.\n > 16385.1 > 16384.1;\n false\n\nSee also: ==, !=, >=, <=, <, in, !, &&, ||, prec, max, min\n" #define HELP_GUESSDEGREE_TEXT "Name: guessdegree\n==> returns the minimal degree needed for a polynomial to approximate a function with a certain error on an interval.\n\nLibrary names:\n sollya_obj_t sollya_lib_guessdegree(sollya_obj_t, sollya_obj_t,\n sollya_obj_t, ...)\n sollya_obj_t sollya_lib_v_guessdegree(sollya_obj_t, sollya_obj_t,\n sollya_obj_t, va_list)\n\nUsage: \n guessdegree({f},{I},{eps},{w},{bound}) : (function, range, constant, function, constant) -> range\n\nParameters: \n {f} is the function to be approximated.\n {I} is the interval where the function must be approximated.\n {eps} is the maximal acceptable error.\n {w} (optional) is a weight function. Default is 1.\n {bound} (optional) is a bound on the degree. Default is currently 128.\n\nDescription: \n * guessdegree tries to find the minimal degree needed to approximate {f}\n on {I} by a polynomial with an error err=p*w-f whose infinity norm not\n greater than {eps}. More precisely, it finds n minimal such that there exists\n a polynomial p of degree n such that ||p*w-f|| < eps.\n\n * guessdegree returns an interval: for common cases, this interval is reduced\n to a single number (i.e. the minimal degree). But in certain cases,\n guessdegree does not succeed in finding the minimal degree. In such cases the\n returned interval is of the form [n,p] such that:\n - no polynomial of degree n-1 gives an error less than {eps}.\n - there exists a polynomial of degree p giving an error less than {eps}.\n\n * The fifth optional argument {bound} is used to prevent guessdegree from\n trying to find too large degrees. If guessdegree does not manage to find a\n degree n satisfying the error and such that n<=bound, an interval of the\n form [*, +Inf] is returned. Note that {bound} must be a positive integer.\n\nExample 1: \n > guessdegree(exp(x),[-1;1],1e-10);\n [10;10]\n\nExample 2: \n > guessdegree(exp(x),[-1;1],1e-10,default, 9);\n [10;infty]\n\nExample 3: \n > guessdegree(1, [-1;1], 1e-8, 1/exp(x));\n [8;9]\n\nSee also: dirtyinfnorm, remez, fpminimax, degree\n" #define HELP_HALFPRECISION_TEXT "Names: halfprecision, HP\n==> rounding to the nearest IEEE 754 half-precision number (binary16).\n\nLibrary names:\n sollya_obj_t sollya_lib_halfprecision(sollya_obj_t)\n sollya_obj_t sollya_lib_halfprecision_obj()\n int sollya_lib_is_halfprecision_obj(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_halfprecision(sollya_obj_t)\n #define SOLLYA_HP(x) sollya_lib_build_function_halfprecision(x)\n\nDescription: \n * halfprecision is both a function and a constant.\n\n * As a function, it rounds its argument to the nearest IEEE 754 half-precision (i.e. IEEE754-2008 binary16) number.\n Subnormal numbers are supported as well as standard numbers: it is the real\n rounding described in the standard.\n\n * As a constant, it symbolizes the half-precision format. It is used in \n contexts when a precision format is necessary, e.g. in the commands \n round and roundcoefficients. It is not supported for implementpoly.\n See the corresponding help pages for examples.\n\nExample 1: \n > display=binary!;\n > HP(0.1);\n 1.100110011_2 * 2^(-4)\n > HP(4.17);\n 1.00001011_2 * 2^(2)\n > HP(1.011_2 * 2^(-23));\n 1.1_2 * 2^(-23)\n\nSee also: single, double, doubleextended, doubledouble, quad, tripledouble, roundcoefficients, fpminimax, implementpoly, round, printsingle\n" #define HELP_HEAD_TEXT "Name: head\n==> gives the first element of a list.\n\nLibrary name:\n sollya_obj_t sollya_lib_head(sollya_obj_t)\n\nUsage: \n head({L}) : list -> any type\n\nParameters: \n {L} is a list.\n\nDescription: \n * head({L}) returns the first element of the list {L}. It is equivalent\n to L[0].\n\n * If {L} is empty, the command will fail with an error.\n\nExample 1: \n > head([|1,2,3|]);\n 1\n > head([|1,2...|]);\n 1\n\nSee also: tail\n" #define HELP_HEXADECIMAL_TEXT "Name: hexadecimal\n==> special value for global state display\n\nLibrary names:\n sollya_obj_t sollya_lib_hexadecimal()\n int sollya_lib_is_hexadecimal(sollya_obj_t)\n\nDescription: \n * hexadecimal is a special value used for the global state display. If\n the global state display is equal to hexadecimal, all data will be\n output in hexadecimal C99/ IEEE 754-2008 notation.\n \n As any value it can be affected to a variable and stored in lists.\n\nSee also: decimal, dyadic, powers, binary, display\n" #define HELP_HONORCOEFFPREC_TEXT "Name: honorcoeffprec\n==> indicates the (forced) honoring the precision of the coefficients in implementpoly\n\nLibrary names:\n sollya_obj_t sollya_lib_honorcoeffprec()\n int sollya_lib_is_honorcoeffprec(sollya_obj_t)\n\nUsage: \n honorcoeffprec : honorcoeffprec\n\nDescription: \n * Used with command implementpoly, honorcoeffprec makes implementpoly honor\n the precision of the given polynomial. This means if a coefficient\n needs a double-double or a triple-double to be exactly stored,\n implementpoly will allocate appropriate space and use a double-double\n or triple-double operation even if the automatic (heuristic)\n determination implemented in command implementpoly indicates that the\n coefficient could be stored on less precision or, respectively, the\n operation could be performed with less precision. See implementpoly\n for details.\n\nExample 1: \n > verbosity = 1!;\n > q = implementpoly(1 - dirtysimplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,\"p\",\"implementation.c\");\n Warning: at least one of the coefficients of the given polynomial has been rounded in a way\n that the target precision can be achieved at lower cost. Nevertheless, the implemented polynomial\n is different from the given one.\n > printexpansion(q);\n 0x3ff0000000000000 + x^2 * 0xbfc5555555555555\n > r = implementpoly(1 - dirtysimplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,\"p\",\"implementation.c\",honorcoeffprec);\n Warning: the inferred precision of the 2th coefficient of the polynomial is greater than\n the necessary precision computed for this step. This may make the automatic determination\n of precisions useless.\n > printexpansion(r);\n 0x3ff0000000000000 + x^2 * (0xbfc5555555555555 + 0xbc65555555555555 + 0xb905555555555555)\n\nSee also: implementpoly, printexpansion, fpminimax\n" #define HELP_HOPITALRECURSIONS_TEXT "Name: hopitalrecursions\n==> controls the number of recursion steps when applying L'Hopital's rule.\n\nLibrary names:\n void sollya_lib_set_hopitalrecursions_and_print(sollya_obj_t)\n void sollya_lib_set_hopitalrecursions(sollya_obj_t)\n sollya_obj_t sollya_lib_get_hopitalrecursions()\n\nUsage: \n hopitalrecursions = {n} : integer -> void\n hopitalrecursions = {n} ! : integer -> void\n hopitalrecursions : integer\n\nParameters: \n {n} represents the number of recursions\n\nDescription: \n * hopitalrecursions is a global variable. Its value represents the number of steps of\n recursion that are tried when applying L'Hopital's rule. This rule is applied\n by the interval evaluator present in the core of Sollya (and particularly\n visible in commands like infnorm).\n\n * If an expression of the form f/g has to be evaluated by interval \n arithmetic on an interval I and if f and g have a common zero\n in I, a direct evaluation leads to NaN.\n Sollya implements a safe heuristic to avoid this, based on L'Hopital's rule: in \n such a case, it can be shown that (f/g)(I) C (f'/g')(I). Since\n the same problem may exist for f'/g', the rule is applied recursively.\n The number of step in this recursion process is controlled by hopitalrecursions.\n\n * Setting hopitalrecursions to 0 makes Sollya use this rule only once;\n setting it to 1 makes Sollya use the rule twice, and so on.\n In particular: the rule is always applied at least once, if necessary.\n\nExample 1: \n > hopitalrecursions=0;\n The number of recursions for Hopital's rule has been set to 0.\n > evaluate(log(1+x)^2/x^2,[-1/2; 1]);\n [-infty;infty]\n > hopitalrecursions=1;\n The number of recursions for Hopital's rule has been set to 1.\n > evaluate(log(1+x)^2/x^2,[-1/2; 1]);\n [-2.5225887222397812376689284858327062723020005374411;6.7725887222397812376689284858327062723020005374412]\n\nSee also: taylorrecursions, infnorm, findzeros, evaluate\n" #define HELP_HORNER_TEXT "Name: horner\n==> brings all polynomial subexpressions of an expression to Horner form\n\nLibrary name:\n sollya_obj_t sollya_lib_horner(sollya_obj_t)\n\nUsage: \n horner({function}) : function -> function\n\nParameters: \n {function} represents the expression to be rewritten in Horner form\n\nDescription: \n * The command horner rewrites the expression representing the function\n {function} in a way such that all polynomial subexpressions (or the\n whole expression itself, if it is a polynomial) are written in Horner\n form. The command horner does not endanger the safety of\n computations even in Sollya's floating-point environment: the\n function returned is mathematically equal to the function {function}.\n\nExample 1: \n > print(horner(1 + 2 * x + 3 * x^2));\n 1 + x * (2 + x * 3)\n > print(horner((x + 1)^7));\n 1 + x * (7 + x * (21 + x * (35 + x * (35 + x * (21 + x * (7 + x))))))\n\nExample 2: \n > print(horner(exp((x + 1)^5) - log(asin(x + x^3) + x)));\n exp(1 + x * (5 + x * (10 + x * (10 + x * (5 + x))))) - log(asin(x * (1 + x^2)) + x)\n\nSee also: canonical, print, coeff, degree, autosimplify, simplify\n" #define HELP_HP_TEXT "Name: HP\n==> short form for halfprecision\n\nSee also: halfprecision\n" #define HELP_IMPLEMENTCONSTANT_TEXT "Name: implementconstant\n==> implements a constant in arbitrary precision\n\nLibrary names:\n void sollya_lib_implementconstant(sollya_obj_t, ...);\n void sollya_lib_v_implementconstant(sollya_obj_t, va_list);\n\nUsage: \n implementconstant({expr}) : constant -> void\n implementconstant({expr},{filename}) : (constant, string) -> void\n implementconstant({expr},{filename},{functionname}) : (constant, string, string) -> void\n\nDescription: \n * The command implementconstant implements the constant expression {expr} in \n arbitrary precision. More precisely, it generates the source code (written\n in C, and using MPFR) of a C function const_something with the following\n signature:\n \n void const_something (mpfr_ptr y, mp_prec_t prec)\n \n Let us denote by c the exact mathematical value of the constant defined by\n the expression {expr}. When called with arguments y and prec (where the\n variable y is supposed to be already initialized), the function\n mpfr_const_something sets the precision of y to a suitable precision and\n stores in it an approximate value of c such that\n |y-c| <= |c|*2^(1-prec).\n\n * When no filename {filename} is given or if default is given as\n {filename}, the source code produced by implementconstant is printed on\n standard output. Otherwise, when {filename} is given as a \n string of characters, the source code is output to a file \n named {filename}. If that file cannot be opened and/or \n written to, implementconstant fails and has no other effect.\n\n * When {functionname} is given as an argument to implementconstant and\n {functionname} evaluates to a string of characters, the default name\n for the C function const_something is\n replaced by {functionname}. When default is given as {functionname},\n the default name is used nevertheless, as if no {functionname}\n argument were given. When choosing a character sequence for\n {functionname}, the user should keep attention to the fact that\n {functionname} must be a valid C identifier in order to enable\n error-free compilation of the produced code.\n\n * If {expr} refers to a constant defined with libraryconstant, the produced\n code uses the external code implementing this constant. The user should\n keep in mind that it is up to them to make sure the symbol for that \n external code can get resolved when the newly generated code is to \n be loaded.\n\n * If a subexpression of {expr} evaluates to 0, implementconstant will most\n likely fail with an error message.\n\n * implementconstant is unable to implement constant expressions {expr} that\n contain procedure-based functions, i.e. functions created from Sollya\n procedures using the function construct. If {expr} contains such a\n procedure-based function, implementconstant prints a warning and fails\n silently. The reason for this lack of functionality is that the\n produced C source code, which is supposed to be compiled, would have\n to call back to the Sollya interpreter in order to evaluate the\n procedure-based function.\n\n * Similarly, implementconstant is currently unable to implement constant\n expressions {expr} that contain library-based functions, i.e.\n functions dynamically bound to Sollya using the library construct.\n If {expr} contains such a library-based function, implementconstant prints\n a warning and fails silently. Support for this feature is in principle\n feasible from a technical standpoint and might be added in a future\n release of Sollya.\n\n * Currently, non-differentiable functions such as double, doubledouble,\n tripledouble, single, halfprecision, quad, doubleextended, \n floor, ceil, nearestint are not supported by implementconstant. \n If implementconstant encounters one of them, a warning message is displayed \n and no code is produced. However, if autosimplify equals on, it is \n possible that Sollya silently simplifies subexpressions of {expr} \n containing such functions and that implementconstant successfully produces \n code for evaluating {expr}.\n\n * While it produces an MPFR-based C source code for {expr}, implementconstant\n takes architectural and system-dependent parameters into account. For\n example, it checks whether literal constants figuring in {expr} can be\n represented on a C long int type or if they must\n be stored in a different manner not to affect their accuracy. These\n tests, performed by Sollya during execution of implementconstant, depend\n themselves on the architecture Sollya is running on. Users should\n keep this matter in mind, especially when trying to compile source\n code on one machine whilst it has been produced on another.\n\nExample 1: \n > implementconstant(exp(1)+log(2)/sqrt(1/10)); \n\n [ The first 100 lines of the output have been removed ]\n\n #include \n \n void\n const_something (mpfr_ptr y, mp_prec_t prec)\n {\n /* Declarations */\n mpfr_t tmp1;\n mpfr_t tmp2;\n mpfr_t tmp3;\n mpfr_t tmp4;\n mpfr_t tmp5;\n mpfr_t tmp6;\n mpfr_t tmp7;\n \n /* Initializations */\n mpfr_init2 (tmp2, prec+5);\n mpfr_init2 (tmp1, prec+3);\n mpfr_init2 (tmp4, prec+8);\n mpfr_init2 (tmp3, prec+7);\n mpfr_init2 (tmp6, prec+11);\n mpfr_init2 (tmp7, prec+11);\n mpfr_init2 (tmp5, prec+11);\n \n /* Core */\n mpfr_set_prec (tmp2, prec+4);\n mpfr_set_ui (tmp2, 1, MPFR_RNDN);\n mpfr_set_prec (tmp1, prec+3);\n mpfr_exp (tmp1, tmp2, MPFR_RNDN);\n mpfr_set_prec (tmp4, prec+8);\n mpfr_set_ui (tmp4, 2, MPFR_RNDN);\n mpfr_set_prec (tmp3, prec+7);\n mpfr_log (tmp3, tmp4, MPFR_RNDN);\n mpfr_set_prec (tmp6, prec+11);\n mpfr_set_ui (tmp6, 1, MPFR_RNDN);\n mpfr_set_prec (tmp7, prec+11);\n mpfr_set_ui (tmp7, 10, MPFR_RNDN);\n mpfr_set_prec (tmp5, prec+11);\n mpfr_div (tmp5, tmp6, tmp7, MPFR_RNDN);\n mpfr_set_prec (tmp4, prec+7);\n mpfr_sqrt (tmp4, tmp5, MPFR_RNDN);\n mpfr_set_prec (tmp2, prec+5);\n mpfr_div (tmp2, tmp3, tmp4, MPFR_RNDN);\n mpfr_set_prec (y, prec+3);\n mpfr_add (y, tmp1, tmp2, MPFR_RNDN);\n \n /* Cleaning stuff */\n mpfr_clear(tmp1);\n mpfr_clear(tmp2);\n mpfr_clear(tmp3);\n mpfr_clear(tmp4);\n mpfr_clear(tmp5);\n mpfr_clear(tmp6);\n mpfr_clear(tmp7);\n }\n\nExample 2: \n > implementconstant(sin(13/17),\"sine_of_thirteen_seventeenth.c\");\n > bashevaluate(\"tail -n 30 sine_of_thirteen_seventeenth.c\");\n #include \n \n void\n const_something (mpfr_ptr y, mp_prec_t prec)\n {\n /* Declarations */\n mpfr_t tmp1;\n mpfr_t tmp2;\n mpfr_t tmp3;\n \n /* Initializations */\n mpfr_init2 (tmp2, prec+6);\n mpfr_init2 (tmp3, prec+6);\n mpfr_init2 (tmp1, prec+6);\n \n /* Core */\n mpfr_set_prec (tmp2, prec+6);\n mpfr_set_ui (tmp2, 13, MPFR_RNDN);\n mpfr_set_prec (tmp3, prec+6);\n mpfr_set_ui (tmp3, 17, MPFR_RNDN);\n mpfr_set_prec (tmp1, prec+6);\n mpfr_div (tmp1, tmp2, tmp3, MPFR_RNDN);\n mpfr_set_prec (y, prec+2);\n mpfr_sin (y, tmp1, MPFR_RNDN);\n \n /* Cleaning stuff */\n mpfr_clear(tmp1);\n mpfr_clear(tmp2);\n mpfr_clear(tmp3);\n }\n\nExample 3: \n > implementconstant(asin(1/3 * pi),default,\"arcsin_of_one_third_pi\"); \n\n [ The first 100 lines of the output have been removed ]\n\n #include \n \n void\n arcsin_of_one_third_pi (mpfr_ptr y, mp_prec_t prec)\n {\n /* Declarations */\n mpfr_t tmp1;\n mpfr_t tmp2;\n mpfr_t tmp3;\n \n /* Initializations */\n mpfr_init2 (tmp2, prec+8);\n mpfr_init2 (tmp3, prec+8);\n mpfr_init2 (tmp1, prec+8);\n \n /* Core */\n mpfr_set_prec (tmp2, prec+8);\n mpfr_const_pi (tmp2, MPFR_RNDN);\n mpfr_set_prec (tmp3, prec+8);\n mpfr_set_ui (tmp3, 3, MPFR_RNDN);\n mpfr_set_prec (tmp1, prec+8);\n mpfr_div (tmp1, tmp2, tmp3, MPFR_RNDN);\n mpfr_set_prec (y, prec+2);\n mpfr_asin (y, tmp1, MPFR_RNDN);\n \n /* Cleaning stuff */\n mpfr_clear(tmp1);\n mpfr_clear(tmp2);\n mpfr_clear(tmp3);\n }\n\nExample 4: \n > implementconstant(ceil(log(19 + 1/3)),\"constant_code.c\",\"magic_constant\");\n > bashevaluate(\"tail -n -9 constant_code.c\");\n void\n magic_constant (mpfr_ptr y, mp_prec_t prec)\n {\n /* Initializations */\n \n /* Core */\n mpfr_set_prec (y, prec);\n mpfr_set_ui (y, 3, MPFR_RNDN);\n }\n\nExample 5: \n > bashexecute(\"gcc -fPIC -Wall -c libraryconstantexample.c -I$HOME/.local/include\");\n > bashexecute(\"gcc -shared -o libraryconstantexample libraryconstantexample.o -lgmp -lmpfr\");\n > euler_gamma = libraryconstant(\"./libraryconstantexample\");\n > implementconstant(euler_gamma^(1/3), \"euler.c\");\n > bashevaluate(\"tail -n -17 euler.c\");\n void\n const_something (mpfr_ptr y, mp_prec_t prec)\n {\n /* Declarations */\n mpfr_t tmp1;\n \n /* Initializations */\n mpfr_init2 (tmp1, prec+1);\n \n /* Core */\n euler_gamma (tmp1, prec+1);\n mpfr_set_prec (y, prec+2);\n mpfr_root (y, tmp1, 3, MPFR_RNDN);\n \n /* Cleaning stuff */\n mpfr_clear(tmp1);\n }\n\nSee also: implementpoly, libraryconstant, library, function, bashevaluate\n" #define HELP_IMPLEMENTPOLY_TEXT "Name: implementpoly\n==> implements a polynomial using double, double-double and triple-double arithmetic and generates a Gappa proof\n\nLibrary names:\n sollya_obj_t sollya_lib_implementpoly(sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t, ...)\n sollya_obj_t sollya_lib_v_implementpoly(sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t, va_list)\n\nUsage: \n implementpoly({polynomial}, {range}, {error bound}, {format}, {functionname}, {filename}) : (function, range, constant, D|double|DD|doubledouble|TD|tripledouble, string, string) -> function\n implementpoly({polynomial}, {range}, {error bound}, {format}, {functionname}, {filename}, {honor coefficient precisions}) : (function, range, constant, D|double|DD|doubledouble|TD|tripledouble, string, string, honorcoeffprec) -> function\n implementpoly({polynomial}, {range}, {error bound}, {format}, {functionname}, {filename}, {proof filename}) : (function, range, constant, D|double|DD|doubledouble|TD|tripledouble, string, string, string) -> function\n implementpoly({polynomial}, {range}, {error bound}, {format}, {functionname}, {filename}, {honor coefficient precisions}, {proof filename}) : (function, range, constant, D|double|DD|doubledouble|TD|tripledouble, string, string, honorcoeffprec, string) -> function\n\nDescription: \n * The command implementpoly implements the polynomial {polynomial} in range\n {range} as a function called {functionname} in C code\n using double, double-double and triple-double arithmetic in a way that\n the rounding error (estimated at its first order) is bounded by {error bound}. \n The produced code is output in a file named {filename}. The\n argument {format} indicates the double, double-double or triple-double\n format of the variable in which the polynomial varies, influencing\n also in the signature of the C function.\n \n If a seventh or eighth argument {proof filename} is given and if this\n argument evaluates to a variable of type string, the command\n implementpoly will produce a Gappa proof that the\n rounding error is less than the given bound. This proof will be output\n in Gappa syntax in a file name {proof filename}.\n \n The command implementpoly returns the polynomial that has been\n implemented. As the command implementpoly tries to adapt the precision\n needed in each evaluation step to its strict minimum and as it applies\n renormalization to double-double and triple-double precision\n coefficients to bring them to a round-to-nearest expansion form, the\n returned polynomial may differ from the polynomial\n {polynomial}. Nevertheless the difference will be small enough that\n the rounding error bound with regard to the polynomial {polynomial}\n (estimated at its first order) will be less than the given error\n bound.\n \n If a seventh argument {honor coefficient precisions} is given and\n evaluates to a variable honorcoeffprec of type honorcoeffprec,\n implementpoly will honor the precision of the given polynomial\n {polynomials}. This means if a coefficient needs a double-double or a\n triple-double to be exactly stored, implementpoly will allocate appropriate\n space and use a double-double or triple-double operation even if the\n automatic (heuristic) determination implemented in command implementpoly\n indicates that the coefficient could be stored on less precision or,\n respectively, the operation could be performed with less\n precision. The use of honorcoeffprec has advantages and\n disadvantages. If the polynomial {polynomial} given has not been\n determined by a process considering directly polynomials with\n floating-point coefficients, honorcoeffprec should not be\n indicated. The implementpoly command can then determine the needed\n precision using the same error estimation as used for the\n determination of the precisions of the operations. Generally, the\n coefficients will get rounded to double, double-double and\n triple-double precision in a way that minimizes their number and\n respects the rounding error bound {error bound}. Indicating\n honorcoeffprec may in this case short-circuit most precision\n estimations leading to sub-optimal code. On the other hand, if the\n polynomial {polynomial} has been determined with floating-point\n precisions in mind, honorcoeffprec should be indicated because such\n polynomials often are very sensitive in terms of error propagation with\n regard to their coefficients' values. Indicating honorcoeffprec\n prevents the implementpoly command from rounding the coefficients and\n altering by many orders of magnitude the approximation error of the\n polynomial with regard to the function it approximates.\n \n The implementer behind the implementpoly command makes some assumptions on\n its input and verifies them. If some assumption cannot be verified,\n the implementation will not succeed and implementpoly will evaluate to a\n variable error of type error. The same behaviour is observed if\n some file is not writable or some other side-effect fails, e.g. if\n the implementer runs out of memory.\n \n As error estimation is performed only on the first order, the code\n produced by the implementpoly command should be considered valid iff a\n Gappa proof has been produced and successfully run\n in Gappa.\n\nExample 1: \n > implementpoly(1 - 1/6 * x^2 + 1/120 * x^4, [-1b-10;1b-10], 1b-30, D, \"p\",\"implementation.c\");\n 1 + x^2 * (-0.166666666666666657414808128123695496469736099243164 + x^2 * 8.3333333333333332176851016015461937058717012405396e-3)\n > bashevaluate(\"tail -n -29 implementation.c\");\n #define p_coeff_0h 1.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00\n #define p_coeff_2h -1.66666666666666657414808128123695496469736099243164062500000000000000000000000000e-01\n #define p_coeff_4h 8.33333333333333321768510160154619370587170124053955078125000000000000000000000000e-03\n \n \n void p(double *p_resh, double x) {\n double p_x_0_pow2h;\n \n \n p_x_0_pow2h = x * x;\n \n \n double p_t_1_0h;\n double p_t_2_0h;\n double p_t_3_0h;\n double p_t_4_0h;\n double p_t_5_0h;\n \n \n \n p_t_1_0h = p_coeff_4h;\n p_t_2_0h = p_t_1_0h * p_x_0_pow2h;\n p_t_3_0h = p_coeff_2h + p_t_2_0h;\n p_t_4_0h = p_t_3_0h * p_x_0_pow2h;\n p_t_5_0h = p_coeff_0h + p_t_4_0h;\n *p_resh = p_t_5_0h;\n \n \n }\n\nExample 2: \n > implementpoly(1 - 1/6 * x^2 + 1/120 * x^4, [-1b-10;1b-10], 1b-30, D, \"p\",\"implementation.c\",\"implementation.gappa\");\n 1 + x^2 * (-0.166666666666666657414808128123695496469736099243164 + x^2 * 8.3333333333333332176851016015461937058717012405396e-3)\n\nExample 3: \n > verbosity = 1!;\n > q = implementpoly(1 - dirtysimplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,\"p\",\"implementation.c\");\n Warning: at least one of the coefficients of the given polynomial has been rounded in a way\n that the target precision can be achieved at lower cost. Nevertheless, the implemented polynomial\n is different from the given one.\n > printexpansion(q);\n 0x3ff0000000000000 + x^2 * 0xbfc5555555555555\n > r = implementpoly(1 - dirtysimplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,\"p\",\"implementation.c\",honorcoeffprec);\n Warning: the inferred precision of the 2th coefficient of the polynomial is greater than\n the necessary precision computed for this step. This may make the automatic determination\n of precisions useless.\n > printexpansion(r);\n 0x3ff0000000000000 + x^2 * (0xbfc5555555555555 + 0xbc65555555555555 + 0xb905555555555555)\n\nExample 4: \n > p = 0x3ff0000000000000 + x * (0x3ff0000000000000 + x * (0x3fe0000000000000 + x * (0x3fc5555555555559 + x * (0x3fa55555555555bd + x * (0x3f811111111106e2 + x * (0x3f56c16c16bf5eb7 + x * (0x3f2a01a01a292dcd + x * (0x3efa01a0218a016a + x * (0x3ec71de360331aad + x * (0x3e927e42e3823bf3 + x * (0x3e5ae6b2710c2c9a + x * (0x3e2203730c0a7c1d + x * 0x3de5da557e0781df))))))))))));\n > q = implementpoly(p,[-1/2;1/2],1b-60,D,\"p\",\"implementation.c\",honorcoeffprec,\"implementation.gappa\");\n > if (q != p) then print(\"During implementation, rounding has happened.\") else print(\"Polynomial implemented as given.\");\t\n Polynomial implemented as given.\n\nSee also: honorcoeffprec, roundcoefficients, double, doubledouble, tripledouble, bashevaluate, printexpansion, error, remez, fpminimax, taylor, implementconstant\n" #define HELP_IN_TEXT "Name: in\n==> containment test operator\n\nLibrary name:\n sollya_obj_t sollya_lib_cmp_in(sollya_obj_t, sollya_obj_t)\n\nUsage: \n {expr} in {range1} : (constant, range) -> boolean\n {range1} in {range2} : (range, range) -> boolean\n\nParameters: \n {expr} represents a constant expression\n {range1} and {range2} represent ranges (intervals)\n\nDescription: \n * When its first operand is a constant expression {expr},\n the operator in evaluates to true iff the constant value\n of the expression {expr} is contained in the interval {range1}.\n\n * When both its operands are ranges (intervals), \n the operator in evaluates to true iff all values\n in {range1} are contained in the interval {range2}.\n\n * in is also used as a keyword for loops over the different\n elements of a list.\n\nExample 1: \n > 5 in [-4;7];\n true\n > 4 in [-1;1];\n false\n > 0 in sin([-17;17]);\n true\n\nExample 2: \n > [5;7] in [2;8];\n true\n > [2;3] in [4;5];\n false\n > [2;3] in [2.5;5];\n false\n\nExample 3: \n > for i in [|1,...,5|] do print(i);\n 1\n 2\n 3\n 4\n 5\n\nSee also: ==, !=, >=, >, <=, <, !, &&, ||, prec, print\n" #define HELP_INF_TEXT "Name: inf\n==> gives the lower bound of an interval.\n\nLibrary name:\n sollya_obj_t sollya_lib_inf(sollya_obj_t)\n\nUsage: \n inf({I}) : range -> constant\n inf({x}) : constant -> constant\n\nParameters: \n {I} is an interval.\n {x} is a real number.\n\nDescription: \n * Returns the lower bound of the interval {I}. Each bound of an interval has its \n own precision, so this command is exact, even if the current precision is too \n small to represent the bound.\n\n * When called on a real number {x}, inf behaves like the identity.\n\nExample 1: \n > inf([1;3]);\n 1\n > inf(0);\n 0\n\nExample 2: \n > display=binary!;\n > I=[0.111110000011111_2; 1];\n > inf(I);\n 1.11110000011111_2 * 2^(-1)\n > prec=12!;\n > inf(I);\n 1.11110000011111_2 * 2^(-1)\n\nSee also: mid, sup, max, min\n" #define HELP_INFNORM_TEXT "Name: infnorm\n==> computes an interval bounding the infinity norm of a function on an interval.\n\nLibrary names:\n sollya_obj_t sollya_lib_infnorm(sollya_obj_t, sollya_obj_t, ...)\n sollya_obj_t sollya_lib_v_infnorm(sollya_obj_t, sollya_obj_t, va_list)\n\nUsage: \n infnorm({f},{I},{filename},{Ilist}) : (function, range, string, list) -> range\n\nParameters: \n {f} is a function.\n {I} is an interval.\n {filename} (optional) is the name of the file into a proof will be saved.\n {IList} (optional) is a list of intervals to be excluded.\n\nDescription: \n * infnorm({f},{range}) computes an interval bounding the infinity norm of the \n given function f on the interval I, e.g. computes an interval J\n such that max {|f(x)|, x in I} C J.\n\n * If {filename} is given, a proof in English will be produced (and stored in file\n called {filename}) proving that max {|f(x)|, x in I} C J.\n\n * If a list {IList} of intervals {I1}, ... ,{In} is given, the infinity norm will\n be computed on I \\ (I1 U ... U I2).\n\n * The function {f} is assumed to be at least twice continuous on {I}. More \n generally, if {f} is Ck, global variables hopitalrecursions and\n taylorrecursions must have values not greater than k. \n\n * If the interval is reduced to a single point, the result of infnorm is an \n interval containing the exact absolute value of {f} at this point.\n\n * If the interval is not bound, the result will be [0, +Inf] \n which is correct but perfectly useless. infnorm is not meant to be used with \n infinite intervals.\n\n * The result of this command depends on the global variables prec, diam,\n taylorrecursions and hopitalrecursions. The contribution of each variable is \n not easy even to analyse.\n \n - The algorithm uses interval arithmetic with precision prec. The\n precision should thus be set high enough to ensure that no critical\n cancellation will occur.\n - When an evaluation is performed on an interval [a,b], if the result\n is considered being too large, the interval is split into [a,(a+b)/2]\n and [(a+b)/2,b] and so on recursively. This recursion step\n is not performed if the (b-a) < d*|I| where d is the value\n of variable diam. In other words, diam controls the minimum length of an\n interval during the algorithm.\n - To perform the evaluation of a function on an interval, Taylor's rule is\n applied, e.g. f([a,b]) C f(m) + [a-m, b-m]*f'([a,b])\n where m=(a+b)/2. This rule is recursively applied n times\n where n is the value of variable taylorrecursions. Roughly speaking,\n the evaluations will avoid decorrelation up to order n.\n - When a function of the form g/h has to be evaluated on an\n interval [a,b] and when g and h vanish at a same point\n z of the interval, the ratio may be defined even if the expression\n g(z)/h(z)=0/0 does not make any sense. In this case, L'Hopital's rule\n may be used and (g/h)([a,b]) C (g'/h')([a,b]).\n Since the same can occur with the ratio g'/h', the rule is applied\n recursively. The variable hopitalrecursions controls the number of \n recursion steps.\n \n\n * The algorithm used for this command is quite complex to be explained here. \n Please find a complete description in the following article:\n S. Chevillard and C. Lauter\n A certified infinity norm for the implementation of elementary functions\n LIP Research Report number RR2007-26\n http://prunel.ccsd.cnrs.fr/ensl-00119810\n\n * Users should be aware about the fact that the algorithm behind\n infnorm is inefficient in most cases and that other, better suited\n algorithms, such as supnorm, are available inside Sollya. As a\n matter of fact, while infnorm is maintained for compatibility reasons\n with legacy Sollya codes, users are advised to avoid using infnorm\n in new Sollya scripts and to replace it, where possible, by the\n supnorm command.\n\nExample 1: \n > infnorm(exp(x),[-2;3]);\n [20.085536923187667740928529654581717896987907838554;20.0855369231876677409285296545817178969879078385544]\n\nExample 2: \n > infnorm(exp(x),[-2;3],\"proof.txt\");\n [20.085536923187667740928529654581717896987907838554;20.0855369231876677409285296545817178969879078385544]\n\nExample 3: \n > infnorm(exp(x),[-2;3],[| [0;1], [2;2.5] |]);\n [20.085536923187667740928529654581717896987907838554;20.0855369231876677409285296545817178969879078385544]\n\nExample 4: \n > infnorm(exp(x),[-2;3],\"proof.txt\", [| [0;1], [2;2.5] |]);\n [20.085536923187667740928529654581717896987907838554;20.0855369231876677409285296545817178969879078385544]\n\nExample 5: \n > infnorm(exp(x),[1;1]);\n [2.7182818284590452353602874713526624977572470936999;2.7182818284590452353602874713526624977572470937]\n\nExample 6: \n > infnorm(exp(x), [log(0);log(1)]);\n [0;infty]\n\nSee also: prec, diam, hopitalrecursions, taylorrecursions, dirtyinfnorm, checkinfnorm, supnorm, findzeros, diff, taylorrecursions, autodiff, numberroots, taylorform\n" #define HELP_INTEGER_TEXT "Name: integer\n==> keyword representing a machine integer type \n\nLibrary name:\n SOLLYA_EXTERNALPROC_TYPE_INTEGER\n\nUsage: \n integer : type type\n\nDescription: \n * integer represents the machine integer type for declarations\n of external procedures externalproc.\n \n Remark that in contrast to other indicators, type indicators like\n integer cannot be handled outside the externalproc context. In\n particular, they cannot be assigned to variables.\n\nSee also: externalproc, boolean, constant, function, list of, range, string, object\n" #define HELP_INTEGRAL_TEXT "Name: integral\n==> computes an interval bounding the integral of a function on an interval.\n\nLibrary name:\n sollya_obj_t sollya_lib_integral(sollya_obj_t, sollya_obj_t)\n\nUsage: \n integral({f},{I}) : (function, range) -> range\n\nParameters: \n {f} is a function.\n {I} is an interval.\n\nDescription: \n * integral({f},{I}) returns an interval J such that the exact value of \n the integral of {f} on {I} lies in J.\n\n * This command is safe but very inefficient. Use dirtyintegral if you just want\n an approximate value.\n\n * The result of this command depends on the global variable diam.\n The method used is the following: {I} is cut into intervals of length not \n greater then d*|I| where d is the value\n of global variable diam.\n On each small interval {J}, an evaluation of {f} by interval is\n performed. The result is multiplied by the length of {J}. Finally all values \n are summed.\n\nExample 1: \n > sin(10);\n -0.54402111088936981340474766185137728168364301291622\n > integral(cos(x),[0;10]);\n [-0.54710197983579690224097637163525943075698599257333;-0.54094015130013183848150540881373370744053741191729]\n > diam=1e-5!;\n > integral(cos(x),[0;10]);\n [-0.54432915685955427101857780295936956775293876382777;-0.54371306401249969508039644221927489010425803173555]\n\nSee also: diam, dirtyintegral, prec\n" #define HELP_ISBOUND_TEXT "Name: isbound\n==> indicates whether a variable is bound or not.\n\nUsage: \n isbound({ident}) : boolean\n\nParameters: \n {ident} is a name.\n\nDescription: \n * isbound({ident}) returns a boolean value indicating whether the name {ident}\n is used or not to represent a variable. It returns true when {ident} is the \n name used to represent the global variable or if the name is currently used\n to refer to a (possibly local) variable.\n\n * When a variable is defined in a block and has not been defined outside, \n isbound returns true when called inside the block, and false outside.\n Note that isbound returns true as soon as a variable has been declared with \n var, even if no value is actually stored in it.\n\n * If {ident1} is bound to a variable and if {ident2} refers to the global \n variable, the command rename({ident2}, {ident1}) hides the value of {ident1}\n which becomes the global variable. However, if the global variable is again\n renamed, {ident1} gets its value back. In this case, isbound({ident1}) returns\n true. If {ident1} was not bound before, isbound({ident1}) returns false after\n that {ident1} has been renamed.\n\nExample 1: \n > isbound(x);\n false\n > isbound(f);\n false\n > isbound(g);\n false\n > f=sin(x);\n > isbound(x);\n true\n > isbound(f);\n true\n > isbound(g);\n false\n\nExample 2: \n > isbound(a);\n false\n > { var a; isbound(a); };\n true\n > isbound(a);\n false\n\nExample 3: \n > f=sin(x);\n > isbound(x);\n true\n > rename(x,y);\n > isbound(x);\n false\n\nExample 4: \n > x=1;\n > f=sin(y);\n > rename(y,x);\n > f;\n sin(x)\n > x;\n x\n > isbound(x);\n true\n > rename(x,y);\n > isbound(x);\n true\n > x;\n 1\n\nSee also: rename\n" #define HELP_ISEVALUABLE_TEXT "Name: isevaluable\n==> tests whether a function can be evaluated at a point \n\nUsage: \n isevaluable({function}, {constant}) : (function, constant) -> boolean\n\nParameters: \n {function} represents a function\n {constant} represents a constant point\n\nDescription: \n * isevaluable applied to function {function} and a constant {constant} returns\n a boolean indicating whether or not a subsequent call to evaluate on the\n same function {function} and constant {constant} will produce a numerical\n result or NaN. This means isevaluable returns false iff evaluate will return NaN.\n\n * The command isevaluable is now considered DEPRECATED in Sollya.\n As checks for NaNs are now possible in Sollya, the command isevaluable\n can be fully emulated with a call to evaluate and a couple of tests, \n as shown below in the last example.\n\nExample 1: \n > isevaluable(sin(pi * 1/x), 0.75);\n true\n > print(evaluate(sin(pi * 1/x), 0.75));\n -0.86602540378443864676372317075293618347140262690519\n\nExample 2: \n > isevaluable(sin(pi * 1/x), 0.5);\n true\n > print(evaluate(sin(pi * 1/x), 0.5));\n [-1.7298645251438126951650861503109812954283676799168e-12715;7.5941198201187963145069564314525661706039084390068e-12716]\n\nExample 3: \n > isevaluable(sin(pi * 1/x), 0);\n true\n > print(evaluate(sin(pi * 1/x), 0));\n [-1;1]\n\nExample 4: \n > procedure isEvaluableEmulation(f, c) {\n \t return match evaluate(f, c) with \n \t \t NaN : (false)\n \t\t [NaN;NaN] : (false)\n \t\t default : (true);\n };\n > isEvaluableEmulation(sin(pi * 1/x), 0.75);\n true\n > isEvaluableEmulation(sin(pi * 1/x), 0.5);\n true\n > isEvaluableEmulation(sin(pi * 1/x), 0);\n true\n\nSee also: evaluate\n" #define HELP_LE_TEXT "Name: <=\n==> less-than-or-equal-to operator\n\nLibrary name:\n sollya_obj_t sollya_lib_cmp_less_equal(sollya_obj_t, sollya_obj_t)\n\nUsage: \n {expr1} <= {expr2} : (constant, constant) -> boolean\n\nParameters: \n {expr1} and {expr2} represent constant expressions\n\nDescription: \n * The operator <= evaluates to true iff its operands {expr1} and\n {expr2} evaluate to two floating-point numbers a1\n respectively a2 with the global precision prec and\n a1 is less than or equal to a2. The user should\n be aware of the fact that because of floating-point evaluation, the\n operator <= is not exactly the same as the mathematical\n operation \"less-than-or-equal-to\".\n\nExample 1: \n > 5 <= 4;\n false\n > 5 <= 5;\n true\n > 5 <= 6;\n true\n > exp(2) <= exp(1);\n false\n > log(1) <= exp(2);\n true\n\nExample 2: \n > prec = 12;\n The precision has been set to 12 bits.\n > 16385.1 <= 16384.1;\n true\n\nSee also: ==, !=, >=, >, <, in, !, &&, ||, prec, max, min\n" #define HELP_LENGTH_TEXT "Name: length\n==> computes the length of a list or string.\n\nLibrary name:\n sollya_obj_t sollya_lib_length(sollya_obj_t)\n\nUsage: \n length({L}) : list -> integer\n length({s}) : string -> integer\n\nParameters: \n {L} is a list.\n {s} is a string.\n\nDescription: \n * length returns the length of a list or a string, e.g. the number of elements\n or letters.\n\n * The empty list or string have length 0.\n If {L} is an end-elliptic list, length returns +Inf.\n\nExample 1: \n > length(\"Hello World!\");\n 12\n\nExample 2: \n > length([|1,...,5|]);\n 5\n\nExample 3: \n > length([| |]);\n 0\n\nExample 4: \n > length([|1,2...|]);\n infty\n\n" #define HELP_LIBRARY_TEXT "Name: library\n==> binds an external mathematical function to a variable in Sollya\n\nLibrary names:\n sollya_obj_t sollya_lib_libraryfunction(sollya_obj_t, char *,\n int (*)(mpfi_t, mpfi_t, int))\n sollya_obj_t sollya_lib_build_function_libraryfunction(sollya_obj_t, char *,\n int (*)(mpfi_t,\n mpfi_t, int))\n sollya_obj_t sollya_lib_libraryfunction_with_data(\n sollya_obj_t, char *,\n int (*)(mpfi_t, mpfi_t, int, void *),\n void *, void (*)(void *))\n sollya_obj_t sollya_lib_build_function_libraryfunction_with_data(\n sollya_obj_t, char *,\n int (*)(mpfi_t,\n mpfi_t, int, void *),\n void *, void (*)(void *))\n\nUsage: \n library({path}) : string -> function\n\nDescription: \n * The command library lets you extend the set of mathematical\n functions known to Sollya.\n By default, Sollya knows the most common mathematical functions such\n as exp, sin, erf, etc. Within Sollya, these functions may be\n composed. This way, Sollya should satisfy the needs of a lot of\n users. However, for particular applications, one may want to\n manipulate other functions such as Bessel functions, or functions\n defined by an integral or even a particular solution of an ODE.\n\n * library makes it possible to let Sollya know about new functions. In\n order to let it know, you have to provide an implementation of the\n function you are interested in. This implementation is a C file containing\n a function of the form:\n int my_ident(sollya_mpfi_t result, sollya_mpfi_t op, int n) \n The semantic of this function is the following: it is an implementation of\n the function and its derivatives in interval arithmetic.\n my_ident(result, I, n) shall store in result an enclosure \n of the image set of the n-th derivative\n of the function f over I: f^(n)(I) C result.\n\n * The integer value returned by the function implementation currently has no meaning.\n\n * You do not need to provide a working implementation for any n. Most functions\n of Sollya requires a relevant implementation only for f, f' and f''. For higher \n derivatives, its is not so critical and the implementation may just store \n [-Inf, +Inf] in result whenever n>2.\n\n * Note that you should respect somehow interval-arithmetic standards in your implementation:\n result has its own precision and you should perform the \n intermediate computations so that result is as tight as possible.\n\n * You can include sollya.h in your implementation and use library \n functionnalities of Sollya for your implementation. However, this requires to have compiled\n Sollya with -fPIC in order to make the Sollya executable code position \n independent and to use a system on with programs, using dlopen to open\n dynamic routines can dynamically open themselves.\n\n * To bind your function into Sollya, you must use the same identifier as the\n function name used in your implementation file (my_ident in the previous\n example). Once the function code has been bound to an identifier, you can use a simple assignment\n to assign the bound identifier to yet another identifier. This way, you may use convenient\n names inside Sollya even if your implementation environment requires you to use a less\n convenient name.\n\n * The dynamic object file whose name is given to library for binding of an\n external library function may also define a destructor function int sollya_external_lib_close(void).\n If Sollya finds such a destructor function in the dynamic object file, it will call \n that function when closing the dynamic object file again. This happens when Sollya\n is terminated or when the current Sollya session is restarted using restart.\n The purpose of the destructor function is to allow the dynamically bound code\n to free any memory that it might have allocated before Sollya is terminated \n or restarted. \n The dynamic object file is not necessarily needed to define a destructor\n function. This ensure backward compatibility with older Sollya external \n library function object files.\n When defined, the destructor function is supposed to return an integer\n value indicating if an error has happened. Upon success, the destructor\n functions is to return a zero value, upon error a non-zero value.\n\nExample 1: \n > bashexecute(\"gcc -fPIC -Wall -c libraryexample.c -I$HOME/.local/include\");\n > bashexecute(\"gcc -shared -o libraryexample libraryexample.o -lgmp -lmpfr\");\n > myownlog = library(\"./libraryexample\");\n > evaluate(log(x), 2);\n 0.69314718055994530941723212145817656807550013436025\n > evaluate(myownlog(x), 2);\n 0.69314718055994530941723212145817656807550013436025\n\nSee also: function, bashexecute, externalproc, externalplot, diff, evaluate, libraryconstant\n" #define HELP_LIBRARYCONSTANT_TEXT "Name: libraryconstant\n==> binds an external mathematical constant to a variable in Sollya\n\nLibrary names:\n sollya_obj_t sollya_lib_libraryconstant(char *, void (*)(mpfr_t, mp_prec_t))\n sollya_obj_t sollya_lib_build_function_libraryconstant(char *,\n void (*)(mpfr_t,\n mp_prec_t))\n sollya_obj_t sollya_lib_libraryconstant_with_data(char *,\n void (*)(mpfr_t,\n mp_prec_t,\n void *),\n void *,\n void (*)(void *))\n sollya_obj_t sollya_lib_build_function_libraryconstant_with_data(\n char *,\n void (*)(mpfr_t,\n mp_prec_t,\n void *),\n void *,\n void (*)(void *))\n\nUsage: \n libraryconstant({path}) : string -> function\n\nDescription: \n * The command libraryconstant lets you extend the set of mathematical\n constants known to Sollya.\n By default, the only mathematical constant known by Sollya is pi.\n For particular applications, one may want to\n manipulate other constants, such as Euler's gamma constant, for instance.\n\n * libraryconstant makes it possible to let Sollya know about new constants.\n In order to let it know, you have to provide an implementation of the\n constant you are interested in. This implementation is a C file containing\n a function of the form:\n void my_ident(mpfr_t result, mp_prec_t prec) \n The semantic of this function is the following: it is an implementation of\n the constant in arbitrary precision.\n my_ident(result, prec) shall set the\n precision of the variable result to a suitable precision (the variable is\n assumed to be already initialized) and store in result an approximate value\n of the constant with a relative error not greater than 2^(1-prec).\n More precisely, if c is the exact value of the constant, the value stored\n in result should satisfy |result-c| <= 2^(1-prec)*|c|.\n\n * You can include sollya.h in your implementation and use library \n functionnalities of Sollya for your implementation. However, this requires to\n have compiled Sollya with -fPIC in order to make the Sollya executable\n code position independent and to use a system on with programs, using dlopen\n to open dynamic routines can dynamically open themselves.\n\n * To bind your constant into Sollya, you must use the same identifier as the\n function name used in your implementation file (my_ident in the previous\n example). Once the function code has been bound to an identifier, you can use\n a simple assignment to assign the bound identifier to yet another identifier.\n This way, you may use convenient names inside Sollya even if your\n implementation environment requires you to use a less convenient name.\n\n * Once your constant is bound, it is considered by Sollya as an infinitely\n accurate constant (i.e. a 0-ary function, exactly like pi).\n\n * The dynamic object file whose name is given to libraryconstant for binding of an\n external library constant may also define a destructor function int sollya_external_lib_close(void).\n If Sollya finds such a destructor function in the dynamic object file, it will call \n that function when closing the dynamic object file again. This happens when Sollya\n is terminated or when the current Sollya session is restarted using restart.\n The purpose of the destructor function is to allow the dynamically bound code\n to free any memory that it might have allocated before Sollya is terminated \n or restarted. \n The dynamic object file is not necessarily needed to define a destructor\n function. This ensure backward compatibility with older Sollya external \n library function object files.\n When defined, the destructor function is supposed to return an integer\n value indicating if an error has happened. Upon success, the destructor\n functions is to return a zero value, upon error a non-zero value.\n\nExample 1: \n > bashexecute(\"gcc -fPIC -Wall -c libraryconstantexample.c -I$HOME/.local/include\");\n > bashexecute(\"gcc -shared -o libraryconstantexample libraryconstantexample.o -lgmp -lmpfr\");\n > euler_gamma = libraryconstant(\"./libraryconstantexample\");\n > prec = 20!;\n > euler_gamma;\n 0.577215\n > prec = 100!;\n > euler_gamma;\n 0.577215664901532860606512090082\n > midpointmode = on;\n Midpoint mode has been activated.\n > [euler_gamma];\n 0.57721566490153286060651209008~2/4~\n\nSee also: bashexecute, externalproc, externalplot, pi, library, evaluate, implementconstant\n" #define HELP_LISTOF_TEXT "Name: list of\n==> keyword used in combination with a type keyword\n\nLibrary names:\n SOLLYA_EXTERNALPROC_TYPE_CONSTANT_LIST\n SOLLYA_EXTERNALPROC_TYPE_FUNCTION_LIST\n SOLLYA_EXTERNALPROC_TYPE_RANGE_LIST\n SOLLYA_EXTERNALPROC_TYPE_INTEGER_LIST\n SOLLYA_EXTERNALPROC_TYPE_STRING_LIST\n SOLLYA_EXTERNALPROC_TYPE_BOOLEAN_LIST\n SOLLYA_EXTERNALPROC_TYPE_OBJECT_LIST\n\nDescription: \n * list of is used in combination with one of the following keywords for\n indicating lists of the respective type in declarations of external\n procedures using externalproc: boolean, constant, function,\n integer, range, object and string.\n\nSee also: externalproc, boolean, constant, function, integer, range, string, object\n" #define HELP_LOG_TEXT "Name: log\n==> natural logarithm.\n\nLibrary names:\n sollya_obj_t sollya_lib_log(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_log(sollya_obj_t)\n #define SOLLYA_LOG(x) sollya_lib_build_function_log(x)\n\nDescription: \n * log is the natural logarithm defined as the inverse of the exponential\n function: log(y) is the unique real number x such that exp(x)=y.\n\n * It is defined only for y in [0; +Inf].\n\nSee also: exp, log2, log10\n" #define HELP_LOG10_TEXT "Name: log10\n==> decimal logarithm.\n\nLibrary names:\n sollya_obj_t sollya_lib_log10(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_log10(sollya_obj_t)\n #define SOLLYA_LOG10(x) sollya_lib_build_function_log10(x)\n\nDescription: \n * log10 is the decimal logarithm defined by: log10(x) = log(x)/log(10).\n\n * It is defined only for x in [0; +Inf].\n\nSee also: log, log2\n" #define HELP_LOG1P_TEXT "Name: log1p\n==> translated logarithm.\n\nLibrary names:\n sollya_obj_t sollya_lib_log1p(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_log1p(sollya_obj_t)\n #define SOLLYA_LOG1P(x) sollya_lib_build_function_log1p(x)\n\nDescription: \n * log1p is the function defined by log1p(x) = log(1+x).\n\n * It is defined only for x in [-1; +Inf].\n\nSee also: log\n" #define HELP_LOG2_TEXT "Name: log2\n==> binary logarithm.\n\nLibrary names:\n sollya_obj_t sollya_lib_log2(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_log2(sollya_obj_t)\n #define SOLLYA_LOG2(x) sollya_lib_build_function_log2(x)\n\nDescription: \n * log2 is the binary logarithm defined by: log2(x) = log(x)/log(2).\n\n * It is defined only for x in [0; +Inf].\n\nSee also: log, log10\n" #define HELP_LT_TEXT "Name: <\n==> less-than operator\n\nLibrary name:\n sollya_obj_t sollya_lib_cmp_less(sollya_obj_t, sollya_obj_t)\n\nUsage: \n {expr1} < {expr2} : (constant, constant) -> boolean\n\nParameters: \n {expr1} and {expr2} represent constant expressions\n\nDescription: \n * The operator < evaluates to true iff its operands {expr1} and\n {expr2} evaluate to two floating-point numbers a1\n respectively a2 with the global precision prec and\n a1 is less than a2. The user should\n be aware of the fact that because of floating-point evaluation, the\n operator < is not exactly the same as the mathematical\n operation \"less-than\".\n\nExample 1: \n > 5 < 4;\n false\n > 5 < 5;\n false\n > 5 < 6;\n true\n > exp(2) < exp(1);\n false\n > log(1) < exp(2);\n true\n\nExample 2: \n > prec = 12;\n The precision has been set to 12 bits.\n > 16384.1 < 16385.1;\n false\n\nSee also: ==, !=, >=, >, <=, in, !, &&, ||, prec, max, min\n" #define HELP_MANTISSA_TEXT "Name: mantissa\n==> returns the integer mantissa of a number.\n\nLibrary name:\n sollya_obj_t sollya_lib_mantissa(sollya_obj_t)\n\nUsage: \n mantissa({x}) : constant -> integer\n\nParameters: \n {x} is a dyadic number.\n\nDescription: \n * mantissa(x) is by definition x if x equals 0, NaN, or Inf.\n\n * If {x} is not zero, it can be uniquely written as x = m*2^e where\n m is an odd integer and e is an integer. mantissa(x) returns m. \n\nExample 1: \n > a=round(Pi,20,RN);\n > e=exponent(a);\n > m=mantissa(a);\n > m;\n 411775\n > a-m*2^e;\n 0\n\nSee also: exponent, precision\n" #define HELP_MAX_TEXT "Name: max\n==> determines which of given constant expressions has maximum value\n\nLibrary names:\n sollya_obj_t sollya_lib_max(sollya_obj_t, ...)\n sollya_obj_t sollya_lib_v_max(sollya_obj_t, va_list)\n\nUsage: \n max({expr1},{expr2},...,{exprn}) : (constant, constant, ..., constant) -> constant\n max({l}) : list -> constant\n\nParameters: \n {expr} are constant expressions.\n {l} is a list of constant expressions.\n\nDescription: \n * max determines which of a given set of constant expressions\n {expr} has maximum value. To do so, max tries to increase the\n precision used for evaluation until it can decide the ordering or some\n maximum precision is reached. In the latter case, a warning is printed\n indicating that there might actually be another expression that has a\n greater value.\n\n * Even though max determines the maximum expression by evaluation, it \n returns the expression that is maximum as is, i.e. as an expression\n tree that might be evaluated to any accuracy afterwards.\n\n * max can be given either an arbitrary number of constant\n expressions in argument or a list of constant expressions. The list\n however must not be end-elliptic.\n\n * Users should be aware that the behavior of max follows the IEEE\n 754-2008 standard with respect to NaNs. In particular, max\n evaluates to NaN if and only if all arguments of max are\n NaNs. This means that NaNs may disappear during computations.\n\nExample 1: \n > max(1,2,3,exp(5),log(0.25));\n 148.41315910257660342111558004055227962348766759388\n > max(17);\n 17\n\nExample 2: \n > l = [|1,2,3,exp(5),log(0.25)|];\n > max(l);\n 148.41315910257660342111558004055227962348766759388\n\nExample 3: \n > print(max(exp(17),sin(62)));\n exp(17)\n\nExample 4: \n > verbosity = 1!;\n > print(max(17 + log2(13)/log2(9),17 + log(13)/log(9)));\n Warning: the tool is unable to decide a maximum computation by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n 17 + log2(13) / log2(9)\n\nSee also: min, ==, !=, >=, >, <, <=, in, inf, sup\n" #define HELP_MID_TEXT "Name: mid\n==> gives the middle of an interval.\n\nLibrary name:\n sollya_obj_t sollya_lib_mid(sollya_obj_t)\n\nUsage: \n mid({I}) : range -> constant\n mid({x}) : constant -> constant\n\nParameters: \n {I} is an interval.\n {x} is a real number.\n\nDescription: \n * Returns the middle of the interval {I}. If the middle is not exactly\n representable at the current precision, the value is returned as an\n unevaluated expression.\n\n * When called on a real number {x}, mid behaves like the identity.\n\nExample 1: \n > mid([1;3]);\n 2\n > mid(17);\n 17\n\nSee also: inf, sup\n" #define HELP_MIDPOINTMODE_TEXT "Name: midpointmode\n==> global variable controlling the way intervals are displayed.\n\nLibrary names:\n void sollya_lib_set_midpointmode_and_print(sollya_obj_t)\n void sollya_lib_set_midpointmode(sollya_obj_t)\n sollya_obj_t sollya_lib_get_midpointmode()\n\nUsage: \n midpointmode = {activation value} : on|off -> void\n midpointmode = {activation value} ! : on|off -> void\n midpointmode : on|off\n\nParameters: \n {activation value} enables or disables the mode.\n\nDescription: \n * midpointmode is a global variable. When its value is off, intervals are displayed\n as usual (in the form [a;b]).\n When its value is on, and if a and b have the same first significant digits,\n the interval in displayed in a way that lets one immediately see the common\n digits of the two bounds.\n\n * This mode is supported only with display set to decimal. In other modes of \n display, midpointmode value is simply ignored.\n\nExample 1: \n > a = round(Pi,30,RD);\n > b = round(Pi,30,RU);\n > d = [a,b];\n > d;\n [3.1415926516056060791015625;3.1415926553308963775634765625]\n > midpointmode=on!;\n > d;\n 0.314159265~1/6~e1\n\nSee also: on, off, roundingwarnings, display, decimal\n" #define HELP_MIN_TEXT "Name: min\n==> determines which of given constant expressions has minimum value\n\nLibrary names:\n sollya_obj_t sollya_lib_min(sollya_obj_t, ...)\n sollya_obj_t sollya_lib_v_min(sollya_obj_t, va_list)\n\nUsage: \n min({expr1},{expr2},...,{exprn}) : (constant, constant, ..., constant) -> constant\n min({l}) : list -> constant\n\nParameters: \n {expr} are constant expressions.\n {l} is a list of constant expressions.\n\nDescription: \n * min determines which of a given set of constant expressions\n {expr} has minimum value. To do so, min tries to increase the\n precision used for evaluation until it can decide the ordering or some\n maximum precision is reached. In the latter case, a warning is printed\n indicating that there might actually be another expression that has a\n lesser value.\n\n * Even though min determines the minimum expression by evaluation, it \n returns the expression that is minimum as is, i.e. as an expression\n tree that might be evaluated to any accuracy afterwards.\n\n * min can be given either an arbitrary number of constant\n expressions in argument or a list of constant expressions. The list\n however must not be end-elliptic.\n\n * Users should be aware that the behavior of min follows the IEEE\n 754-2008 standard with respect to NaNs. In particular, min\n evaluates to NaN if and only if all arguments of min are\n NaNs. This means that NaNs may disappear during computations.\n\nExample 1: \n > min(1,2,3,exp(5),log(0.25));\n -1.3862943611198906188344642429163531361510002687205\n > min(17);\n 17\n\nExample 2: \n > l = [|1,2,3,exp(5),log(0.25)|];\n > min(l);\n -1.3862943611198906188344642429163531361510002687205\n\nExample 3: \n > print(min(exp(17),sin(62)));\n sin(62)\n\nExample 4: \n > verbosity = 1!;\n > print(min(17 + log2(13)/log2(9),17 + log(13)/log(9)));\n Warning: the tool is unable to decide a minimum computation by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal.\n 17 + log(13) / log(9)\n\nSee also: max, ==, !=, >=, >, <, <=, in, inf, sup\n" #define HELP_MINUS_TEXT "Name: -\n==> subtraction function\n\nLibrary names:\n sollya_obj_t sollya_lib_sub(sollya_obj_t, sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_sub(sollya_obj_t, sollya_obj_t)\n #define SOLLYA_SUB(x,y) sollya_lib_build_function_sub((x), (y))\n sollya_obj_t sollya_lib_neg(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_neg(sollya_obj_t)\n #define SOLLYA_NEG(x) sollya_lib_build_function_neg(x)\n\nUsage: \n {function1} - {function2} : (function, function) -> function\n {interval1} - {interval2} : (range, range) -> range\n {interval1} - {constant} : (range, constant) -> range\n {interval1} - {constant} : (constant, range) -> range\n - {function1} : function -> function\n - {interval1} : range -> range\n\nParameters: \n {function1} and {function2} represent functions\n {interval1} and {interval2} represent intervals (ranges)\n {constant} represents a constant or constant expression\n\nDescription: \n * - represents the subtraction (function) on reals. \n The expression {function1} - {function2} stands for\n the function composed of the subtraction function and the two\n functions {function1} and {function2}, where {function1} is \n the subtrahend and {function2} the subtractor.\n\n * - can be used for interval arithmetic on intervals\n (ranges). - will evaluate to an interval that safely\n encompasses all images of the subtraction function with arguments varying\n in the given intervals. Any combination of intervals with intervals\n or constants (resp. constant expressions) is supported. However, it is\n not possible to represent families of functions using an interval as\n one argument and a function (varying in the free variable) as the\n other one.\n\n * - stands also for the negation function.\n\nExample 1: \n > 5 - 2;\n 3\n\nExample 2: \n > x - 2;\n -2 + x\n\nExample 3: \n > x - x;\n 0\n\nExample 4: \n > diff(sin(x) - exp(x));\n cos(x) - exp(x)\n\nExample 5: \n > [1;2] - [3;4];\n [-3;-1]\n > [1;2] - 17;\n [-16;-15]\n > 13 - [-4;17];\n [-4;17]\n\nExample 6: \n > -exp(x);\n -exp(x)\n > -13;\n -13\n > -[13;17];\n [-17;-13]\n\nSee also: +, *, /, ^\n" #define HELP_MULT_TEXT "Name: *\n==> multiplication function\n\nLibrary names:\n sollya_obj_t sollya_lib_mul(sollya_obj_t, sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_mul(sollya_obj_t, sollya_obj_t)\n #define SOLLYA_MUL(x,y) sollya_lib_build_function_mul((x), (y))\n\nUsage: \n {function1} * {function2} : (function, function) -> function\n {interval1} * {interval2} : (range, range) -> range\n {interval1} * {constant} : (range, constant) -> range\n {interval1} * {constant} : (constant, range) -> range\n\nParameters: \n {function1} and {function2} represent functions\n {interval1} and {interval2} represent intervals (ranges)\n {constant} represents a constant or constant expression\n\nDescription: \n * * represents the multiplication (function) on reals. \n The expression {function1} * {function2} stands for\n the function composed of the multiplication function and the two\n functions {function1} and {function2}.\n\n * * can be used for interval arithmetic on intervals\n (ranges). * will evaluate to an interval that safely\n encompasses all images of the multiplication function with arguments varying\n in the given intervals. Any combination of intervals with intervals\n or constants (resp. constant expressions) is supported. However, it is\n not possible to represent families of functions using an interval as\n one argument and a function (varying in the free variable) as the\n other one.\n\nExample 1: \n > 5 * 2;\n 10\n\nExample 2: \n > x * 2;\n x * 2\n\nExample 3: \n > x * x;\n x^2\n\nExample 4: \n > diff(sin(x) * exp(x));\n sin(x) * exp(x) + exp(x) * cos(x)\n\nExample 5: \n > [1;2] * [3;4];\n [3;8]\n > [1;2] * 17;\n [17;34]\n > 13 * [-4;17];\n [-52;221]\n\nSee also: +, -, /, ^\n" #define HELP_NEARESTINT_TEXT "Name: nearestint\n==> the function mapping the reals to the integers nearest to them.\n\nLibrary names:\n sollya_obj_t sollya_lib_nearestint(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_nearestint(sollya_obj_t)\n #define SOLLYA_NEARESTINT(x) sollya_lib_build_function_nearestint(x)\n\nDescription: \n * nearestint is defined as usual: nearestint(x) is the integer nearest to x, with the\n special rule that the even integer is chosen if there exist two integers equally near to x.\n\n * It is defined for every real number x.\n\nSee also: ceil, floor, round, RN\n" #define HELP_NEQ_TEXT "Name: !=\n==> negated equality test operator\n\nLibrary name:\n sollya_obj_t sollya_lib_cmp_not_equal(sollya_obj_t, sollya_obj_t)\n\nUsage: \n {expr1} != {expr2} : (any type, any type) -> boolean\n\nParameters: \n {expr1} and {expr2} represent expressions\n\nDescription: \n * The operator != evaluates to true iff its operands {expr1} and\n {expr2} are syntactically unequal and both different from error,\n constant expressions that are not constants and that evaluate to two\n different floating-point number with the global precision prec or \n polynomials that are unequal while automatic expression simplification \n is activated. The user should be aware of the fact that because of \n floating-point evaluation, the operator != is not exactly the \n same as the negation of the mathematical equality. Further, expressions \n that are polynomials may not be structurally equal when != evaluates \n to false; in order to obtain purely structural tests, the user should \n deactivate automatic simplification using autosimplify.\n \n Note that the expressions !({expr1} != {expr2}) and {expr1}\n == {expr2} do not evaluate to the same boolean value. See error\n for details.\n\nExample 1: \n > \"Hello\" != \"Hello\";\n false\n > \"Hello\" != \"Salut\";\n true\n > \"Hello\" != 5;\n true\n > 5 + x != 5 + x;\n false\n\nExample 2: \n > 1 != exp(0);\n false\n > asin(1) * 2 != pi;\n false\n > exp(5) != log(4);\n true\n\nExample 3: \n > sin(pi/6) != 1/2 * sqrt(3);\n true\n\nExample 4: \n > prec = 12;\n The precision has been set to 12 bits.\n > 16384.1 != 16385.1;\n false\n\nExample 5: \n > error != error;\n false\n\nExample 6: \n > p = x + x^2;\n > q = x * (1 + x);\n > autosimplify = on;\n Automatic pure tree simplification has been activated.\n > p != q;\n false\n > autosimplify = off;\n Automatic pure tree simplification has been deactivated.\n > p != q;\n true\n\nSee also: ==, >, >=, <=, <, in, !, &&, ||, error, prec, autosimplify\n" #define HELP_NOP_TEXT "Name: nop\n==> no operation\n\nUsage: \n nop : void -> void\n nop() : void -> void\n nop({n}) : integer -> void\n\nDescription: \n * The command nop does nothing. This means it is an explicit parse\n element in the Sollya language that finally does not produce any\n result or side-effect.\n\n * The command nop may take an optional positive integer argument\n {n}. The argument controls how much (useless) multiprecision\n floating-point multiplications Sollya performs while doing nothing.\n With this behaviour, nop can be used for calibration of timing\n tests.\n\n * The keyword nop is implicit in some procedure\n definitions. Procedures without imperative body get parsed as if they\n had an imperative body containing one nop statement.\n\nExample 1: \n > nop;\n\nExample 2: \n > nop(100);\n\nExample 3: \n > succ = proc(n) { return n + 1; };\n > succ;\n proc(n)\n {\n nop;\n return (n) + (1);\n }\n > succ(5);\n 6\n\nSee also: proc, time\n" #define HELP_NOT_TEXT "Name: !\n==> boolean NOT operator\n\nLibrary name:\n sollya_obj_t sollya_lib_negate(sollya_obj_t)\n\nUsage: \n ! {expr} : boolean -> boolean\n\nParameters: \n {expr} represents a boolean expression\n\nDescription: \n * ! evaluates to the boolean NOT of the boolean expression\n {expr}. ! {expr} evaluates to true iff {expr} does not evaluate\n to true.\n\nExample 1: \n > ! false;\n true\n\nExample 2: \n > ! (1 == exp(0));\n false\n\nSee also: &&, ||\n" #define HELP_NUMBERROOTS_TEXT "Name: numberroots\n==> Computes the number of roots of a polynomial in a given range.\n\nLibrary name:\n sollya_obj_t sollya_lib_numberroots(sollya_obj_t, sollya_obj_t)\n\nUsage: \n numberroots({p}, {I}) : (function, range) -> integer\n\nParameters: \n {p} is a polynomial.\n {I} is an interval.\n\nDescription: \n * numberroots rigorously computes the number of roots of polynomial the p in\n the interval I. The technique used is Sturm's algorithm. The value returned\n is not just a numerical estimation of the number of roots of p in I: it is\n the exact number of roots.\n\n * The command findzeros computes safe enclosures of all the zeros of a\n function, without forgetting any, but it is not guaranteed to separate them\n all in distinct intervals. numberroots is more accurate since it guarantees \n the exact number of roots. However, it does not compute them. It may be used,\n for instance, to certify that findzeros did not put two distinct roots in \n the same interval.\n\n * Multiple roots are counted only once.\n\n * The interval I must be bounded. The algorithm cannot handle unbounded\n intervals. Moreover, the interval is considered as a closed interval: if one\n (or both) of the endpoints of I are roots of p, they are counted.\n\n * The argument p can be any expression, but if Sollya fails to prove that\n it is a polynomial an error is produced. Also, please note that if the\n coefficients of p or the endpoints of I are not exactly representable,\n they are first numerically evaluated, before the algorithm is used. In that\n case, the counted number of roots corresponds to the rounded polynomial on\n the rounded interval *and not* to the exact parameters given by the user.\n A warning is displayed to inform the user.\n\nExample 1: \n > numberroots(1+x-x^2, [1,2]);\n 1\n > findzeros(1+x-x^2, [1,2]);\n [|[1.617919921875;1.6180419921875]|]\n\nExample 2: \n > numberroots((1+x)*(1-x), [-1,1]);\n 2\n > numberroots(x^2, [-1,1]);\n 1\n\nExample 3: \n > verbosity = 1!;\n > numberroots(x-pi, [0,4]);\n Warning: the 0th coefficient of the polynomial is neither a floating point\n constant nor can be evaluated without rounding to a floating point constant.\n Will faithfully evaluate it with the current precision (165 bits) \n 1\n\nExample 4: \n > verbosity = 1!;\n > numberroots(1+x-x^2, [0, @Inf@]);\n Warning: the given interval must have finite bounds.\n Warning: at least one of the given expressions or a subexpression is not correctly typed\n or its evaluation has failed because of some error on a side-effect.\n error\n > numberroots(exp(x), [0, 1]);\n Warning: the given function must be a polynomial in this context.\n Warning: at least one of the given expressions or a subexpression is not correctly typed\n or its evaluation has failed because of some error on a side-effect.\n error\n\nSee also: dirtyfindzeros, findzeros\n" #define HELP_NUMERATOR_TEXT "Name: numerator\n==> gives the numerator of an expression\n\nLibrary name:\n sollya_obj_t sollya_lib_numerator(sollya_obj_t)\n\nUsage: \n numerator({expr}) : function -> function\n\nParameters: \n {expr} represents an expression\n\nDescription: \n * If {expr} represents a fraction {expr1}/{expr2}, numerator({expr})\n returns the numerator of this fraction, i.e. {expr1}.\n \n If {expr} represents something else, numerator({expr}) \n returns the expression itself, i.e. {expr}.\n \n Note that for all expressions {expr}, numerator({expr}) / denominator({expr})\n is equal to {expr}.\n\nExample 1: \n > numerator(5/3);\n 5\n\nExample 2: \n > numerator(exp(x));\n exp(x)\n\nExample 3: \n > a = 5/3;\n > b = numerator(a)/denominator(a);\n > print(a);\n 5 / 3\n > print(b);\n 5 / 3\n\nExample 4: \n > a = exp(x/3);\n > b = numerator(a)/denominator(a);\n > print(a);\n exp(x / 3)\n > print(b);\n exp(x / 3)\n\nSee also: denominator, rationalmode\n" #define HELP_OBJECT_TEXT "Name: object\n==> keyword representing a Sollya object type \n\nLibrary name:\n SOLLYA_EXTERNALPROC_TYPE_OBJECT\n\nUsage: \n object : type type\n\nDescription: \n * object represents the Sollya object type for declarations\n of external procedures externalproc.\n \n Remark that in contrast to other indicators, type indicators like\n object cannot be handled outside the externalproc context. In\n particular, they cannot be assigned to variables.\n\nSee also: externalproc, boolean, constant, function, list of, range, string, integer\n" #define HELP_OBJECTNAME_TEXT "Name: objectname\n==> returns, given a Sollya object, a string that can be reparsed to the object\n\nLibrary name:\n sollya_obj_t sollya_lib_objectname(sollya_obj_t);\n\nUsage: \n objectname({obj}) : any type -> string\n\nDescription: \n * objectname({obj}) queries the Sollya symbol table in order to recover the\n name of an identifier the object {obj} is assigned to. If it succeeds, it\n returns a string containing the recovered identifier. In contrast, if it\n does not succeed, it returns a string simply containing a textual\n representation of {obj}.\n\n * The only condition for an identifier to be eligible to be returned by\n objectname({obj}) is to be accessible in the scope objectname is executed in,\n i.e., not to be shadowed by an identifier of the same name which does not\n hold the object {obj}.\n\n * In any case, if the string returned by objectname is given to the parse\n command in the same scope, the original object {obj} is recovered.\n\n * objectname is particularly useful in combination with getbacktrace, when\n the Sollya procedure stack is to be displayed in a fashion, where\n procedures are identified by their name and not their procedural content.\n\n * objectname may also be used to get a string representation of the free\n mathematical variable.\n\n * If an object is simply to be cast into a string, without trying to\n retrieve an identifier for it, objectname is not appropriate. In this case,\n it suffices to concatenate it to an empty string with the @ operator.\n\nExample 1: \n > s = \"Hello\";\n > objectname(\"Hello\");\n s\n\nExample 2: \n > f = exp(x);\n > g = sin(x);\n > [| objectname(exp(x)), objectname(sin(x)), objectname(cos(x)) |];\n [|\"f\", \"g\", \"cos(x)\"|]\n\nExample 3: \n > o = { .f = exp(x), .I = [-1;1] };\n > s1 = o@\"\"; s1;\n { .f = exp(x), .I = [-1;1] }\n > s2 = objectname({ .I = [-1;1], .f = exp(x)}); s2;\n o\n > parse(s1) == parse(s2);\n true\n > write(\"s2 = \\\"\", s2, \"\\\" parses to \", parse(s2), \"\\n\");\n s2 = \"o\" parses to { .f = exp(x), .I = [-1;1] }\n\nExample 4: \n > n = 1664;\n > objectname(n);\n n\n\nExample 5: \n > f = exp(x);\n > g = sin(x);\n > procedure test() {\n var f;\n var h;\n f = tan(x);\n h = cos(x);\n [| objectname(exp(x)), objectname(sin(x)), objectname(cos(x)), objectname(tan(x)) |];\n };\n > test();\n [|\"exp(x)\", \"g\", \"h\", \"f\"|]\n\nExample 6: \n > procedure apply_proc(p, a, b) {\n return p(a, b);\n };\n > procedure show_trace_and_add(n, m) {\n var i, bt;\n bt = getbacktrace();\n write(\"Procedure stack:\\n\");\n for i from 0 to length(bt) - 1 do {\n \twrite(\" Procedure \", objectname((bt[i]).called_proc), \" called with \", length((bt[i]).passed_args), \" arguments\\n\");\n };\n write(\"\\n\");\n return n + m;\n };\n > procedure show_and_succ(u) {\n \t return apply_proc(show_trace_and_add, u, 1);\n };\n > show_and_succ(16);\n Procedure stack:\n Procedure show_trace_and_add called with 2 arguments\n Procedure apply_proc called with 3 arguments\n Procedure show_and_succ called with 1 arguments\n \n 17\n\nExample 7: \n > f = exp(three_decker_sauerkraut_and_toadstool_sandwich_with_arsenic_sauce);\n > g = sin(_x_);\n > h = f(g);\n > h;\n exp(sin(three_decker_sauerkraut_and_toadstool_sandwich_with_arsenic_sauce))\n > objectname(_x_);\n three_decker_sauerkraut_and_toadstool_sandwich_with_arsenic_sauce\n\nSee also: parse, var, getbacktrace, proc, procedure, @\n" #define HELP_OFF_TEXT "Name: off\n==> special value for certain global variables.\n\nLibrary names:\n sollya_obj_t sollya_lib_off()\n int sollya_lib_is_off(sollya_obj_t)\n\nDescription: \n * off is a special value used to deactivate certain functionnalities\n of Sollya.\n\n * As any value it can be affected to a variable and stored in lists.\n\nExample 1: \n > canonical=on;\n Canonical automatic printing output has been activated.\n > p=1+x+x^2;\n > mode=off;\n > p;\n 1 + x + x^2\n > canonical=mode;\n Canonical automatic printing output has been deactivated.\n > p;\n 1 + x * (1 + x)\n\nSee also: on, autosimplify, canonical, timing, fullparentheses, midpointmode, rationalmode, roundingwarnings, timing, dieonerrormode\n" #define HELP_ON_TEXT "Name: on\n==> special value for certain global variables.\n\nLibrary names:\n sollya_obj_t sollya_lib_on()\n int sollya_lib_is_on(sollya_obj_t)\n\nDescription: \n * on is a special value used to activate certain functionnalities \n of Sollya.\n\n * As any value it can be affected to a variable and stored in lists.\n\nExample 1: \n > p=1+x+x^2;\n > mode=on;\n > p;\n 1 + x * (1 + x)\n > canonical=mode;\n Canonical automatic printing output has been activated.\n > p;\n 1 + x + x^2\n\nSee also: off, autosimplify, canonical, timing, fullparentheses, midpointmode, rationalmode, roundingwarnings, timing, dieonerrormode\n" #define HELP_OR_TEXT "Name: ||\n==> boolean OR operator\n\nLibrary name:\n sollya_obj_t sollya_lib_or(sollya_obj_t, sollya_obj_t)\n\nUsage: \n {expr1} || {expr2} : (boolean, boolean) -> boolean\n\nParameters: \n {expr1} and {expr2} represent boolean expressions\n\nDescription: \n * || evaluates to the boolean OR of the two\n boolean expressions {expr1} and {expr2}. || evaluates to \n true iff at least one of {expr1} or {expr2} evaluates to true.\n\nExample 1: \n > false || false;\n false\n\nExample 2: \n > (1 == exp(0)) || (0 == log(1));\n true\n\nSee also: &&, !\n" #define HELP_PARSE_TEXT "Name: parse\n==> parses an expression contained in a string\n\nLibrary name:\n sollya_obj_t sollya_lib_parse(sollya_obj_t)\n\nUsage: \n parse({string}) : string -> function | error\n\nParameters: \n {string} represents a character sequence\n\nDescription: \n * parse({string}) parses the character sequence {string} containing\n an expression built on constants and base functions.\n \n If the character sequence does not contain a well-defined expression,\n a warning is displayed indicating a syntax error and parse returns\n a error of type error.\n\n * The character sequence to be parsed by parse may contain commands that \n return expressions, including parse itself. Those commands get executed after the string has been parsed.\n parse({string}) will return the expression computed by the commands contained in the character \n sequence {string}.\n\nExample 1: \n > parse(\"exp(x)\");\n exp(x)\n\nExample 2: \n > text = \"remez(exp(x),5,[-1;1])\";\n > print(\"The string\", text, \"gives\", parse(text));\n The string remez(exp(x),5,[-1;1]) gives 8.7381909882756203676868315731687604903964388498642e-3 * x^5 + 4.3793696379596015478233171265365272893795005588381e-2 * x^4 + 0.16642465614952768185129433844012193925654065755905 * x^3 + 0.49919698262963614991826575452094101562044819693772 * x^2 + 1.00003834650599815466340068058231011540878088492516 * x + 1.00004475029559502606203712816558243384077522932213\n\nExample 3: \n > verbosity = 1!;\n > parse(\"5 + * 3\");\n Warning: syntax error, unexpected *. Will try to continue parsing (expecting \";\"). May leak memory.\n Warning: the string \"5 + * 3\" could not be parsed by the miniparser.\n Warning: at least one of the given expressions or a subexpression is not correctly typed\n or its evaluation has failed because of some error on a side-effect.\n error\n\nSee also: execute, readfile, print, error, dieonerrormode\n" #define HELP_PERTURB_TEXT "Name: perturb\n==> indicates random perturbation of sampling points for externalplot\n\nLibrary names:\n sollya_obj_t sollya_lib_perturb()\n int sollya_lib_is_perturb(sollya_obj_t)\n\nUsage: \n perturb : perturb\n\nDescription: \n * The use of perturb in the command externalplot enables the addition\n of some random noise around each sampling point in externalplot.\n \n See externalplot for details.\n\nExample 1: \n > bashexecute(\"gcc -fPIC -c externalplotexample.c\");\n > bashexecute(\"gcc -shared -o externalplotexample externalplotexample.o -lgmp -lmpfr\");\n > externalplot(\"./externalplotexample\",relative,exp(x),[-1/2;1/2],12,perturb);\n\nSee also: externalplot, absolute, relative, bashexecute\n" #define HELP_PI_TEXT "Name: pi\n==> the constant Pi.\n\nLibrary names:\n sollya_obj_t sollya_lib_pi()\n int sollya_lib_is_pi(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_pi()\n #define SOLLYA_PI (sollya_lib_build_function_pi())\n\nDescription: \n * pi is the constant Pi, defined as half the period of sine and cosine.\n\n * In Sollya, pi is considered a 0-ary function. This way, the constant \n is not evaluated at the time of its definition but at the time of its use. For \n instance, when you define a constant or a function relating to Pi, the current\n precision at the time of the definition does not matter. What is important is \n the current precision when you evaluate the function or the constant value.\n\n * Remark that when you define an interval, the bounds are first evaluated and \n then the interval is defined. In this case, pi will be evaluated as any \n other constant value at the definition time of the interval, thus using the \n current precision at this time.\n\nExample 1: \n > verbosity=1!; prec=12!;\n > a = 2*pi;\n > a;\n Warning: rounding has happened. The value displayed is a faithful rounding to 12 bits of the true result.\n 6.283\n > prec=20!;\n > a;\n Warning: rounding has happened. The value displayed is a faithful rounding to 20 bits of the true result.\n 6.28319\n\nExample 2: \n > display=binary;\n Display mode is binary numbers.\n > prec=12!;\n > d = [pi; 5];\n > d;\n [1.1001001_2 * 2^(1);1.01_2 * 2^(2)]\n > prec=20!;\n > d;\n [1.1001001_2 * 2^(1);1.01_2 * 2^(2)]\n\nSee also: cos, sin, tan, asin, acos, atan, evaluate, prec, libraryconstant\n" #define HELP_PLOT_TEXT "Name: plot\n==> plots one or several functions\n\nLibrary names:\n void sollya_lib_plot(sollya_obj_t, sollya_obj_t, ...)\n void sollya_lib_v_plot(sollya_obj_t, sollya_obj_t, va_list)\n\nUsage: \n plot({f1}, ... ,{fn}, {I}) : (function, ... ,function, range) -> void\n plot({f1}, ... ,{fn}, {I}, file, {name}) : (function, ... ,function, range, file, string) -> void\n plot({f1}, ... ,{fn}, {I}, postscript, {name}) : (function, ... ,function, range, postscript, string) -> void\n plot({f1}, ... ,{fn}, {I}, postscriptfile, {name}) : (function, ... ,function, range, postscriptfile, string) -> void\n plot({L}, {I}) : (list, range) -> void\n plot({L}, {I}, file, {name}) : (list, range, file, string) -> void\n plot({L}, {I}, postscript, {name}) : (list, range, postscript, string) -> void\n plot({L}, {I}, postscriptfile, {name}) : (list, range, postscriptfile, string) -> void\n\nParameters: \n {f1}, ..., {fn} are functions to be plotted.\n {L} is a list of functions to be plotted.\n {I} is the interval where the functions have to be plotted.\n {name} is a string representing the name of a file.\n\nDescription: \n * This command plots one or several functions {f1}, ... ,{fn} on an interval {I}.\n Functions can be either given as parameters of plot or as a list {L}\n which elements are functions.\n The functions are drawn on the same plot with different colors.\n\n * If {L} contains an element that is not a function (or a constant), an error\n occurs.\n\n * plot relies on the value of global variable points. Let n be the \n value of this variable. The algorithm is the following: each function is \n evaluated at n evenly distributed points in {I}. At each point, the \n computed value is a faithful rounding of the exact value with a sufficiently\n high precision. Each point is finally plotted.\n This should avoid numerical artefacts such as critical cancellations.\n\n * You can save the function plot either as a data file or as a postscript file.\n\n * If you use argument file with a string {name}, Sollya will save a data file\n called name.dat and a gnuplot directives file called name.p. Invoking gnuplot\n on name.p will plot the data stored in name.dat.\n\n * If you use argument postscript with a string {name}, Sollya will save a \n postscript file called name.eps representing your plot.\n\n * If you use argument postscriptfile with a string {name}, Sollya will \n produce the corresponding name.dat, name.p and name.eps.\n\n * This command uses gnuplot to produce the final plot.\n If your terminal is not graphic (typically if you use Sollya through \n ssh without -X)\n gnuplot should be able to detect that and produce an ASCII-art version on the\n standard output. If it is not the case, you can either store the plot in a\n postscript file to view it locally, or use asciiplot command.\n\n * If every function is constant, plot will not plot them but just display\n their value.\n\n * If the interval is reduced to a single point, plot will just display the\n value of the functions at this point.\n\nExample 1: \n > plot(sin(x),0,cos(x),[-Pi,Pi]);\n\nExample 2: \n > plot(sin(x),0,cos(x),[-Pi,Pi],postscriptfile,\"plotSinCos\");\n\nExample 3: \n > plot(exp(0), sin(1), [0;1]);\n 1\n 0.84147098480789650665250232163029899962256306079837\n\nExample 4: \n > plot(sin(x), cos(x), [1;1]);\n 0.84147098480789650665250232163029899962256306079837\n 0.54030230586813971740093660744297660373231042061792\n\nSee also: externalplot, asciiplot, file, postscript, postscriptfile, points\n" #define HELP_PLUS_TEXT "Name: +\n==> addition function\n\nLibrary names:\n sollya_obj_t sollya_lib_add(sollya_obj_t, sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_add(sollya_obj_t, sollya_obj_t)\n #define SOLLYA_ADD(x,y) sollya_lib_build_function_add((x), (y))\n\nUsage: \n {function1} + {function2} : (function, function) -> function\n {interval1} + {interval2} : (range, range) -> range\n {interval1} + {constant} : (range, constant) -> range\n {interval1} + {constant} : (constant, range) -> range\n\nParameters: \n {function1} and {function2} represent functions\n {interval1} and {interval2} represent intervals (ranges)\n {constant} represents a constant or constant expression\n\nDescription: \n * + represents the addition (function) on reals. \n The expression {function1} + {function2} stands for\n the function composed of the addition function and the two\n functions {function1} and {function2}.\n\n * + can be used for interval arithmetic on intervals\n (ranges). + will evaluate to an interval that safely\n encompasses all images of the addition function with arguments varying\n in the given intervals. Any combination of intervals with intervals\n or constants (resp. constant expressions) is supported. However, it is\n not possible to represent families of functions using an interval as\n one argument and a function (varying in the free variable) as the\n other one.\n\nExample 1: \n > 1 + 2;\n 3\n\nExample 2: \n > x + 2;\n 2 + x\n\nExample 3: \n > x + x;\n x * 2\n\nExample 4: \n > diff(sin(x) + exp(x));\n cos(x) + exp(x)\n\nExample 5: \n > [1;2] + [3;4];\n [4;6]\n > [1;2] + 17;\n [18;19]\n > 13 + [-4;17];\n [9;30]\n\nSee also: -, *, /, ^\n" #define HELP_POINTS_TEXT "Name: points\n==> controls the number of points chosen by Sollya in certain commands.\n\nLibrary names:\n void sollya_lib_set_points_and_print(sollya_obj_t)\n void sollya_lib_set_points(sollya_obj_t)\n sollya_obj_t sollya_lib_get_points()\n\nUsage: \n points = {n} : integer -> void\n points = {n} ! : integer -> void\n points : constant\n\nParameters: \n {n} represents the number of points\n\nDescription: \n * points is a global variable. Its value represents the number of points\n used in numerical algorithms of Sollya (namely dirtyinfnorm,\n dirtyintegral, dirtyfindzeros, plot).\n\nExample 1: \n > f=x^2*sin(1/x);\n > points=10;\n The number of points has been set to 10.\n > dirtyfindzeros(f, [0;1]);\n [|0, 0.31830988618379067153776752674502872406891929148092|]\n > points=100;\n The number of points has been set to 100.\n > dirtyfindzeros(f, [0;1]);\n [|0, 2.4485375860291590118289809749617594159147637806224e-2, 3.9788735772973833942220940843128590508614911435115e-2, 4.5472840883398667362538218106432674866988470211559e-2, 5.3051647697298445256294587790838120678153215246819e-2, 6.3661977236758134307553505349005744813783858296184e-2, 7.957747154594766788444188168625718101722982287023e-2, 0.106103295394596890512589175581676241356306430493638, 0.15915494309189533576888376337251436203445964574046, 0.31830988618379067153776752674502872406891929148092|]\n\nSee also: dirtyinfnorm, dirtyintegral, dirtyfindzeros, plot, diam, prec\n" #define HELP_POSTSCRIPT_TEXT "Name: postscript\n==> special value for commands plot and externalplot\n\nLibrary names:\n sollya_obj_t sollya_lib_postscript()\n int sollya_lib_is_postscript(sollya_obj_t)\n\nDescription: \n * postscript is a special value used in commands plot and externalplot to save\n the result of the command in a postscript file.\n\n * As any value it can be affected to a variable and stored in lists.\n\nExample 1: \n > savemode=postscript;\n > name=\"plotSinCos\";\n > plot(sin(x),0,cos(x),[-Pi,Pi],savemode, name);\n\nSee also: externalplot, plot, file, postscriptfile\n" #define HELP_POSTSCRIPTFILE_TEXT "Name: postscriptfile\n==> special value for commands plot and externalplot\n\nLibrary names:\n sollya_obj_t sollya_lib_postscriptfile()\n int sollya_lib_is_postscriptfile(sollya_obj_t)\n\nDescription: \n * postscriptfile is a special value used in commands plot and externalplot to save\n the result of the command in a data file and a postscript file.\n\n * As any value it can be affected to a variable and stored in lists.\n\nExample 1: \n > savemode=postscriptfile;\n > name=\"plotSinCos\";\n > plot(sin(x),0,cos(x),[-Pi,Pi],savemode, name);\n\nSee also: externalplot, plot, file, postscript\n" #define HELP_POWER_TEXT "Name: ^\n==> power function\n\nLibrary names:\n sollya_obj_t sollya_lib_pow(sollya_obj_t, sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_pow(sollya_obj_t, sollya_obj_t)\n #define SOLLYA_POW(x,y) sollya_lib_build_function_pow((x), (y))\n\nUsage: \n {function1} ^ {function2} : (function, function) -> function\n {interval1} ^ {interval2} : (range, range) -> range\n {interval1} ^ {constant} : (range, constant) -> range\n {interval1} ^ {constant} : (constant, range) -> range\n\nParameters: \n {function1} and {function2} represent functions\n {interval1} and {interval2} represent intervals (ranges)\n {constant} represents a constant or constant expression\n\nDescription: \n * ^ represents the power (function) on reals. \n The expression {function1} ^ {function2} stands for\n the function composed of the power function and the two\n functions {function1} and {function2}, where {function1} is\n the base and {function2} the exponent.\n If {function2} is a constant integer, ^ is defined\n on negative values of {function1}. Otherwise ^\n is defined as exp(y * log(x)).\n\n * Note that whenever several ^ are composed, the priority goes\n to the last ^. This corresponds to the natural way of\n thinking when a tower of powers is written on a paper.\n Thus, 2^3^5 is interpreted as 2^(3^5).\n\n * ^ can be used for interval arithmetic on intervals\n (ranges). ^ will evaluate to an interval that safely\n encompasses all images of the power function with arguments\n varying in the given intervals. If the intervals given contain points\n where the power function is not defined, infinities and NaNs will be\n produced in the output interval. Any combination of intervals with\n intervals or constants (resp. constant expressions) is\n supported. However, it is not possible to represent families of\n functions using an interval as one argument and a function (varying in\n the free variable) as the other one.\n\nExample 1: \n > 5 ^ 2;\n 25\n\nExample 2: \n > x ^ 2;\n x^2\n\nExample 3: \n > 3 ^ (-5);\n 4.1152263374485596707818930041152263374485596707819e-3\n\nExample 4: \n > (-3) ^ (-2.5);\n NaN\n\nExample 5: \n > diff(sin(x) ^ exp(x));\n sin(x)^exp(x) * ((cos(x) * exp(x)) / sin(x) + exp(x) * log(sin(x)))\n\nExample 6: \n > 2^3^5;\n 1.4134776518227074636666380005943348126619871175005e73\n > (2^3)^5;\n 32768\n > 2^(3^5);\n 1.4134776518227074636666380005943348126619871175005e73\n\nExample 7: \n > [1;2] ^ [3;4];\n [1;16.000000000000000000000000000000000000000000000001]\n > [1;2] ^ 17;\n [1;131072]\n > 13 ^ [-4;17];\n [3.501277966457757081334687160813696999404782745702e-5;8650415919381337933]\n\nSee also: +, -, *, /\n" #define HELP_POWERS_TEXT "Name: powers\n==> special value for global state display\n\nLibrary names:\n sollya_obj_t sollya_lib_powers()\n int sollya_lib_is_powers(sollya_obj_t)\n\nDescription: \n * powers is a special value used for the global state display. If\n the global state display is equal to powers, all data will be\n output in dyadic notation with numbers displayed in a Maple and\n PARI/GP compatible format.\n \n As any value it can be affected to a variable and stored in lists.\n\nSee also: decimal, dyadic, hexadecimal, binary, display\n" #define HELP_PREC_TEXT "Name: prec\n==> controls the precision used in numerical computations.\n\nLibrary names:\n void sollya_lib_set_prec_and_print(sollya_obj_t)\n void sollya_lib_set_prec(sollya_obj_t)\n sollya_obj_t sollya_lib_get_prec()\n\nDescription: \n * prec is a global variable. Its value represents the precision of the \n floating-point format used in numerical computations.\n\n * Many commands try to adapt their working precision in order to have \n approximately n correct bits in output, where n is the value of prec.\n\nExample 1: \n > display=binary!;\n > prec=50;\n The precision has been set to 50 bits.\n > dirtyinfnorm(exp(x),[1;2]);\n 1.110110001110011001001011100011010100110111011011_2 * 2^(2)\n > prec=100;\n The precision has been set to 100 bits.\n > dirtyinfnorm(exp(x),[1;2]);\n 1.11011000111001100100101110001101010011011101101011011100110000110011101000111011101000100000011011_2 * 2^(2)\n\nSee also: evaluate, diam\n" #define HELP_PRECISION_TEXT "Name: precision\n==> returns the precision necessary to represent a number.\n\nLibrary name:\n sollya_obj_t sollya_lib_precision(sollya_obj_t)\n\nUsage: \n precision({x}) : constant -> integer\n\nParameters: \n {x} is a dyadic number.\n\nDescription: \n * precision(x) is by definition |x| if x equals 0, NaN, or Inf.\n\n * If {x} is not zero, it can be uniquely written as x = m*2^e where\n m is an odd integer and e is an integer. precision(x) returns the number\n of bits necessary to write m in binary (i.e. 1+floor(log2(m))).\n\nExample 1: \n > a=round(Pi,20,RN);\n > precision(a);\n 19\n > m=mantissa(a);\n > 1+floor(log2(m));\n 19\n\nExample 2: \n > a=255;\n > precision(a);\n 8\n > m=mantissa(a);\n > 1+floor(log2(m));\n 8\n\nExample 3: \n > a=256;\n > precision(a);\n 1\n > m=mantissa(a);\n > 1+floor(log2(m));\n 1\n\nSee also: mantissa, exponent, round\n" #define HELP_PREPEND_TEXT "Name: .:\n==> add an element at the beginning of a list.\n\nLibrary name:\n sollya_obj_t sollya_lib_prepend(sollya_obj_t, sollya_obj_t)\n\nUsage: \n {x}.:{L} : (any type, list) -> list\n\nParameters: \n {x} is an object of any type.\n {L} is a list (possibly empty).\n\nDescription: \n * .: adds the element {x} at the beginning of the list {L}.\n\n * Note that since {x} may be of any type, it can be in particular a list.\n\nExample 1: \n > 1.:[|2,3,4|];\n [|1, 2, 3, 4|]\n\nExample 2: \n > [|1,2,3|].:[|4,5,6|];\n [|[|1, 2, 3|], 4, 5, 6|]\n\nExample 3: \n > 1.:[||];\n [|1|]\n\nSee also: :., @\n" #define HELP_PRINT_TEXT "Name: print\n==> prints an expression\n\nUsage: \n print({expr1},...,{exprn}) : (any type,..., any type) -> void\n print({expr1},...,{exprn}) > {filename} : (any type,..., any type, string) -> void\n print({expr1},...,{exprn}) >> {filename} : (any type,...,any type, string) -> void\n\nParameters: \n {expr} represents an expression\n {filename} represents a character sequence indicating a file name\n\nDescription: \n * print({expr1},...,{exprn}) prints the expressions {expr1} through\n {exprn} separated by spaces and followed by a newline.\n \n If a second argument {filename} is given after a single \">\", the\n displaying is not output on the standard output of Sollya but if in\n the file {filename} that get newly created or overwritten. If a double\n \">>\" is given, the output will be appended to the file {filename}.\n \n The global variables display, midpointmode and fullparentheses have\n some influence on the formatting of the output (see display,\n midpointmode and fullparentheses).\n \n Remark that if one of the expressions {expri} given in argument is of\n type string, the character sequence {expri} evaluates to is\n displayed. However, if {expri} is of type list and this list\n contains a variable of type string, the expression for the list\n is displayed, i.e. all character sequences get displayed surrounded\n by double quotes (\"). Nevertheless, escape sequences used upon defining\n character sequences are interpreted immediately.\n\nExample 1: \n > print(x + 2 + exp(sin(x))); \n x + 2 + exp(sin(x))\n > print(\"Hello\",\"world\");\n Hello world\n > print(\"Hello\",\"you\", 4 + 3, \"other persons.\");\n Hello you 7 other persons.\n\nExample 2: \n > print(\"Hello\");\n Hello\n > print([|\"Hello\"|]);\n [|\"Hello\"|]\n > s = \"Hello\";\n > print(s,[|s|]);\n Hello [|\"Hello\"|]\n > t = \"Hello\\tyou\";\n > print(t,[|t|]);\n Hello\tyou [|\"Hello\\tyou\"|]\n\nExample 3: \n > print(x + 2 + exp(sin(x))) > \"foo.sol\";\n > readfile(\"foo.sol\");\n x + 2 + exp(sin(x))\n \n\nExample 4: \n > print(x + 2 + exp(sin(x))) >> \"foo.sol\";\n\nExample 5: \n > display = decimal;\n Display mode is decimal numbers.\n > a = evaluate(sin(pi * x), 0.25);\n > b = evaluate(sin(pi * x), [0.25; 0.25 + 1b-50]);\n > print(a);\n 0.70710678118654752440084436210484903928483593768847\n > display = binary;\n Display mode is binary numbers.\n > print(a);\n 1.01101010000010011110011001100111111100111011110011001001000010001011001011111011000100110110011011101010100101010111110100111110001110101101111011000001011101010001_2 * 2^(-1)\n > display = hexadecimal;\n Display mode is hexadecimal numbers.\n > print(a);\n 0x1.6a09e667f3bcc908b2fb1366ea957d3e3adec1751p-1\n > display = dyadic;\n Display mode is dyadic numbers.\n > print(a);\n 33070006991101558613323983488220944360067107133265b-165\n > display = powers;\n Display mode is dyadic numbers in integer-power-of-2 notation.\n > print(a);\n 33070006991101558613323983488220944360067107133265 * 2^(-165)\n > display = decimal;\n Display mode is decimal numbers.\n > midpointmode = off;\n Midpoint mode has been deactivated.\n > print(b);\n [0.70710678118654752440084436210484903928483593768845;0.70710678118654949743721782517557347782646274417049]\n > midpointmode = on;\n Midpoint mode has been activated.\n > print(b);\n 0.7071067811865~4/5~\n > display = dyadic;\n Display mode is dyadic numbers.\n > print(b);\n [2066875436943847413332748968013809022504194195829b-161;16535003495550825444196237019385936414432675156571b-164]\n > display = decimal;\n Display mode is decimal numbers.\n > autosimplify = off;\n Automatic pure tree simplification has been deactivated.\n > fullparentheses = off;\n Full parentheses mode has been deactivated.\n > print(x + x * ((x + 1) + 1));\n x + x * (x + 1 + 1)\n > fullparentheses = on;\n Full parentheses mode has been activated.\n > print(x + x * ((x + 1) + 1));\n x + (x * ((x + 1) + 1))\n\nSee also: write, printexpansion, printdouble, printsingle, printxml, readfile, autosimplify, display, midpointmode, fullparentheses, evaluate, rationalmode\n" #define HELP_PRINTDOUBLE_TEXT "Name: printdouble\n==> prints a constant value as a hexadecimal double precision number\n\nLibrary name:\n void sollya_lib_printdouble(sollya_obj_t)\n\nUsage: \n printdouble({constant}) : constant -> void\n\nParameters: \n {constant} represents a constant\n\nDescription: \n * Prints a constant value as a hexadecimal number on 16 hexadecimal\n digits. The hexadecimal number represents the integer equivalent to\n the 64 bit memory representation of the constant considered as a\n double precision number.\n \n If the constant value does not hold on a double precision number, it\n is first rounded to the nearest double precision number before\n displayed. A warning is displayed in this case.\n\nExample 1: \n > printdouble(3);\n 0x4008000000000000\n\nExample 2: \n > prec=100!;\n > verbosity = 1!;\n > printdouble(exp(5));\n Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation to 100 bits will be used.\n Warning: rounding down occurred before printing a value as a double.\n 0x40628d389970338f\n\nSee also: printsingle, printexpansion, double\n" #define HELP_PRINTEXPANSION_TEXT "Name: printexpansion\n==> prints a polynomial in Horner form with its coefficients written as a expansions of double precision numbers\n\nLibrary name:\n void sollya_lib_printexpansion(sollya_obj_t)\n\nUsage: \n printexpansion({polynomial}) : function -> void\n\nParameters: \n {polynomial} represents the polynomial to be printed\n\nDescription: \n * The command printexpansion prints the polynomial {polynomial} in Horner form\n writing its coefficients as expansions of double precision\n numbers. The double precision numbers themselves are displayed in\n hexadecimal memory notation (see printdouble). \n \n If some of the coefficients of the polynomial {polynomial} are not\n floating-point constants but constant expressions, they are evaluated\n to floating-point constants using the global precision prec. If a\n rounding occurs in this evaluation, a warning is displayed.\n \n If the exponent range of double precision is not sufficient to display\n all the mantissa bits of a coefficient, the coefficient is displayed\n rounded and a warning is displayed.\n \n If the argument {polynomial} does not a polynomial, nothing but a\n warning or a newline is displayed. Constants can be displayed using\n printexpansion since they are polynomials of degree 0.\n\nExample 1: \n > printexpansion(roundcoefficients(taylor(exp(x),5,0),[|DD...|]));\n 0x3ff0000000000000 + x * (0x3ff0000000000000 + x * (0x3fe0000000000000 + x * ((0x3fc5555555555555 + 0x3c65555555555555) + x * ((0x3fa5555555555555 + 0x3c45555555555555) + x * (0x3f81111111111111 + 0x3c01111111111111)))))\n\nExample 2: \n > printexpansion(remez(exp(x),5,[-1;1]));\n (0x3ff0002eec90e5a6 + 0x3c9ea6a6a0087757 + 0xb8eb3e644ef44998) + x * ((0x3ff00028358fd3ac + 0x3c8ffa7d96c95f7a + 0xb91da9809b13dd54 + 0x35c0000000000000) + x * ((0x3fdff2d7e6a9fea5 + 0x3c74460e4c0e4fe2 + 0x38fcd1b6b4e85bb0 + 0x3590000000000000) + x * ((0x3fc54d6733b4839e + 0x3c6654e4d8614a44 + 0xb905c7a26b66ea92 + 0xb598000000000000) + x * ((0x3fa66c209b7150a8 + 0x3c34b1bba8f78092 + 0xb8c75f6eb90dae02 + 0x3560000000000000) + x * (0x3f81e554242ab128 + 0xbc23e920a76e760c + 0x38c0589c2cae6caf + 0x3564000000000000)))))\n\nExample 3: \n > verbosity = 1!;\n > prec = 3500!;\n > printexpansion(pi);\n (0x400921fb54442d18 + 0x3ca1a62633145c07 + 0xb92f1976b7ed8fbc + 0x35c4cf98e804177d + 0x32631d89cd9128a5 + 0x2ec0f31c6809bbdf + 0x2b5519b3cd3a431b + 0x27e8158536f92f8a + 0x246ba7f09ab6b6a9 + 0xa0eedd0dbd2544cf + 0x1d779fb1bd1310ba + 0x1a1a637ed6b0bff6 + 0x96aa485fca40908e + 0x933e501295d98169 + 0x8fd160dbee83b4e0 + 0x8c59b6d799ae131c + 0x08f6cf70801f2e28 + 0x05963bf0598da483 + 0x023871574e69a459 + 0x8000000005702db3 + 0x8000000000000000)\n Warning: the expansion is not complete because of the limited exponent range of double precision.\n Warning: rounding occurred while printing.\n\nSee also: printdouble, horner, print, prec, remez, taylor, roundcoefficients, fpminimax, implementpoly\n" #define HELP_PRINTSINGLE_TEXT "Name: printsingle\n==> prints a constant value as a hexadecimal single precision number\n\nLibrary name:\n void sollya_lib_printsingle(sollya_obj_t)\n\nUsage: \n printsingle({constant}) : constant -> void\n\nParameters: \n {constant} represents a constant\n\nDescription: \n * Prints a constant value as a hexadecimal number on 8 hexadecimal\n digits. The hexadecimal number represents the integer equivalent to\n the 32 bit memory representation of the constant considered as a\n single precision number.\n \n If the constant value does not hold on a single precision number, it\n is first rounded to the nearest single precision number before it is\n displayed. A warning is displayed in this case.\n\nExample 1: \n > printsingle(3);\n 0x40400000\n\nExample 2: \n > prec=100!;\n > verbosity = 1!;\n > printsingle(exp(5));\n Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation to 100 bits will be used.\n Warning: rounding up occurred before printing a value as a single.\n 0x431469c5\n\nSee also: printdouble, single\n" #define HELP_PRINTXML_TEXT "Name: printxml\n==> prints an expression as an MathML-Content-Tree\n\nLibrary names:\n void sollya_lib_printxml(sollya_obj_t)\n void sollya_lib_printxml_newfile(sollya_obj_t, sollya_obj_t)\n void sollya_lib_printxml_appendfile(sollya_obj_t, sollya_obj_t)\n\nUsage: \n printxml({expr}) : function -> void\n printxml({expr}) > {filename} : (function, string) -> void\n printxml({expr}) > > {filename} : (function, string) -> void\n\nParameters: \n {expr} represents a functional expression\n {filename} represents a character sequence indicating a file name\n\nDescription: \n * printxml({expr}) prints the functional expression {expr} as a tree of\n MathML Content Definition Markups. This XML tree can be re-read in\n external tools or by usage of the readxml command.\n \n If a second argument {filename} is given after a single \">\", the\n MathML tree is not output on the standard output of Sollya but if in\n the file {filename} that get newly created or overwritten. If a double\n \">\" is given, the output will be appended to the file {filename}.\n\nExample 1: \n > printxml(x + 2 + exp(sin(x)));\n \n \n \n \n \n \n \n \n \n \n \n \n x \n \n \n \n \n \n x \n 2 \n \n \n \n \n \n x \n \n \n \n \n \n \n (x + 1b1) + exp(sin(x))\n \n \n \n\nExample 2: \n > printxml(x + 2 + exp(sin(x))) > \"foo.xml\";\n\nExample 3: \n > printxml(x + 2 + exp(sin(x))) >> \"foo.xml\";\n\nSee also: readxml, print, write\n" #define HELP_PROC_TEXT "Name: proc\n==> defines a Sollya procedure\n\nUsage: \n proc({formal parameter1}, {formal parameter2},..., {formal parameter n}) { {procedure body} } : void -> procedure\n proc({formal parameter1}, {formal parameter2},..., {formal parameter n}) { {procedure body} return {expression}; } : void -> procedure\n proc({formal list parameter} = ...) { {procedure body} } : void -> procedure\n proc({formal list parameter} = ...) { {procedure body} return {expression}; } : void -> procedure\n\nParameters: \n {formal parameter1}, {formal parameter2} through {formal parameter n} represent identifiers used as formal parameters\n {formal list parameter} represents an identifier used as a formal parameter for the list of an arbitrary number of parameters\n {procedure body} represents the imperative statements in the body of the procedure\n {expression} represents the expression proc shall evaluate to\n\nDescription: \n * The proc keyword allows for defining procedures in the Sollya\n language. These procedures are common Sollya objects that can be\n applied to actual parameters after definition. Upon such an\n application, the Sollya interpreter applies the actual parameters to\n the formal parameters {formal parameter1} through {formal parameter n}\n (resp. builds up the list of arguments and applies it to the list\n {formal list parameter}) and executes the {procedure body}. The\n procedure applied to actual parameters evaluates then to the\n expression {expression} in the return statement after the {procedure body} \n or to void, if no return statement is given (i.e. a return\n void statement is implicitly given).\n\n * Sollya procedures defined by proc have no name. They can be bound\n to an identifier by assigning the procedure object a proc\n expression produces to an identifier. However, it is possible to use\n procedures without giving them any name. For instance, Sollya\n procedures, i.e. procedure objects, can be elements of lists. They can\n even be given as an argument to other internal Sollya procedures. See\n also procedure on this subject.\n\n * Upon definition of a Sollya procedure using proc, no type check\n is performed. More precisely, the statements in {procedure body} are\n merely parsed but not interpreted upon procedure definition with\n proc. Type checks are performed once the procedure is applied to\n actual parameters or to void. At this time, if the procedure was\n defined using several different formal parameters {formal parameter 1}\n through {formal parameter n}, it is checked whether the number of\n actual parameters corresponds to the number of formal parameters. If\n the procedure was defined using the syntax for a procedure with an\n arbitrary number of parameters by giving a {formal list parameter},\n the number of actual arguments is not checked but only a list\n {formal list parameter} of appropriate length is built up. Type checks are\n further performed upon execution of each statement in {procedure body}\n and upon evaluation of the expression {expression} to be returned.\n \n Procedures defined by proc containing a quit or restart command\n cannot be executed (i.e. applied). Upon application of a procedure,\n the Sollya interpreter checks beforehand for such a statement. If one\n is found, the application of the procedure to its arguments evaluates\n to error. A warning is displayed. Remark that in contrast to other\n type or semantic correctness checks, this check is really performed\n before interpreting any other statement in the body of the procedure.\n\n * Through the var keyword it is possible to declare local\n variables and thus to have full support of recursive procedures. This\n means a procedure defined using proc may contain in its {procedure body} \n an application of itself to some actual parameters: it suffices\n to assign the procedure (object) to an identifier with an appropriate\n name.\n\n * Sollya procedures defined using proc may return other\n procedures. Further {procedure body} may contain assignments of\n locally defined procedure objects to identifiers. See var for the\n particular behaviour of local and global variables.\n\n * The expression {expression} returned by a procedure is evaluated with\n regard to Sollya commands, procedures and external\n procedures. Simplification may be performed. However, an application\n of a procedure defined by proc to actual parameters evaluates to the\n expression {expression} that may contain the free global variable or\n that may be composed.\n\nExample 1: \n > succ = proc(n) { return n + 1; };\n > succ(5);\n 6\n > 3 + succ(0);\n 4\n > succ;\n proc(n)\n {\n nop;\n return (n) + (1);\n }\n\nExample 2: \n > add = proc(m,n) { var res; res := m + n; return res; };\n > add(5,6);\n 11\n > add;\n proc(m, n)\n {\n var res;\n res := (m) + (n);\n return res;\n }\n > verbosity = 1!;\n > add(3);\n Warning: at least one of the given expressions or a subexpression is not correctly typed\n or its evaluation has failed because of some error on a side-effect.\n error\n > add(true,false);\n Warning: at least one of the given expressions or a subexpression is not correctly typed\n or its evaluation has failed because of some error on a side-effect.\n Warning: the given expression or command could not be handled.\n error\n\nExample 3: \n > succ = proc(n) { return n + 1; };\n > succ(5);\n 6\n > succ(x);\n 1 + x\n\nExample 4: \n > hey = proc() { print(\"Hello world.\"); };\n > hey();\n Hello world.\n > print(hey());\n Hello world.\n void\n > hey;\n proc()\n {\n print(\"Hello world.\");\n return void;\n }\n\nExample 5: \n > fac = proc(n) { var res; if (n == 0) then res := 1 else res := n * fac(n - 1); return res; };\n > fac(5);\n 120\n > fac(11);\n 39916800\n > fac;\n proc(n)\n {\n var res;\n if (n) == (0) then\n res := 1\n else\n res := (n) * (fac((n) - (1)));\n return res;\n }\n\nExample 6: \n > myprocs = [| proc(m,n) { return m + n; }, proc(m,n) { return m - n; } |];\n > (myprocs[0])(5,6);\n 11\n > (myprocs[1])(5,6);\n -1\n > succ = proc(n) { return n + 1; };\n > pred = proc(n) { return n - 1; };\n > applier = proc(p,n) { return p(n); };\n > applier(succ,5);\n 6\n > applier(pred,5);\n 4\n\nExample 7: \n > verbosity = 1!;\n > myquit = proc(n) { print(n); quit; };\n > myquit;\n proc(n)\n {\n print(n);\n quit;\n return void;\n }\n > myquit(5);\n Warning: a quit or restart command may not be part of a procedure body.\n The procedure will not be executed.\n Warning: an error occurred while executing a procedure.\n Warning: the given expression or command could not be handled.\n error\n\nExample 8: \n > printsucc = proc(n) { var succ; succ = proc(n) { return n + 1; }; print(\"Successor of\",n,\"is\",succ(n)); };\n > printsucc(5);\n Successor of 5 is 6\n\nExample 9: \n > makeadd = proc(n) { var add; print(\"n =\",n); add = proc(m,n) { return n + m; }; return add; };\n > makeadd(4);\n n = 4\n proc(m, n)\n {\n nop;\n return (n) + (m);\n }\n > (makeadd(4))(5,6);\n n = 4\n 11\n\nExample 10: \n > sumall = proc(L = ...) { var acc, i; acc = 0; for i in L do acc = acc + i; return acc; };\n > sumall;\n proc(L = ...)\n {\n var acc, i;\n acc = 0;\n for i in L do\n acc = (acc) + (i);\n return acc;\n }\n > sumall();\n 0\n > sumall(2);\n 2\n > sumall(2,5);\n 7\n > sumall(2,5,7,9,16);\n 39\n > sumall @ [|1,...,10|];\n 55\n\nSee also: return, externalproc, void, quit, restart, var, @, bind, getbacktrace, error\n" #define HELP_PROCEDURE_TEXT "Name: procedure\n==> defines and assigns a Sollya procedure\n\nUsage: \n procedure {identifier}({formal parameter1}, {formal parameter2},..., {formal parameter n}) { {procedure body} } : void -> void\n procedure {identifier}({formal parameter1}, {formal parameter2},..., {formal parameter n}) { {procedure body} return {expression}; } : void -> void\n procedure {identifier}({formal list parameter} = ...) { {procedure body} } : void -> void\n procedure {identifier}({formal list parameter} = ...) { {procedure body} return {expression}; } : void -> void\n\nParameters: \n {identifier} represents the name of the procedure to be defined and assigned\n {formal parameter1}, {formal parameter2} through {formal parameter n} represent identifiers used as formal parameters\n {formal list parameter} represents an identifier used as a formal parameter for the list of an arbitrary number of parameters\n {procedure body} represents the imperative statements in the body of the procedure\n {expression} represents the expression procedure shall evaluate to\n\nDescription: \n * The procedure keyword allows for defining and assigning procedures in\n the Sollya language. It is an abbreviation to a procedure definition\n using proc with the same formal parameters, procedure body and\n return-expression followed by an assignment of the procedure (object)\n to the identifier {identifier}. In particular, all rules concerning\n local variables declared using the var keyword apply for procedure.\n\nExample 1: \n > procedure succ(n) { return n + 1; };\n > succ(5);\n 6\n > 3 + succ(0);\n 4\n > succ;\n proc(n)\n {\n nop;\n return (n) + (1);\n }\n\nExample 2: \n > procedure myprint(L = ...) { var i; for i in L do i; };\n > myprint(\"Lyon\",\"Nancy\",\"Beaverton\",\"Coye-la-Foret\",\"Amberg\",\"Nizhny Novgorod\",\"Cluj-Napoca\");\n Lyon\n Nancy\n Beaverton\n Coye-la-Foret\n Amberg\n Nizhny Novgorod\n Cluj-Napoca\n\nSee also: proc, var, bind, getbacktrace\n" #define HELP_QD_TEXT "Name: QD\n==> short form for quad\n\nSee also: quad\n" #define HELP_QUAD_TEXT "Names: quad, QD\n==> rounding to the nearest IEEE 754 quad (binary128).\n\nLibrary names:\n sollya_obj_t sollya_lib_quad(sollya_obj_t)\n sollya_obj_t sollya_lib_quad_obj()\n int sollya_lib_is_quad_obj(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_quad(sollya_obj_t)\n #define SOLLYA_QD(x) sollya_lib_build_function_quad(x)\n\nDescription: \n * quad is both a function and a constant.\n\n * As a function, it rounds its argument to the nearest IEEE 754 quad precision (i.e. IEEE754-2008 binary128) number.\n Subnormal numbers are supported as well as standard numbers: it is the real\n rounding described in the standard.\n\n * As a constant, it symbolizes the quad precision format. It is used in \n contexts when a precision format is necessary, e.g. in the commands \n round and roundcoefficients. It is not supported for implementpoly.\n See the corresponding help pages for examples.\n\nExample 1: \n > display=binary!;\n > QD(0.1);\n 1.100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001101_2 * 2^(-4)\n > QD(4.17);\n 1.000010101110000101000111101011100001010001111010111000010100011110101110000101000111101011100001010001111010111_2 * 2^(2)\n > QD(1.011_2 * 2^(-16493));\n 1.1_2 * 2^(-16493)\n\nSee also: halfprecision, single, double, doubleextended, doubledouble, tripledouble, roundcoefficients, implementpoly, fpminimax, round, printsingle\n" #define HELP_QUIT_TEXT "Name: quit\n==> quits Sollya\n\nUsage: \n quit : void -> void\n\nDescription: \n * The command quit, when executed, stops the execution of a Sollya\n script and leaves the Sollya interpreter unless the quit command \n is executed in a Sollya script read into a main Sollya script by\n execute or #include.\n \n Upon exiting the Sollya interpreter, all state is thrown away, all\n memory is deallocated, all bound libraries are unbound and the\n temporary files produced by plot and externalplot are deleted.\n \n If the quit command does not lead to a halt of the Sollya\n interpreter, a warning is displayed.\n\nExample 1: \n > quit;\n\nSee also: restart, execute, plot, externalplot, return\n" #define HELP_RANGE_TEXT "Name: range\n==> keyword representing a range type \n\nLibrary name:\n SOLLYA_EXTERNALPROC_TYPE_RANGE\n\nUsage: \n range : type type\n\nDescription: \n * range represents the range type for declarations\n of external procedures by means of externalproc.\n \n Remark that in contrast to other indicators, type indicators like\n range cannot be handled outside the externalproc context. In\n particular, they cannot be assigned to variables.\n\nSee also: externalproc, boolean, constant, function, integer, list of, string, object\n" #define HELP_RATIONALAPPROX_TEXT "Name: rationalapprox\n==> returns a fraction close to a given number.\n\nLibrary name:\n sollya_obj_t sollya_lib_rationalapprox(sollya_obj_t, sollya_obj_t)\n\nUsage: \n rationalapprox({x},{n}) : (constant, integer) -> function\n\nParameters: \n {x} is a number to approximate.\n {n} is a integer (representing a format).\n\nDescription: \n * rationalapprox({x},{n}) returns a constant function of the form a/b where a and b are\n integers. The value a/b is an approximation of {x}. The quality of this \n approximation is determined by the parameter {n} that indicates the number of\n correct bits that a/b should have.\n\n * The command is not safe in the sense that it is not ensured that the error \n between a/b and {x} is less than 2^(-n).\n\n * The following algorithm is used: {x} is first rounded downwards and upwards to\n a format of {n} bits, thus obtaining an interval [xl,xu]. This interval is then\n developed into a continued fraction as far as the representation is the same\n for every elements of [xl,xu]. The corresponding fraction is returned.\n\n * Since rational numbers are not a primitive object of Sollya, the fraction is\n returned as a constant function. This can be quite amazing, because Sollya\n immediately simplifies a constant function by evaluating it when the constant\n has to be displayed.\n To avoid this, you can use print (that displays the expression representing\n the constant and not the constant itself) or the commands numerator \n and denominator.\n\nExample 1: \n > pi10 = rationalapprox(Pi,10);\n > pi50 = rationalapprox(Pi,50);\n > pi100 = rationalapprox(Pi,100);\n > print( pi10, \": \", dirtysimplify(floor(-log2(abs(pi10-Pi)/Pi))), \"bits.\" );\n 3.140625 : 11 bits.\n > print( pi50, \": \", dirtysimplify(floor(-log2(abs(pi50-Pi)/Pi))), \"bits.\" );\n 85563208 / 27235615 : 51 bits.\n > print( pi100, \": \", dirtysimplify(floor(-log2(abs(pi100-Pi)/Pi))), \"bits.\" );\n 4422001152019829 / 1407566683404023 : 100 bits.\n\nExample 2: \n > a=0.1;\n > b=rationalapprox(a,4);\n > numerator(b); denominator(b);\n 1\n 10\n > print(dirtysimplify(floor(-log2(abs((b-a)/a)))), \"bits.\");\n 166 bits.\n\nSee also: print, numerator, denominator, rationalmode\n" #define HELP_RATIONALMODE_TEXT "Name: rationalmode\n==> global variable controlling if rational arithmetic is used or not.\n\nLibrary names:\n void sollya_lib_set_rationalmode_and_print(sollya_obj_t)\n void sollya_lib_set_rationalmode(sollya_obj_t)\n sollya_obj_t sollya_lib_get_rationalmode()\n\nUsage: \n rationalmode = {activation value} : on|off -> void\n rationalmode = {activation value} ! : on|off -> void\n rationalmode : on|off\n\nParameters: \n {activation value} controls if rational arithmetic should be used or not\n\nDescription: \n * rationalmode is a global variable. When its value is off, which is the default,\n Sollya will not use rational arithmetic to simplify expressions. All computations,\n including the evaluation of constant expressions given on the Sollya prompt,\n will be performed using floating-point and interval arithmetic. Constant expressions\n will be approximated by floating-point numbers, which are in most cases faithful \n roundings of the expressions, when shown at the prompt. \n\n * When the value of the global variable rationalmode is on, Sollya will use \n rational arithmetic when simplifying expressions. Constant expressions, given \n at the Sollya prompt, will be simplified to rational numbers and displayed \n as such when they are in the set of the rational numbers. Otherwise, flaoting-point\n and interval arithmetic will be used to compute a floating-point approximation,\n which is in most cases a faithful rounding of the constant expression.\n\nExample 1: \n > rationalmode=off!;\n > 19/17 + 3/94;\n 1.1495619524405506883604505632040050062578222778473\n > rationalmode=on!;\n > 19/17 + 3/94;\n 1837 / 1598\n\nExample 2: \n > rationalmode=off!;\n > exp(19/17 + 3/94);\n 3.1568097739551413675470920894482427634032816281442\n > rationalmode=on!;\n > exp(19/17 + 3/94);\n 3.1568097739551413675470920894482427634032816281442\n\nSee also: on, off, numerator, denominator, simplify, rationalapprox, autosimplify\n" #define HELP_RD_TEXT "Name: RD\n==> constant representing rounding-downwards mode.\n\nLibrary names:\n sollya_obj_t sollya_lib_round_down()\n int sollya_lib_is_round_down(sollya_obj_t)\n\nDescription: \n * RD is used in command round to specify that the value x must be rounded\n to the greatest floating-point number y such that y <= x.\n\nExample 1: \n > display=binary!;\n > round(Pi,20,RD);\n 1.1001001000011111101_2 * 2^(1)\n\nSee also: RZ, RU, RN, round, floor\n" #define HELP_READFILE_TEXT "Name: readfile\n==> reads the content of a file into a string variable\n\nUsage: \n readfile({filename}) : string -> string\n\nParameters: \n {filename} represents a character sequence indicating a file name\n\nDescription: \n * readfile opens the file indicated by {filename}, reads it and puts its\n contents in a character sequence of type string that is returned.\n \n If the file indicated by {filename} cannot be opened for reading, a\n warning is displayed and readfile evaluates to an error variable of\n type error.\n\nExample 1: \n > print(\"Hello world\") > \"myfile.txt\";\n > t = readfile(\"myfile.txt\"); \n > t;\n Hello world\n \n\nExample 2: \n > verbosity=1!;\n > readfile(\"afile.txt\");\n Warning: the file \"afile.txt\" could not be opened for reading.\n Warning: at least one of the given expressions or a subexpression is not correctly typed\n or its evaluation has failed because of some error on a side-effect.\n error\n\nSee also: parse, execute, write, print, bashexecute, error\n" #define HELP_READXML_TEXT "Name: readxml\n==> reads an expression written as a MathML-Content-Tree in a file\n\nLibrary name:\n sollya_obj_t sollya_lib_readxml(sollya_obj_t)\n\nUsage: \n readxml({filename}) : string -> function | error\n\nParameters: \n {filename} represents a character sequence indicating a file name\n\nDescription: \n * readxml({filename}) reads the first occurrence of a lambda\n application with one bounded variable on applications of the supported\n basic functions in file {filename} and returns it as a Sollya\n functional expression.\n \n If the file {filename} does not contain a valid MathML-Content tree,\n readxml tries to find an \"annotation encoding\" markup of type\n \"sollya/text\". If this annotation contains a character sequence\n that can be parsed by parse, readxml returns that expression. Otherwise\n readxml displays a warning and returns an error variable of type\n error.\n\nExample 1: \n > readxml(\"readxmlexample.xml\");\n 2 + _x_ + exp(sin(_x_))\n\nSee also: printxml, readfile, parse, error\n" #define HELP_RELATIVE_TEXT "Name: relative\n==> indicates a relative error for externalplot, fpminimax or supnorm\n\nLibrary names:\n sollya_obj_t sollya_lib_relative()\n int sollya_lib_is_relative(sollya_obj_t)\n\nUsage: \n relative : absolute|relative\n\nDescription: \n * The use of relative in the command externalplot indicates that during\n plotting in externalplot a relative error is to be considered.\n \n See externalplot for details.\n\n * Used with fpminimax, relative indicates that fpminimax must try to minimize\n the relative error.\n \n See fpminimax for details.\n\n * When given in argument to supnorm, relative indicates that a relative error\n is to be considered for supremum norm computation.\n \n See supnorm for details.\n\nExample 1: \n > bashexecute(\"gcc -fPIC -c externalplotexample.c\");\n > bashexecute(\"gcc -shared -o externalplotexample externalplotexample.o -lgmp -lmpfr\");\n > externalplot(\"./externalplotexample\",absolute,exp(x),[-1/2;1/2],12,perturb);\n\nSee also: externalplot, fpminimax, absolute, bashexecute, supnorm\n" #define HELP_REMEZ_TEXT "Name: remez\n==> computes the minimax of a function on an interval.\n\nLibrary names:\n sollya_obj_t sollya_lib_remez(sollya_obj_t, sollya_obj_t, sollya_obj_t, ...)\n sollya_obj_t sollya_lib_v_remez(sollya_obj_t, sollya_obj_t, sollya_obj_t,\n va_list)\n\nUsage: \n remez({f}, {n}, {range}, {w}, {quality}, {bounds}) : (function, integer, range, function, constant, range) -> function\n remez({f}, {L}, {range}, {w}, {quality}, {bounds}) : (function, list, range, function, constant, range) -> function\n\nParameters: \n {f} is the function to be approximated\n {n} is the degree of the polynomial that must approximate {f}\n {L} is a list of integers or a list of functions and indicates the basis for the approximation of {f}\n {range} is the interval where the function must be approximated\n {w} (optional) is a weight function. Default is 1.\n {quality} (optional) is a parameter that controls the quality of the returned polynomial {p}, with respect to the exact minimax p*. Default is 1e-5.\n {bounds} (optional) is a parameter that allows the user to make the algorithm stop earlier, whenever a given accuracy is reached or a given accuracy is proved unreachable. Default is [0, +Inf].\n\nDescription: \n * remez computes an approximation of the function f with respect to\n the weight function w on the interval {range}. More precisely, it\n searches p such that ||p*w-f|| is\n (almost) minimal among all p of a certain form. The norm is\n the infinity norm, e.g. ||g|| = max {|g(x)|, x in {range}}.\n\n * If w=1 (the default case), it consists in searching the best\n polynomial approximation of f with respect to the absolute error.\n If f=1 and w is of the form 1/g, it consists in\n searching the best polynomial approximation of g with respect to the\n relative error.\n\n * If n is given, p is searched among the polynomials with degree not\n greater than n.\n If {L} is given and is a list of integers, p is searched as a linear\n combination of monomials X^k where k belongs to {L}.\n In the case when {L} is a list of integers, it may contain ellipses but\n cannot be end-elliptic.\n If {L} is given and is a list of functions g_k, p is searched as a\n linear combination of the g_k. In that case {L} cannot contain ellipses.\n It is the user responsibility to check that the g_k are linearly independent\n over the interval {range}. Moreover, the functions w*g_k must be at least\n twice differentiable over {range}. If these conditions are not fulfilled, the\n algorithm might fail or even silently return a result as if it successfully\n found the minimax, though the returned p is not optimal.\n\n * The polynomial is obtained by a convergent iteration called Remez'\n algorithm (and an extension of this algorithm, due to Stiefel).\n The algorithm computes a sequence p1, ..., pk, ...\n such that ek = ||pk*w-f|| converges towards\n the optimal value e. The algorithm is stopped when the relative error\n between ek and e is less than {quality}.\n\n * The optional argument {bounds} is an interval [satisfying_err, target_err]\n with the following behavior: \n - if, during the algorithm, we manage to prove that target_err is\n unreachable, we stop the algorithm returning the last computed\n polynomial.\n - if, during the algorithm, we obtain a polynomial with an error smaller\n than satisfying_err, we stop the algorithm returning that polynomial.\n - otherwise we loop until we find an optimal polynomial with the required\n quality, as usual. \n Examples of use: \n [0, +Inf] (compute the optimal polynomial with the required quality) \n [target_err] (stops as soon as a polynomial achieving target_err is\n obtained or as soon as such a polynomial is proved not to\n exist). \n [0, target_err] (finds the optimal polynomial, but provided that its error\n is smaller than target_err). \n [satisfying_err, +Inf] (stops as soon as a polynomial achieving\n satisfying_err is obtained. If such a polynomial\n does not exist, returns the optimal polynomial).\n\nExample 1: \n > p = remez(exp(x),5,[0;1]);\n > degree(p);\n 5\n > dirtyinfnorm(p-exp(x),[0;1]);\n 1.1295698151096148707171193829266077607222634589363e-6\n\nExample 2: \n > p = remez(1,[|0,2,4,6,8|],[0,Pi/4],1/cos(x));\n > canonical=on!;\n > p;\n 0.99999999994393732180959690352543887130348096061124 + -0.49999999571556857768772053063721544670949467222259 * x^2 + 4.1666613233473633009941059480570275870113220089059e-2 * x^4 + -1.3886529147145693651355523880319714051047635695061e-3 * x^6 + 2.4372679177224179934800328511009205218114284220126e-5 * x^8\n\nExample 3: \n > p1 = remez(exp(x),5,[0;1],default,1e-5);\n > p2 = remez(exp(x),5,[0;1],default,1e-10);\n > p3 = remez(exp(x),5,[0;1],default,1e-15);\n > dirtyinfnorm(p1-exp(x),[0;1]);\n 1.1295698151096148707171193829266077607222634589363e-6\n > dirtyinfnorm(p2-exp(x),[0;1]);\n 1.12956980227478675612619255125474525171079325793124e-6\n > dirtyinfnorm(p3-exp(x),[0;1]);\n 1.12956980227478675612619255125474525171079325793124e-6\n\nExample 4: \n > L = [|exp(x), sin(x), cos(x)-1, sin(x^3)|];\n > g = (2^x-1)/x;\n > p1 = remez(g, L, [-1/16;1/16]);\n > p2 = remez(g, 3, [-1/16;1/16]);\n > dirtyinfnorm(p1 - g, [-1/16;1/16]);\n 9.8841323829271038137685646777951687620288462194746e-8\n > dirtyinfnorm(p2 - g, [-1/16;1/16]);\n 2.54337800593461418356437401152248866818783932027105e-9\n\nExample 5: \n > f = sin(x);\n > I = [-3b-5;-1b-1074];\n > time(popt = remez(1, [|1, 3, 4, 5, 7, 8, 9|], I, 1/f));\n 0.123003671000000000000000000000000000005312485158598\n > time(p1 = remez(1, [|1, 3, 4, 5, 7, 8, 9|], I, 1/f, default, [0, 1b-73]));\n 0.10779709599999999999999999999999999999979213799222\n > time(p2 = remez(1, [|1, 3, 4, 5, 7, 8, 9|], I, 1/f, default, [3b-72, +@Inf@]));\n 0.117226489999999999999999999999999999992463113903884\n > dirtyinfnorm(popt/f-1, I);\n 2.06750931454112835098093903810531156576504665659064e-22\n > dirtyinfnorm(p1/f-1, I);\n 2.49711266837493110470637913808914046704452778960875e-22\n > dirtyinfnorm(p2/f-1, I);\n 5.4567247553615435246376977231253834265248756996947e-22\n > 1b-73;\n 1.05879118406787542383540312584955245256423950195312e-22\n > 3b-72;\n 6.3527471044072525430124187550973147153854370117187e-22\n\nSee also: dirtyinfnorm, infnorm, fpminimax, guessdegree, taylorform, taylor\n" #define HELP_RENAME_TEXT "Name: rename\n==> rename the free variable.\n\nLibrary name:\n void sollya_lib_name_free_variable(const char *)\n\nUsage: \n rename({ident1},{ident2}) : void\n\nParameters: \n {ident1} is the current name of the free variable.\n {ident2} is a fresh name.\n\nDescription: \n * rename permits a change of the name of the free variable. Sollya can handle\n only one free variable at a time. The first time in a session that an\n unbound name is used in a context where it can be interpreted as a free\n variable, the name is used to represent the free variable of Sollya. In the\n following, this name can be changed using rename.\n\n * Be careful: if {ident2} has been set before, its value will be lost. Use\n the command isbound to know if {ident2} is already used or not.\n\n * If {ident1} is not the current name of the free variable, an error occurs.\n\n * If rename is used at a time when the name of the free variable has not been\n defined, {ident1} is just ignored and the name of the free variable is set\n to {ident2}.\n\n * It is always possible to use the special keyword _x_ to denote the free\n variable. Hence {ident1} can be _x_.\n\nExample 1: \n > f=sin(x);\n > f;\n sin(x)\n > rename(x,y);\n > f;\n sin(y)\n\nExample 2: \n > a=1;\n > f=sin(x);\n > rename(x,a);\n > a;\n a\n > f;\n sin(a)\n\nExample 3: \n > verbosity=1!;\n > f=sin(x);\n > rename(y, z);\n Warning: the current free variable is named \"x\" and not \"y\". Can only rename the free variable.\n The last command will have no effect.\n > rename(_x_, z);\n Information: the free variable has been renamed from \"x\" to \"z\".\n\nExample 4: \n > verbosity=1!;\n > rename(x,y);\n Information: the free variable has been named \"y\".\n > isbound(x);\n false\n > isbound(y);\n true\n\nSee also: isbound\n" #define HELP_RESTART_TEXT "Name: restart\n==> brings Sollya back to its initial state\n\nUsage: \n restart : void -> void\n\nDescription: \n * The command restart brings Sollya back to its initial state. All\n current state is abandoned, all libraries unbound and all memory freed.\n \n The restart command has no effect when executed inside a Sollya\n script read into a main Sollya script using execute. It is executed\n in a Sollya script included by a #include macro.\n \n Using the restart command in nested elements of imperative\n programming like for or while loops is possible. Since in most cases\n abandoning the current state of Sollya means altering a loop\n invariant, warnings for the impossibility of continuing a loop may\n follow unless the state is rebuilt.\n\nExample 1: \n > print(exp(x));\n exp(x)\n > a = 3;\n > restart;\n The tool has been restarted.\n > print(x);\n x\n > a;\n Warning: the identifier \"a\" is neither assigned to, nor bound to a library function nor external procedure, nor equal to the current free variable.\n Will interpret \"a\" as \"x\".\n x\n\nExample 2: \n > print(exp(x));\n exp(x)\n > for i from 1 to 10 do {\n \tprint(i);\n \tif (i == 5) then restart;\n };\n 1\n 2\n 3\n 4\n 5\n The tool has been restarted.\n Warning: the tool has been restarted inside a for loop.\n The for loop will no longer be executed.\n\nExample 3: \n > print(exp(x));\n exp(x)\n > a = 3;\n > for i from 1 to 10 do {\n \tprint(i);\n \tif (i == 5) then {\n \t\trestart;\n \t\ti = 7;\n \t};\n };\n 1\n 2\n 3\n 4\n 5\n The tool has been restarted.\n 8\n 9\n 10\n > print(x);\n x\n > a;\n Warning: the identifier \"a\" is neither assigned to, nor bound to a library function nor external procedure, nor equal to the current free variable.\n Will interpret \"a\" as \"x\".\n x\n\nSee also: quit, execute\n" #define HELP_RETURN_TEXT "Name: return\n==> indicates an expression to be returned in a procedure\n\nUsage: \n return {expression} : void\n\nParameters: \n {expression} represents the expression to be returned\n\nDescription: \n * The keyword return allows for returning the (evaluated) expression\n {expression} at the end of a begin-end-block ({}-block) used as a\n Sollya procedure body. See proc for further details concerning\n Sollya procedure definitions.\n \n Statements for returning expressions using return are only possible\n at the end of a begin-end-block used as a Sollya procedure\n body. Only one return statement can be given per begin-end-block.\n\n * If at the end of a procedure definition using proc no return\n statement is given, a return void statement is implicitly\n added. Procedures, i.e. procedure objects, when printed out in Sollya\n defined with an implicit return void statement are displayed with\n this statement explicitly given.\n\nExample 1: \n > succ = proc(n) { var res; res := n + 1; return res; };\n > succ(5);\n 6\n > succ;\n proc(n)\n {\n var res;\n res := (n) + (1);\n return res;\n }\n\nExample 2: \n > hey = proc(s) { print(\"Hello\",s); };\n > hey(\"world\");\n Hello world\n > hey;\n proc(s)\n {\n print(\"Hello\", s);\n return void;\n }\n\nSee also: proc, void\n" #define HELP_REVERT_TEXT "Name: revert\n==> reverts a list.\n\nLibrary name:\n sollya_obj_t sollya_lib_revert(sollya_obj_t)\n\nUsage: \n revert({L}) : list -> list\n\nParameters: \n {L} is a list.\n\nDescription: \n * revert({L}) returns the same list, but with its elements in reverse order.\n\n * If {L} is an end-elliptic list, revert will fail with an error.\n\nExample 1: \n > revert([| |]);\n [| |]\n\nExample 2: \n > revert([|2,3,5,2,1,4|]);\n [|4, 1, 2, 5, 3, 2|]\n\n" #define HELP_RN_TEXT "Name: RN\n==> constant representing rounding-to-nearest mode.\n\nLibrary names:\n sollya_obj_t sollya_lib_round_to_nearest()\n int sollya_lib_is_round_to_nearest(sollya_obj_t)\n\nDescription: \n * RN is used in command round to specify that the value must be rounded\n to the nearest representable floating-point number.\n\nExample 1: \n > display=binary!;\n > round(Pi,20,RN);\n 1.100100100001111111_2 * 2^(1)\n\nSee also: RD, RU, RZ, round, nearestint\n" #define HELP_ROUND_TEXT "Name: round\n==> rounds a number to a floating-point format.\n\nLibrary name:\n sollya_obj_t sollya_lib_round(sollya_obj_t, sollya_obj_t, sollya_obj_t)\n\nUsage: \n round({x},{n},{mode}) : (constant, integer, RN|RZ|RU|RD) -> constant\n round({x},{format},{mode}) : (constant, HP|halfprecision|SG|single|D|double|DE|doubleextended|DD|doubledouble|QD|quad|TD|tripledouble, RN|RZ|RU|RD) -> constant\n\nParameters: \n {x} is a constant to be rounded.\n {n} is the precision of the target format.\n {format} is the name of a supported floating-point format.\n {mode} is the desired rounding mode.\n\nDescription: \n * If used with an integer parameter {n}, round({x},{n},{mode}) rounds {x} to a floating-point number with \n precision {n}, according to rounding-mode {mode}. \n\n * If used with a format parameter {format}, round({x},{format},{mode}) rounds {x} to a floating-point number in the \n floating-point format {format}, according to rounding-mode {mode}. \n\n * Subnormal numbers are handled for the case when {format} is one of\n halfprecision, single, double, doubleextended, doubledouble,\n quad or tripledouble. Otherwise, when {format} is an integer,\n round does not take any exponent range into consideration,\n i.e. typically uses the full exponent range of the underlying MPFR\n library.\n\n * It is worth mentionning that the result of round does not depend on\n the current global precision of Sollya, unless a warning is\n displayed. As a matter of fact, round rounds the given constant or\n constant expression {x} applying all rules of IEEE 754 correct\n rounding, unless a warning is displayed. The result of round is\n hence the floating-point value of the given precision {n} or format\n {format} that is nearest to {x} (resp. just below or just above,\n depending on {mode}), computed as if infinite precision were used for\n evaluating the constant {x}, unless a warning is displayed.\n\nExample 1: \n > display=binary!;\n > round(Pi,20,RN);\n 1.100100100001111111_2 * 2^(1)\n\nExample 2: \n > printdouble(round(exp(17),53,RU));\n 0x417709348c0ea4f9\n > printdouble(D(exp(17)));\n 0x417709348c0ea4f9\n\nExample 3: \n > display=binary!;\n > a=2^(-1100);\n > round(a,53,RN);\n 1_2 * 2^(-1100)\n > round(a,D,RN);\n 0\n > double(a);\n 0\n\nSee also: RN, RD, RU, RZ, halfprecision, single, double, doubleextended, doubledouble, quad, tripledouble, roundcoefficients, roundcorrectly, printdouble, printsingle, ceil, floor, nearestint\n" #define HELP_ROUNDCOEFFICIENTS_TEXT "Name: roundcoefficients\n==> rounds the coefficients of a polynomial to classical formats.\n\nLibrary name:\n sollya_obj_t sollya_lib_roundcoefficients(sollya_obj_t, sollya_obj_t)\n\nUsage: \n roundcoefficients({p},{L}) : (function, list) -> function\n\nParameters: \n {p} is a function. Usually a polynomial.\n {L} is a list of formats.\n\nDescription: \n * If {p} is a polynomial and {L} a list of floating-point formats, \n roundcoefficients({p},{L}) rounds each coefficient of {p} to the corresponding format\n in {L}.\n\n * If {p} is not a polynomial, roundcoefficients does not do anything.\n\n * If {L} contains other elements than HP, halfprecision, SG, single, D, double, \n DE, doubleextended, DD, doubledouble, QD, quad, TD and tripledouble,\n an error occurs.\n\n * The coefficients in {p} corresponding to X^i is rounded to the \n format L[i]. If {L} does not contain enough elements\n (e.g. if length(L) < degree(p)+1), a warning is displayed. However, the\n coefficients corresponding to an element of {L} are rounded. The trailing \n coefficients (that do not have a corresponding element in {L}) are kept with\n their own precision.\n If {L} contains too much elements, the trailing useless elements are ignored.\n In particular {L} may be end-elliptic in which case roundcoefficients has the \n natural behavior.\n\nExample 1: \n > p=exp(1) + x*(exp(2) + x*exp(3));\n > display=binary!;\n > roundcoefficients(p,[|DD,D,D|]);\n 1.010110111111000010101000101100010100010101110110100101010011010101011111101110001010110001000000010011101_2 * 2^(1) + x * (1.110110001110011001001011100011010100110111011010111_2 * 2^(2) + x * (1.010000010101111001011011111101101111101100010000011_2 * 2^(4)))\n > roundcoefficients(p,[|DD,D...|]);\n 1.010110111111000010101000101100010100010101110110100101010011010101011111101110001010110001000000010011101_2 * 2^(1) + x * (1.110110001110011001001011100011010100110111011010111_2 * 2^(2) + x * (1.010000010101111001011011111101101111101100010000011_2 * 2^(4)))\n\nExample 2: \n > f=sin(exp(1)*x);\n > display=binary!;\n > f;\n sin(x * (1.0101101111110000101010001011000101000101011101101001010100110101010111111011100010101100010000000100111001111010011110011110001110110001011100111000101100000111101_2 * 2^(1)))\n > roundcoefficients(f,[|D...|]);\n sin(x * (1.0101101111110000101010001011000101000101011101101001010100110101010111111011100010101100010000000100111001111010011110011110001110110001011100111000101100000111101_2 * 2^(1)))\n\nExample 3: \n > p=exp(1) + x*(exp(2) + x*exp(3));\n > verbosity=1!;\n > display=binary!;\n > roundcoefficients(p,[|DD,D|]);\n Warning: the number of the given formats does not correspond to the degree of the given polynomial.\n Warning: the 0th coefficient of the given polynomial does not evaluate to a floating-point constant without any rounding.\n Will evaluate the coefficient in the current precision in floating-point before rounding to the target format.\n Warning: the 1th coefficient of the given polynomial does not evaluate to a floating-point constant without any rounding.\n Will evaluate the coefficient in the current precision in floating-point before rounding to the target format.\n Warning: rounding may have happened.\n 1.010110111111000010101000101100010100010101110110100101010011010101011111101110001010110001000000010011101_2 * 2^(1) + x * (1.110110001110011001001011100011010100110111011010111_2 * 2^(2) + x * (1.01000001010111100101101111110110111110110001000001011111001011010100101111011111110001010011011101000100110000111010001110010000010110000101100000111001011100101001_2 * 2^(4)))\n\nSee also: halfprecision, single, double, doubleextended, doubledouble, quad, tripledouble, fpminimax, remez, implementpoly, subpoly\n" #define HELP_ROUNDCORRECTLY_TEXT "Name: roundcorrectly\n==> rounds an approximation range correctly to some precision\n\nLibrary name:\n sollya_obj_t sollya_lib_roundcorrectly(sollya_obj_t)\n\nUsage: \n roundcorrectly({range}) : range -> constant\n\nParameters: \n {range} represents a range in which an exact value lies\n\nDescription: \n * Let {range} be a range of values, determined by some approximation\n process, safely bounding an unknown value v. The command\n roundcorrectly({range}) determines a precision such that for this precision,\n rounding to the nearest any value in {range} yields to the same\n result, i.e. to the correct rounding of v.\n \n If no such precision exists, a warning is displayed and roundcorrectly\n evaluates to NaN.\n\nExample 1: \n > printbinary(roundcorrectly([1.010001_2; 1.0101_2]));\n 1.01_2\n > printbinary(roundcorrectly([1.00001_2; 1.001_2]));\n 1_2\n\nExample 2: \n > roundcorrectly([-1; 1]);\n NaN\n\nSee also: round, mantissa, exponent, precision\n" #define HELP_ROUNDINGWARNINGS_TEXT "Name: roundingwarnings\n==> global variable controlling whether or not a warning is displayed when roundings occur.\n\nLibrary names:\n void sollya_lib_set_roundingwarnings_and_print(sollya_obj_t)\n void sollya_lib_set_roundingwarnings(sollya_obj_t)\n sollya_obj_t sollya_lib_get_roundingwarnings()\n\nUsage: \n roundingwarnings = {activation value} : on|off -> void\n roundingwarnings = {activation value} ! : on|off -> void\n roundingwarnings : on|off\n\nParameters: \n {activation value} controls if warnings should be shown or not\n\nDescription: \n * roundingwarnings is a global variable. When its value is on, warnings are\n emitted in appropriate verbosity modes (see verbosity) when roundings\n occur. When its value is off, these warnings are suppressed.\n\n * This mode depends on a verbosity of at least 1. See\n verbosity for more details.\n\n * Default is on when the standard input is a terminal and\n off when Sollya input is read from a file.\n\nExample 1: \n > verbosity=1!;\n > roundingwarnings = on;\n Rounding warning mode has been activated.\n > exp(0.1);\n Warning: Rounding occurred when converting the constant \"0.1\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n Warning: rounding has happened. The value displayed is a faithful rounding to 165 bits of the true result.\n 1.1051709180756476248117078264902466682245471947375\n > roundingwarnings = off;\n Rounding warning mode has been deactivated.\n > exp(0.1);\n 1.1051709180756476248117078264902466682245471947375\n\nSee also: on, off, verbosity, midpointmode, rationalmode, suppressmessage, unsuppressmessage, showmessagenumbers, getsuppressedmessages\n" #define HELP_RU_TEXT "Name: RU\n==> constant representing rounding-upwards mode.\n\nLibrary names:\n sollya_obj_t sollya_lib_round_up()\n int sollya_lib_is_round_up(sollya_obj_t)\n\nDescription: \n * RU is used in command round to specify that the value x must be rounded\n to the smallest floating-point number y such that x <= y.\n\nExample 1: \n > display=binary!;\n > round(Pi,20,RU);\n 1.100100100001111111_2 * 2^(1)\n\nSee also: RZ, RD, RN, round, ceil\n" #define HELP_RZ_TEXT "Name: RZ\n==> constant representing rounding-to-zero mode.\n\nLibrary names:\n sollya_obj_t sollya_lib_round_towards_zero()\n int sollya_lib_is_round_towards_zero(sollya_obj_t)\n\nDescription: \n * RZ is used in command round to specify that the value must be rounded\n to the closest floating-point number towards zero. It just consists in \n truncating the value to the desired format.\n\nExample 1: \n > display=binary!;\n > round(Pi,20,RZ);\n 1.1001001000011111101_2 * 2^(1)\n\nSee also: RD, RU, RN, round, floor, ceil\n" #define HELP_SEARCHGAL_TEXT "Name: searchgal\n==> searches for a preimage of a function such that the rounding the image yields an error smaller than a constant\n\nLibrary name:\n sollya_obj_t sollya_lib_searchgal(sollya_obj_t, sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t, sollya_obj_t)\n\nUsage: \n searchgal({function}, {start}, {preimage precision}, {steps}, {format}, {error bound}) : (function, constant, integer, integer, HP|halfprecision|SG|single|D|double|DE|doubleextended|DD|doubledouble|QD|quad|TD|tripledouble, constant) -> list\n searchgal({list of functions}, {start}, {preimage precision}, {steps}, {list of format}, {list of error bounds}) : (list, constant, integer, integer, list, list) -> list\n\nParameters: \n {function} represents the function to be considered\n {start} represents a value around which the search is to be performed\n {preimage precision} represents the precision (discretization) for the eligible preimage values\n {steps} represents the binary logarithm (log2) of the number of search steps to be performed\n {format} represents the format the image of the function is to be rounded to\n {error bound} represents a upper bound on the relative rounding error when rounding the image\n {list of functions} represents the functions to be considered\n {list of formats} represents the respective formats the images of the functions are to be rounded to\n {list of error bounds} represents a upper bound on the relative rounding error when rounding the image\n\nDescription: \n * The command searchgal searches for a preimage z of function\n {function} or a list of functions {list of functions} such that\n z is a floating-point number with {preimage precision}\n significant mantissa bits and the image y of the function,\n respectively each image yi of the functions, rounds to\n format {format} respectively to the corresponding format in {list of format} \n with a relative rounding error less than {error bound}\n respectively the corresponding value in {list of error bounds}. During\n this search, at most 2^{steps} attempts are made. The search\n starts with a preimage value equal to {start}. This value is then\n increased and decreased by 1 ulp in precision {preimage precision} \n until a value is found or the step limit is reached.\n \n If the search finds an appropriate preimage z, searchgal\n evaluates to a list containing this value. Otherwise, searchgal\n evaluates to an empty list.\n\nExample 1: \n > searchgal(log(x),2,53,15,DD,1b-112);\n [| |]\n > searchgal(log(x),2,53,18,DD,1b-112);\n [|2.0000000000384972054234822280704975128173828125|]\n\nExample 2: \n > f = exp(x);\n > s = searchgal(f,2,53,18,DD,1b-112);\n > if (s != [||]) then {\n v = s[0];\n print(\"The rounding error is 2^(\",evaluate(log2(abs(DD(f)/f - 1)),v),\")\");\n } else print(\"No value found\");\n The rounding error is 2^( -112.106878438809380148206984258358542322113874177832 )\n\nExample 3: \n > searchgal([|sin(x),cos(x)|],1,53,15,[|D,D|],[|1b-62,1b-60|]);\n [|1.00000000000159494639717649988597258925437927246094|]\n\nSee also: round, double, doubledouble, tripledouble, evaluate, worstcase\n" #define HELP_SG_TEXT "Name: SG\n==> short form for single\n\nSee also: single\n" #define HELP_SHOWMESSAGENUMBERS_TEXT "Name: showmessagenumbers\n==> activates, deactivates or inspects the state variable controlling the displaying of numbers for messages\n\nLibrary names:\n void sollya_lib_set_showmessagenumbers_and_print(sollya_obj_t)\n void sollya_lib_set_showmessagenumbers(sollya_obj_t)\n sollya_obj_t sollya_lib_get_showmessagenumbers()\n\nUsage: \n showmessagenumbers = {activation value} : on|off -> void\n showmessagenumbers = {activation value} ! : on|off -> void\n showmessagenumbers : on|off\n\nParameters: \n {activation value} represents on or off, i.e. activation or deactivation\n\nDescription: \n * An assignment showmessagenumbers = {activation value}, where {activation value}\n is one of on or off, activates respectively deactivates the\n displaying of numbers for warning and information messages. Every\n Sollya warning or information message (that is not fatal to the\n tool's execution) has a message number. By default, these numbers are\n not displayed when a message is output. When message number displaying\n is activated, the message numbers are displayed together with the\n message. This allows the user to recover the number of a particular\n message in order to suppress resp. unsuppress the displaying of this\n particular message (see suppressmessage and unsuppressmessage).\n\n * The user should be aware of the fact that message number display\n activation resp. deactivation through showmessagenumbers does not affect message\n displaying in general. For instance, even with message number\n displaying activated, messages with only displayed when general\n verbosity and rounding warning mode are set accordingly.\n\n * If the assignment showmessagenumbers = {activation value} is followed by an\n exclamation mark, no message indicating the new state is\n displayed. Otherwise the user is informed of the new state of the\n global mode by an indication.\n\nExample 1: \n > verbosity = 1;\n The verbosity level has been set to 1.\n > 0.1;\n Warning: Rounding occurred when converting the constant \"0.1\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n 0.1\n > showmessagenumbers = on;\n Displaying of message numbers has been activated.\n > 0.1;\n Warning (174): Rounding occurred when converting the constant \"0.1\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n 0.1\n > showmessagenumbers;\n on\n > showmessagenumbers = off!;\n > 0.1;\n Warning: Rounding occurred when converting the constant \"0.1\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n 0.1\n\nExample 2: \n > showmessagenumbers = on;\n Displaying of message numbers has been activated.\n > verbosity = 1;\n The verbosity level has been set to 1.\n > diff(0.1 * x + 1.5 * x^2);\n Warning (174): Rounding occurred when converting the constant \"0.1\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n 0.1 + x * 3\n > verbosity = 0;\n The verbosity level has been set to 0.\n > diff(0.1 * x + 1.5 * x^2);\n 0.1 + x * 3\n > verbosity = 12;\n The verbosity level has been set to 12.\n > diff(0.1 * x + 1.5 * x^2);\n Warning (174): Rounding occurred when converting the constant \"0.1\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n Information (196): formally differentiating a function.\n Information (197): differentiating the expression '0.1 * x + 1.5 * x^2'\n Information (195): expression '0.1 + 2 * 1.5 * x' has been simplified to expression '0.1 + 3 * x'.\n 0.1 + x * 3\n\nSee also: getsuppressedmessages, suppressmessage, unsuppressmessage, verbosity, roundingwarnings\n" #define HELP_SIMPLIFY_TEXT "Name: simplify\n==> simplifies an expression representing a function\n\nLibrary name:\n sollya_obj_t sollya_lib_simplify(sollya_obj_t)\n\nUsage: \n simplify({function}) : function -> function\n\nParameters: \n {function} represents the expression to be simplified\n\nDescription: \n * The command simplify simplifies the expression given in argument\n representing the function {function}. The command simplify does not\n endanger the safety of computations even in Sollya's floating-point\n environment: the function returned is mathematically equal to the\n function {function}. \n \n Remark that the simplification provided by simplify is not perfect:\n they may exist simpler equivalent expressions for expressions returned\n by simplify.\n\nExample 1: \n > print(simplify((6 + 2) + (5 + exp(0)) * x));\n 8 + 6 * x\n\nExample 2: \n > print(simplify((log(x - x + 1) + asin(1))));\n (pi) / 2\n\nExample 3: \n > print(simplify((log(x - x + 1) + asin(1)) - (atan(1) * 2)));\n (pi) / 2 - (pi) / 4 * 2\n\nSee also: dirtysimplify, autosimplify, rationalmode, horner\n" #define HELP_SIN_TEXT "Name: sin\n==> the sine function.\n\nLibrary names:\n sollya_obj_t sollya_lib_sin(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_sin(sollya_obj_t)\n #define SOLLYA_SIN(x) sollya_lib_build_function_sin(x)\n\nDescription: \n * sin is the usual sine function.\n\n * It is defined for every real number x.\n\nSee also: asin, cos, tan\n" #define HELP_SINGLE_TEXT "Names: single, SG\n==> rounding to the nearest IEEE 754 single (binary32).\n\nLibrary names:\n sollya_obj_t sollya_lib_single(sollya_obj_t)\n sollya_obj_t sollya_lib_single_obj()\n int sollya_lib_is_single_obj(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_single(sollya_obj_t)\n #define SOLLYA_SG(x) sollya_lib_build_function_single(x)\n\nDescription: \n * single is both a function and a constant.\n\n * As a function, it rounds its argument to the nearest IEEE 754 single precision (i.e. IEEE754-2008 binary32) number.\n Subnormal numbers are supported as well as standard numbers: it is the real\n rounding described in the standard.\n\n * As a constant, it symbolizes the single precision format. It is used in \n contexts when a precision format is necessary, e.g. in the commands \n round and roundcoefficients. In is not supported for implementpoly.\n See the corresponding help pages for examples.\n\nExample 1: \n > display=binary!;\n > SG(0.1);\n 1.10011001100110011001101_2 * 2^(-4)\n > SG(4.17);\n 1.000010101110000101001_2 * 2^(2)\n > SG(1.011_2 * 2^(-1073));\n 0\n\nSee also: halfprecision, double, doubleextended, doubledouble, quad, tripledouble, roundcoefficients, implementpoly, round, printsingle\n" #define HELP_SINH_TEXT "Name: sinh\n==> the hyperbolic sine function.\n\nLibrary names:\n sollya_obj_t sollya_lib_sinh(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_sinh(sollya_obj_t)\n #define SOLLYA_SINH(x) sollya_lib_build_function_sinh(x)\n\nDescription: \n * sinh is the usual hyperbolic sine function: sinh(x) = (exp(x)-exp(-x))/2.\n\n * It is defined for every real number x.\n\nSee also: asinh, cosh, tanh\n" #define HELP_SORT_TEXT "Name: sort\n==> sorts a list of real numbers.\n\nLibrary name:\n sollya_obj_t sollya_lib_sort(sollya_obj_t)\n\nUsage: \n sort({L}) : list -> list\n\nParameters: \n {L} is a list.\n\nDescription: \n * If {L} contains only constant values, sort({L}) returns the same list, but\n sorted in increasing order.\n\n * If {L} contains at least one element that is not a constant, the command fails \n with a type error.\n\n * If {L} is an end-elliptic list, sort will fail with an error.\n\nExample 1: \n > sort([| |]);\n [| |]\n > sort([|2,3,5,2,1,4|]);\n [|1, 2, 2, 3, 4, 5|]\n\n" #define HELP_SQRT_TEXT "Name: sqrt\n==> square root.\n\nLibrary names:\n sollya_obj_t sollya_lib_sqrt(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_sqrt(sollya_obj_t)\n #define SOLLYA_SQRT(x) sollya_lib_build_function_sqrt(x)\n\nDescription: \n * sqrt is the square root, e.g. the inverse of the function square: sqrt(y)\n is the unique positive x such that x^2=y.\n\n * It is defined only for x in [0; +Inf].\n\n" #define HELP_STRING_TEXT "Name: string\n==> keyword representing a string type \n\nLibrary name:\n SOLLYA_EXTERNALPROC_TYPE_STRING\n\nUsage: \n string : type type\n\nDescription: \n * string represents the string type for declarations\n of external procedures by means of externalproc.\n \n Remark that in contrast to other indicators, type indicators like\n string cannot be handled outside the externalproc context. In\n particular, they cannot be assigned to variables.\n\nSee also: externalproc, boolean, constant, function, integer, list of, range, object\n" #define HELP_SUBPOLY_TEXT "Name: subpoly\n==> restricts the monomial basis of a polynomial to a list of monomials\n\nLibrary name:\n sollya_obj_t sollya_lib_subpoly(sollya_obj_t, sollya_obj_t)\n\nUsage: \n subpoly({polynomial}, {list}) : (function, list) -> function\n\nParameters: \n {polynomial} represents the polynomial the coefficients are taken from\n {list} represents the list of monomials to be taken\n\nDescription: \n * subpoly extracts the coefficients of a polynomial {polynomial} and builds up a\n new polynomial out of those coefficients associated to monomial degrees figuring in\n the list {list}. \n \n If {polynomial} represents a function that is not a polynomial, subpoly returns 0.\n \n If {list} is a list that is end-elliptic, let be j the last value explicitly specified\n in the list. All coefficients of the polynomial associated to monomials greater or\n equal to j are taken.\n\nExample 1: \n > p = taylor(exp(x),5,0);\n > s = subpoly(p,[|1,3,5|]);\n > print(p);\n 1 + x * (1 + x * (0.5 + x * (1 / 6 + x * (1 / 24 + x / 120))))\n > print(s);\n x * (1 + x^2 * (1 / 6 + x^2 / 120))\n\nExample 2: \n > p = remez(atan(x),10,[-1,1]);\n > subpoly(p,[|1,3,5...|]);\n x * (0.99986632941452949026018468446163586361700915018232 + x^2 * (-0.33030478502455936362667794059988443130926433421739 + x^2 * (0.18015929317818756462894237037824735129130095574422 + x * (2.2845584115424788285112501565358576642429856963072e-9 + x * (-8.5156349064111377895500552996061844977507560037485e-2 + x * (-2.717563409627750199168187692393409435243830189218e-9 + x * (2.08451134307114729373239910549169872454686955895e-2 + x * 1.10889861181129057657199664386826630081793400489512e-9)))))))\n\nExample 3: \n > subpoly(exp(x),[|1,2,3|]);\n 0\n\nSee also: roundcoefficients, taylor, remez, fpminimax, implementpoly\n" #define HELP_SUBSTITUTE_TEXT "Name: substitute\n==> replace the occurrences of the free variable in an expression.\n\nLibrary name:\n sollya_obj_t sollya_lib_substitute(sollya_obj_t, sollya_obj_t)\n\nUsage: \n substitute({f},{g}) : (function, function) -> function\n substitute({f},{t}) : (function, constant) -> constant\n\nParameters: \n {f} is a function.\n {g} is a function.\n {t} is a real number.\n\nDescription: \n * substitute({f}, {g}) produces the function (f o g) : x -> f(g(x)).\n\n * substitute({f}, {t}) is the constant f(t). Note that the constant is\n represented by its expression until it has been evaluated (exactly the same\n way as if you type the expression {f} replacing instances of the free variable \n by {t}).\n\n * If {f} is stored in a variable {F}, the effect of the commands substitute({F},{g}) or substitute({F},{t}) is absolutely equivalent to \n writing {F(g)} resp. {F(t)}.\n\nExample 1: \n > f=sin(x);\n > g=cos(x);\n > substitute(f,g);\n sin(cos(x))\n > f(g);\n sin(cos(x))\n\nExample 2: \n > a=1;\n > f=sin(x);\n > substitute(f,a);\n 0.84147098480789650665250232163029899962256306079837\n > f(a);\n 0.84147098480789650665250232163029899962256306079837\n\nSee also: evaluate, composepolynomials\n" #define HELP_SUP_TEXT "Name: sup\n==> gives the upper bound of an interval.\n\nLibrary name:\n sollya_obj_t sollya_lib_sup(sollya_obj_t)\n\nUsage: \n sup({I}) : range -> constant\n sup({x}) : constant -> constant\n\nParameters: \n {I} is an interval.\n {x} is a real number.\n\nDescription: \n * Returns the upper bound of the interval {I}. Each bound of an interval has its \n own precision, so this command is exact, even if the current precision is too \n small to represent the bound.\n\n * When called on a real number {x}, sup behaves like the identity.\n\nExample 1: \n > sup([1;3]);\n 3\n > sup(5);\n 5\n\nExample 2: \n > display=binary!;\n > I=[0; 0.111110000011111_2];\n > sup(I);\n 1.11110000011111_2 * 2^(-1)\n > prec=12!;\n > sup(I);\n 1.11110000011111_2 * 2^(-1)\n\nSee also: inf, mid, max, min\n" #define HELP_SUPNORM_TEXT "Name: supnorm\n==> computes an interval bounding the supremum norm of an approximation error (absolute or relative) between a given polynomial and a function.\n\nLibrary name:\n sollya_obj_t sollya_lib_supnorm(sollya_obj_t, sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t)\n\nUsage: \n supnorm({p}, {f}, {I}, {errorType}, {accuracy}) : (function, function, range, absolute|relative, constant) -> range\n\nParameters: \n {p} is a polynomial.\n {f} is a function.\n {I} is an interval.\n {errorType} is the type of error to be considered: absolute or relative (see details below).\n {accuracy} is a constant that controls the relative tightness of the interval returned. \n\nDescription: \n * supnorm({p}, {f}, {I}, {errorType}, {accuracy}) tries to compute an\n interval bound r=[l,u] for the supremum norm of the error function\n epsilon_absolute=p-f (when {errorType} evaluates to absolute)\n or epsilon_relative=p/f-1 (when {errorType} evaluates to relative),\n over the interval I, such that sup{|epsilon(x)|, x in I} C r\n and 0<|u/l-1|< {accuracy}. If supnorm succeeds in computing a suitable\n interval r, which it returns, that interval is guaranteed to contain the\n supremum norm value and to satisfy the required quality. Otherwise, supnorm\n evaluates to error, displaying a corresponding error message. These failure\n cases are rare and basically happen only for functions which are too\n complicated.\n\n * Roughly speaking, supnorm is based on taylorform to obtain a higher\n degree polynomial approximation for {f}. This process is coupled with\n an a posteriori validation of a potential supremum norm upper bound. \n The validation is based on showing a certain polynomial the problem gets\n reduced to does not vanish. In cases when this process alone does not \n succeed, for instance because taylorform is unable to compute a \n sufficiently good approximation to {f}, supnorm falls back to\n bisecting the working interval until safe supremum norm bounds can be\n computed with the required accuracy or until the width of the\n subintervals becomes less than diam times the original interval {I}, \n in which case supnorm fails.\n\n * The algorithm used for supnorm is quite complex, which makes it impossible \n to explain it here in further detail. \n Please find a complete description in the following article:\n \n Sylvain Chevillard, John Harrison, Mioara Joldes, Christoph Lauter\n Efficient and accurate computation of upper bounds of approximation errors\n Journal of Theoretical Computer Science (TCS), 2010\n LIP Research Report number RR LIP2010-2\n http://prunel.ccsd.cnrs.fr/ensl-00445343/fr/\n\n * In practical cases, supnorm should be able to automatically handle\n removable discontinuities that relative errors might have. This means\n that usually, if {f} vanishes at a point x0 in the interval\n considered, the approximation polynomial {p} is designed such that it\n also vanishes at the same point with a multiplicity large\n enough. Hence, although {f} vanishes, epsilon_relative=p/f-1 may be \n defined by continuous extension at such points x0, called \n removable discontinuities (see Example 3).\n\nExample 1: \n > p = remez(exp(x), 5, [-1;1]);\n > midpointmode=on!;\n > supnorm(p, exp(x), [-1;1], absolute, 2^(-40));\n 0.45205513967~0/2~e-4\n\nExample 2: \n > prec=200!;\n > midpointmode=on!;\n > d = [1;2];\n > f = exp(cos(x)^2 + 1);\n > p = remez(1,15,d,1/f,1e-40);\n > theta=1b-60;\n > prec=default!;\n > mode=relative;\n > supnorm(p,f,d,mode,theta);\n 0.30893006200251428~5/6~e-13\n\nExample 3: \n > midpointmode=on!;\n > mode=relative;\n > theta=1b-135;\n > d = [-1b-2;1b-2];\n > f = expm1(x);\n > p = x * (1 + x * ( 2097145 * 2^(-22) + x * ( 349527 * 2^(-21) + x * (87609 * 2^(-21) + x * 4369 * 2^(-19))))); \n > theta=1b-40;\n > supnorm(p,f,d,mode,theta);\n 0.98349131972~2/3~e-7\n\nSee also: dirtyinfnorm, infnorm, checkinfnorm, absolute, relative, taylorform, autodiff, numberroots, diam\n" #define HELP_SUPPRESSMESSAGE_TEXT "Name: suppressmessage\n==> suppresses the displaying of messages with a certain number\n\nLibrary names:\n void sollya_lib_suppressmessage(sollya_obj_t, ...);\n void sollya_lib_v_suppressmessage(sollya_obj_t, va_list);\n\nUsage: \n suppressmessage({msg num 1}, ..., {msg num n}) : (integer, ..., integer) -> void\n suppressmessage({msg list}) : list -> void\n\nParameters: \n {msg num 1} thru {msg num n} represent the numbers of n messages to be suppressed\n {msg list} represents a list with numbers of messages to be suppressed\n\nDescription: \n * The suppressmessage command allows particular warning and information\n messages to be suppressed from message output, while maintaining\n global verbosity levels (see verbosity) high. Every Sollya warning\n or information message (that is not fatal to the tool's execution) has\n a message number. When these message numbers {msg num 1} thru {msg num n} \n are given to suppressmessage, the corresponding message are no longer\n displayed. The unsuppressmessage command reverts this suppression\n from output for a particular message.\n\n * Instead of giving suppressmessage several message numbers {msg num 1} thru\n {msg num n} or calling suppressmessage several times, it is possible to give\n a whole list {msg list} of message numbers to suppressmessage.\n\n * The user should be aware that suppressmessage presents sticky behavior for\n the warning and information messages suppressed from output. This\n means that even if subsequent calls to suppressmessage occur, a message\n suppressed by a call to suppressmessage stays suppressed until it is\n unsuppressed using unsuppressmessage or the tool is restarted. This\n behavior distinguishes message suppression from other global states of\n the Sollya tool. The user may use getsuppressedmessages to obtain a\n list of currently suppressed messages.\n\n * When suppressmessage is used on message numbers that do not exist in the\n current version of the tool, a warning is displayed. The call has no\n other effect though.\n\nExample 1: \n > verbosity = 1;\n The verbosity level has been set to 1.\n > 0.1;\n Warning: Rounding occurred when converting the constant \"0.1\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n 0.1\n > suppressmessage(174);\n > 0.1;\n 0.1\n > suppressmessage(407);\n > 0.1;\n 0.1\n > verbosity = 12;\n The verbosity level has been set to 12.\n > showmessagenumbers = on;\n Displaying of message numbers has been activated.\n > diff(exp(x * 0.1));\n Information (196): formally differentiating a function.\n Information (197): differentiating the expression 'exp(x * 0.1)'\n Information (207): no Horner simplification will be performed because the given tree is already in Horner form.\n exp(x * 0.1) * 0.1\n > suppressmessage(207, 196);\n > diff(exp(x * 0.1));\n Information (197): differentiating the expression 'exp(x * 0.1)'\n exp(x * 0.1) * 0.1\n > unsuppressmessage(174);\n > 0.1;\n Warning (174): Rounding occurred when converting the constant \"0.1\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n 0.1\n\nExample 2: \n > verbosity = 12;\n The verbosity level has been set to 12.\n > showmessagenumbers = on; \n Displaying of message numbers has been activated.\n > diff(exp(x * 0.1));\n Warning (174): Rounding occurred when converting the constant \"0.1\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n Information (196): formally differentiating a function.\n Information (197): differentiating the expression 'exp(x * 0.1)'\n Information (207): no Horner simplification will be performed because the given tree is already in Horner form.\n exp(x * 0.1) * 0.1\n > suppressmessage([| 174, 207, 196 |]);\n > diff(exp(x * 0.1));\n Information (197): differentiating the expression 'exp(x * 0.1)'\n exp(x * 0.1) * 0.1\n\nSee also: getsuppressedmessages, suppressmessage, unsuppressmessage, verbosity, roundingwarnings\n" #define HELP_TAIL_TEXT "Name: tail\n==> gives the tail of a list.\n\nLibrary name:\n sollya_obj_t sollya_lib_tail(sollya_obj_t)\n\nUsage: \n tail({L}) : list -> list\n\nParameters: \n {L} is a list.\n\nDescription: \n * tail({L}) returns the list {L} without its first element.\n\n * If {L} is empty, the command will fail with an error.\n\n * tail can also be used with end-elliptic lists. In this case, the result of\n tail is also an end-elliptic list.\n\nExample 1: \n > tail([|1,2,3|]);\n [|2, 3|]\n > tail([|1,2...|]);\n [|2...|]\n\nSee also: head\n" #define HELP_TAN_TEXT "Name: tan\n==> the tangent function.\n\nLibrary names:\n sollya_obj_t sollya_lib_tan(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_tan(sollya_obj_t)\n #define SOLLYA_TAN(x) sollya_lib_build_function_tan(x)\n\nDescription: \n * tan is the tangent function, defined by tan(x) = sin(x)/cos(x).\n\n * It is defined for every real number x that is not of the form n*Pi+Pi/2 where n is an integer.\n\nSee also: atan, cos, sin\n" #define HELP_TANH_TEXT "Name: tanh\n==> the hyperbolic tangent function.\n\nLibrary names:\n sollya_obj_t sollya_lib_tanh(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_tanh(sollya_obj_t)\n #define SOLLYA_TANH(x) sollya_lib_build_function_tanh(x)\n\nDescription: \n * tanh is the hyperbolic tangent function, defined by tanh(x) = sinh(x)/cosh(x).\n\n * It is defined for every real number x.\n\nSee also: atanh, cosh, sinh\n" #define HELP_TAYLOR_TEXT "Name: taylor\n==> computes a Taylor expansion of a function in a point\n\nLibrary name:\n sollya_obj_t sollya_lib_taylor(sollya_obj_t, sollya_obj_t, sollya_obj_t)\n\nUsage: \n taylor({function}, {degree}, {point}) : (function, integer, constant) -> function\n\nParameters: \n {function} represents the function to be expanded\n {degree} represents the degree of the expansion to be delivered\n {point} represents the point in which the function is to be developed\n\nDescription: \n * The command taylor returns an expression that is a Taylor expansion\n of function {function} in point {point} having the degree {degree}.\n \n Let f be the function {function}, t be the point {point} and\n n be the degree {degree}. Then, taylor({function},{degree},{point}) \n evaluates to an expression mathematically equal to\n f(t) + f'(t) * x + ... + 1/(n!) * f[n](t) * x^n.\n In other words, if p(x) denotes the polynomial returned by taylor,\n p(x-t) is the Taylor polynomial of degree n of f developed at point t.\n \n Remark that taylor evaluates to 0 if the degree {degree} is negative.\n\nExample 1: \n > print(taylor(exp(x),3,1));\n exp(1) + x * (exp(1) + x * (0.5 * exp(1) + x * exp(1) / 6))\n\nExample 2: \n > print(taylor(asin(x),7,0));\n x * (1 + x^2 * (1 / 6 + x^2 * (3 / 40 + x^2 * 5 / 112)))\n\nExample 3: \n > print(taylor(erf(x),6,0));\n x * (1 / sqrt((pi) / 4) + x^2 * ((sqrt((pi) / 4) * 4 / (pi) * (-2)) / 6 + x^2 * (sqrt((pi) / 4) * 4 / (pi) * 12) / 120))\n\nSee also: remez, fpminimax, taylorform\n" #define HELP_TAYLORFORM_TEXT "Name: taylorform\n==> computes a rigorous polynomial approximation (polynomial, interval error bound) for a function, based on Taylor expansions.\n\nLibrary names:\n sollya_obj_t sollya_lib_taylorform(sollya_obj_t, sollya_obj_t,\n sollya_obj_t, ...)\n sollya_obj_t sollya_lib_v_taylorform(sollya_obj_t, sollya_obj_t,\n sollya_obj_t, va_list)\n\nUsage: \n taylorform({f}, {n}, {x0}, {I}, {errorType}) : (function, integer, constant, range, absolute|relative) -> list\n taylorform({f}, {n}, {x0}, {I}, {errorType}) : (function, integer, range, range, absolute|relative) -> list\n taylorform({f}, {n}, {x0}, {errorType}) : (function, integer, constant, absolute|relative) -> list\n taylorform({f}, {n}, {x0}, {errorType}) : (function, integer, range, absolute|relative) -> list\n\nParameters: \n {f} is the function to be approximated.\n {n} is the degree of the polynomial that must approximate {f}.\n {x0} is the point (it can be a real number or an interval) where the Taylor exansion of the function is to be considered.\n {I} is the interval over which the function is to be approximated. If this parameter is omitted, the behavior is changed (see detailed description below).\n {errorType} (optional) is the type of error to be considered. See the detailed description below. Default is absolute.\n\nDescription: \n * WARNING: taylorform is a certified command, not difficult to use but not\n completely straightforward to use either. In order to be sure to use it\n correctly, the reader is invited to carefully read this documentation\n entirely.\n\n * taylorform computes an approximation polynomial and an interval error\n bound for function f. \n More precisely, it returns a list\n L=[p, coeffErrors, Delta] where:\n \n - p is an approximation polynomial of degree n such that p(x-x0) is\n roughly speaking a numerical Taylor expansion of f at the point x0.\n - coeffsErrors is a list of n+1 intervals. Each interval coeffsErrors[i]\n contains an enclosure of all the errors accumulated when computing the i-th\n coefficient of p.\n - Delta is an interval that provides a bound for the approximation error\n between p and f. Its significance depends on the {errorType} considered.\n \n\n * The polynomial p and the bound Delta are obtained using Taylor Models\n principles.\n\n * Please note that x0 can be an interval. In general, it is meant to be a\n small interval approximating a non representable value. If x0 is given as a\n constant expression, it is first numerically evaluated (leading to a faithful\n rounding xapprox0 at precision prec), and it is then replaced by the (exactly\n representable) point-interval [xapprox0, xapprox0]. In particular, it is not\n the same to call taylorform with x0 = pi and with x0 = [pi], for instance.\n In general, if the point around which one desires to compute the polynomial\n is not exactly representable, one should preferably use a small interval\n for x0.\n\n * More formally, the mathematical property ensured by the algorithm may be\n stated as follows. For all xi0 in x0, there exist (small) values\n eps[i] in coeffsErrors[i] such that:\n \n If {errorType} is absolute, for all x in I, there exists delta in Delta such\n that f(x) - p(x-xi0) = sum{i=0...n} eps[i]*(x-xi0)^i + delta.\n \n If {errorType} is relative, for all x in I, there exists delta in Delta such\n that f(x) - p(x-xi0) = sum{i=0...n} eps[i]*(x-xi0)^i + delta*(x-xi0)^(n+1).\n\n * It is also possible to use a large interval for x0, though it is not\n obvious to give an intuitive sense to the result of taylorform in that case.\n A particular case that might be interesting is when x0=I in relative mode.\n In that case, denoting by p_i the coefficient of p of order i, the interval\n p_i + coeffsError[i] gives an enclosure of f^(i)(I)/i!.\n However, the command autodiff is more convenient for computing such\n enclosures.\n\n * When the interval I is not given, the approximated Taylor polynomial is\n computed but no remainder is produced. In that case the returned list\n is L=[p, coeffErrors].\n\n * The relative case is especially useful when functions with removable\n singularities are considered. In such a case, this routine is able to compute\n a finite remainder bound, provided that the expansion point given is the\n problematic removable singularity point.\n\n * The algorithm does not guarantee that by increasing the degree of the\n approximation, the remainder bound will become smaller. Moreover, it may \n even become larger due to the dependency phenomenon present with interval\n arithmetic. In order to reduce this phenomenon, a possible solution is to\n split the definition domain I into several smaller intervals. \n\n * The command taylor also computes a Taylor polynomial of a function. However\n it does not provide a bound on the remainder. Besides, taylor is a somehow\n symbolic command: each coefficient of the Taylor polynomial is computed\n exactly and returned as an expression tree exactly equal to theoretical\n value. It is henceforth much more inefficient than taylorform and taylorform\n should be preferred if only numercial (yet safe) computations are required.\n The same difference exists between commands diff and autodiff.\n\nExample 1: \n > TL=taylorform(sin(x)/x, 10, 0, [-1,1], relative);\n > p=TL[0];\n > Delta=TL[2];\n > errors=TL[1];\n > for epsi in errors do epsi;\n [0;0]\n [0;0]\n [0;5.3455294201843912922810729343029637576303937602101e-51]\n [0;0]\n [-3.3409558876152445576756705839393523485189961001313e-52;3.3409558876152445576756705839393523485189961001313e-52]\n [0;0]\n [-1.04404871487976392427364705748104760891218628129103e-53;1.04404871487976392427364705748104760891218628129103e-53]\n [0;0]\n [-1.63132611699963113167757352731413688892529106451724e-55;1.63132611699963113167757352731413688892529106451724e-55]\n [0;0]\n [-1.91171029335894273243465647732125416670932546623114e-57;1.91171029335894273243465647732125416670932546623114e-57]\n > p; Delta;\n 1 + x^2 * (-0.16666666666666666666666666666666666666666666666667 + x^2 * (8.3333333333333333333333333333333333333333333333333e-3 + x^2 * (-1.984126984126984126984126984126984126984126984127e-4 + x^2 * (2.7557319223985890652557319223985890652557319223986e-6 + x^2 * (-2.5052108385441718775052108385441718775052108385442e-8)))))\n [-1.6135797443886066084999806203254010793747502812764e-10;1.6135797443886066084999806203254010793747502812764e-10]\n\nExample 2: \n > TL=taylorform(exp(x), 10, 0, [-1,1], absolute);\n > p=TL[0];\n > Delta=TL[2];\n > p; Delta;\n 1 + x * (1 + x * (0.5 + x * (0.16666666666666666666666666666666666666666666666667 + x * (4.1666666666666666666666666666666666666666666666668e-2 + x * (8.3333333333333333333333333333333333333333333333333e-3 + x * (1.3888888888888888888888888888888888888888888888889e-3 + x * (1.984126984126984126984126984126984126984126984127e-4 + x * (2.4801587301587301587301587301587301587301587301587e-5 + x * (2.7557319223985890652557319223985890652557319223986e-6 + x * 2.7557319223985890652557319223985890652557319223986e-7)))))))))\n [-2.3114271964118761944124253418268474583253955510297e-8;2.7312660755642474420206278018039434042553645532164e-8]\n\nExample 3: \n > TL1 = taylorform(exp(x), 10, log2(10), [-1,1], absolute);\n > TL2 = taylorform(exp(x), 10, [log2(10)], [-1,1], absolute);\n > TL1==TL2;\n false\n\nExample 4: \n > TL1 = taylorform(exp(x), 3, 0, [0,1], relative);\n > TL2 = taylorform(exp(x), 3, 0, relative);\n > TL1[0]==TL2[0];\n true\n > TL1[1]==TL2[1];\n true\n > length(TL1);\n 3\n > length(TL2);\n 2\n\nExample 5: \n > f = exp(cos(x)); x0 = 0;\n > TL = taylorform(f, 3, x0);\n > T1 = TL[0];\n > T2 = taylor(f, 3, x0);\n > print(coeff(T1, 2));\n -1.35914091422952261768014373567633124887862354685\n > print(coeff(T2, 2));\n -(0.5 * exp(1))\n\nSee also: diff, autodiff, taylor, remez, chebyshevform\n" #define HELP_TAYLORRECURSIONS_TEXT "Name: taylorrecursions\n==> controls the number of recursion steps when applying Taylor's rule.\n\nLibrary names:\n void sollya_lib_set_taylorrecursions_and_print(sollya_obj_t)\n void sollya_lib_set_taylorrecursions(sollya_obj_t)\n sollya_obj_t sollya_lib_get_taylorrecursions()\n\nUsage: \n taylorrecursions = {n} : integer -> void\n taylorrecursions = {n} ! : integer -> void\n taylorrecursions : integer\n\nParameters: \n {n} represents the number of recursions\n\nDescription: \n * taylorrecursions is a global variable. Its value represents the number of steps\n of recursion that are used when applying Taylor's rule. This rule is applied\n by the interval evaluator present in the core of Sollya (and particularly\n visible in commands like infnorm).\n\n * To improve the quality of an interval evaluation of a function f, in \n particular when there are problems of decorrelation), the evaluator of Sollya\n uses Taylor's rule: f([a,b]) C f(m) + [a-m, b-m]*f'([a,b]) where m=(a+b)/2.\n This rule can be applied recursively.\n The number of step in this recursion process is controlled by taylorrecursions.\n\n * Setting taylorrecursions to 0 makes Sollya use this rule only once;\n setting it to 1 makes Sollya use the rule twice, and so on.\n In particular: the rule is always applied at least once.\n\nExample 1: \n > f=exp(x);\n > p=remez(f,3,[0;1]);\n > taylorrecursions=0;\n The number of recursions for Taylor evaluation has been set to 0.\n > evaluate(f-p, [0;1]);\n [-0.46839364816268368775174657814112460243249079671039;0.46947781754646820647293019728402934746974652584671]\n > taylorrecursions=1;\n The number of recursions for Taylor evaluation has been set to 1.\n > evaluate(f-p, [0;1]);\n [-0.138131114954063839905475752120786856031651747712954;0.13921528433784835862665937126369160106890747684927]\n\nSee also: hopitalrecursions, evaluate, infnorm\n" #define HELP_TD_TEXT "Name: TD\n==> short form for tripledouble\n\nSee also: tripledouble\n" #define HELP_TIME_TEXT "Name: time\n==> procedure for timing Sollya code.\n\nUsage: \n time({code}) : code -> constant\n\nParameters: \n {code} is the code to be timed.\n\nDescription: \n * time permits timing a Sollya instruction, resp. a begin-end block\n of Sollya instructions. The timing value, measured in seconds, is returned\n as a Sollya constant (and not merely displayed as for timing). This \n permits performing computations of the timing measurement value inside Sollya.\n\n * The extended nop command permits executing a defined number of\n useless instructions. Taking the ratio of the time needed to execute a\n certain Sollya instruction and the time for executing a nop\n therefore gives a way to abstract from the speed of a particular \n machine when evaluating an algorithm's performance.\n\nExample 1: \n > t = time(p=remez(sin(x),10,[-1;1]));\n > write(t,\"s were spent computing p = \",p,\"\\n\");\n 3.0139338000000000000000000000000000003738494837423e-2s were spent computing p = 9.0486898749977990986908851357759191711354777014602e-17 * x^10 + 2.68762595115123596299959320959141640012683406736586e-6 * x^9 + -2.4247978492521313349073232289246205727856268698001e-16 * x^8 + -1.98344863020965929701245606503586461226130937598776e-4 * x^7 + 2.2748214757753544349162426281857910162575492126267e-16 * x^6 + 8.3333037186560980567697821420813799547276481409702e-3 * x^5 + -8.574715198972066974170696130354953131211051121887e-17 * x^4 + -0.166666661386013237076216566493953847771564552744173 * x^3 + 1.05699558969863875841493332282097022580493449058156e-17 * x^2 + 0.99999999973628365676559825181776417246038944720795 * x + (-3.1206530956601883024316320853642604562810646600878e-19)\n\nExample 2: \n > write(time({ p=remez(sin(x),10,[-1;1]); write(\"The error is 2^(\", log2(dirtyinfnorm(p-sin(x),[-1;1])), \")\\n\"); }), \" s were spent\\n\");\n The error is 2^(log2(2.39601979446524486606649528289933482070294808074097e-11))\n 5.3484197000000000000000000000000000000439749991614e-2 s were spent\n\nExample 3: \n > t = time(bashexecute(\"sleep 10\"));\n > write(~(t-10),\"s of execution overhead.\\n\");\n 1.1357700000000000000000000000000007830985228274052e-3s of execution overhead.\n\nExample 4: \n > ratio := time(p=remez(sin(x),10,[-1;1]))/time(nop(10));\n > write(\"This ratio = \", ratio, \" should somehow be independent of the type of machine.\\n\");\n This ratio = 1.70787349643470160681947005324445638682837945364347 should somehow be independent of the type of machine.\n\nSee also: timing, nop\n" #define HELP_TIMING_TEXT "Name: timing\n==> global variable controlling timing measures in Sollya.\n\nLibrary names:\n void sollya_lib_set_timing_and_print(sollya_obj_t)\n void sollya_lib_set_timing(sollya_obj_t)\n sollya_obj_t sollya_lib_get_timing()\n\nUsage: \n timing = {activation value} : on|off -> void\n timing = {activation value} ! : on|off -> void\n timing : on|off\n\nParameters: \n {activation value} controls if timing should be performed or not\n\nDescription: \n * timing is a global variable. When its value is on, the time spent in each \n command is measured and displayed (for verbosity levels higher than 1).\n\nExample 1: \n > verbosity=1!;\n > timing=on;\n Timing has been activated.\n > p=remez(sin(x),10,[-1;1]);\n Information: Remez: computing the quality of approximation spent 3 ms\n Information: Remez: computing the quality of approximation spent 3 ms\n Information: Remez: computing the quality of approximation spent 3 ms\n Information: computing a minimax approximation spent 22 ms\n Information: assignment spent 26 ms\n Information: full execution of the last parse chunk spent 30 ms\n\nSee also: on, off, time\n" #define HELP_TRIPLEDOUBLE_TEXT "Names: tripledouble, TD\n==> represents a number as the sum of three IEEE doubles.\n\nLibrary names:\n sollya_obj_t sollya_lib_triple_double(sollya_obj_t)\n sollya_obj_t sollya_lib_triple_double_obj()\n int sollya_lib_is_triple_double_obj(sollya_obj_t)\n sollya_obj_t sollya_lib_build_function_triple_double(sollya_obj_t)\n #define SOLLYA_TD(x) sollya_lib_build_function_triple_double(x)\n\nDescription: \n * tripledouble is both a function and a constant.\n\n * As a function, it rounds its argument to the nearest number that can be written\n as the sum of three double precision numbers.\n\n * The algorithm used to compute tripledouble(x) is the following: let xh = double(x),\n let xm = double(x - xh) and let xl = double(x - xh - xm). \n Return the number xh + xm + xl. Note that if the\n current precision is not sufficient to represent exactly xh + xm + xl, a rounding will\n occur and the result of tripledouble(x) will be useless.\n\n * As a constant, it symbolizes the triple-double precision format. It is used in \n contexts when a precision format is necessary, e.g. in the commands \n roundcoefficients and implementpoly.\n See the corresponding help pages for examples.\n\nExample 1: \n > verbosity=1!;\n > a = 1+ 2^(-55)+2^(-115);\n > TD(a);\n 1.00000000000000002775557561562891353466491600711096\n > prec=110!;\n > TD(a);\n 1.000000000000000027755575615628913534664916007110955975699724\n\nSee also: halfprecision, single, double, doubleextended, doubledouble, quad, roundcoefficients, implementpoly, fpminimax, printexpansion\n" #define HELP_TRUE_TEXT "Name: true\n==> the boolean value representing the truth.\n\nLibrary names:\n sollya_obj_t sollya_lib_true()\n int sollya_lib_is_true(sollya_obj_t)\n\nDescription: \n * true is the usual boolean value.\n\nExample 1: \n > true && false;\n false\n > 2>1;\n true\n\nSee also: false, &&, ||\n" #define HELP_UNSUPPRESSMESSAGE_TEXT "Name: unsuppressmessage\n==> unsuppresses the displaying of messages with a certain number\n\nLibrary names:\n void sollya_lib_unsuppressmessage(sollya_obj_t, ...);\n void sollya_lib_v_unsuppressmessage(sollya_obj_t, va_list);\n\nUsage: \n unsuppressmessage({msg num 1}, ..., {msg num n}) : (integer, ..., integer) -> void\n unsuppressmessage({msg list}) : list -> void\n\nParameters: \n {msg num 1} thru {msg num n} represent the numbers of n messages to be suppressed\n {msg list} represents a list with numbers of messages to be suppressed\n\nDescription: \n * The unsuppressmessage command allows particular warning and information\n messages that have been suppressed from message output to be\n unsuppressed, i.e. activated for display again. Every Sollya warning\n or information message (that is not fatal to the tool's execution) has\n a message number. When these message numbers {msg num 1} thru {msg num n} \n are given to unsuppressmessage, the corresponding message are displayed\n again, as they are by default at according verbosity levels. Actually,\n the unsuppressmessage command just reverts the effects of the suppressmessage\n command.\n\n * Instead of giving unsuppressmessage several message numbers {msg num 1} thru\n {msg num n} or calling unsuppressmessage several times, it is possible to give\n a whole list {msg list} of message numbers to unsuppressmessage.\n\n * The user should be aware that unsuppressmessage presents sticky behavior for\n the warning and information messages suppressed from output. In fact,\n unsuppressmessage just unsuppresses the warning or information messages given\n in argument. All other suppressed messages stay suppressed until they\n get unsuppressed by subsequent calls to unsuppressmessage or the Sollya tool\n is restarted. This behavior distinguishes message suppression from\n other global states of the Sollya tool. The user may use\n getsuppressedmessages to obtain a list of currently suppressed\n messages. In particular, in order to unsuppressed all currently\n suppressed warning or information messages, the user may feed the\n output of getsuppressedmessages (a list) into unsuppressmessage.\n\n * The user should also note that unsuppressing warning or information\n messages with unsuppressmessage just reverts the effects of the suppressmessage\n command but that other conditions exist that affect the actual displaying \n of a message, such as global verbosity (see verbosity) and modes\n like rounding warnings (see roundingwarnings). A message will not just \n get displayed because it was unsuppressed with unsuppressmessage.\n\n * When unsuppressmessage is used on message numbers that do not exist in the\n current version of the tool, a warning is displayed. The call has no\n other effect though.\n\nExample 1: \n > verbosity = 1;\n The verbosity level has been set to 1.\n > 0.1;\n Warning: Rounding occurred when converting the constant \"0.1\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n 0.1\n > suppressmessage(174);\n > 0.1;\n 0.1\n > suppressmessage(174);\n > 0.1;\n 0.1\n\nExample 2: \n > verbosity = 12;\n The verbosity level has been set to 12.\n > showmessagenumbers = on; \n Displaying of message numbers has been activated.\n > diff(exp(x * 0.1));\n Warning (174): Rounding occurred when converting the constant \"0.1\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n Information (196): formally differentiating a function.\n Information (197): differentiating the expression 'exp(x * 0.1)'\n Information (207): no Horner simplification will be performed because the given tree is already in Horner form.\n exp(x * 0.1) * 0.1\n > suppressmessage([| 174, 207, 196 |]);\n > diff(exp(x * 0.1));\n Information (197): differentiating the expression 'exp(x * 0.1)'\n exp(x * 0.1) * 0.1\n > unsuppressmessage([| 174, 196 |]);\n\nExample 3: \n > verbosity = 12;\n The verbosity level has been set to 12.\n > showmessagenumbers = on;\n Displaying of message numbers has been activated.\n > suppressmessage(207, 387, 390, 388, 391, 196, 195, 197, 205);\n > getsuppressedmessages();\n [|195, 196, 197, 205, 207, 387, 388, 390, 391|]\n > evaluate(x/sin(x) - 1, [-1;1]);\n [0;0.8508157176809256179117532413986501934703966550941]\n > unsuppressmessage(getsuppressedmessages());\n > getsuppressedmessages();\n [| |]\n\nSee also: getsuppressedmessages, suppressmessage, unsuppressmessage, verbosity, roundingwarnings\n" #define HELP_VAR_TEXT "Name: var\n==> declaration of a local variable in a scope\n\nUsage: \n var {identifier1}, {identifier2},... , {identifiern} : void\n\nParameters: \n {identifier1}, {identifier2},... , {identifiern} represent variable identifiers\n\nDescription: \n * The keyword var allows for the declaration of local variables\n {identifier1} through {identifiern} in a begin-end-block ({}-block).\n Once declared as a local variable, an identifier will shadow\n identifiers declared in higher scopes and undeclared identifiers\n available at top-level.\n \n Variable declarations using var are only possible in the\n beginning of a begin-end-block. Several var statements can be\n given. Once another statement is given in a begin-end-block, no more\n var statements can be given.\n \n Variables declared by var statements are dereferenced as error\n until they are assigned a value. \n\nExample 1: \n > exp(x); \n exp(x)\n > a = 3; \n > {var a, b; a=5; b=3; {var a; var b; b = true; a = 1; a; b;}; a; b; }; \n 1\n true\n 5\n 3\n > a;\n 3\n\nSee also: error, proc\n" #define HELP_VERBOSITY_TEXT "Name: verbosity\n==> global variable controlling the amount of information displayed by commands.\n\nLibrary names:\n void sollya_lib_set_verbosity_and_print(sollya_obj_t)\n void sollya_lib_set_verbosity(sollya_obj_t)\n sollya_obj_t sollya_lib_get_verbosity()\n\nUsage: \n verbosity = {n} : integer -> void\n verbosity = {n} ! : integer -> void\n verbosity : integer\n\nParameters: \n {n} controls the amount of information to be displayed\n\nDescription: \n * verbosity accepts any integer value. At level 0, commands do not display anything\n on standard output. Note that very critical information may however be displayed on\n standard error.\n\n * Default level is 1. It displays important information such as warnings when \n roundings happen.\n\n * For higher levels more information is displayed depending on the command.\n\nExample 1: \n > verbosity=0!;\n > 1.2+\"toto\";\n error\n > verbosity=1!;\n > 1.2+\"toto\";\n Warning: Rounding occurred when converting the constant \"1.2\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n Warning: at least one of the given expressions or a subexpression is not correctly typed\n or its evaluation has failed because of some error on a side-effect.\n error\n > verbosity=2!;\n > 1.2+\"toto\";\n Warning: Rounding occurred when converting the constant \"1.2\" to floating-point with 165 bits.\n If safe computation is needed, try to increase the precision.\n Warning: at least one of the given expressions or a subexpression is not correctly typed\n or its evaluation has failed because of some error on a side-effect.\n Information: the expression or a partial evaluation of it has been the following:\n (1.2) + (\"toto\")\n error\n\nSee also: roundingwarnings, suppressmessage, unsuppressmessage, showmessagenumbers, getsuppressedmessages\n" #define HELP_VOID_TEXT "Name: void\n==> the functional result of a side-effect or empty argument resp. the corresponding type\n\nLibrary names:\n sollya_obj_t sollya_lib_void()\n int sollya_lib_is_void(sollya_obj_t)\n SOLLYA_EXTERNALPROC_TYPE_VOID\n\nUsage: \n void : void | type type\n\nDescription: \n * The variable void represents the functional result of a\n side-effect or an empty argument. It is used only in combination with\n the applications of procedures or identifiers bound through\n externalproc to external procedures.\n \n The void result produced by a procedure or an external procedure\n is not printed at the prompt. However, it is possible to print it out\n in a print statement or in complex data types such as lists.\n \n The void argument is implicit when giving no argument to a\n procedure or an external procedure when applied. It can nevertheless be given\n explicitly. For example, suppose that foo is a procedure or an\n external procedure with a void argument. Then foo() and foo(void) are\n correct calls to foo. Here, a distinction must be made for procedures having an\n arbitrary number of arguments. In this case, an implicit void\n as the only parameter to a call of such a procedure gets converted into \n an empty list of arguments, an explicit void gets passed as-is in the\n formal list of parameters the procedure receives.\n\n * void is used also as a type identifier for\n externalproc. Typically, an external procedure taking void as an\n argument or returning void is bound with a signature void ->\n some type or some type -> void. See externalproc for more\n details.\n\nExample 1: \n > print(void);\n void\n > void;\n\nExample 2: \n > hey = proc() { print(\"Hello world.\"); };\n > hey;\n proc()\n {\n print(\"Hello world.\");\n return void;\n }\n > hey();\n Hello world.\n > hey(void);\n Hello world.\n > print(hey());\n Hello world.\n void\n\nExample 3: \n > bashexecute(\"gcc -fPIC -Wall -c externalprocvoidexample.c\");\n > bashexecute(\"gcc -fPIC -shared -o externalprocvoidexample externalprocvoidexample.o\");\n > externalproc(foo, \"./externalprocvoidexample\", void -> void);\n > foo;\n foo\n > foo();\n Hello from the external world.\n > foo(void);\n Hello from the external world.\n > print(foo());\n Hello from the external world.\n void\n\nExample 4: \n > procedure blub(L = ...) { print(\"Argument list:\", L); };\n > blub(1);\n Argument list: [|1|]\n > blub();\n Argument list: [| |]\n > blub(void); \n Argument list: [|void|]\n\nSee also: error, proc, externalproc\n" #define HELP_WORSTCASE_TEXT "Name: worstcase\n==> searches for hard-to-round cases of a function\n\nLibrary names:\n void sollya_lib_worstcase(sollya_obj_t, sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t, ...)\n void sollya_lib_v_worstcase(sollya_obj_t, sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t, va_list)\n\nUsage: \n worstcase({function}, {preimage precision}, {preimage exponent range}, {image precision}, {error bound}) : (function, integer, range, integer, constant) -> void\n worstcase({function}, {preimage precision}, {preimage exponent range}, {image precision}, {error bound}, {filename}) : (function, integer, range, integer, constant, string) -> void\n\nParameters: \n {function} represents the function to be considered\n {preimage precision} represents the precision of the preimages\n {preimage exponent range} represents the exponents in the preimage format\n {image precision} represents the precision of the format the images are to be rounded to\n {error bound} represents the upper bound for the search w.r.t. the relative rounding error\n {filename} represents a character sequence containing a filename\n\nDescription: \n * The worstcase command is deprecated. It searches for hard-to-round cases of\n a function. The command searchgal has a comparable functionality.\n\nExample 1: \n > worstcase(exp(x),24,[1,2],24,1b-26);\n prec = 165\n x = 1.99999988079071044921875\t\tf(x) = 7.3890552520751953125\t\teps = 4.5998601423446695596184695493764120138001954979037e-9 = 2^(-27.695763) \n x = 2\t\tf(x) = 7.38905620574951171875\t\teps = 1.44563608749673018122228379395533417878125150587072e-8 = 2^(-26.043720) \n \n\nSee also: round, searchgal, evaluate\n" #define HELP_WRITE_TEXT "Name: write\n==> prints an expression without separators\n\nUsage: \n write({expr1},...,{exprn}) : (any type,..., any type) -> void\n write({expr1},...,{exprn}) > {filename} : (any type,..., any type, string) -> void\n write({expr1},...,{exprn}) >> {filename} : (any type,...,any type, string) -> void\n\nParameters: \n {expr} represents an expression\n {filename} represents a character sequence indicating a file name\n\nDescription: \n * write({expr1},...,{exprn}) prints the expressions {expr1} through\n {exprn}. The character sequences corresponding to the expressions are\n concatenated without any separator. No newline is displayed at the\n end. In contrast to print, write expects the user to give all\n separators and newlines explicitly.\n \n If a second argument {filename} is given after a single \">\", the\n displaying is not output on the standard output of Sollya but if in\n the file {filename} that get newly created or overwritten. If a double\n \">>\" is given, the output will be appended to the file {filename}.\n \n The global variables display, midpointmode and fullparentheses have\n some influence on the formatting of the output (see display,\n midpointmode and fullparentheses).\n \n Remark that if one of the expressions {expri} given in argument is of\n type string, the character sequence {expri} evaluates to is\n displayed. However, if {expri} is of type list and this list\n contains a variable of type string, the expression for the list\n is displayed, i.e. all character sequences get displayed surrounded\n by quotes (\"). Nevertheless, escape sequences used upon defining\n character sequences are interpreted immediately.\n\nExample 1: \n > write(x + 2 + exp(sin(x))); \n > write(\"Hello\\n\");\n x + 2 + exp(sin(x))Hello\n > write(\"Hello\",\"world\\n\");\n Helloworld\n > write(\"Hello\",\"you\", 4 + 3, \"other persons.\\n\");\n Helloyou7other persons.\n\nExample 2: \n > write(\"Hello\",\"\\n\");\n Hello\n > write([|\"Hello\"|],\"\\n\");\n [|\"Hello\"|]\n > s = \"Hello\";\n > write(s,[|s|],\"\\n\");\n Hello[|\"Hello\"|]\n > t = \"Hello\\tyou\";\n > write(t,[|t|],\"\\n\");\n Hello\tyou[|\"Hello\\tyou\"|]\n\nExample 3: \n > write(x + 2 + exp(sin(x))) > \"foo.sol\";\n > readfile(\"foo.sol\");\n x + 2 + exp(sin(x))\n\nExample 4: \n > write(x + 2 + exp(sin(x))) >> \"foo.sol\";\n\nSee also: print, printexpansion, printdouble, printsingle, printxml, readfile, autosimplify, display, midpointmode, fullparentheses, evaluate, roundingwarnings, autosimplify\n" #define HELP_XFREEVARIABLE_TEXT "Name: _x_\n==> universal name for the mathematical free variable.\n\nLibrary names:\n sollya_obj_t sollya_lib_free_variable()\n sollya_obj_t sollya_lib_build_function_free_variable()\n #define SOLLYA_X_ (sollya_lib_build_function_free_variable())\n\nDescription: \n * _x_ is an identifier that always denotes the mathematical free variable.\n It cannot be assigned.\n\n * Sollya manipulates mathematical functions of a single variable. The first\n time that a variable name is used without having been assigned before, this\n variable name is automatically considered by Sollya as the name of the\n free variable. Subsequently, any other unassigned variable name will be\n considered as the free variable with a warning making this conversion\n explicit. This is convenient for an every-day use of the interactive tool,\n but it has the drawback that the free variable name can change from a\n session to another. There are contexts (e.g., within a procedure, or for\n doing pattern matching) when one might want to refer to the free variable\n regardless of its name in the current session. For this purpose _x_ is\n a universal identifier, always available and always denoting the free\n variable, whatever its name is in the current context.\n\nExample 1: \n > verbosity=1!;\n > sin(a);\n sin(a)\n > b;\n Warning: the identifier \"b\" is neither assigned to, nor bound to a library function nor external procedure, nor equal to the current free variable.\n Will interpret \"b\" as \"a\".\n a\n > _x_;\n a\n\nExample 2: \n > verbosity=1!;\n > sin(y);\n sin(y)\n > f = proc(a) {\n return sin(a + _x_);\n };\n > rename(y,z);\n Information: the free variable has been renamed from \"y\" to \"z\".\n > f(1);\n sin(1 + z)\n\nExample 3: \n > f = sin(y);\n > match f with\n sin(a) : { print(\"sin of a with a =\", a);\n match a with\n _x_ : { print(\"a turns out to be the free variable\"); }\n \t default : { print(\"a is some expression\"); };\n }\n _x_ : { print(\"Free variable\") ; }\n default: { print(\"Something else\"); };\n sin of a with a = y\n a turns out to be the free variable\n\nSee also: rename, isbound, proc\n" #endif /* ifdef HELP_H*/ sollya-6.0+ds/hooks.c000066400000000000000000001165571300174114700145700ustar00rootroot00000000000000/* Copyright 2014-2016 by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributor Ch. Lauter christoph.lauter@lip6.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "general.h" #include "execute.h" #include "infnorm.h" #include "sturm.h" #include "hooks.h" int addEvaluationHook(eval_hook_t **hookPtr, void *data, int (*evaluateFunc)(sollya_mpfi_t, sollya_mpfi_t, mp_prec_t, int, void *), void (*freeFunc)(void *), int (*compareFunc)(void *, void *), void *(*copyFunc)(void *), int (*composeFunc)(eval_hook_t **, void *, node *)) { eval_hook_t *newHook, *curr; /* Check if this hook has already been installed. If yes, deallocate the hook we have been given. */ for (curr=*hookPtr;curr!=NULL;curr=curr->nextHook) { if (((curr->evaluateHook == evaluateFunc) && (curr->freeHook == freeFunc) && (curr->compareHook == compareFunc) && (curr->copyHook == copyFunc) && (curr->composeHook == composeFunc)) && curr->compareHook(curr->data, data)) { freeFunc(data); return 0; } } /* Here, we know that the new hook does not yet exist Create a new hook. */ newHook = (eval_hook_t *) safeMalloc(sizeof(eval_hook_t)); newHook->data = data; newHook->gettingUsed = 0; newHook->reuseMPFIInit = 0; newHook->evaluateHook = evaluateFunc; newHook->freeHook = freeFunc; newHook->compareHook = compareFunc; newHook->copyHook = copyFunc; newHook->composeHook = composeFunc; newHook->nextHook = *hookPtr; /* Assign the new hook */ *hookPtr = newHook; /* Signal success */ return 1; } int addEvaluationHookFromCopy(eval_hook_t **newHookPtr, eval_hook_t *hook) { int res, r; eval_hook_t *curr; res = 0; for (curr=hook; curr != NULL; curr=curr->nextHook) { r = addEvaluationHook(newHookPtr, curr->copyHook(curr->data), curr->evaluateHook, curr->freeHook, curr->compareHook, curr->copyHook, curr->composeHook); res = res || r; } return res; } int addEvaluationHookFromComposition(eval_hook_t **newHookPtr, eval_hook_t *hook, node *t) { int res, r; eval_hook_t *curr; res = 0; for (curr=hook; curr != NULL; curr=curr->nextHook) { r = curr->composeHook(newHookPtr, curr->data, t); res = res || r; } return res; } void freeEvaluationHook(eval_hook_t **hookPtr) { eval_hook_t *curr, *next; curr = *hookPtr; while (curr != NULL) { next = curr->nextHook; curr->freeHook(curr->data); if (curr->reuseMPFIInit) { sollya_mpfi_clear(curr->reuseMPFI); curr->reuseMPFIInit = 0; } safeFree(curr); curr = next; } *hookPtr = NULL; } int evaluateWithEvaluationHook(sollya_mpfi_t y, sollya_mpfi_t x, mp_prec_t prec, int tight, eval_hook_t *hook) { eval_hook_t *curr; int res, resCurr, yOnceSet, inconsistency; if (hook == NULL) return 0; if (tight) { /* Tight evaluation */ for (curr=hook;curr!=NULL;curr=curr->nextHook) { if (curr->gettingUsed <= 0) { curr->gettingUsed = 1; res = curr->evaluateHook(y,x,prec,tight,curr->data); curr->gettingUsed = 0; if (res) return 1; } } return 0; } /* Loose evaluation */ res = 0; yOnceSet = 0; inconsistency = 0; for (curr=hook;curr!=NULL;curr=curr->nextHook) { if (curr->gettingUsed <= 0) { curr->gettingUsed = 1; if (curr->reuseMPFIInit) { sollya_mpfi_set_prec(curr->reuseMPFI, sollya_mpfi_get_prec(y)); } else { sollya_mpfi_init2(curr->reuseMPFI, sollya_mpfi_get_prec(y)); curr->reuseMPFIInit = 1; } resCurr = curr->evaluateHook(curr->reuseMPFI,x,prec,tight,curr->data); if (resCurr) { res = 1; if (yOnceSet) { sollya_mpfi_intersect(y, y, curr->reuseMPFI); if (sollya_mpfi_is_empty(y)) { printMessage(1,SOLLYA_MSG_ANNOTATION_INCOHERENT,"Warning: an inconsistency has been detected between the results obtained with the evaluation of two distinct annotations of the same function.\n"); sollya_mpfi_set(y, curr->reuseMPFI); res = 0; inconsistency = 1; } } else { yOnceSet = 1; sollya_mpfi_set(y, curr->reuseMPFI); } } curr->gettingUsed = 0; } } if (inconsistency) { res = 0; } return res; } node_eval_hook_t *createNodeEvalHook(node *func, sollya_mpfi_t dom, sollya_mpfi_t delta, sollya_mpfi_t t) { node_eval_hook_t *newNodeEvalHook; newNodeEvalHook = (node_eval_hook_t *) safeMalloc(sizeof(node_eval_hook_t)); sollya_mpfi_init2(newNodeEvalHook->domain, sollya_mpfi_get_prec(dom)); sollya_mpfi_set(newNodeEvalHook->domain, dom); sollya_mpfi_init2(newNodeEvalHook->delta, sollya_mpfi_get_prec(delta)); sollya_mpfi_set(newNodeEvalHook->delta, delta); sollya_mpfi_init2(newNodeEvalHook->t, sollya_mpfi_get_prec(t)); sollya_mpfi_set(newNodeEvalHook->t, t); newNodeEvalHook->func = copyThing(func); return newNodeEvalHook; } int evaluateNodeEvalHook(sollya_mpfi_t y, sollya_mpfi_t x, mp_prec_t prec, int tight, void *data) { node_eval_hook_t *hook; mp_prec_t p, pY, pX; sollya_mpfi_t myY, myYRnd, myYRndWithDelta, redX; int okay; hook = (node_eval_hook_t *) data; if (sollya_mpfi_has_nan(x)) return 0; if (sollya_mpfi_has_infinity(x)) return 0; if (!sollya_mpfi_is_inside(x, hook->domain)) return 0; if (sollya_mpfi_is_zero(hook->t) && sollya_mpfi_is_zero(hook->delta) && (!tight)) { evaluateIntervalPlain(y, hook->func, x); return (!(sollya_mpfi_has_nan(y) || sollya_mpfi_has_infinity(y))); } pY = sollya_mpfi_get_prec(y); pX = sollya_mpfi_get_prec(x); p = pY + 10; if (prec > p) p = prec; sollya_mpfi_init2(redX, (p > pX ? p : pX)); sollya_mpfi_sub(redX, x, hook->t); if (sollya_mpfi_is_zero(hook->delta) && (!tight)) { evaluateIntervalPlain(y, hook->func, redX); sollya_mpfi_clear(redX); return (!(sollya_mpfi_has_nan(y) || sollya_mpfi_has_infinity(y))); } sollya_mpfi_init2(myY, pY + 10); if (tight) { evaluateInterval(myY, hook->func, NULL, redX); } else { evaluateIntervalPlain(myY, hook->func, redX); } if (!tight) { sollya_mpfi_add(y, myY, hook->delta); sollya_mpfi_clear(myY); sollya_mpfi_clear(redX); return (!(sollya_mpfi_has_nan(y) || sollya_mpfi_has_infinity(y))); } okay = 0; sollya_mpfi_init2(myYRnd, pY + 1); sollya_mpfi_init2(myYRndWithDelta, pY + 1); sollya_mpfi_set(myYRnd, myY); sollya_mpfi_blow_1ulp(myYRnd); sollya_mpfi_add(myYRndWithDelta, myY, hook->delta); if (sollya_mpfi_is_inside(myYRndWithDelta, myYRnd) && (!(sollya_mpfi_has_nan(myYRndWithDelta) || (sollya_mpfi_has_infinity(myYRndWithDelta) && (!sollya_mpfi_is_infinity(myYRndWithDelta)))))) okay = 1; if (okay) sollya_mpfi_set(y, myYRndWithDelta); sollya_mpfi_clear(myYRnd); sollya_mpfi_clear(myYRndWithDelta); sollya_mpfi_clear(myY); sollya_mpfi_clear(redX); return okay; } void freeNodeEvalHook(void *data) { node_eval_hook_t *hook; hook = (node_eval_hook_t *) data; freeThing(hook->func); sollya_mpfi_clear(hook->domain); sollya_mpfi_clear(hook->delta); sollya_mpfi_clear(hook->t); safeFree(hook); } void *copyNodeEvalHook(void *data) { node_eval_hook_t *hook; hook = (node_eval_hook_t *) data; return (void *) createNodeEvalHook(hook->func, hook->domain, hook->delta, hook->t); } int composeNodeEvalHook(eval_hook_t **hookPtr, void *data, node *g) { eval_hook_t *f; int okay; f = NULL; okay = addEvaluationHook(&f, copyNodeEvalHook(data), evaluateNodeEvalHook, freeNodeEvalHook, compareNodeEvalHook, copyNodeEvalHook, composeNodeEvalHook); if (okay) { okay = addEvaluationHook(hookPtr, (void *) createCompositionEvalHook(f, g), evaluateCompositionEvalHook, freeCompositionEvalHook, compareCompositionEvalHook, copyCompositionEvalHook, composeCompositionEvalHook); freeEvaluationHook(&f); } return okay; } int compareNodeEvalHook(void *data1, void *data2) { node_eval_hook_t *hook1, *hook2; hook1 = (node_eval_hook_t *) data1; hook2 = (node_eval_hook_t *) data2; if (!sollya_mpfi_equal_p(hook1->domain, hook2->domain)) return 0; if (!sollya_mpfi_equal_p(hook1->delta, hook2->delta)) return 0; if (!sollya_mpfi_equal_p(hook1->t, hook2->t)) return 0; if (!isEqualThing(hook1->func, hook2->func)) return 0; return 1; } int evaluatePolyEvalHook(sollya_mpfi_t, sollya_mpfi_t, mp_prec_t, int, void *); poly_eval_hook_t *createPolyEvalHook(int degree, mpfr_t *coeffs, sollya_mpfi_t dom, sollya_mpfi_t delta, sollya_mpfi_t t) { poly_eval_hook_t *newPolyEvalHook; mpfr_t *derivCoeffs; int i, derivPolyCoeffsOkay, coeffsOkay; node *derivPoly, *poly; sollya_mpfi_t X, Y; mpfr_t ymax, deltamax; mpfr_t nbRoots; mp_prec_t maxPrec; unsigned long pp, ppp; mp_prec_t p; /* Allocate memory for the hook */ newPolyEvalHook = (poly_eval_hook_t *) safeMalloc(sizeof(poly_eval_hook_t)); /* Set some technical stuff */ newPolyEvalHook->reusedVarMyYInit = 0; newPolyEvalHook->reusedVarXInit = 0; newPolyEvalHook->reusedVarTempInit = 0; newPolyEvalHook->reusedVarMyYBInit = 0; newPolyEvalHook->reusedVarXAInit = 0; newPolyEvalHook->reusedVarXBInit = 0; newPolyEvalHook->reusedVarMyYRndInit = 0; newPolyEvalHook->reusedVarMyYRndWithDeltaInit = 0; newPolyEvalHook->reusedVarAInit = 0; newPolyEvalHook->reusedVarBInit = 0; /* Set the easy stuff */ sollya_mpfi_init2(newPolyEvalHook->domain, sollya_mpfi_get_prec(dom)); sollya_mpfi_set(newPolyEvalHook->domain, dom); sollya_mpfi_init2(newPolyEvalHook->delta, sollya_mpfi_get_prec(delta)); sollya_mpfi_set(newPolyEvalHook->delta, delta); sollya_mpfi_init2(newPolyEvalHook->t, sollya_mpfi_get_prec(t)); sollya_mpfi_set(newPolyEvalHook->t, t); newPolyEvalHook->degree = degree; newPolyEvalHook->coefficients = (mpfr_t *) safeCalloc(degree + 1, sizeof(mpfr_t)); for (i=0;i<=degree;i++) { mpfr_init2(newPolyEvalHook->coefficients[i], mpfr_get_prec(coeffs[i])); mpfr_set(newPolyEvalHook->coefficients[i], coeffs[i], GMP_RNDN); /* exact as precision the same */ } /* Try to precompute information on whether the polynomial is monotone over the whole interval */ newPolyEvalHook->polynomialIsMonotone = 0; if (degree >= 1) { derivCoeffs = (mpfr_t *) safeCalloc(degree, sizeof(mpfr_t)); derivPolyCoeffsOkay = 1; maxPrec = sollya_mpfi_get_prec(dom); if (sollya_mpfi_get_prec(t) > maxPrec) maxPrec = sollya_mpfi_get_prec(t); for (i=1;i<=degree;i++) { mpfr_init2(derivCoeffs[i-1],mpfr_get_prec(coeffs[i]) + 8 * sizeof(int) + 5); mpfr_mul_si(derivCoeffs[i-1],coeffs[i],i,GMP_RNDN); /* exact because precision enough */ derivPolyCoeffsOkay = derivPolyCoeffsOkay && mpfr_number_p(derivCoeffs[i-1]); if (mpfr_get_prec(derivCoeffs[i-1]) > maxPrec) maxPrec = mpfr_get_prec(derivCoeffs[i-1]); } derivPoly = makePolynomial(derivCoeffs, degree-1); for (i=0;i sollya_mpfi_get_prec(t) ? sollya_mpfi_get_prec(dom) : sollya_mpfi_get_prec(t))); sollya_mpfi_init2(Y, sollya_mpfi_get_prec(X)); sollya_mpfi_sub(X, dom, t); evaluateInterval(Y, derivPoly, NULL, X); if (!(sollya_mpfi_has_zero_inside(Y) || sollya_mpfi_has_nan(Y))) { /* The derivative of the polynomial does not change sign, so the polynomial is monotonous over the whole (shifted) domain. */ newPolyEvalHook->polynomialIsMonotone = 1; } else { /* We still do not know */ mpfr_init2(nbRoots, 8 * sizeof(int) + 5); if (getNrRoots(nbRoots, derivPoly, X, maxPrec, 1)) { if (mpfr_zero_p(nbRoots)) { /* We surely know that there is no root of the derivative polynomial in the domain */ newPolyEvalHook->polynomialIsMonotone = 1; } } mpfr_clear(nbRoots); } sollya_mpfi_clear(X); sollya_mpfi_clear(Y); } freeThing(derivPoly); } else { if (degree == 0) newPolyEvalHook->polynomialIsMonotone = 1; } /* Try to precompute information on whether the polynomial has a zero in the interval Do not consider zeros at zero when t is zero. */ newPolyEvalHook->polynomialHasZero = 0; if ((degree >= 0) && (!(sollya_mpfi_is_zero(t) && mpfr_zero_p(coeffs[0])))) { if (degree >= 1) { coeffsOkay = 1; maxPrec = sollya_mpfi_get_prec(dom); if (sollya_mpfi_get_prec(t) > maxPrec) maxPrec = sollya_mpfi_get_prec(t); for (i=0;i<=degree;i++) { coeffsOkay = coeffsOkay && mpfr_number_p(coeffs[i]); if (mpfr_get_prec(coeffs[i]) > maxPrec) maxPrec = mpfr_get_prec(coeffs[i]); } if (coeffsOkay) { poly = makePolynomial(coeffs, degree); sollya_mpfi_init2(X, (sollya_mpfi_get_prec(dom) > sollya_mpfi_get_prec(t) ? sollya_mpfi_get_prec(dom) : sollya_mpfi_get_prec(t))); sollya_mpfi_init2(Y, sollya_mpfi_get_prec(X)); sollya_mpfi_sub(X, dom, t); evaluateInterval(Y, poly, NULL, X); if (sollya_mpfi_has_nan(Y) || sollya_mpfi_has_infinity(Y) || sollya_mpfi_has_zero(Y)) { mpfr_init2(nbRoots, 8 * sizeof(int) + 5); if (getNrRoots(nbRoots, poly, X, maxPrec, 1)) { if (mpfr_number_p(nbRoots) && (!mpfr_zero_p(nbRoots))) { newPolyEvalHook->polynomialHasZero = 1; } } mpfr_clear(nbRoots); } sollya_mpfi_clear(X); sollya_mpfi_clear(Y); freeThing(poly); } } else { if (degree == 0) { if (mpfr_number_p(coeffs[0]) && mpfr_zero_p(coeffs[0])) { newPolyEvalHook->polynomialHasZero = 1; } } } } /* Precompute information on whether we have an exact representation and/or what the maximum accuracy we can expect is */ newPolyEvalHook->exactRepresentation = 0; newPolyEvalHook->maxPrecKnown = 0; newPolyEvalHook->maxPrec = 0; if (sollya_mpfi_is_zero(newPolyEvalHook->delta)) { /* If the error interval delta is not zero, the representation is exact (i.e. the function we are hooking (up with ;-) is a polynomial.) */ newPolyEvalHook->exactRepresentation = 1; } else { /* Here, the error interval delta is not zero Use the hook we are just about to create to get bounds on the represented function. We just need some low precision. */ if (!(sollya_mpfi_has_nan(newPolyEvalHook->delta) || sollya_mpfi_has_infinity(newPolyEvalHook->delta))) { sollya_mpfi_init2(Y, 12); if (evaluatePolyEvalHook(Y, dom, 15, 0, (void *) newPolyEvalHook)) { if (!(sollya_mpfi_has_nan(Y) || sollya_mpfi_has_infinity(Y))) { sollya_mpfi_abs(Y, Y); mpfr_init2(ymax, 12); mpfr_init2(deltamax, sollya_mpfi_get_prec(newPolyEvalHook->delta)); sollya_mpfi_get_right(ymax, Y); sollya_mpfi_set_prec(Y, sollya_mpfi_get_prec(newPolyEvalHook->delta)); sollya_mpfi_abs(Y, newPolyEvalHook->delta); sollya_mpfi_get_right(deltamax, Y); if (mpfr_number_p(ymax) && mpfr_number_p(deltamax) && (!mpfr_zero_p(deltamax))) { mpfr_div(ymax, deltamax, ymax, GMP_RNDU); if (mpfr_sgn(ymax) > 0) { mpfr_log2(ymax, ymax, GMP_RNDU); mpfr_neg(ymax, ymax, GMP_RNDN); if (mpfr_sgn(ymax) > 0) { mpfr_ceil(ymax, ymax); if (mpfr_fits_ulong_p(ymax, GMP_RNDD)) { pp = mpfr_get_ui(ymax, GMP_RNDD) + 5; /* some margin accounting for the errors made here */ p = (mp_prec_t) pp; ppp = (unsigned long) p; if ((ppp == pp) && (p >= 7)) { newPolyEvalHook->maxPrecKnown = 1; newPolyEvalHook->maxPrec = p; } } } } } mpfr_clear(ymax); mpfr_clear(deltamax); } } sollya_mpfi_clear(Y); } } return newPolyEvalHook; } void *copyPolyEvalHook(void *data) { poly_eval_hook_t *hook, *newPolyEvalHook; int i; hook = (poly_eval_hook_t *) data; /* Allocate memory for the hook */ newPolyEvalHook = (poly_eval_hook_t *) safeMalloc(sizeof(poly_eval_hook_t)); /* Set some technical stuff */ newPolyEvalHook->reusedVarMyYInit = 0; newPolyEvalHook->reusedVarXInit = 0; newPolyEvalHook->reusedVarTempInit = 0; newPolyEvalHook->reusedVarMyYBInit = 0; newPolyEvalHook->reusedVarXAInit = 0; newPolyEvalHook->reusedVarXBInit = 0; newPolyEvalHook->reusedVarMyYRndInit = 0; newPolyEvalHook->reusedVarMyYRndWithDeltaInit = 0; newPolyEvalHook->reusedVarAInit = 0; newPolyEvalHook->reusedVarBInit = 0; /* Copy the basic stuff */ sollya_mpfi_init2(newPolyEvalHook->domain, sollya_mpfi_get_prec(hook->domain)); sollya_mpfi_set(newPolyEvalHook->domain, hook->domain); sollya_mpfi_init2(newPolyEvalHook->delta, sollya_mpfi_get_prec(hook->delta)); sollya_mpfi_set(newPolyEvalHook->delta, hook->delta); sollya_mpfi_init2(newPolyEvalHook->t, sollya_mpfi_get_prec(hook->t)); sollya_mpfi_set(newPolyEvalHook->t, hook->t); newPolyEvalHook->degree = hook->degree; newPolyEvalHook->coefficients = (mpfr_t *) safeCalloc(hook->degree + 1, sizeof(mpfr_t)); for (i=0;i<=hook->degree;i++) { mpfr_init2(newPolyEvalHook->coefficients[i], mpfr_get_prec(hook->coefficients[i])); mpfr_set(newPolyEvalHook->coefficients[i], hook->coefficients[i], GMP_RNDN); /* exact as precision the same */ } /* Copy the precomputed stuff */ newPolyEvalHook->polynomialIsMonotone = hook->polynomialIsMonotone; newPolyEvalHook->polynomialHasZero = hook->polynomialHasZero; newPolyEvalHook->exactRepresentation = hook->exactRepresentation; newPolyEvalHook->maxPrecKnown = hook->maxPrecKnown; newPolyEvalHook->maxPrec = hook->maxPrec; /* Return the copy */ return (void *) newPolyEvalHook; } int composePolyEvalHook(eval_hook_t **hookPtr, void *data, node *g) { eval_hook_t *f; int okay; f = NULL; okay = addEvaluationHook(&f, copyPolyEvalHook(data), evaluatePolyEvalHook, freePolyEvalHook, comparePolyEvalHook, copyPolyEvalHook, composePolyEvalHook); if (okay) { okay = addEvaluationHook(hookPtr, (void *) createCompositionEvalHook(f, g), evaluateCompositionEvalHook, freeCompositionEvalHook, compareCompositionEvalHook, copyCompositionEvalHook, composeCompositionEvalHook); freeEvaluationHook(&f); } return okay; } int evaluatePolyEvalHook(sollya_mpfi_t y, sollya_mpfi_t x, mp_prec_t prec, int tight, void *data) { poly_eval_hook_t *hook; mp_prec_t p, pY, pX; int okay, i, polynomialIsMonotone; hook = (poly_eval_hook_t *) data; if (sollya_mpfi_has_nan(x)) return 0; if (sollya_mpfi_has_infinity(x)) return 0; if (!sollya_mpfi_is_inside(x, hook->domain)) return 0; pY = sollya_mpfi_get_prec(y); pX = sollya_mpfi_get_prec(x); p = pY + 10; if (hook->polynomialHasZero) { if (hook->maxPrecKnown) { p = (hook->maxPrec + 10 > p ? hook->maxPrec + 10 : p); } else { p *= 2; } } if (prec > p) p = prec; if ((!(hook->exactRepresentation)) && hook->maxPrecKnown && tight && (hook->maxPrec < pY)) { return 0; } if (hook->reusedVarMyYInit) { sollya_mpfi_set_prec(hook->reusedVarMyY, p); } else { sollya_mpfi_init2(hook->reusedVarMyY, p); hook->reusedVarMyYInit = 1; } if (hook->reusedVarXInit) { sollya_mpfi_set_prec(hook->reusedVarX, (p > pX ? p : pX)); } else { sollya_mpfi_init2(hook->reusedVarX, (p > pX ? p : pX)); hook->reusedVarXInit = 1; } sollya_mpfi_sub(hook->reusedVarX, x, hook->t); if (!sollya_mpfi_is_point_and_real(x)) { polynomialIsMonotone = hook->polynomialIsMonotone; if (!polynomialIsMonotone) { /* Try to determine if the polynomial is monotone over x - t Compute a bounding of its derivative and check if that interval contains zero. */ if (hook->reusedVarTempInit) { sollya_mpfi_set_prec(hook->reusedVarTemp, p); } else { sollya_mpfi_init2(hook->reusedVarTemp, p); hook->reusedVarTempInit = 1; } sollya_mpfi_set_si(hook->reusedVarMyY, 0); for (i=hook->degree;i>=1;i--) { sollya_mpfi_mul(hook->reusedVarMyY, hook->reusedVarMyY, hook->reusedVarX); sollya_mpfi_set_fr(hook->reusedVarTemp, hook->coefficients[i]); sollya_mpfi_mul_ui(hook->reusedVarTemp, hook->reusedVarTemp, (unsigned int) i); sollya_mpfi_add(hook->reusedVarMyY, hook->reusedVarMyY, hook->reusedVarTemp); } if (!(sollya_mpfi_has_zero_inside(hook->reusedVarMyY) || sollya_mpfi_has_nan(hook->reusedVarMyY))) polynomialIsMonotone = 1; } if (polynomialIsMonotone) { /* Do a Horner evaluation in interval arithmetic over both endpoint point-intervals and take the hull */ if (hook->reusedVarMyYBInit) { sollya_mpfi_set_prec(hook->reusedVarMyYB, p); } else { sollya_mpfi_init2(hook->reusedVarMyYB, p); hook->reusedVarMyYBInit = 1; } if (hook->reusedVarXAInit) { sollya_mpfi_set_prec(hook->reusedVarXA, sollya_mpfi_get_prec(hook->reusedVarX)); } else { sollya_mpfi_init2(hook->reusedVarXA, sollya_mpfi_get_prec(hook->reusedVarX)); hook->reusedVarXAInit = 1; } if (hook->reusedVarXBInit) { sollya_mpfi_set_prec(hook->reusedVarXB, sollya_mpfi_get_prec(hook->reusedVarX)); } else { sollya_mpfi_init2(hook->reusedVarXB, sollya_mpfi_get_prec(hook->reusedVarX)); hook->reusedVarXBInit = 1; } if (hook->reusedVarAInit) { mpfr_set_prec(hook->reusedVarA, sollya_mpfi_get_prec(hook->reusedVarX)); } else { mpfr_init2(hook->reusedVarA, sollya_mpfi_get_prec(hook->reusedVarX)); hook->reusedVarAInit = 1; } if (hook->reusedVarBInit) { mpfr_set_prec(hook->reusedVarB, sollya_mpfi_get_prec(hook->reusedVarX)); } else { mpfr_init2(hook->reusedVarB, sollya_mpfi_get_prec(hook->reusedVarX)); hook->reusedVarBInit = 1; } sollya_mpfi_get_left(hook->reusedVarA, hook->reusedVarX); sollya_mpfi_get_right(hook->reusedVarB, hook->reusedVarX); sollya_mpfi_set_fr(hook->reusedVarXA, hook->reusedVarA); sollya_mpfi_set_fr(hook->reusedVarXB, hook->reusedVarB); sollya_mpfi_set_si(hook->reusedVarMyY, 0); sollya_mpfi_set_si(hook->reusedVarMyYB, 0); for (i=hook->degree;i>=0;i--) { sollya_mpfi_mul(hook->reusedVarMyY, hook->reusedVarMyY, hook->reusedVarXA); sollya_mpfi_mul(hook->reusedVarMyYB, hook->reusedVarMyYB, hook->reusedVarXB); sollya_mpfi_add_fr(hook->reusedVarMyY, hook->reusedVarMyY, hook->coefficients[i]); sollya_mpfi_add_fr(hook->reusedVarMyYB, hook->reusedVarMyYB, hook->coefficients[i]); } sollya_mpfi_union(hook->reusedVarMyY, hook->reusedVarMyY, hook->reusedVarMyYB); if (tight) { okay = 0; if (hook->reusedVarMyYRndInit) { sollya_mpfi_set_prec(hook->reusedVarMyYRnd, pY + 5); } else { sollya_mpfi_init2(hook->reusedVarMyYRnd, pY + 5); hook->reusedVarMyYRndInit = 1; } if (hook->reusedVarMyYRndWithDeltaInit) { sollya_mpfi_set_prec(hook->reusedVarMyYRndWithDelta, pY + 5); } else { sollya_mpfi_init2(hook->reusedVarMyYRndWithDelta, pY + 5); hook->reusedVarMyYRndWithDeltaInit = 1; } sollya_mpfi_set(hook->reusedVarMyYRnd, hook->reusedVarMyY); sollya_mpfi_blow_1ulp(hook->reusedVarMyYRnd); sollya_mpfi_add(hook->reusedVarMyYRndWithDelta, hook->reusedVarMyY, hook->delta); if (sollya_mpfi_is_inside(hook->reusedVarMyYRndWithDelta, hook->reusedVarMyYRnd) && (!(sollya_mpfi_has_nan(hook->reusedVarMyYRndWithDelta) || (sollya_mpfi_has_infinity(hook->reusedVarMyYRndWithDelta) && (!sollya_mpfi_is_infinity(hook->reusedVarMyYRndWithDelta)))))) okay = 1; if (okay) sollya_mpfi_set(y, hook->reusedVarMyYRndWithDelta); } else { sollya_mpfi_add(y, hook->reusedVarMyY, hook->delta); okay = (!(sollya_mpfi_has_nan(y) || sollya_mpfi_has_infinity(y))); } return okay; } /* Fall through if we could not determine monotononicity */ } /* Regular Horner evaluation with interval arithmetic */ sollya_mpfi_set_fr(hook->reusedVarMyY, hook->coefficients[hook->degree]); for (i=hook->degree-1;i>=0;i--) { sollya_mpfi_mul(hook->reusedVarMyY, hook->reusedVarMyY, hook->reusedVarX); sollya_mpfi_add_fr(hook->reusedVarMyY, hook->reusedVarMyY, hook->coefficients[i]); } if (tight) { okay = 0; if (hook->reusedVarMyYRndInit) { sollya_mpfi_set_prec(hook->reusedVarMyYRnd, pY + 5); } else { sollya_mpfi_init2(hook->reusedVarMyYRnd, pY + 5); hook->reusedVarMyYRndInit = 1; } if (hook->reusedVarMyYRndWithDeltaInit) { sollya_mpfi_set_prec(hook->reusedVarMyYRndWithDelta, pY + 5); } else { sollya_mpfi_init2(hook->reusedVarMyYRndWithDelta, pY + 5); hook->reusedVarMyYRndWithDeltaInit = 1; } sollya_mpfi_set(hook->reusedVarMyYRnd, hook->reusedVarMyY); sollya_mpfi_blow_1ulp(hook->reusedVarMyYRnd); sollya_mpfi_add(hook->reusedVarMyYRndWithDelta, hook->reusedVarMyY, hook->delta); if (sollya_mpfi_is_inside(hook->reusedVarMyYRndWithDelta, hook->reusedVarMyYRnd) && (!(sollya_mpfi_has_nan(hook->reusedVarMyYRndWithDelta) || (sollya_mpfi_has_infinity(hook->reusedVarMyYRndWithDelta) && (!sollya_mpfi_is_infinity(hook->reusedVarMyYRndWithDelta)))))) okay = 1; if (okay) sollya_mpfi_set(y, hook->reusedVarMyYRndWithDelta); } else { sollya_mpfi_add(y, hook->reusedVarMyY, hook->delta); okay = (!(sollya_mpfi_has_nan(y) || sollya_mpfi_has_infinity(y))); } return okay; } void freePolyEvalHook(void *data) { poly_eval_hook_t *hook; int i; hook = (poly_eval_hook_t *) data; sollya_mpfi_clear(hook->domain); sollya_mpfi_clear(hook->delta); sollya_mpfi_clear(hook->t); for (i=0;i<=hook->degree;i++) { mpfr_clear(hook->coefficients[i]); } safeFree(hook->coefficients); if (hook->reusedVarMyYInit) sollya_mpfi_clear(hook->reusedVarMyY); if (hook->reusedVarXInit) sollya_mpfi_clear(hook->reusedVarX); if (hook->reusedVarTempInit) sollya_mpfi_clear(hook->reusedVarTemp); if (hook->reusedVarMyYBInit) sollya_mpfi_clear(hook->reusedVarMyYB); if (hook->reusedVarXAInit) sollya_mpfi_clear(hook->reusedVarXA); if (hook->reusedVarXBInit) sollya_mpfi_clear(hook->reusedVarXB); if (hook->reusedVarMyYRndInit) sollya_mpfi_clear(hook->reusedVarMyYRnd); if (hook->reusedVarMyYRndWithDeltaInit) sollya_mpfi_clear(hook->reusedVarMyYRndWithDelta); if (hook->reusedVarAInit) mpfr_clear(hook->reusedVarA); if (hook->reusedVarBInit) mpfr_clear(hook->reusedVarB); safeFree(hook); } int comparePolyEvalHook(void *data1, void *data2) { poly_eval_hook_t *hook1, *hook2; int i; hook1 = (poly_eval_hook_t *) data1; hook2 = (poly_eval_hook_t *) data2; if (!sollya_mpfi_equal_p(hook1->domain, hook2->domain)) return 0; if (!sollya_mpfi_equal_p(hook1->delta, hook2->delta)) return 0; if (!sollya_mpfi_equal_p(hook1->t, hook2->t)) return 0; if (hook1->degree != hook2->degree) return 0; for (i=0;i<=hook1->degree;i++) { if (!mpfr_equal_p(hook1->coefficients[i], hook2->coefficients[i])) return 0; } return 1; } int addPolyEvaluationHook(eval_hook_t **hookPtr, node *func, sollya_mpfi_t dom, sollya_mpfi_t delta, sollya_mpfi_t t, mp_prec_t prec) { int degree, okay, i, coeffsOkay; node **coeffs; mpfr_t *evaluatedCoeffs; sollya_mpfi_t globalDelta, c, shiftedDom; mp_prec_t p, evalPrec, pp; mp_exp_t maxExp; if (!isPolynomial(func)) return 0; getCoefficients(°ree, &coeffs, func); evaluatedCoeffs = (mpfr_t *) safeCalloc(degree+1,sizeof(mpfr_t)); evalPrec = prec; if (!(sollya_mpfi_is_zero(delta) || sollya_mpfi_has_nan(delta) || sollya_mpfi_has_infinity(delta))) { maxExp = sollya_mpfi_max_exp(delta); if (maxExp < 0) { pp = -maxExp; if ((pp > evalPrec) && (pp < 4 * evalPrec)) { evalPrec = pp; if (evalPrec < 12) evalPrec = 12; } } } sollya_mpfi_init2(globalDelta, (sollya_mpfi_get_prec(delta) > evalPrec ? sollya_mpfi_get_prec(delta) : evalPrec)); p = prec; if (sollya_mpfi_get_prec(dom) > p) p = sollya_mpfi_get_prec(dom); if (sollya_mpfi_get_prec(t) > p) p = sollya_mpfi_get_prec(t); sollya_mpfi_init2(shiftedDom, p); sollya_mpfi_sub(shiftedDom, dom, t); sollya_mpfi_set_si(globalDelta, 0); sollya_mpfi_init2(c, evalPrec + 5); coeffsOkay = 1; for (i=degree;i>=0;i--) { if ((coeffs[i] != NULL) && (accessThruMemRef(coeffs[i])->nodeType == CONSTANT)) { mpfr_init2(evaluatedCoeffs[i],mpfr_get_prec(*(accessThruMemRef(coeffs[i])->value))); mpfr_set(evaluatedCoeffs[i],*(accessThruMemRef(coeffs[i])->value),GMP_RNDN); /* exact */ sollya_mpfi_set_si(c, 0); freeThing(coeffs[i]); } else { mpfr_init2(evaluatedCoeffs[i],evalPrec); if (coeffs[i] == NULL) { sollya_mpfi_set_si(c, 0); } else { evaluateConstantExpressionToSharpInterval(c, coeffs[i]); freeThing(coeffs[i]); } sollya_mpfi_mid(evaluatedCoeffs[i], c); coeffsOkay = coeffsOkay && mpfr_number_p(evaluatedCoeffs[i]); sollya_mpfi_sub_fr(c, c, evaluatedCoeffs[i]); } sollya_mpfi_mul(globalDelta, globalDelta, shiftedDom); sollya_mpfi_add(globalDelta, globalDelta, c); } safeFree(coeffs); sollya_mpfi_add(globalDelta, globalDelta, delta); sollya_mpfi_clear(c); sollya_mpfi_clear(shiftedDom); if (coeffsOkay && (!(sollya_mpfi_has_nan(globalDelta) || sollya_mpfi_has_infinity(globalDelta)))) { okay = addEvaluationHook(hookPtr, (void *) createPolyEvalHook(degree, evaluatedCoeffs, dom, globalDelta, t), evaluatePolyEvalHook, freePolyEvalHook, comparePolyEvalHook, copyPolyEvalHook, composePolyEvalHook); } else { okay = 0; } sollya_mpfi_clear(globalDelta); for (i=0;i<=degree;i++) { mpfr_clear(evaluatedCoeffs[i]); } safeFree(evaluatedCoeffs); return okay; } int addNodeEvaluationHook(eval_hook_t **hookPtr, node *func, sollya_mpfi_t dom, sollya_mpfi_t delta, sollya_mpfi_t t, mp_prec_t prec) { UNUSED_PARAM(prec); return addEvaluationHook(hookPtr, (void *) createNodeEvalHook(func, dom, delta, t), evaluateNodeEvalHook, freeNodeEvalHook, compareNodeEvalHook, copyNodeEvalHook, composeNodeEvalHook); } int chooseAndAddEvaluationHook(eval_hook_t **hookPtr, node *func, sollya_mpfi_t dom, sollya_mpfi_t delta, sollya_mpfi_t t, mp_prec_t prec) { if (isPolynomial(func)) return addPolyEvaluationHook(hookPtr, func, dom, delta, t, prec); return addNodeEvaluationHook(hookPtr, func, dom, delta, t, prec); } int copyFunctionAndChooseAndAddEvaluationHook(node **copyPtr, node *orig, node *func, sollya_mpfi_t dom, sollya_mpfi_t delta, sollya_mpfi_t t, mp_prec_t prec) { node *copy; int okay; copy = addMemRef(copyThing(orig)); if (copy->nodeType != MEMREF) { freeThing(copy); return 0; } okay = chooseAndAddEvaluationHook(&(copy->evaluationHook), func, dom, delta, t, prec); if (okay) { *copyPtr = copy; } else { freeThing(copy); } return okay; } composition_eval_hook_t *createCompositionEvalHook(eval_hook_t *f, node *g) { composition_eval_hook_t *newCompositionEvalHook; newCompositionEvalHook = (composition_eval_hook_t *) safeMalloc(sizeof(composition_eval_hook_t)); newCompositionEvalHook->reusedVarTInit = 0; newCompositionEvalHook->reusedVarTAInit = 0; newCompositionEvalHook->reusedVarTBInit = 0; newCompositionEvalHook->reusedVarTempInit = 0; newCompositionEvalHook->f = NULL; addEvaluationHookFromCopy(&(newCompositionEvalHook->f), f); newCompositionEvalHook->g = copyThing(g); return newCompositionEvalHook; } int evaluateCompositionEvalHook(sollya_mpfi_t y, sollya_mpfi_t x, mp_prec_t prec, int tight, void *data) { composition_eval_hook_t * hook; mp_prec_t p, pX; int res, resA, resB; hook = (composition_eval_hook_t *) data; if (sollya_mpfi_has_nan(x)) return 0; if (sollya_mpfi_has_infinity(x)) return 0; p = sollya_mpfi_get_prec(y) + 30; pX = sollya_mpfi_get_prec(x) + 10; if (pX > p) p = pX; if (prec > p) p = prec; if (hook->reusedVarTInit) { sollya_mpfi_set_prec(hook->reusedVarT, p); } else { sollya_mpfi_init2(hook->reusedVarT, p); hook->reusedVarTInit = 1; } evaluateInterval(hook->reusedVarT, hook->g, NULL, x); if (sollya_mpfi_has_nan(hook->reusedVarT) || sollya_mpfi_has_infinity(hook->reusedVarT)) { return 0; } res = evaluateWithEvaluationHook(y, hook->reusedVarT, prec, tight, hook->f); if (sollya_mpfi_is_point_and_real(x) && (!sollya_mpfi_is_point_and_real(hook->reusedVarT))) { if (!res) { p *= 8; sollya_mpfi_set_prec(hook->reusedVarT, p); evaluateInterval(hook->reusedVarT, hook->g, NULL, x); if (sollya_mpfi_has_nan(hook->reusedVarT) || sollya_mpfi_has_infinity(hook->reusedVarT)) { return res; } res = evaluateWithEvaluationHook(y, hook->reusedVarT, prec, tight, hook->f); } else { if (!tight) { if (sollya_mpfi_has_zero(y)) { if (sollya_mpfi_has_zero(hook->reusedVarT) || (sollya_mpfi_get_prec(y) <= (12 + 10))) { p *= 8; sollya_mpfi_set_prec(hook->reusedVarT, p); evaluateInterval(hook->reusedVarT, hook->g, NULL, x); if (sollya_mpfi_has_nan(hook->reusedVarT) || sollya_mpfi_has_infinity(hook->reusedVarT)) { return res; } res = evaluateWithEvaluationHook(y, hook->reusedVarT, prec, tight, hook->f); } else { /* t has no zero, the precision of y is at least 12 + 10 bits. */ if (!sollya_mpfi_enclosure_accurate_enough(hook->reusedVarT, sollya_mpfi_get_prec(y) - 10)) { p *= 8; sollya_mpfi_set_prec(hook->reusedVarT, p); evaluateInterval(hook->reusedVarT, hook->g, NULL, x); if (sollya_mpfi_has_nan(hook->reusedVarT) || sollya_mpfi_has_infinity(hook->reusedVarT)) { return res; } res = evaluateWithEvaluationHook(y, hook->reusedVarT, prec, tight, hook->f); } } } else { /* y has no zero, the precision of y is at least 12 + 10 bits. */ if (!sollya_mpfi_enclosure_accurate_enough(y, sollya_mpfi_get_prec(y) - 10)) { p *= 8; sollya_mpfi_set_prec(hook->reusedVarT, p); evaluateInterval(hook->reusedVarT, hook->g, NULL, x); if (sollya_mpfi_has_nan(hook->reusedVarT) || sollya_mpfi_has_infinity(hook->reusedVarT)) { return res; } res = evaluateWithEvaluationHook(y, hook->reusedVarT, prec, tight, hook->f); } } } } } if ((!res) && (!sollya_mpfi_is_point_and_real(hook->reusedVarT))) { if (hook->reusedVarTAInit) { sollya_mpfi_set_prec(hook->reusedVarTA, sollya_mpfi_get_prec(hook->reusedVarT)); } else { sollya_mpfi_init2(hook->reusedVarTA, sollya_mpfi_get_prec(hook->reusedVarT)); hook->reusedVarTAInit = 1; } if (hook->reusedVarTBInit) { sollya_mpfi_set_prec(hook->reusedVarTB, sollya_mpfi_get_prec(y)); } else { sollya_mpfi_init2(hook->reusedVarTB, sollya_mpfi_get_prec(y)); hook->reusedVarTBInit = 1; } if (hook->reusedVarTempInit) { mpfr_set_prec(hook->reusedVarTemp, sollya_mpfi_get_prec(hook->reusedVarT)); } else { mpfr_init2(hook->reusedVarTemp, sollya_mpfi_get_prec(hook->reusedVarT)); hook->reusedVarTempInit = 1; } sollya_mpfi_get_left(hook->reusedVarTemp, hook->reusedVarT); sollya_mpfi_set_fr(hook->reusedVarTA, hook->reusedVarTemp); resA = evaluateWithEvaluationHook(hook->reusedVarTB, hook->reusedVarTA, prec, tight, hook->f); if (resA) { sollya_mpfi_get_right(hook->reusedVarTemp, hook->reusedVarT); sollya_mpfi_set_fr(hook->reusedVarTA, hook->reusedVarTemp); resB = evaluateWithEvaluationHook(hook->reusedVarTB, hook->reusedVarTA, prec, tight, hook->f); if (resB) { /* We can use the hook for f to evaluate f at each end-point of t, but not over t. This probably means that f has a zero in t. However, t is just an approximation and with a finer t we might do the whole evaluation. */ p *= 8; sollya_mpfi_set_prec(hook->reusedVarT, p); evaluateInterval(hook->reusedVarT, hook->g, NULL, x); if (sollya_mpfi_has_nan(hook->reusedVarT) || sollya_mpfi_has_infinity(hook->reusedVarT)) { return 0; } res = evaluateWithEvaluationHook(y, hook->reusedVarT, prec, tight, hook->f); } } } return res; } void freeCompositionEvalHook(void *data) { composition_eval_hook_t *hook; hook = (composition_eval_hook_t *) data; if (hook->reusedVarTInit) sollya_mpfi_clear(hook->reusedVarT); if (hook->reusedVarTAInit) sollya_mpfi_clear(hook->reusedVarTA); if (hook->reusedVarTBInit) sollya_mpfi_clear(hook->reusedVarTB); if (hook->reusedVarTempInit) mpfr_clear(hook->reusedVarTemp); freeThing(hook->g); freeEvaluationHook(&(hook->f)); safeFree(hook); } int compareCompositionEvalHook(void *data1, void *data2) { composition_eval_hook_t *hook1, *hook2; eval_hook_t *curr1, *curr2; int found; hook1 = (composition_eval_hook_t *) data1; hook2 = (composition_eval_hook_t *) data2; for (curr1=hook1->f;curr1!=NULL;curr1=curr1->nextHook) { found = 0; for (curr2=hook2->f;(!found) && (curr2!=NULL);curr2=curr2->nextHook) { if (((curr2->evaluateHook == curr1->evaluateHook) && (curr2->freeHook == curr1->freeHook) && (curr2->compareHook == curr1->compareHook) && (curr2->copyHook == curr1->copyHook) && (curr2->composeHook == curr1->composeHook)) && curr2->compareHook(curr2->data, curr1->data)) { found = 1; } } if (!found) return 0; } if (!isEqualThing(hook1->g, hook2->g)) return 0; return 1; } void *copyCompositionEvalHook(void *data) { composition_eval_hook_t *hook; hook = (composition_eval_hook_t *) data; return (void *) createCompositionEvalHook(hook->f, hook->g); } int composeCompositionEvalHook(eval_hook_t **hookPtr, void *data, node *g) { composition_eval_hook_t *hook; node *h, *temp; int okay; hook = (composition_eval_hook_t *) data; temp = substitute(hook->g, g); h = simplifyTreeErrorfree(temp); free_memory(temp); okay = addEvaluationHook(hookPtr, (void *) createCompositionEvalHook(hook->f, h), evaluateCompositionEvalHook, freeCompositionEvalHook, compareCompositionEvalHook, copyCompositionEvalHook, composeCompositionEvalHook); freeThing(h); return okay; } sollya-6.0+ds/hooks.h000066400000000000000000000145041300174114700145620ustar00rootroot00000000000000/* Copyright 2014 by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France Contributor Ch. Lauter christoph.lauter@lip6.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef HOOKS_H #define HOOKS_H #include #include #include "mpfi-compat.h" /* We need to know the nodeStruct structure */ struct nodeStruct; /* General framework for evaluation hooks */ typedef struct __eval_hook_t_struct eval_hook_t; struct __eval_hook_t_struct { void *data; int gettingUsed; int reuseMPFIInit; sollya_mpfi_t reuseMPFI; int (*evaluateHook)(sollya_mpfi_t, sollya_mpfi_t, mp_prec_t, int, void *); void (*freeHook)(void *); int (*compareHook)(void *, void *); void *(*copyHook)(void *); int (*composeHook)(eval_hook_t **, void *, struct nodeStruct *); eval_hook_t *nextHook; }; int addEvaluationHook(eval_hook_t **, void *, int (*)(sollya_mpfi_t, sollya_mpfi_t, mp_prec_t, int, void *), void (*)(void *), int (*)(void *, void *), void *(*)(void *), int (*)(eval_hook_t **, void *, struct nodeStruct *)); int addEvaluationHookFromCopy(eval_hook_t **, eval_hook_t *); int addEvaluationHookFromComposition(eval_hook_t **, eval_hook_t *, struct nodeStruct *); void freeEvaluationHook(eval_hook_t **); int evaluateWithEvaluationHook(sollya_mpfi_t, sollya_mpfi_t, mp_prec_t, int, eval_hook_t *); /* General one-replaces-one node-represented function evaluation hooks */ typedef struct __node_eval_hook_t_struct node_eval_hook_t; struct __node_eval_hook_t_struct { sollya_mpfi_t domain; sollya_mpfi_t delta; sollya_mpfi_t t; struct nodeStruct *func; }; node_eval_hook_t *createNodeEvalHook(struct nodeStruct *, sollya_mpfi_t, sollya_mpfi_t, sollya_mpfi_t); int evaluateNodeEvalHook(sollya_mpfi_t, sollya_mpfi_t, mp_prec_t, int, void *); void freeNodeEvalHook(void *); int compareNodeEvalHook(void *, void *); void *copyNodeEvalHook(void *); int composeNodeEvalHook(eval_hook_t **, void *, struct nodeStruct *); /* Polynomial replacement function evaluation hooks */ typedef struct __poly_eval_hook_t_struct poly_eval_hook_t; struct __poly_eval_hook_t_struct { sollya_mpfi_t domain; sollya_mpfi_t delta; sollya_mpfi_t t; int degree; int polynomialIsMonotone; int polynomialHasZero; int maxPrecKnown; mp_prec_t maxPrec; int exactRepresentation; mpfr_t *coefficients; int reusedVarMyYInit; sollya_mpfi_t reusedVarMyY; int reusedVarXInit; sollya_mpfi_t reusedVarX; int reusedVarTempInit; sollya_mpfi_t reusedVarTemp; int reusedVarMyYBInit; sollya_mpfi_t reusedVarMyYB; int reusedVarXAInit; sollya_mpfi_t reusedVarXA; int reusedVarXBInit; sollya_mpfi_t reusedVarXB; int reusedVarMyYRndInit; sollya_mpfi_t reusedVarMyYRnd; int reusedVarMyYRndWithDeltaInit; sollya_mpfi_t reusedVarMyYRndWithDelta; int reusedVarAInit; mpfr_t reusedVarA; int reusedVarBInit; mpfr_t reusedVarB; }; poly_eval_hook_t *createPolyEvalHook(int, mpfr_t *, sollya_mpfi_t, sollya_mpfi_t, sollya_mpfi_t); int evaluatePolyEvalHook(sollya_mpfi_t, sollya_mpfi_t, mp_prec_t, int, void *); void freePolyEvalHook(void *); int comparePolyEvalHook(void *, void *); void *copyPolyEvalHook(void *); int composePolyEvalHook(eval_hook_t **, void *, struct nodeStruct *); /* Composition evaluation hooks */ typedef struct __composition_eval_hook_t_struct composition_eval_hook_t; struct __composition_eval_hook_t_struct { eval_hook_t *f; struct nodeStruct *g; sollya_mpfi_t reusedVarT; sollya_mpfi_t reusedVarTA; sollya_mpfi_t reusedVarTB; mpfr_t reusedVarTemp; int reusedVarTInit; int reusedVarTAInit; int reusedVarTBInit; int reusedVarTempInit; }; composition_eval_hook_t *createCompositionEvalHook(eval_hook_t *, struct nodeStruct *); int evaluateCompositionEvalHook(sollya_mpfi_t, sollya_mpfi_t, mp_prec_t, int, void *); void freeCompositionEvalHook(void *); int compareCompositionEvalHook(void *, void *); void *copyCompositionEvalHook(void *); int composeCompositionEvalHook(eval_hook_t **, void *, struct nodeStruct *); /* Helper functions that install either a general or a polynomial replacement hook */ int chooseAndAddEvaluationHook(eval_hook_t **, struct nodeStruct *, sollya_mpfi_t, sollya_mpfi_t, sollya_mpfi_t, mp_prec_t); int copyFunctionAndChooseAndAddEvaluationHook(struct nodeStruct **, struct nodeStruct *, struct nodeStruct *, sollya_mpfi_t, sollya_mpfi_t, sollya_mpfi_t, mp_prec_t); #endif /* ifdef HOOKS_H*/ sollya-6.0+ds/implement.c000066400000000000000000014145751300174114700154410ustar00rootroot00000000000000/* Copyright 2006-2015 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include "implement.h" #include /* fprinft, fopen, fclose, */ #include /* exit, free, mktemp */ #include #include #include "general.h" #include "expression.h" #include "double.h" #include "infnorm.h" #include "proof.h" #include "printf.h" #define MIN(a,b) (a > b ? b : a) void emitLegalNoticeAndDisclaimer(FILE *fd) { sollyaFprintf(fd, "/*\n"); sollyaFprintf(fd, " This code was generated using non-trivial code generation commands of\n"); sollyaFprintf(fd, " the Sollya software program.\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " Before using, modifying and/or integrating this code into other\n"); sollyaFprintf(fd, " software, review the copyright and license status of this generated\n"); sollyaFprintf(fd, " code. In particular, see the exception below.\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " Sollya is\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " Copyright 2006-2016 by\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon -\n"); sollyaFprintf(fd, " UCB Lyon 1 - INRIA 5668,\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2)\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN\n"); sollyaFprintf(fd, " Sorbonne Universités\n"); sollyaFprintf(fd, " UPMC Univ Paris 06\n"); sollyaFprintf(fd, " UMR 7606, LIP6\n"); sollyaFprintf(fd, " Boîte Courrier 169\n"); sollyaFprintf(fd, " 4, place Jussieu\n"); sollyaFprintf(fd, " F-75252 Paris Cedex 05\n"); sollyaFprintf(fd, " France\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " CNRS, LIP6, UPMC\n"); sollyaFprintf(fd, " Sorbonne Universités, UPMC Univ Paris 06,\n"); sollyaFprintf(fd, " CNRS, LIP6 UMR 7606, 4 place Jussieu 75005 Paris\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " and by\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS,\n"); sollyaFprintf(fd, " Sophia Antipolis, France.\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " Contributors Ch. Lauter, S. Chevillard, M. Joldes, M. Mezzarobba\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " christoph.lauter@ens-lyon.org\n"); sollyaFprintf(fd, " sylvain.chevillard@ens-lyon.org\n"); sollyaFprintf(fd, " joldes@laas.fr\n"); sollyaFprintf(fd, " marc@mezzarobba.net\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " The Sollya software is a computer program whose purpose is to provide\n"); sollyaFprintf(fd, " an environment for safe floating-point code development. It is\n"); sollyaFprintf(fd, " particularly targeted to the automated implementation of\n"); sollyaFprintf(fd, " mathematical floating-point libraries (libm). Amongst other features,\n"); sollyaFprintf(fd, " it offers a certified infinity norm, an automatic polynomial\n"); sollyaFprintf(fd, " implementer and a fast Remez algorithm.\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " The Sollya software is governed by the CeCILL-C license under French\n"); sollyaFprintf(fd, " law and abiding by the rules of distribution of free software. You\n"); sollyaFprintf(fd, " can use, modify and/ or redistribute the software under the terms of\n"); sollyaFprintf(fd, " the CeCILL-C license as circulated by CEA, CNRS and INRIA at the\n"); sollyaFprintf(fd, " following URL \"http://www.cecill.info\".\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " As a counterpart to the access to the source code and rights to copy,\n"); sollyaFprintf(fd, " modify and redistribute granted by the license, users are provided\n"); sollyaFprintf(fd, " only with a limited warranty and the software's author, the holder of\n"); sollyaFprintf(fd, " the economic rights, and the successive licensors have only limited\n"); sollyaFprintf(fd, " liability.\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " In this respect, the user's attention is drawn to the risks associated\n"); sollyaFprintf(fd, " with loading, using, modifying and/or developing or reproducing the\n"); sollyaFprintf(fd, " software by the user in light of its specific status of free software,\n"); sollyaFprintf(fd, " that may mean that it is complicated to manipulate, and that also\n"); sollyaFprintf(fd, " therefore means that it is reserved for developers and experienced\n"); sollyaFprintf(fd, " professionals having in-depth computer knowledge. Users are therefore\n"); sollyaFprintf(fd, " encouraged to load and test the software's suitability as regards\n"); sollyaFprintf(fd, " their requirements in conditions enabling the security of their\n"); sollyaFprintf(fd, " systems and/or data to be ensured and, more generally, to use and\n"); sollyaFprintf(fd, " operate it in the same conditions as regards security.\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " The fact that you are presently reading this means that you have had\n"); sollyaFprintf(fd, " knowledge of the CeCILL-C license and that you accept its terms.\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " The Sollya program is distributed WITHOUT ANY WARRANTY; without even\n"); sollyaFprintf(fd, " the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\n"); sollyaFprintf(fd, " PURPOSE.\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " This generated program is distributed WITHOUT ANY WARRANTY; without\n"); sollyaFprintf(fd, " even the implied warranty of MERCHANTABILITY or FITNESS FOR A\n"); sollyaFprintf(fd, " PARTICULAR PURPOSE.\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " As a special exception, you may create a larger work that contains\n"); sollyaFprintf(fd, " part or all of this software generated using Sollya and distribute\n"); sollyaFprintf(fd, " that work under terms of your choice, so long as that work isn't\n"); sollyaFprintf(fd, " itself a numerical code generator using the skeleton of this code or a\n"); sollyaFprintf(fd, " modified version thereof as a code skeleton. Alternatively, if you\n"); sollyaFprintf(fd, " modify or redistribute this generated code itself, or its skeleton,\n"); sollyaFprintf(fd, " you may (at your option) remove this special exception, which will\n"); sollyaFprintf(fd, " cause this generated code and its skeleton and the resulting Sollya\n"); sollyaFprintf(fd, " output files to be licensed under the CeCILL-C licence without this\n"); sollyaFprintf(fd, " special exception.\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, " This special exception was added by the Sollya copyright holders in\n"); sollyaFprintf(fd, " version 4.1 of Sollya.\n"); sollyaFprintf(fd, " \n"); sollyaFprintf(fd, "*/\n"); sollyaFprintf(fd, "\n"); sollyaFprintf(fd, "\n"); } int determinePowers(mpfr_t *coefficients, int degree, int *mulPrec, int *powPrec) { int i,k; for (i=0;i=1) { if (mulPrec[i-1] > powPrec[k-1]) powPrec[k-1] = mulPrec[i-1]; } k=1; i++; } return 1; } int determinePrecisionsHelper(mpfr_t *coefficients, int degree, int *addPrec, int *mulPrec, mpfr_t accuracy, rangetype range, mp_prec_t prec) { mpfr_t temp, temp2; int precOfAccur, res; node *q, *tempNode, *tempNode2, *qCopy; qCopy = NULL; mpfr_init2(temp,prec); mpfr_log2(temp,accuracy,GMP_RNDN); precOfAccur = -mpfr_get_si(temp,GMP_RNDD); if (degree == 0) { /* In this case, the polynomial is a constant. No addition and no multiplication must be done. addPrec, mulPrec will be -1 */ addPrec[0] = -1; mulPrec[0] = -1; mpfr_clear(temp); return 1; } /* In this case, we check if the constant coefficient is zero. If this is the case, no addition must be made, so addPrec will be -1. The multiplication must be performed with the precision demanded by the target accuracy. Thus, mulPrec will be precOfAccur. We continue then filling in the values for the higher degrees with the same accuracy. */ if (mpfr_zero_p(coefficients[0])) { addPrec[0] = -1; mulPrec[0] = precOfAccur; res = determinePrecisionsHelper(coefficients+1, degree-1, addPrec+1, mulPrec+1, accuracy, range, prec); mpfr_clear(temp); return res; } /* If we are here, we have a non-zero constant coefficient and thus an addition to do. Notate p(x) = c + x * q(x) We compute alpha = || x * q(x) / c ||^\infty in the given range. The addition must be made with the precision demanded by the target accuracy. If alpha is less than 1/2, the addition can be performed without any cancellation. We check this condition. If it cannot be fulfilled, we do not know how to implement the polynomial automatically. The multiplication and the following steps can then be performed with an accuracy of accuracy / alpha. */ addPrec[0] = precOfAccur; q = makePolynomial(coefficients+1,degree-1); if (verbosity >= 3) { qCopy = copyTree(q); } tempNode = (node *) safeMalloc(sizeof(node)); tempNode->nodeType = VARIABLE; tempNode2 = (node *) safeMalloc(sizeof(node)); tempNode2->nodeType = MUL; tempNode2->child1 = tempNode; tempNode2->child2 = q; tempNode = (node *) safeMalloc(sizeof(node)); tempNode->nodeType = DIV; tempNode->child1 = tempNode2; tempNode2 = (node *) safeMalloc(sizeof(node)); tempNode2->nodeType = CONSTANT; tempNode2->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(tempNode2->value),mpfr_get_prec(coefficients[0])); mpfr_set(*(tempNode2->value),coefficients[0],GMP_RNDN); tempNode->child2 = tempNode2; tempNode2 = horner(tempNode); free_memory(tempNode); tempNode = tempNode2; uncertifiedInfnorm(temp, NULL, tempNode, *(range.a), *(range.b), defaultpoints, prec); free_memory(tempNode); mpfr_init2(temp2,prec); mpfr_set_d(temp2,0.5,GMP_RNDN); if (mpfr_cmp(temp,temp2) >= 0) { printMessage(1,SOLLYA_MSG_COEFF_NOT_TWICE_GREATER_THAN_SUBPOLY,"Warning: a coefficient is not at least 2 times greater than a already evaluated sub-polynomial.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This procedure is not able to implement the polynomial correctly in this case.\n"); printMessage(3,SOLLYA_MSG_CONTINUATION,"Information: the subpolynomial q(%s) that has already been handled is\n%b\nThe current coefficient is c = \n%v\n|| %s * q(%s) / c || is approximately %v\n", ((variablename == NULL) ? "_x_" : variablename),qCopy,coefficients[0],((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),temp); mpfr_set_d(temp,1.0,GMP_RNDN); res = 0; } else { res = 1; } if (verbosity >= 3) free_memory(qCopy); mpfr_div(temp2,accuracy,temp,GMP_RNDN); mpfr_set_d(temp,0.5,GMP_RNDN); if (mpfr_cmp(temp2,temp) >= 0) { mpfr_set(temp2,temp,GMP_RNDN); } mpfr_log2(temp,temp2,GMP_RNDN); precOfAccur = -mpfr_get_si(temp,GMP_RNDD); mulPrec[0] = precOfAccur; /* We really do want to have a non-lazy evaluation here, so we use & and not && */ res = (!(!res)) & (!(!(determinePrecisionsHelper(coefficients+1, degree-1, addPrec+1, mulPrec+1, temp2, range, prec)))); mpfr_clear(temp); mpfr_clear(temp2); return res; } int determineCoefficientFormat(mpfr_t coefficient) { mpfr_t temp; int res; mpfr_init2(temp,mpfr_get_prec(coefficient)); if (mpfr_round_to_double(temp,coefficient) == 0) { res = 1; } else { if (mpfr_round_to_doubledouble(temp,coefficient) == 0) { res = 2; } else { if (mpfr_round_to_tripledouble(temp,coefficient) == 0) { res = 3; } else { res = 4; } } } mpfr_clear(temp); return res; } int determinePrecisions(mpfr_t *coefficients, int *coeffsAutoRound, int degree, int *addPrec, int *mulPrec, mpfr_t accuracy, rangetype range, mp_prec_t prec) { int res, i, currentPrec, format, coeffPrec, rounded; mpfr_t temp; currentPrec = 0; coeffPrec = 0; /* Recursively determine the precisions needed on the unrounded polynomial */ res = determinePrecisionsHelper(coefficients, degree, addPrec, mulPrec, accuracy, range, prec); /* Check the coefficients' precision, round them if needed or adapt the precision of the steps if needed */ /* First check if the precisions must be adapted for the grace of forced coefficient formats */ rounded = 0; mpfr_init2(temp,prec); for (i=degree;i>=0;i--) { if (mulPrec[i] >= 0) { currentPrec = mulPrec[i]; break; } } for (i=degree;i>=0;i--) { /* Check if the precision of the next step is at least as great as the one of the previous (multiplication) */ if (mulPrec[i] >= 0) { if (currentPrec > mulPrec[i]) { mulPrec[i] = currentPrec; printMessage(2,SOLLYA_MSG_PREC_OF_HORNER_STEP_GREATER_THAN_FOR_PREV_ONE,"Information: the precision of a previous Horner step is greater than the one of the next.\n"); printMessage(2,SOLLYA_MSG_CONTINUATION,"Must adapt the precision for the next step on a multiplication.\n"); } else currentPrec = mulPrec[i]; } if ((!coeffsAutoRound[i]) && (!mpfr_zero_p(coefficients[i]))) { /* The coefficient will not be rounded automatically Its precision must be taken into account */ format = determineCoefficientFormat(coefficients[i]); if (format > 3) { res = 0; printMessage(1,SOLLYA_MSG_NO_AUTO_ROUND_FOR_COEFF_W_PREC_HIGHER_THAN_TD,"Warning: a coefficient's precision is higher than triple-double but no automatic rounding will be performed.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This should not occur. The coefficient will now be rounded to a triple-double.\n"); format = 3; mpfr_round_to_tripledouble(temp,coefficients[i]); mpfr_set(coefficients[i],temp,GMP_RNDN); } switch (format) { case 3: coeffPrec = 159; break; case 2: coeffPrec = 102; break; case 1: coeffPrec = 53; break; default: sollyaFprintf(stderr,"Error: in determinePrecisions: unknown expansion format.\n"); } if (coeffPrec > currentPrec) { currentPrec = coeffPrec; printMessage(1,SOLLYA_MSG_INFERED_COEFF_PREC_HIGHER_THAN_REQUIRED,"Warning: the inferred precision of the %dth coefficient of the polynomial is greater than\n",i); printMessage(1,SOLLYA_MSG_CONTINUATION,"the necessary precision computed for this step. This may make the automatic determination\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"of precisions useless.\n"); } } /* Check if the precision of the next step is at least as great as the one of the previous (addition) */ if (addPrec[i] >= 0) { if (currentPrec > addPrec[i]) { printMessage(2,SOLLYA_MSG_PREC_OF_HORNER_STEP_GREATER_THAN_FOR_PREV_ONE,"Information: the precision of a previous Horner step is greater than the one of the next.\n"); printMessage(2,SOLLYA_MSG_CONTINUATION,"Must adapt the precision for the next step on an addition.\n"); addPrec[i] = currentPrec; } else currentPrec = addPrec[i]; } } currentPrec = 50; /* Second, round automatically the coefficients for which the precision is computed automatically */ for (i=degree;i>=0;i--) { if (coeffsAutoRound[i]) { /* Automatically round the coefficient to the computed necessary precision */ if (addPrec[i] >= 0) currentPrec = addPrec[i]; else { if ((i > 0) && (mulPrec[i-1] >= 0)) currentPrec = mulPrec[i-1]; } if (currentPrec > 102) { /* Round to triple-double */ if (mpfr_round_to_tripledouble(temp, coefficients[i]) != 0) { rounded = 1; printMessage(2,SOLLYA_MSG_COEFF_HAS_BEEN_ROUNDED_TO_TRIPLE_DOUBLE,"Information: the %dth coefficient of the polynomial has automatically been rounded to a triple-double.\n",i); } if (mpfr_set(coefficients[i],temp,GMP_RNDN) != 0) { printMessage(1,SOLLYA_MSG_ERROR_ON_HANDLING_A_COEFFICIENT,"Warning: there was an error during the internal handling of a coefficient.\n"); res = 0; } } else { if (currentPrec > 53) { /* Round to double-double */ if (mpfr_round_to_doubledouble(temp, coefficients[i]) != 0) { rounded = 1; printMessage(2,SOLLYA_MSG_COEFF_HAS_BEEN_ROUNDED_TO_DOUBLE_DOUBLE,"Information: the %dth coefficient of the polynomial has automatically been rounded to a double-double.\n",i); } if (mpfr_set(coefficients[i],temp,GMP_RNDN) != 0) { printMessage(1,SOLLYA_MSG_ERROR_ON_HANDLING_A_COEFFICIENT,"Warning: there was an error during the internal handling of a coefficient.\n"); res = 0; } } else { /* Round to double */ if (mpfr_round_to_double(temp, coefficients[i]) != 0) { rounded = 1; printMessage(2,SOLLYA_MSG_COEFF_HAS_BEEN_ROUNDED_TO_DOUBLE,"Information: the %dth coefficient of the polynomial has automatically been rounded to a double.\n",i); } if (mpfr_set(coefficients[i],temp,GMP_RNDN) != 0) { printMessage(1,SOLLYA_MSG_ERROR_ON_HANDLING_A_COEFFICIENT,"Warning: there was an error during the internal handling of a coefficient.\n"); res = 0; } } } } } if (rounded) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_IMPLEMENTED_POLY_DIFFERS_FROM_ORIGINAL_ONE,"Warning: at least one of the coefficients of the given polynomial has been rounded in a way\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"that the target precision can be achieved at lower cost. Nevertheless, the implemented polynomial\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"is different from the given one.\n"); } } mpfr_clear(temp); return res; } int implementPowers(int *powPrec, int degree, int variablePrecision, FILE *fd, char *name, int *overlaps, int *varNum, chain **gappaAssign) { int i, k, l, res, issuedCode, issuedVariables, c, t, c2, t2; int *powers, *operand1, *operand2; char *code, *variables, *codeIssue, *variablesIssue, *buffer1, *buffer2, *operand1Name, *operand2Name, *resultName; gappaAssignment *newAssign; int op1format, op2format; op1format = -1; op2format = -1; res = 1; code = (char *) safeCalloc(CODESIZE,sizeof(char)); variables = (char *) safeCalloc(CODESIZE,sizeof(char)); buffer1 = (char *) safeCalloc(CODESIZE,sizeof(char)); buffer2 = (char *) safeCalloc(CODESIZE,sizeof(char)); resultName = NULL; operand1Name = NULL; operand2Name = NULL; if (gappaAssign != NULL) { resultName = (char *) safeCalloc(CODESIZE,sizeof(char)); operand1Name = (char *) safeCalloc(CODESIZE,sizeof(char)); operand2Name = (char *) safeCalloc(CODESIZE,sizeof(char)); } codeIssue = code; variablesIssue = variables; issuedCode = 0; issuedVariables = 0; powers = (int *) safeCalloc(degree,sizeof(int)); operand1 = (int *) safeCalloc(degree,sizeof(int)); operand2 = (int *) safeCalloc(degree,sizeof(int)); for (i=0;i0;i--) { if (powers[i] >= 0) { if ((i % 2) == 1) { if (powers[i] > powers[(i+1)/2-1]) powers[(i+1)/2-1] = powers[i]; operand1[i] = (i+1)/2 - 1; operand2[i] = (i+1)/2 - 1; } else { for (k=i-1;k>0;k--) { if (powers[k] >= 0) break; } l = i - k - 1; if (powers[i] > powers[k]) powers[k] = powers[i]; if (powers[i] > powers[l]) powers[l] = powers[i]; operand1[i] = k; operand2[i] = l; } } } for (i=1;i= 0) { /* Test whether we must produce a double, a double-double or a triple-double */ if (powers[i] > 102) { /* Produce a triple-double or an exact result for x^2 with x as a double */ if (operand1[i] == 0) { /* The first operand is x */ if (operand2[i] == 0) { /* The second operand is x, too */ switch (variablePrecision) { case 1: /* Produce an exact double-double x^2 instead of a triple-double */ /* The operation's precision is always infinite because of the operator */ c = sollya_snprintf(buffer1,CODESIZE, "Mul12(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,%s,%s);", name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1],((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow2h, %s_%s_%d_pow2m;", name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); if ((c < 0) || (c >= CODESIZE)) res = 0; overlaps[i] = 53; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); newAssign = newGappaOperation(GAPPA_MUL_EXACT, -1, 2, 53, resultName, 1, 1, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Produce a triple-double x^2 out of two double-double x's */ /* The operation's precision is fixed because of the operands */ c = sollya_snprintf(buffer1,CODESIZE, "Mul23(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,&%s_%s_%d_pow2l,%sh,%sm,%sh,%sm);", name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow2h, %s_%s_%d_pow2m, %s_%s_%d_pow2l;", name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); if ((c < 0) || (c >= CODESIZE)) res = 0; overlaps[i] = 49; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); newAssign = newGappaOperation(GAPPA_MUL_REL, 149, 3, overlaps[i], resultName, 2, 2, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 3: /* Produce a triple-double x^2 out of two triple-double x's */ /* The operation's precision is fixed because the operands are renormalized x's */ c = sollya_snprintf(buffer1,CODESIZE, "Mul33(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,&%s_%s_%d_pow2l,%sh,%sm,%sl,%sh,%sm,%sl);", name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow2h, %s_%s_%d_pow2m, %s_%s_%d_pow2l;", name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); if ((c < 0) || (c >= CODESIZE)) res = 0; overlaps[i] = 48; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); newAssign = newGappaOperation(GAPPA_MUL_REL, 140, 3, overlaps[i], resultName, 3, 3, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: res = 0; } } else { /* The first operand is x and the second is x^? as a triple-double */ switch (variablePrecision) { case 1: if (operand2[i] == 1) { /* Produce a triple-double out if a double x and an exact double-double x^2 */ /* The operation's precision is fixed because of the operands */ c = sollya_snprintf(buffer1,CODESIZE, "Mul123(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s,%s_%s_%d_pow2h,%s_%s_%d_pow2m);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, ((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE)) res = 0; overlaps[i] = 47; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]); newAssign = newGappaOperation(GAPPA_MUL_REL, 154, 3, overlaps[i], resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* Produce a triple-double out of a double x and a triple-double x^? */ /* The operation's precision depends on the overlap of the triple-double x^? We must check if this value must be renormalized. The precision is roughly 100 + overlap bits. */ c = 0; c2 = 0; if (overlaps[operand2[i]] + 100 < powers[i]) { /* If we are here, we must renormalize the operand */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); varNum[operand2[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand2[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]-1,operand2[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand2[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } t = c; t2 = c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul133(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, ((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; overlaps[i] = overlaps[operand2[i]] - 5; if (overlaps[i] > 47) overlaps[i] = 47; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, overlaps[operand2[i]] + 100, 3, overlaps[i], resultName, 1, 1, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } break; case 2: /* Produce a triple-double out of a double-double x and a triple-double x^? */ /* The operation's precision depends on the overlap of the triple-double x^? We must check if this value must be renormalized. The precision is roughly 96 + overlap bits. */ c = 0; c2 = 0; if (overlaps[operand2[i]] + 96 < powers[i]) { /* If we are here, we must renormalize the operand */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); varNum[operand2[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand2[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]-1,operand2[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand2[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } t = c; t2 = c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul233(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%sh,%sm,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; overlaps[i] = overlaps[operand2[i]] - 4; if (overlaps[i] > 48) overlaps[i] = 48; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, overlaps[operand2[i]] + 96, 3, overlaps[i], resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 3: /* Produce a triple-double out of a triple-double x and a triple-double x^? */ /* The operation's precision depends on the overlap of the triple-double x^? The triple-double x is supposed to be renormalized anytime. We must check if this value must be renormalized. The precision is roughly 98 + overlap bits. */ c = 0; c2 = 0; if (overlaps[operand2[i]] + 98 < powers[i]) { /* If we are here, we must renormalize the operand */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); varNum[operand2[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand2[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]-1,operand2[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand2[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } t = c; t2 = c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul33(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%sh,%sm,%sl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename), name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; overlaps[i] = overlaps[operand2[i]] - 4; if (overlaps[i] > 48) overlaps[i] = 48; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, overlaps[operand2[i]] + 98, 3, overlaps[i], resultName, 3, 3, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: res = 0; } } } else { /* The first operand is not x */ if (operand2[i] == 0) { /* The second operand is x and the first is x^? as a triple-double */ switch (variablePrecision) { case 1: if (operand1[i] == 1) { /* Produce a triple-double out an exact double-double x^2 and a double x */ /* The operation's precision is fixed because of the operands */ c = sollya_snprintf(buffer1,CODESIZE, "Mul123(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s,%s_%s_%d_pow2h,%s_%s_%d_pow2m);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, ((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE)) res = 0; overlaps[i] = 47; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]); newAssign = newGappaOperation(GAPPA_MUL_REL, 154, 3, overlaps[i], resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* Produce a triple-double out of a triple-double x^? and a double x*/ /* The operation's precision depends on the overlap of the triple-double x^? We must check if this value must be renormalized. The precision is roughly 100 + overlap bits. */ c = 0; c2 = 0; if (overlaps[operand1[i]] + 100 < powers[i]) { /* If we are here, we must renormalize the operand */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); varNum[operand1[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand1[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]-1,operand1[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand1[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } t = c; t2 = c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul133(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, ((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; overlaps[i] = overlaps[operand1[i]] - 5; if (overlaps[i] > 47) overlaps[i] = 47; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, overlaps[operand1[i]] + 100, 3, overlaps[i], resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } break; case 2: /* Produce a triple-double out of a triple-double x^? and a double-double x */ /* The operation's precision depends on the overlap of the triple-double x^? We must check if this value must be renormalized. The precision is roughly 96 + overlap bits. */ c = 0; c2 = 0; if (overlaps[operand1[i]] + 96 < powers[i]) { /* If we are here, we must renormalize the operand */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); varNum[operand1[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand1[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]-1,operand1[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand1[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } t = c; t2 = c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul233(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%sh,%sm,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; overlaps[i] = overlaps[operand1[i]] - 4; if (overlaps[i] > 48) overlaps[i] = 48; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, overlaps[operand1[i]] + 96, 3, overlaps[i], resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 3: /* Produce a triple-double out of a triple-double x^? and a triple-double x */ /* The operation's precision depends on the overlap of the triple-double x^? We must check if this value must be renormalized. The precision is roughly 98 + overlap bits. */ c = 0; c2 = 0; if (overlaps[operand1[i]] + 98 < powers[i]) { /* If we are here, we must renormalize the operand */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); varNum[operand1[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand1[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]-1,operand1[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand1[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } t = c; t2 = c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul33(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%sh,%sm,%sl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename), name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE)) res = 0; overlaps[i] = overlaps[operand1[i]] - 4; if (overlaps[i] > 48) overlaps[i] = 48; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, overlaps[operand1[i]] + 98, 3, overlaps[i], resultName, 3, 3, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: res = 0; } } else { /* None of the opernands is x */ if (variablePrecision == 1) { if (operand1[i] == 1) { /* The first operand is a double-double x^2 */ if (operand2[i] == 1) { /* The second operand is a double-double x^2 */ /* Produce a triple-double x^4 out of two double-double x^2 */ /* The operation's precision is fixed because of the operands */ c = sollya_snprintf(buffer1,CODESIZE, "Mul23(&%s_%s_%d_pow4h,&%s_%s_%d_pow4m,&%s_%s_%d_pow4l,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2h,%s_%s_%d_pow2m);", name,((variablename == NULL) ? "_x_" : variablename),varNum[3],name,((variablename == NULL) ? "_x_" : variablename),varNum[3],name,((variablename == NULL) ? "_x_" : variablename),varNum[3], name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow4h, %s_%s_%d_pow4m, %s_%s_%d_pow4l;", name,((variablename == NULL) ? "_x_" : variablename),varNum[3],name,((variablename == NULL) ? "_x_" : variablename),varNum[3],name,((variablename == NULL) ? "_x_" : variablename),varNum[3]); if ((c < 0) || (c >= CODESIZE)) res = 0; overlaps[i] = 49; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow4",name,((variablename == NULL) ? "_x_" : variablename),varNum[3]); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 149, 3, overlaps[i], resultName, 2, 2, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* Produce a triple-double out of a double-double x^2 and a triple-double x^? */ /* The operation's precision depends on the overlap of the triple-double x^? We must check if this value must be renormalized. The precision is roughly 96 + overlap bits. */ c = 0; c2 = 0; if (overlaps[operand2[i]] + 96 < powers[i]) { /* If we are here, we must renormalize the operand */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); varNum[operand2[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand2[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]-1,operand2[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand2[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } t = c; t2 = c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul233(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1], name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; overlaps[i] = overlaps[operand2[i]] - 4; if (overlaps[i] > 48) overlaps[i] = 48; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, overlaps[operand2[i]] + 96, 3, overlaps[i], resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } else { /* The first operand is surely a triple-double */ if (operand2[i] == 1) { /* The second operand is a double-double x^2 */ /* Produce a triple-double out of a triple-double x^? and a double-double x^2 */ /* The operation's precision depends on the overlap of the triple-double x^? We must check if this value must be renormalized. The precision is roughly 96 + overlap bits. */ c = 0; c2 = 0; if (overlaps[operand1[i]] + 96 < powers[i]) { /* If we are here, we must renormalize the operand */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); varNum[operand1[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand1[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]-1,operand1[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand1[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } t = c; t2 = c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul233(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1], name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; overlaps[i] = overlaps[operand1[i]] - 4; if (overlaps[i] > 48) overlaps[i] = 48; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, overlaps[operand1[i]] + 96, 3, overlaps[i], resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* Both operands are surely triple-doubles; we produce a triple-double */ /* The operation's precision depends on the overlap of *both* triple-double x^? We must check if one or two of the values must be renormalized. The precision is roughly 97 + min(overlaps of both) */ t = 0; c2 = 0; t2 = 0; if (MIN(overlaps[operand1[i]],overlaps[operand2[i]]) + 97 < powers[i]) { /* We renormalize first the operand with the higher overlap (i.e. lower value) */ if (overlaps[operand1[i]] < overlaps[operand2[i]]) { /* Renormalize first opernand1[i] */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); varNum[operand1[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand1[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]-1,operand1[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand1[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* Renormalize first opernand2[i] */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); varNum[operand2[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand2[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]-1,operand2[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand2[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } t += c; t2 += c2; /* Check once again the precision */ if (MIN(overlaps[operand1[i]],overlaps[operand2[i]]) + 97 < powers[i]) { /* If we are here, we must renormalize also the other operand. Since the overlap value of the other is now greater, we renormalize the operand with the higher overlap as before. */ if (overlaps[operand1[i]] < overlaps[operand2[i]]) { /* Renormalize first opernand1[i] */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); varNum[operand1[i]]++; if ((c < 0) || (c >= CODESIZE-t)) res = 0; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; overlaps[operand1[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]-1,operand1[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand1[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* Renormalize first opernand2[i] */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); varNum[operand2[i]]++; if ((c < 0) || (c >= CODESIZE-t)) res = 0; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; overlaps[operand2[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]-1,operand2[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand2[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } t += c; t2 += c2; } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul33(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; overlaps[i] = overlaps[operand1[i]] - 4; if (overlaps[i] > overlaps[operand2[i]] - 4) overlaps[i] = overlaps[operand2[i]] - 4; if (overlaps[i] > 48) overlaps[i] = 48; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, MIN(overlaps[operand1[i]],overlaps[operand2[i]]) + 97, 3, overlaps[i], resultName, 3, 3, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } else { /* Both operands are surely triple-doubles; we produce a triple-double */ /* The operation's precision depends on the overlap of *both* triple-double x^? We must check if one or two of the values must be renormalized. The precision is roughly 97 + min(overlaps of both) */ t = 0; t2 = 0; if (MIN(overlaps[operand1[i]],overlaps[operand2[i]]) + 97 < powers[i]) { /* We renormalize first the operand with the higher overlap (i.e. lower value) */ if (overlaps[operand1[i]] < overlaps[operand2[i]]) { /* Renormalize first opernand1[i] */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); varNum[operand1[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand1[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]-1,operand1[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand1[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* Renormalize first opernand2[i] */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); varNum[operand2[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand2[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]-1,operand2[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand2[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } t += c; t2 += c2; /* Check once again the precision */ if (MIN(overlaps[operand1[i]],overlaps[operand2[i]]) + 97 < powers[i]) { /* If we are here, we must renormalize also the other operand. Since the overlap value of the other is now greater, we renormalize the operand with the higher overlap as before. */ if (overlaps[operand1[i]] < overlaps[operand2[i]]) { /* Renormalize first opernand1[i] */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); varNum[operand1[i]]++; if ((c < 0) || (c >= CODESIZE-t)) res = 0; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; overlaps[operand1[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]-1,operand1[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand1[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* Renormalize first opernand2[i] */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); varNum[operand2[i]]++; if ((c < 0) || (c >= CODESIZE-t)) res = 0; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; overlaps[operand2[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]-1,operand2[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand2[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } t += c; t2 += c2; } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul33(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; overlaps[i] = overlaps[operand1[i]] - 4; if (overlaps[i] > overlaps[operand2[i]] - 4) overlaps[i] = overlaps[operand2[i]] - 4; if (overlaps[i] > 48) overlaps[i] = 48; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, MIN(overlaps[operand1[i]],overlaps[operand2[i]]) + 97, 3, overlaps[i], resultName, 3, 3, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } } else { if (powers[i] > 53) { overlaps[i] = 53; /* Produce a double-double */ if (operand1[i] == 0) { /* The first operand is x */ if (operand2[i] == 0) { /* The second operand is x */ switch (variablePrecision) { case 1: /* Produce a double-double x^2 out of a double x and a double x */ c = sollya_snprintf(buffer1,CODESIZE, "Mul12(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,%s,%s);", name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1],((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow2h, %s_%s_%d_pow2m;", name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); newAssign = newGappaOperation(GAPPA_MUL_EXACT, -1, 2, 53, resultName, 1, 1, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: case 3: /* Produce a double-double x^2 out of a double-double or better x and a double-double or better x */ c = sollya_snprintf(buffer1,CODESIZE, "Mul22(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,%sh,%sm,%sh,%sm);", name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1],((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow2h, %s_%s_%d_pow2m;", name,((variablename == NULL) ? "_x_" : variablename),varNum[1],name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 2, variablePrecision, operand1Name, 2, variablePrecision, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: res = 0; } } else { /* The first operand is x and the second is x^? as a double-double or better */ switch (variablePrecision) { case 1: /* Produce a double-double out of a double x and a double-double or better x^? */ /* If x^? is actually a triple-double, its higher overlap affects the precision of the operation. We check if overlap[operand] is less than 53 (only triple-doubles can be like that) and renormalize the whole triple-double (and adjust its overlap) if 53 + overlap[operand] is less than powers[i]. */ c = 0; c2 = 0; op2format = 2; if (overlaps[operand2[i]] < 53) { op2format = 3; /* We must perhaps renormalize */ if (overlaps[operand2[i]] + 53 < powers[i]) { /* We renormalize */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); varNum[operand2[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand2[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]-1,operand2[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand2[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } t = c; t2 = c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul122(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,%s,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, ((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 1, 1, operand1Name, 2, op2format, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: case 3: /* Produce a double-double out of a double-double or better x and a double-double or better x^? */ /* If x^? is actually a triple-double, its higher overlap affects the precision of the operation. We check if overlap[operand] is less than 53 (only triple-doubles can be like that) and renormalize the whole triple-double (and adjust its overlap) if 53 + overlap[operand] is less than powers[i]. The usage of a triple-double x as a double-double is not critical because x is supposed to be renormalized in this case. */ c = 0; c2 = 0; op2format = 2; if (overlaps[operand2[i]] < 53) { op2format = 3; /* We must perhaps renormalize */ if (overlaps[operand2[i]] + 53 < powers[i]) { /* We renormalize */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); varNum[operand2[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand2[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]-1,operand2[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand2[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } t = c; t2 = c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul22(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,%sh,%sm,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename), name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 2, variablePrecision, operand1Name, 2, op2format, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: res = 0; } } } else { /* The first opernand is x^? as a double-double or better */ if (operand2[i] == 0) { /* The second operand is x */ switch (variablePrecision) { case 1: /* Produce a double-double out of a double-double or better x^? and a double x */ /* If x^? is actually a triple-double, its higher overlap affects the precision of the operation. We check if overlap[operand] is less than 53 (only triple-doubles can be like that) and renormalize the whole triple-double (and adjust its overlap) if 53 + overlap[operand] is less than powers[i]. */ c = 0; c2 = 0; op2format = 2; if (overlaps[operand1[i]] < 53) { op2format = 3; /* We must perhaps renormalize */ if (overlaps[operand1[i]] + 53 < powers[i]) { /* We renormalize */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); varNum[operand1[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand1[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]-1,operand1[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand1[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } t = c; t2 = c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul122(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,%s,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, ((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 1, 1, operand1Name, 2, op2format, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: case 3: /* Produce a double-double out of a double-double or better x^? and a double-double or better x */ /* If x^? is actually a triple-double, its higher overlap affects the precision of the operation. We check if overlap[operand] is less than 53 (only triple-doubles can be like that) and renormalize the whole triple-double (and adjust its overlap) if 53 + overlap[operand] is less than powers[i]. The usage of a triple-double x as a double-double is not critical because x is supposed to be renormalized in this case. */ c = 0; c2 = 0; op2format = 2; if (overlaps[operand1[i]] < 53) { op2format = 3; /* We must perhaps renormalize */ if (overlaps[operand1[i]] + 53 < powers[i]) { /* We renormalize */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); varNum[operand1[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand1[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]-1,operand1[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand1[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } t = c; t2 = c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul22(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,%sh,%sm,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename), name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 2, variablePrecision, operand1Name, 2, op2format, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: res = 0; } } else { /* None of the operands is x and thus both double-doubles or better */ /* Produce a double-double out of two double-doubles or better */ /* If operands are actually triple-doubles, their higher overlaps affect the precision of the operation. We check if overlap[operand] is less than 53 (only triple-doubles can be like that) and renormalize the whole triple-double (and adjust its overlap) if 53 + overlap[operand] is less than powers[i]. We do this for both one after the other. */ t = 0; t2 = 0; op1format = 2; c = 0; c2 = 0; op2format = 2; if (overlaps[operand1[i]] < 53) { op1format = 3; /* We must perhaps renormalize */ if (overlaps[operand1[i]] + 53 < powers[i]) { /* We renormalize */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]+1,operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); varNum[operand1[i]]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; overlaps[operand1[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]]-1,operand1[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand1[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } t += c; t2 += c2; c = 0; c2 = 0; if (overlaps[operand2[i]] < 53) { op2format = 3; /* We must perhaps renormalize */ if (overlaps[operand2[i]] + 53 < powers[i]) { /* We renormalize */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]+1,operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); varNum[operand2[i]]++; if ((c < 0) || (c >= CODESIZE-t)) res = 0; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; overlaps[operand2[i]] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]]-1,operand2[i]+1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, overlaps[operand2[i]], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } t += c; t2 += c2; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul22(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 2, op1format, operand1Name, 2, op2format, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } else { /* Produce a double */ overlaps[i] = 53; if (operand1[i] == 0) { /* The first operand is x */ if (operand2[i] == 0) { /* The second operand is x */ if (variablePrecision == 1) { /* Produce x^2 as a double out of x as a double */ c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow2h = %s * %s;", name,((variablename == NULL) ? "_x_" : variablename),varNum[1],((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow2h;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, variablePrecision, operand1Name, 1, variablePrecision, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* Produce x^2 as a double out of x as a double-double or better */ /* Here the usage of a triple-double x as a double is not critical because we suppose that x is renormalized. */ c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow2h = %sh * %sh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow2h;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),varNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, variablePrecision, operand1Name, 1, variablePrecision, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } else { /* The first operand is x, the second is x^? as a double or better */ if (variablePrecision == 1) { /* Produce a double out of a double x and a double or better x^? */ /* If x^? is a triple-double (overlaps[operand] < 53) that we want to use as a double, we must check if overlaps[operand] is not less than the precision needed (powers[i]). If this is the case, since we do not want to renormalize the whole triple-double, we use a rounded sum of the higher and middle value. */ if ((overlaps[operand2[i]] < 53) && (overlaps[operand2[i]] < powers[i])) { c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow%dh = %s * (%s_%s_%d_pow%dh + %s_%s_%d_pow%dm);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 2, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow%dh = %s * %s_%s_%d_pow%dh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 1, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE)) res = 0; } else { /* Produce a double out of a double-double or better x and a double or better x^? */ /* If x^? is a triple-double (overlaps[operand] < 53) that we want to use as a double, we must check if overlaps[operand] is not less than the precision needed (powers[i]). If this is the case, since we do not want to renormalize the whole triple-double, we use a rounded sum of the higher and middle value. */ if ((overlaps[operand2[i]] < 53) && (overlaps[operand2[i]] < powers[i])) { c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow%dh = %sh * (%s_%s_%d_pow%dh + %s_%s_%d_pow%dm);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, variablePrecision, operand1Name, 2, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow%dh = %sh * %s_%s_%d_pow%dh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, variablePrecision, operand1Name, 1, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE)) res = 0; } } } else { /* The first operand is x^? as a double or better */ if (operand2[i] == 0) { /* The second operand is x */ if (variablePrecision == 1) { /* Produce a double out of a double or better x^? and a double x */ /* If x^? is a triple-double (overlaps[operand] < 53) that we want to use as a double, we must check if overlaps[operand] is not less than the precision needed (powers[i]). If this is the case, since we do not want to renormalize the whole triple-double, we use a rounded sum of the higher and middle value. */ if ((overlaps[operand1[i]] < 53) && (overlaps[operand1[i]] < powers[i])) { c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow%dh = %s * (%s_%s_%d_pow%dh + %s_%s_%d_pow%dm);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 2, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow%dh = %s * %s_%s_%d_pow%dh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 1, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE)) res = 0; } else { /* Produce a double out of a double or better x^? and a double-double or better x */ /* If x^? is a triple-double (overlaps[operand] < 53) that we want to use as a double, we must check if overlaps[operand] is not less than the precision needed (powers[i]). If this is the case, since we do not want to renormalize the whole triple-double, we use a rounded sum of the higher and middle value. The usage of a triple-double x as a double is not a problem because this value is supposed to be renormalized in this case. */ if ((overlaps[operand1[i]] < 53) && (overlaps[operand1[i]] < powers[i])) { c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow%dh = %sh * (%s_%s_%d_pow%dh + %s_%s_%d_pow%dm);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, variablePrecision, operand1Name, 2, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow%dh = %sh * %s_%s_%d_pow%dh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,((variablename == NULL) ? "_x_" : variablename),name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, variablePrecision, operand1Name, 1, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE)) res = 0; } } else { /* Produce a double out of two doubles or better */ /* If one of the operands is a triple-double (overlaps[operand] < 53) that we want to use as a double, we must check if overlaps[operand] is not less than the precision needed (powers[i]). If this is the case, since we do not want to renormalize the whole triple-double, we use a rounded sum of the higher and middle value. */ if ((overlaps[operand1[i]] < 53) && (overlaps[operand1[i]] < powers[i])) { if ((overlaps[operand2[i]] < 53) && (overlaps[operand2[i]] < powers[i])) { /* Both operands are low precision triple-doubles */ c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow%dh = (%s_%s_%d_pow%dh + %s_%s_%d_pow%dm) * (%s_%s_%d_pow%dh + %s_%s_%d_pow%dm);", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 2, 3, operand1Name, 2, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* Only the first operand is a low precision triple-double */ c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow%dh = (%s_%s_%d_pow%dh + %s_%s_%d_pow%dm) * %s_%s_%d_pow%dh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 2, 3, operand1Name, 1, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } else { if ((overlaps[operand2[i]] < 53) && (overlaps[operand2[i]] < powers[i])) { /* Only the second operand is a low precision triple-double */ c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow%dh = (%s_%s_%d_pow%dh + %s_%s_%d_pow%dm) * %s_%s_%d_pow%dh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1, name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 2, 2, operand1Name, 1, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* Both operands can be truncated to a double without problems */ c = sollya_snprintf(buffer1,CODESIZE, "%s_%s_%d_pow%dh = %s_%s_%d_pow%dh * %s_%s_%d_pow%dh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1,name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand1[i]],operand1[i]+1); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),varNum[operand2[i]],operand2[i]+1); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 2, operand1Name, 1, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh;", name,((variablename == NULL) ? "_x_" : variablename),varNum[i],i+1); if ((c < 0) || (c >= CODESIZE)) res = 0; } } } } /* Issue the buffers to code and variable buffers */ c = sollya_snprintf(codeIssue,CODESIZE-issuedCode,"%s\n",buffer1); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedCode) { res = 0; c = CODESIZE-issuedCode; } issuedCode += c; codeIssue += c; c = sollya_snprintf(variablesIssue,CODESIZE-issuedVariables,"%s\n",buffer2); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedVariables) { res = 0; c = CODESIZE-issuedVariables; } issuedVariables += c; variablesIssue += c; } /* end if powers[i] >= 0 */ } /* end loop */ /* Issue the variable definitions and the code */ if (sollyaFprintf(fd,"%s\n\n%s\n\n",variables,code) < 0) res = 0; safeFree(powers); safeFree(operand1); safeFree(operand2); safeFree(code); safeFree(variables); safeFree(buffer1); safeFree(buffer2); safeFree(operand1Name); safeFree(operand2Name); safeFree(resultName); return res; } int implementCoefficients(mpfr_t *coefficients, int degree, FILE *fd, char *name, mp_prec_t prec, chain **gappaAssign) { int res, i, format; double current, constHi, constMi, constLo; mpfr_t temp, temp2; gappaAssignment *newAssignment; char *resultVariable; res = 1; mpfr_init2(temp,prec); mpfr_init2(temp2,prec); for (i=0;i<=degree;i++) { if (!mpfr_zero_p(coefficients[i])) { constHi = 0.0; constMi = 0.0; constLo = 0.0; if ((format = determineCoefficientFormat(coefficients[i])) > 3) { printMessage(1,SOLLYA_MSG_COEFF_DOES_NOT_EVEN_HOLD_ON_TRIPLE_DOUBLE,"Warning: tried to implement a coefficient that cannot even be written on a triple-double.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This should not occur. The coefficient will be rounded to a triple-double.\n"); format = 3; } if (mpfr_set(temp,coefficients[i],GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_INTERNAL_HANDLING_OF_A_COEFFICIENT,"Warning: a rounding occurred on internal handling (on copying) of the %dth coefficient.\n"); } res = 0; } current = sollya_mpfr_get_d(temp,GMP_RNDN); if (mpfr_set_d(temp2,current,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_INTERNAL_HANDLING_OF_A_COEFFICIENT,"Warning: a rounding occurred on internal handling (on recasting) of the %dth coefficient.\n"); } res = 0; } if (mpfr_sub(temp,temp,temp2,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_INTERNAL_HANDLING_OF_A_COEFFICIENT,"Warning: a rounding occurred on internal handling (on a subtraction) of the %dth coefficient.\n"); } res = 0; } sollyaFprintf(fd,"#define %s_coeff_%dh %1.80e\n",name,i,current); constHi = current; current = sollya_mpfr_get_d(temp,GMP_RNDN); if (current != 0.0) { if (mpfr_set_d(temp2,current,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_INTERNAL_HANDLING_OF_A_COEFFICIENT,"Warning: a rounding occurred on internal handling (on recasting) of the %dth coefficient.\n"); } res = 0; } if (mpfr_sub(temp,temp,temp2,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_INTERNAL_HANDLING_OF_A_COEFFICIENT,"Warning: a rounding occurred on internal handling (on a subtraction) of the %dth coefficient.\n"); } res = 0; } sollyaFprintf(fd,"#define %s_coeff_%dm %1.80e\n",name,i,current); constMi = current; current = sollya_mpfr_get_d(temp,GMP_RNDN); if (current != 0.0) { if (mpfr_set_d(temp2,current,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_INTERNAL_HANDLING_OF_A_COEFFICIENT,"Warning: a rounding occurred on internal handling (on recasting) of the %dth coefficient.\n"); } res = 0; } if (mpfr_sub(temp,temp,temp2,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_INTERNAL_HANDLING_OF_A_COEFFICIENT,"Warning: a rounding occurred on internal handling (on a subtraction) of the %dth coefficient.\n"); } res = 0; } sollyaFprintf(fd,"#define %s_coeff_%dl %1.80e\n",name,i,current); constLo = current; } } if (gappaAssign != NULL) { resultVariable = (char *) safeCalloc(CODESIZE,sizeof(char)); sprintf(resultVariable,"%s_coeff_%d",name,i); newAssignment = newGappaConstant(format, resultVariable, constHi, constMi, constLo); safeFree(resultVariable); *gappaAssign = addElement(*gappaAssign,newAssignment); } } } sollyaFprintf(fd,"\n\n"); mpfr_clear(temp); mpfr_clear(temp2); return res; } int implementHorner(mpfr_t *coefficients, int *addPrec, int *mulPrec, int degree, int variablePrecision, FILE *fd, char *name, int *powerOverlaps, int *powVarNum, chain **gappaAssign, int resultType) { int res, i, k, variableNumber, comingFormat, producedFormat, issuedCode, issuedVariables, c, c2, t2; int coeffFormat, currOverlap, t, oldCurrOverlap; char *code, *variables, *codeIssue, *variablesIssue, *buffer1, *buffer2; int *tempVarNum; char *resultName, *operand1Name, *operand2Name, *operand3Name; int op2format; gappaAssignment *newAssign; op2format = -1; resultName = NULL; operand1Name = NULL; operand2Name = NULL; operand3Name = NULL; if (gappaAssign != NULL) { resultName = (char *) safeCalloc(CODESIZE,sizeof(char)); operand1Name = (char *) safeCalloc(CODESIZE,sizeof(char)); operand2Name = (char *) safeCalloc(CODESIZE,sizeof(char)); operand3Name = (char *) safeCalloc(CODESIZE,sizeof(char)); } res = 1; code = (char *) safeCalloc(CODESIZE,sizeof(char)); variables = (char *) safeCalloc(CODESIZE,sizeof(char)); buffer1 = (char *) safeCalloc(CODESIZE,sizeof(char)); buffer2 = (char *) safeCalloc(CODESIZE,sizeof(char)); tempVarNum = (int *) safeCalloc((2* degree) + 3,sizeof(int)); codeIssue = code; variablesIssue = variables; issuedCode = 0; issuedVariables = 0; currOverlap = 53; /* Initialise with the first step */ variableNumber = 1; for (i=degree;((i>=0) && (mpfr_zero_p(coefficients[i])));i--); switch (producedFormat = determineCoefficientFormat(coefficients[i])) { case 3: c = sollya_snprintf(buffer1,CODESIZE, "%s_t_%d_%dh = %s_coeff_%dh; %s_t_%d_%dm = %s_coeff_%dm; %s_t_%d_%dl = %s_coeff_%dl;", name,variableNumber,tempVarNum[variableNumber],name,i, name,variableNumber,tempVarNum[variableNumber],name,i, name,variableNumber,tempVarNum[variableNumber],name,i); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber], name,variableNumber,tempVarNum[variableNumber], name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; variableNumber++; /* The overlap should be 53 since we have correctly rounded coefficients But: there is the case of double renormalization in the firststep in strange honorcoeffprec cases. */ currOverlap = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); newAssign = newGappaOperation(GAPPA_COPY, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: c = sollya_snprintf(buffer1,CODESIZE, "%s_t_%d_%dh = %s_coeff_%dh; %s_t_%d_%dm = %s_coeff_%dm;", name,variableNumber,tempVarNum[variableNumber],name,i, name,variableNumber,tempVarNum[variableNumber],name,i); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber], name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; variableNumber++; /* The overlap is 53 since we have correctly rounded coefficients */ currOverlap = 53; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); newAssign = newGappaOperation(GAPPA_COPY, -1, 2, currOverlap, resultName, 2, 2, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 1: c = sollya_snprintf(buffer1,CODESIZE, "%s_t_%d_%dh = %s_coeff_%dh;", name,variableNumber,tempVarNum[variableNumber],name,i); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh;", name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; variableNumber++; /* The overlap is 53 since we have correctly rounded coefficients */ currOverlap = 53; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); newAssign = newGappaOperation(GAPPA_COPY, -1, 1, -1, resultName, 1, 1, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: printMessage(1,SOLLYA_MSG_A_COEFF_COULD_NOT_BE_STORED_IN_ANY_KNOWN_FORMAT,"Warning: a coefficient could not be stored in a known format. The implementation may be wrong.\n"); producedFormat = 1; res = 0; } comingFormat = producedFormat; c = sollya_snprintf(codeIssue,CODESIZE-issuedCode,"%s\n",buffer1); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedCode) { res = 0; c = CODESIZE-issuedCode; } issuedCode += c; codeIssue += c; c = sollya_snprintf(variablesIssue,CODESIZE-issuedVariables,"%s\n",buffer2); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedVariables) { res = 0; c = CODESIZE-issuedVariables; } issuedVariables += c; variablesIssue += c; /* Continue with the normal steps */ while (i>=0) { i--; k = 1; while ((i>=0) && (mpfr_zero_p(coefficients[i]))) { i--; k++; } if (i>=0) { coeffFormat = determineCoefficientFormat(coefficients[i]); /* Special case: fused addition and multiplication */ /* We have two special operators: MulAdd212 and MulAdd22 We can use them if - 53 < addPrec[i] <= 102 - 53 < mulPrec[i] <= 102 - comingFormat = 2 - coeffFormat = 2 The value for x^k will either be completely correct (k = 1, variablePrecision = 1) or can be rounded down because of the target accuracy. */ if ((53 < addPrec[i]) && (addPrec[i] <= 102) && (53 < mulPrec[i]) && (mulPrec[i] <= 102) && (comingFormat == 2) && (coeffFormat == 2)) { producedFormat = 2; if (k == 1) { /* Multiplication by a pure x, two possible cases: x as a double or a double-double (or better) */ if (variablePrecision == 1) { /* Multiplication by x stored as a double */ c = sollya_snprintf(buffer1,CODESIZE, "MulAdd212(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_coeff_%dh,%s_coeff_%dm,%s,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i,name,i, ((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand3Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_FMA_REL, 100, 2, 53, resultName, 2, 2, operand1Name, 1, 1, operand2Name); newAssign->operand3UsedType = 2; newAssign->operand3ComingType = 2; newAssign->operand3Variable = (char *) safeCalloc(strlen(operand3Name)+1,sizeof(char)); strcpy(newAssign->operand3Variable,operand3Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* Multiplication by x stored as a double-double (or better) */ c = sollya_snprintf(buffer1,CODESIZE, "MulAdd22(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_coeff_%dh,%s_coeff_%dm,%sh,%sm,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i,name,i, ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand3Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_FMA_REL, 100, 2, 53, resultName, 2, 2, operand1Name, 2, variablePrecision, operand2Name); newAssign->operand3UsedType = 2; newAssign->operand3ComingType = 2; newAssign->operand3Variable = (char *) safeCalloc(strlen(operand3Name)+1,sizeof(char)); strcpy(newAssign->operand3Variable,operand3Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } else { /* Multiplication by x^k, which will be in any case at least a double-double */ /* We have to check that if x^k is actually a triple-double that is read as a double-double that the precision obtained is sufficient regardless of the overlap in the triple-double The obtained precision is roughly 53 + overlap value. If it is not sufficient, we renormalize the whole triple-double value. */ t = 0; t2 = 0; if ((powerOverlaps[k-1] < 53) && (mulPrec[i] > (53 + powerOverlaps[k-1]))) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; powerOverlaps[k-1] = 52; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "MulAdd22(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_coeff_%dh,%s_coeff_%dm,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i,name,i, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; if (gappaAssign != NULL) { if (powerOverlaps[k-1] < 53) op2format = 3; else op2format = 2; sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand3Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_FMA_REL, 100, 2, 53, resultName, 2, 2, operand1Name, 2, op2format, operand2Name); newAssign->operand3UsedType = 2; newAssign->operand3ComingType = 2; newAssign->operand3Variable = (char *) safeCalloc(strlen(operand3Name)+1,sizeof(char)); strcpy(newAssign->operand3Variable,operand3Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } variableNumber++; comingFormat = producedFormat; /* Issue the generated buffers to memory */ c = sollya_snprintf(codeIssue,CODESIZE-issuedCode,"%s\n",buffer1); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedCode) { res = 0; c = CODESIZE-issuedCode; } issuedCode += c; codeIssue += c; c = sollya_snprintf(variablesIssue,CODESIZE-issuedVariables,"%s\n",buffer2); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedVariables) { res = 0; c = CODESIZE-issuedVariables; } issuedVariables += c; variablesIssue += c; /* The overlap is 53 since we have always double-double operations */ currOverlap = 53; } else { /* General case: multiplication followed by addition */ /* Generate first the multiplication by x or the correspondant power of x in the buffer */ /* mulPrec[i] determines the format to produce and influences on the precision of x or the power of x */ if (mulPrec[i] > 102) { /* Produce a triple-double (or a double-double exactly if comingFormat = 1 and x as a double */ if (k == 1) { /* Multiply by pure x as a double, double-double or triple-double */ switch (variablePrecision) { case 3: /* Multiply comingFormat by a triple-double x, produce a triple-double */ producedFormat = 3; switch (comingFormat) { case 3: /* Multiply the triple-double temporary by a triple-double x, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The overlap of x is fixed by hypothesis, so the precision depends only on the overlap of the entering temporary. If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + currOverlap)) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; tempVarNum[variableNumber-1]++; currOverlap = 52; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul33(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%sh,%sm,%sl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(48,currOverlap-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + oldCurrOverlap, 3, currOverlap, resultName, 3, 3, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Multiply the double-double temporary by a triple-double x, produce a triple-double */ /* The precision is fixed because of the operands' formats: - x is supposed to be non-overlapping by hypothesis - the other operand is a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul233(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%sh,%sm,%sl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 48; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 149, 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by a triple-double x, produce a triple-double */ /* The precision is fixed because of the operands' formats: - x is supposed to be non-overlapping by hypothesis - the other operand is a double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul133(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%sh,%sm,%sl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 47; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 152, 3, currOverlap, resultName, 1, 1, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } break; case 2: producedFormat = 3; switch (comingFormat) { case 3: /* Multiply the triple-double temporary by a double-double x, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The overlap of x is fixed by hypothesis, so the precision depends only on the overlap of the entering temporary. If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + currOverlap)) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 52; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul233(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%sh,%sm,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE+t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(48,currOverlap-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + oldCurrOverlap, 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Multiply the double-double temporary by a double-double x, produce a triple-double */ /* The precision is fixed because of the operands' formats: both operands are double-doubles */ c = sollya_snprintf(buffer1,CODESIZE, "Mul23(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%sh,%sm,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 49; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 149, 3, currOverlap, resultName, 2, 2, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by a double-double x, produce a triple-double */ /* The precision is fixed because of the operands' formats: the operands are double and double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul123(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%sh,%sm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 47; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 154, 3, currOverlap, resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } break; case 1: switch (comingFormat) { case 3: /* Multiply the triple-double temporary by a double x, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The overlap of x is fixed by hypothesis, so the precision depends only on the overlap of the entering temporary. If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (100 + currOverlap)) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 52; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } producedFormat = 3; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul133(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(47,currOverlap-5); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 100 + oldCurrOverlap, 3, currOverlap, resultName, 1, 1, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Multiply the double-double temporary by a double x, produce a triple-double */ /* The precision is fixed because of the operands' formats: the operands are double and double-double */ producedFormat = 3; c = sollya_snprintf(buffer1,CODESIZE, "Mul123(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 47; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 154, 3, currOverlap, resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by a double x, produce a double-double */ /* The precision is fixed because of the operands' formats: both operands are doubles, we produce an exact double-double */ producedFormat = 2; c = sollya_snprintf(buffer1,CODESIZE, "Mul12(&%s_t_%d_%dh,&%s_t_%d_%dm,%s,%s_t_%d_%dh);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 53; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_EXACT, -1, 2, 53, resultName, 1, 1, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } break; default: printMessage(1,SOLLYA_MSG_IMPLEMENTPOLY_FREE_VAR_HAS_UNKNOWN_FORMAT,"Warning: the variable %s has an unknown format. This should not occur.\n",((variablename == NULL) ? "_x_" : variablename)); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; producedFormat = 1; } } else { producedFormat = 3; if (k == 2) { /* Multiply by x^2, which is a double-double if x is a double or a triple-double otherwise */ if (variablePrecision == 1) { /* Multiply comingFormat by a double-double x^2, produce a triple-double */ switch (comingFormat) { case 3: /* Multiply the triple-double temporary by a double-double x^2, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The second operand is x^2 as a double-double, so the precision depends only on the overlap of the entering temporary. If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + currOverlap)) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 52; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul233(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(48,currOverlap-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + oldCurrOverlap, 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Multiply the double-double temporary by a double-double x^2, produce a triple-double */ /* The precision is fixed because of the operands' formats: both operands are double-doubles */ c = sollya_snprintf(buffer1,CODESIZE, "Mul23(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 49; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 149, 3, currOverlap, resultName, 2, 2, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by a double-double x^2, produce a triple-double */ /* The precision is fixed because of the operands' formats: the operands are a double and a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul123(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_%s_%d_pow2h,%s_%s_%d_pow2m);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 47; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 154, 3, currOverlap, resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } else { /* Multiply comingFormat by a triple-double x^2, produce a triple-double */ switch (comingFormat) { case 3: /* Multiply the triple-double temporary by a triple-double x^2, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The precision is roughly 97 + min(overlaps) bits. If it is not sufficient, we renormalize first the operands with the higher overlap (lower value), check again and renormalize once again if needed. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + MIN(currOverlap,powerOverlaps[1]))) { /* The precision is not sufficient, we have to renormalize at least one operand */ if (currOverlap < powerOverlaps[1]) { /* We have to renormalize first the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; currOverlap = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* We have to renormalize first x^2 */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,&%s_%s_%d_pow2l,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); powVarNum[1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; powerOverlaps[1] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]-1,2); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } if (mulPrec[i] > (97 + MIN(currOverlap,powerOverlaps[1]))) { /* The precision is still not sufficient, we have to renormalize the other operand */ if (currOverlap <= powerOverlaps[1]) { /* We have to renormalize the temporary */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; tempVarNum[variableNumber-1]++; t += c; currOverlap = 52; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; t2 += c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* We have to renormalize x^2 */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,&%s_%s_%d_pow2l,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); powVarNum[1]++; if ((c < 0) || (c >= CODESIZE-t)) res = 0; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; t += c; t2 += c2; powerOverlaps[1] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]-1,2); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul33(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(48,MIN(currOverlap,powerOverlaps[1])-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, (97 + MIN(oldCurrOverlap,powerOverlaps[1])), 3, currOverlap, resultName, 3, 3, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Multiply the double-double temporary by a triple-double x^2, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The temporary is a double-double, so the precision only depends on the triple-double x^2 If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + powerOverlaps[1])) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,&%s_%s_%d_pow2l,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); powVarNum[1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; powerOverlaps[1] = 52; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]-1,2); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul233(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; currOverlap = MIN(48,powerOverlaps[1]-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + powerOverlaps[1], 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by a triple-double x^2, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The temporary is a double, so the precision only depends on the triple-double x^2 If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (100 + powerOverlaps[1])) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,&%s_%s_%d_pow2l,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); powVarNum[1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; powerOverlaps[1] = 52; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]-1,2); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul133(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; currOverlap = MIN(47,powerOverlaps[1] - 5); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 100 + powerOverlaps[1], 3, currOverlap, resultName, 1, 1, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } else { /* Multiply by x^k, which is in any case a triple-double, produce a triple-double */ switch (comingFormat) { case 3: /* Multiply the triple-double temporary by a triple-double x^k, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The precision is roughly 97 + min(overlaps) bits. If it is not sufficient, we renormalize first the operands with the higher overlap (lower value), check again and renormalize once again if needed. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + MIN(currOverlap,powerOverlaps[k-1]))) { /* The precision is not sufficient, we have to renormalize at least one operand */ if (currOverlap < powerOverlaps[k-1]) { /* We have to renormalize first the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; t = c; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t2 = c2; currOverlap = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* We have to renormalize first x^k */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; powerOverlaps[k-1] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } if (mulPrec[i] > (97 + MIN(currOverlap,powerOverlaps[k-1]))) { /* The precision is still not sufficient, we have to renormalize the other operand */ if (currOverlap <= powerOverlaps[k-1]) { /* We have to renormalize the temporary */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; t += c; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; t2 += c2; currOverlap = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* We have to renormalize x^k */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE-t)) res = 0; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; t += c; t2 += c2; powerOverlaps[k-1] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul33(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(48,MIN(currOverlap,powerOverlaps[k-1])-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + MIN(oldCurrOverlap,powerOverlaps[k-1]), 3, currOverlap, resultName, 3, 3, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Multiply the double-double temporary by a triple-double x^k, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The temporary is a double-double, so the precision only depends on the triple-double x^k If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + powerOverlaps[k-1])) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; powerOverlaps[k-1] = 52; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul233(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; currOverlap = MIN(48,powerOverlaps[k-1]-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + powerOverlaps[k-1], 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by a triple-double x^k, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The temporary is a double-double, so the precision only depends on the triple-double x^k If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (100 + powerOverlaps[k-1])) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; powerOverlaps[k-1] = 52; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul133(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; currOverlap = MIN(47,powerOverlaps[k-1]-5); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 100 + powerOverlaps[k-1], 3, currOverlap, resultName, 1, 1, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } } else { if (mulPrec[i] > 53) { /* Produce a double-double */ producedFormat = 2; currOverlap = 53; if (k == 1) { /* Multiply comingFormat by x as a double or double-double (or better), produce a double-double */ switch (variablePrecision) { case 3: case 2: /* Multiply comingFormat by x as a double-double (or better), produce a double-double */ switch (comingFormat) { case 3: printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; break; case 2: /* Multiply the double-double temporary by x as double-double (or better), produce a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul22(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_t_%d_%dh,%s_t_%d_%dm,%sh,%sm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 2, 2, operand1Name, 2, variablePrecision, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by x as a double-double (or better), produce a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul122(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_t_%d_%dh,%sh,%sm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 1, 1, operand1Name, 2, variablePrecision, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } break; case 1: /* Multiply comingFormat by x as a double, produce a double-double */ switch (comingFormat) { case 3: printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; break; case 2: /* Multiply the double-double temporary by x as double, produce a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul122(&%s_t_%d_%dh,&%s_t_%d_%dm,%s,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by x as a double, produce a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul12(&%s_t_%d_%dh,&%s_t_%d_%dm,%s,%s_t_%d_%dh);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_EXACT, -1, 2, 53, resultName, 1, 1, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } break; default: printMessage(1,SOLLYA_MSG_IMPLEMENTPOLY_FREE_VAR_HAS_UNKNOWN_FORMAT,"Warning: the variable %s has an unknown format. This should not occur.\n",((variablename == NULL) ? "_x_" : variablename)); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; } } else { /* Multiply comingFormat by x^k which should be at least a double-double in any case */ switch (comingFormat) { case 3: printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; break; case 2: /* Multiply the double-double temporary by x^k as double-double, produce a double-double */ /* We have to check that if x^k is actually a triple-double that is read as a double-double that the precision obtained is sufficient regardless of the overlap in the triple-double The obtained precision is roughly 53 + overlap value. If it is not sufficient, we renormalize the whole triple-double value. */ t = 0; t2 = 0; if ((powerOverlaps[k-1] < 53) && (mulPrec[i] > (53 + powerOverlaps[k-1]))) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; powerOverlaps[k-1] = 52; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul22(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_t_%d_%dh,%s_t_%d_%dm,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; if (gappaAssign != NULL) { if (powerOverlaps[k-1] < 53) op2format = 3; else op2format = 2; sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 2, 2, operand1Name, 2, op2format, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by x^k as a double-double, produce a double-double */ /* We have to check that if x^k is actually a triple-double that is read as a double-double that the precision obtained is sufficient regardless of the overlap in the triple-double The obtained precision is roughly 53 + overlap value. If it is not sufficient, we renormalize the whole triple-double value. */ t = 0; t2 = 0; if ((powerOverlaps[k-1] < 53) && (mulPrec[i] > (53 + powerOverlaps[k-1]))) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; powerOverlaps[k-1] = 52; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul122(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_t_%d_%dh,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; if (gappaAssign != NULL) { if (powerOverlaps[k-1] < 53) op2format = 3; else op2format = 2; sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 1, 1, operand1Name, 2, op2format, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } else { /* Produce a double */ producedFormat = 1; currOverlap = 53; if (k == 1) { /* Multiply by x as a double (or better) */ if (comingFormat == 1) { switch (variablePrecision) { case 3: case 2: /* Multiply the double temporary by x as a double-double (or better) read as a double, produce a double */ c = sollya_snprintf(buffer1,CODESIZE, "%s_t_%d_%dh = %s_t_%d_%dh * %sh;", name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh;", name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 1, variablePrecision, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 1: /* Multiply the double temporary by x as a double, produce a double */ c = sollya_snprintf(buffer1,CODESIZE, "%s_t_%d_%dh = %s_t_%d_%dh * %s;", name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh;", name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: printMessage(1,SOLLYA_MSG_IMPLEMENTPOLY_FREE_VAR_HAS_UNKNOWN_FORMAT,"Warning: the variable %s has an unknown format. This should not occur.\n",((variablename == NULL) ? "_x_" : variablename)); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; } } else { printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; } } else { if (comingFormat == 1) { /* Multiply the double temporary by x^k as a double (or better) */ /* We have to check that if x^k is actually a triple-double that is read as a double that the precision obtained is sufficient regardless of the overlap in the triple-double The obtained precision is roughly the overlap value. If it is not sufficient, we use valueh + valuem instead of valueh. */ if ((powerOverlaps[k-1] < 53) && (mulPrec[i] > (53 + powerOverlaps[k-1]))) { c = sollya_snprintf(buffer1,CODESIZE, "%s_t_%d_%dh = %s_t_%d_%dh * (%s_%s_%d_pow%dh + %s_%s_%d_pow%dm);", name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 2, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { c = sollya_snprintf(buffer1,CODESIZE, "%s_t_%d_%dh = %s_t_%d_%dh * %s_%s_%d_pow%dh;", name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if (gappaAssign != NULL) { if (powerOverlaps[k-1] < 53) op2format = 3; else op2format = 2; sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 1, op2format, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh;", name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; } else { printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; } } } } variableNumber++; comingFormat = producedFormat; /* Issue the multiplication to memory */ c = sollya_snprintf(codeIssue,CODESIZE-issuedCode,"%s\n",buffer1); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedCode) { res = 0; c = CODESIZE-issuedCode; } issuedCode += c; codeIssue += c; c = sollya_snprintf(variablesIssue,CODESIZE-issuedVariables,"%s\n",buffer2); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedVariables) { res = 0; c = CODESIZE-issuedVariables; } issuedVariables += c; variablesIssue += c; /* Generate the addition with the next coefficient in the buffer */ /* addPrec[i] indicates the format to produce coeffFormat = determineCoefficientFormat(coefficients[i]) indicates the format of the coefficient */ if (addPrec[i] > 102) { /* Produce a triple-double or an exact double-double result The result is a double-double if comingFormat is a double and the coefficient is a double */ switch (comingFormat) { case 3: /* Add the coefficient to the triple-double temporary, produce a triple-double */ producedFormat = 3; switch (coeffFormat) { case 3: /* Add the triple-double coefficient to the triple-double temporary, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The overlap of the coefficient is zero because the coefficient is correctly rounded. The precision depends thus only on the overlap of the coming temporary value. If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (addPrec[i] > (97 + currOverlap)) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 52; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Add33(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_coeff_%dh,%s_coeff_%dm,%s_coeff_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i,name,i,name,i, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = currOverlap - 5; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_REL, 97 + oldCurrOverlap, 3, currOverlap, resultName, 3, 3, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Add the double-double coefficient to the triple-double temporary, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The overlap of the coefficient is zero because the coefficient is correctly rounded. The precision depends thus only on the overlap of the coming temporary value. If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (addPrec[i] > (103 + currOverlap)) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 52; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Add233(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_coeff_%dh,%s_coeff_%dm,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i,name,i, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE+t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(45,currOverlap - 5); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_REL, 103 + oldCurrOverlap, 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 1: /* Add the double coefficient to the triple-double temporary, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The overlap of the coefficient is zero because the coefficient is correctly rounded. The precision depends thus only on the overlap of the coming temporary value. If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (addPrec[i] > (104 + currOverlap)) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 52; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Add133(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_coeff_%dh,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(47,currOverlap - 2); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_REL, 104 + oldCurrOverlap, 3, currOverlap, resultName, 1, 1, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: printMessage(1,SOLLYA_MSG_A_COEFF_COULD_NOT_BE_STORED_IN_ANY_KNOWN_FORMAT,"Warning: a coefficient could not be stored in a known format. The implementation may be wrong.\n"); res = 0; } break; case 2: /* Add the coefficient to the double-double temporary, produce a triple-double */ producedFormat = 3; switch (coeffFormat) { case 3: /* Add the triple-double coefficient to the double-double temporary, produce a triple-double */ /* The precision of the following operation is fixed because the temporary is a double-double and the coefficient is correctly rounded. */ c = sollya_snprintf(buffer1,CODESIZE, "Add233Cond(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_coeff_%dh,%s_coeff_%dm,%s_coeff_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], name,i,name,i,name,i); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 45; /* TODO: Verify this value */ if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_REL, 152, 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Add the double-double coefficient to the double-double temporary, produce a triple-double */ /* The precision of the following operation is fixed because the temporary is a double-double and the coefficient is correctly rounded. */ c = sollya_snprintf(buffer1,CODESIZE, "Add23(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_coeff_%dh,%s_coeff_%dm,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i,name,i, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 45; /* TODO: verify this value and precision bound below */ if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_REL, 140, 3, currOverlap, resultName, 2, 2, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 1: /* Add the double coefficient to the double-double temporary, produce a triple-double */ /* The precision of the following operation is fixed because the temporary is a double-double and the coefficient is a double. */ c = sollya_snprintf(buffer1,CODESIZE, "Add123(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_coeff_%dh,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_REL, 159, 3, currOverlap, resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: printMessage(1,SOLLYA_MSG_A_COEFF_COULD_NOT_BE_STORED_IN_ANY_KNOWN_FORMAT,"Warning: a coefficient could not be stored in a known format. The implementation may be wrong.\n"); res = 0; } break; default: /* Add the coefficient to the double temporary, produce a triple-double or a double-double */ switch (coeffFormat) { case 3: /* Add the triple-double coefficient to the double temporary, produce a triple-double */ /* The precision of the following operation is fixed because the temporary is a double-double and the coefficient is correctly rounded. */ producedFormat = 3; c = sollya_snprintf(buffer1,CODESIZE, "Add133Cond(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_coeff_%dh,%s_coeff_%dm,%s_coeff_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,i,name,i,name,i); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 47; /* TODO: Verify this value and the precision bound below */ if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_REL, 140, 3, currOverlap, resultName, 1, 1, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Add the double-double coefficient to the double temporary, produce a triple-double */ producedFormat = 3; /* The precision of the following operation is fixed because the temporary is a double and the coefficient is correctly rounded. */ c = sollya_snprintf(buffer1,CODESIZE, "Add213(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_coeff_%dh,%s_coeff_%dm,%s_t_%d_%dh);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i,name,i, name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 47; /* TODO: Verify this value */ if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_REL, 159, 3, currOverlap, resultName, 2, 2, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 1: /* Add the double coefficient to the double temporary, produce a double-double */ /* The precision of the following operation is fixed because it is exact. */ producedFormat = 2; c = sollya_snprintf(buffer1,CODESIZE, "Add12(%s_t_%d_%dh,%s_t_%d_%dm,%s_coeff_%dh,%s_t_%d_%dh);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i, name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 53; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_EXACT, -1, 2, currOverlap, resultName, 1, 1, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: printMessage(1,SOLLYA_MSG_A_COEFF_COULD_NOT_BE_STORED_IN_ANY_KNOWN_FORMAT,"Warning: a coefficient could not be stored in a known format. The implementation may be wrong.\n"); res = 0; } } } else { if (addPrec[i] > 53) { producedFormat = 2; currOverlap = 53; /* Produce a double-double */ switch (comingFormat) { case 3: printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; break; case 2: /* Add the coefficient to the double-double temporary, produce a double-double */ switch (coeffFormat) { case 3: printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions in coefficient rounding. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; break; case 2: /* Add the double-double coefficient to the double-double temporary, produce a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Add22(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_coeff_%dh,%s_coeff_%dm,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i,name,i, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_REL, 102, 2, currOverlap, resultName, 2, 2, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 1: /* Add the double coefficient to the double-double temporary, produce a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Add122(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_coeff_%dh,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; /* TODO: verify the following precision bound */ if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_REL, 102, 2, currOverlap, resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: printMessage(1,SOLLYA_MSG_A_COEFF_COULD_NOT_BE_STORED_IN_ANY_KNOWN_FORMAT,"Warning: a coefficient could not be stored in a known format. The implementation may be wrong.\n"); res = 0; } break; default: /* Add the coefficient to the double temporary, produce a double-double */ switch (coeffFormat) { case 3: printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions in coefficient rounding. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; break; case 2: /* Add the double-double coefficient to the double temporary, produce a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Add212(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_coeff_%dh,%s_coeff_%dm,%s_t_%d_%dh);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i,name,i, name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; /* TODO: verify the following precision bound */ if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_REL, 102, 2, currOverlap, resultName, 2, 2, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 1: /* Add the double coefficient to the double temporary, produce a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Add12(%s_t_%d_%dh,%s_t_%d_%dm,%s_coeff_%dh,%s_t_%d_%dh);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,i, name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_EXACT, -1, 2, currOverlap, resultName, 1, 1, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: printMessage(1,SOLLYA_MSG_A_COEFF_COULD_NOT_BE_STORED_IN_ANY_KNOWN_FORMAT,"Warning: a coefficient could not be stored in a known format. The implementation may be wrong.\n"); res = 0; } } } else { /* Produce a double */ producedFormat = 1; currOverlap = 53; if (comingFormat == 1) { if (coeffFormat == 1) { /* Add the double coefficient to the double temporary, produce a double */ c = sollya_snprintf(buffer1,CODESIZE, "%s_t_%d_%dh = %s_coeff_%dh + %s_t_%d_%dh;", name,variableNumber,tempVarNum[variableNumber], name,i, name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh;", name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_coeff_%d",name,i); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_ADD_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions in coefficient rounding. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; } } else { printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; } } } variableNumber++; comingFormat = producedFormat; /* Issue the addition to memory */ c = sollya_snprintf(codeIssue,CODESIZE-issuedCode,"%s\n",buffer1); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedCode) { res = 0; c = CODESIZE-issuedCode; } issuedCode += c; codeIssue += c; c = sollya_snprintf(variablesIssue,CODESIZE-issuedVariables,"%s\n",buffer2); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedVariables) { res = 0; c = CODESIZE-issuedVariables; } issuedVariables += c; variablesIssue += c; } /* Special fused or normal case */ } else { k--; if (k > 0) { /* The evaluation ends with the last multiplication by x or a power */ i = 0; if (mulPrec[i] > 102) { /* Produce a triple-double (or a double-double exactly if comingFormat = 1 and x as a double */ if (k == 1) { /* Multiply by pure x as a double, double-double or triple-double */ switch (variablePrecision) { case 3: /* Multiply comingFormat by a triple-double x, produce a triple-double */ producedFormat = 3; switch (comingFormat) { case 3: /* Multiply the triple-double temporary by a triple-double x, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The overlap of x is fixed by hypothesis, so the precision depends only on the overlap of the entering temporary. If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + currOverlap)) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 52; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul33(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%sh,%sm,%sl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(48,currOverlap-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + oldCurrOverlap, 3, currOverlap, resultName, 3, 3, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Multiply the double-double temporary by a triple-double x, produce a triple-double */ /* The precision is fixed because of the operands' formats: - x is supposed to be non-overlapping by hypothesis - the other operand is a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul233(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%sh,%sm,%sl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 48; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 149, 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by a triple-double x, produce a triple-double */ /* The precision is fixed because of the operands' formats: - x is supposed to be non-overlapping by hypothesis - the other operand is a double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul133(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%sh,%sm,%sl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 47; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 149, 3, currOverlap, resultName, 1, 1, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } break; case 2: producedFormat = 3; switch (comingFormat) { case 3: /* Multiply the triple-double temporary by a double-double x, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The overlap of x is fixed by hypothesis, so the precision depends only on the overlap of the entering temporary. If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + currOverlap)) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 52; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul233(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%sh,%sm,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE+t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(48,currOverlap-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + oldCurrOverlap, 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Multiply the double-double temporary by a double-double x, produce a triple-double */ /* The precision is fixed because of the operands' formats: both operands are double-doubles */ c = sollya_snprintf(buffer1,CODESIZE, "Mul23(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%sh,%sm,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 49; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 149, 3, currOverlap, resultName, 2, 2, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by a double-double x, produce a triple-double */ /* The precision is fixed because of the operands' formats: the operands are double and double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul123(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%sh,%sm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 47; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 154, 3, currOverlap, resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } break; case 1: switch (comingFormat) { case 3: /* Multiply the triple-double temporary by a double x, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The overlap of x is fixed by hypothesis, so the precision depends only on the overlap of the entering temporary. If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (100 + currOverlap)) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 52; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } producedFormat = 3; c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul133(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(47,currOverlap-5); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 100 + oldCurrOverlap, 3, currOverlap, resultName, 1, 1, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Multiply the double-double temporary by a double x, produce a triple-double */ /* The precision is fixed because of the operands' formats: the operands are double and double-double */ producedFormat = 3; c = sollya_snprintf(buffer1,CODESIZE, "Mul123(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 47; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 154, 3, currOverlap, resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by a double x, produce a double-double */ /* The precision is fixed because of the operands' formats: both operands are doubles, we produce an exact double-double */ producedFormat = 2; c = sollya_snprintf(buffer1,CODESIZE, "Mul12(&%s_t_%d_%dh,&%s_t_%d_%dm,%s,%s_t_%d_%dh);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 53; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_EXACT, -1, 2, 53, resultName, 1, 1, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } break; default: printMessage(1,SOLLYA_MSG_IMPLEMENTPOLY_FREE_VAR_HAS_UNKNOWN_FORMAT,"Warning: the variable %s has an unknown format. This should not occur.\n",((variablename == NULL) ? "_x_" : variablename)); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; producedFormat = 1; } } else { producedFormat = 3; if (k == 2) { /* Multiply by x^2, which is a double-double if x is a double or a triple-double otherwise */ if (variablePrecision == 1) { /* Multiply comingFormat by a double-double x^2, produce a triple-double */ switch (comingFormat) { case 3: /* Multiply the triple-double temporary by a double-double x^2, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The second operand is x^2 as a double-double, so the precision depends only on the overlap of the entering temporary. If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + currOverlap)) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 52; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul233(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE+t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(48,currOverlap-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + oldCurrOverlap, 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Multiply the double-double temporary by a double-double x^2, produce a triple-double */ /* The precision is fixed because of the operands' formats: both operands are double-doubles */ c = sollya_snprintf(buffer1,CODESIZE, "Mul23(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 49; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 149, 3, currOverlap, resultName, 2, 2, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by a double-double x^2, produce a triple-double */ /* The precision is fixed because of the operands' formats: the operands are a double and a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul123(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_%s_%d_pow2h,%s_%s_%d_pow2m);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = 47; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 154, 3, currOverlap, resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } else { /* Multiply comingFormat by a triple-double x^2, produce a triple-double */ switch (comingFormat) { case 3: /* Multiply the triple-double temporary by a triple-double x^2, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The precision is roughly 97 + min(overlaps) bits. If it is not sufficient, we renormalize first the operands with the higher overlap (lower value), check again and renormalize once again if needed. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + MIN(currOverlap,powerOverlaps[1]))) { /* The precision is not sufficient, we have to renormalize at least one operand */ if (currOverlap < powerOverlaps[1]) { /* We have to renormalize first the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; t = c; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t2 = c2; currOverlap = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* We have to renormalize first x^2 */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,&%s_%s_%d_pow2l,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); powVarNum[1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; powerOverlaps[1] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]-1,2); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } if (mulPrec[i] > (97 + MIN(currOverlap,powerOverlaps[1]))) { /* The precision is still not sufficient, we have to renormalize the other operand */ if (currOverlap <= powerOverlaps[1]) { /* We have to renormalize the temporary */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; t += c; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; currOverlap = 52; t2 += c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* We have to renormalize x^2 */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,&%s_%s_%d_pow2l,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); powVarNum[1]++; if ((c < 0) || (c >= CODESIZE-t)) res = 0; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; t += c; t2 += c2; powerOverlaps[1] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]-1,2); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul33(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(48,MIN(currOverlap,powerOverlaps[1])-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, (97 + MIN(oldCurrOverlap,powerOverlaps[1])), 3, currOverlap, resultName, 3, 3, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Multiply the double-double temporary by a triple-double x^2, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The temporary is a double-double, so the precision only depends on the triple-double x^2 If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + powerOverlaps[1])) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,&%s_%s_%d_pow2l,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); powVarNum[1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; powerOverlaps[1] = 52; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]-1,2); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul233(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; currOverlap = MIN(48,powerOverlaps[1]-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + powerOverlaps[1], 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by a triple-double x^2, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The temporary is a double, so the precision only depends on the triple-double x^2 If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (100 + powerOverlaps[1])) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow2h,&%s_%s_%d_pow2m,&%s_%s_%d_pow2l,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]+1, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); powVarNum[1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; powerOverlaps[1] = 52; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],2); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]-1,2); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul133(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_%s_%d_pow2h,%s_%s_%d_pow2m,%s_%s_%d_pow2l);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1],name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; currOverlap = MIN(48,powerOverlaps[1]-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow2",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + powerOverlaps[1], 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } else { /* Multiply by x^k, which is in any case a triple-double, produce a triple-double */ switch (comingFormat) { case 3: /* Multiply the triple-double temporary by a triple-double x^k, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The precision is roughly 97 + min(overlaps) bits. If it is not sufficient, we renormalize first the operands with the higher overlap (lower value), check again and renormalize once again if needed. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + MIN(currOverlap,powerOverlaps[k-1]))) { /* The precision is not sufficient, we have to renormalize at least one operand */ if (currOverlap < powerOverlaps[k-1]) { /* We have to renormalize first the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; tempVarNum[variableNumber-1]++; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; currOverlap = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* We have to renormalize first x^k */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; powerOverlaps[k-1] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } if (mulPrec[i] > (97 + MIN(currOverlap,powerOverlaps[k-1]))) { /* The precision is still not sufficient, we have to renormalize the other operand */ if (currOverlap <= powerOverlaps[k-1]) { /* We have to renormalize the temporary */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE-t)) res = 0; tempVarNum[variableNumber-1]++; t += c; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; t2 += c2; currOverlap = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { /* We have to renormalize x^k */ c = sollya_snprintf(buffer1+t,CODESIZE-t, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE-t)) res = 0; c2 = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE-t2)) res = 0; t += c; t2 += c2; powerOverlaps[k-1] = 52; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul33(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; oldCurrOverlap = currOverlap; currOverlap = MIN(48,MIN(currOverlap,powerOverlaps[k-1])-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + MIN(oldCurrOverlap,powerOverlaps[k-1]), 3, currOverlap, resultName, 3, 3, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 2: /* Multiply the double-double temporary by a triple-double x^k, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The temporary is a double-double, so the precision only depends on the triple-double x^k If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (97 + powerOverlaps[k-1])) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; powerOverlaps[k-1] = 52; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul233(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; currOverlap = MIN(48,powerOverlaps[k-1]-4); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 97 + powerOverlaps[k-1], 3, currOverlap, resultName, 2, 2, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by a triple-double x^k, produce a triple-double */ /* We have to check the precision of the operation which depends on the overlap of the entering triple-double operands. The temporary is a double-double, so the precision only depends on the triple-double x^k If the precision is not sufficient, we renormalize. */ t = 0; t2 = 0; if (mulPrec[i] > (100 + powerOverlaps[k-1])) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; powerOverlaps[k-1] = 52; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul133(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; currOverlap = MIN(47,powerOverlaps[k-1]-5); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 100 + powerOverlaps[k-1], 3, currOverlap, resultName, 1, 1, operand1Name, 3, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } } else { if (mulPrec[i] > 53) { /* Produce a double-double */ producedFormat = 2; currOverlap = 53; if (k == 1) { /* Multiply comingFormat by x as a double or double-double (or better), produce a double-double */ switch (variablePrecision) { case 3: case 2: /* Multiply comingFormat by x as a double-double (or better), produce a double-double */ switch (comingFormat) { case 3: printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; break; case 2: /* Multiply the double-double temporary by x as double-double (or better), produce a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul22(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_t_%d_%dh,%s_t_%d_%dm,%sh,%sm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 2, 2, operand1Name, 2, variablePrecision, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by x as a double-double (or better), produce a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul122(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_t_%d_%dh,%sh,%sm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 1, 1, operand1Name, 2, variablePrecision, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } break; case 1: /* Multiply comingFormat by x as a double, produce a double-double */ switch (comingFormat) { case 3: printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; break; case 2: /* Multiply the double-double temporary by x as double, produce a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul122(&%s_t_%d_%dh,&%s_t_%d_%dm,%s,%s_t_%d_%dh,%s_t_%d_%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 1, 1, operand1Name, 2, 2, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by x as a double, produce a double-double */ c = sollya_snprintf(buffer1,CODESIZE, "Mul12(&%s_t_%d_%dh,&%s_t_%d_%dm,%s,%s_t_%d_%dh);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], ((variablename == NULL) ? "_x_" : variablename), name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); sollya_snprintf(operand2Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_EXACT, -1, 2, 53, resultName, 1, 1, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } break; default: printMessage(1,SOLLYA_MSG_IMPLEMENTPOLY_FREE_VAR_HAS_UNKNOWN_FORMAT,"Warning: the variable %s has an unknown format. This should not occur.\n",((variablename == NULL) ? "_x_" : variablename)); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; } } else { /* Multiply comingFormat by x^k which should be at least a double-double in any case */ switch (comingFormat) { case 3: printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; break; case 2: /* Multiply the double-double temporary by x^k as double-double, produce a double-double */ /* We have to check that if x^k is actually a triple-double that is read as a double-double that the precision obtained is sufficient regardless of the overlap in the triple-double The obtained precision is roughly 53 + overlap value. If it is not sufficient, we renormalize the whole triple-double value. */ t = 0; t2 = 0; if ((powerOverlaps[k-1] < 53) && (mulPrec[i] > (53 + powerOverlaps[k-1]))) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; powerOverlaps[k-1] = 52; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul22(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_t_%d_%dh,%s_t_%d_%dm,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; if (gappaAssign != NULL) { if (powerOverlaps[k-1] < 53) op2format = 3; else op2format = 2; sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 2, 2, operand1Name, 2, op2format, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: /* Multiply the double temporary by x^k as a double-double, produce a double-double */ /* We have to check that if x^k is actually a triple-double that is read as a double-double that the precision obtained is sufficient regardless of the overlap in the triple-double The obtained precision is roughly 53 + overlap value. If it is not sufficient, we renormalize the whole triple-double value. */ t = 0; t2 = 0; if ((powerOverlaps[k-1] < 53) && (mulPrec[i] > (53 + powerOverlaps[k-1]))) { /* We must renormalize the power */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_%s_%d_pow%dh,&%s_%s_%d_pow%dm,&%s_%s_%d_pow%dl,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm,%s_%s_%d_pow%dl);\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]+1,k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); powVarNum[k-1]++; if ((c < 0) || (c >= CODESIZE)) res = 0; powerOverlaps[k-1] = 52; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_%s_%d_pow%dh, %s_%s_%d_pow%dm, %s_%s_%d_pow%dl;\n", name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1]-1,k); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, powerOverlaps[k-1], resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } c = sollya_snprintf(buffer1+t,CODESIZE-t, "Mul122(&%s_t_%d_%dh,&%s_t_%d_%dm,%s_t_%d_%dh,%s_%s_%d_pow%dh,%s_%s_%d_pow%dm);", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k,name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if ((c < 0) || (c >= CODESIZE-t)) res = 0; c = sollya_snprintf(buffer2+t2,CODESIZE-t2, "double %s_t_%d_%dh, %s_t_%d_%dm;", name,variableNumber,tempVarNum[variableNumber],name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE-t2)) res = 0; if (gappaAssign != NULL) { if (powerOverlaps[k-1] < 53) op2format = 3; else op2format = 2; sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_MUL_REL, 102, 2, 53, resultName, 1, 1, operand1Name, 2, op2format, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } else { /* Produce a double */ producedFormat = 1; currOverlap = 53; if (k == 1) { /* Multiply by x as a double (or better) */ if (comingFormat == 1) { switch (variablePrecision) { case 3: case 2: /* Multiply the double temporary by x as a double-double (or better) read as a double, produce a double */ c = sollya_snprintf(buffer1,CODESIZE, "%s_t_%d_%dh = %s_t_%d_%dh * %sh;", name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh;", name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 1, variablePrecision, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; case 1: /* Multiply the double temporary by x as a double, produce a double */ c = sollya_snprintf(buffer1,CODESIZE, "%s_t_%d_%dh = %s_t_%d_%dh * %s;", name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], ((variablename == NULL) ? "_x_" : variablename)); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh;", name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand2Name,CODESIZE,"%s",((variablename == NULL) ? "_x_" : variablename)); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 1, 1, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: printMessage(1,SOLLYA_MSG_IMPLEMENTPOLY_FREE_VAR_HAS_UNKNOWN_FORMAT,"Warning: the variable %s has an unknown format. This should not occur.\n",((variablename == NULL) ? "_x_" : variablename)); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; } } else { printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; } } else { if (comingFormat == 1) { /* Multiply the double temporary by x^k as a double (or better) */ /* We have to check that if x^k is actually a triple-double that is read as a double that the precision obtained is sufficient regardless of the overlap in the triple-double The obtained precision is roughly the overlap value. If it is not sufficient, we use valueh + valuem instead of valueh. */ if ((powerOverlaps[k-1] < 53) && (mulPrec[i] > (53 + powerOverlaps[k-1]))) { c = sollya_snprintf(buffer1,CODESIZE, "%s_t_%d_%dh = %s_t_%d_%dh * (%s_%s_%d_pow%dh + %s_%s_%d_pow%dm);", name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k, name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 2, 3, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { c = sollya_snprintf(buffer1,CODESIZE, "%s_t_%d_%dh = %s_t_%d_%dh * %s_%s_%d_pow%dh;", name,variableNumber,tempVarNum[variableNumber], name,variableNumber-1,tempVarNum[variableNumber-1], name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); if (gappaAssign != NULL) { if (powerOverlaps[k-1] < 53) op2format = 3; else op2format = 2; sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber,tempVarNum[variableNumber]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand2Name,CODESIZE,"%s_%s_%d_pow%d",name,((variablename == NULL) ? "_x_" : variablename),powVarNum[k-1],k); newAssign = newGappaOperation(GAPPA_MUL_DOUBLE, 53, 1, -1, resultName, 1, 1, operand1Name, 1, op2format, operand2Name); *gappaAssign = addElement(*gappaAssign,newAssign); } } if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh;", name,variableNumber,tempVarNum[variableNumber]); if ((c < 0) || (c >= CODESIZE)) res = 0; } else { printMessage(1,SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT,"Warning: error in the management of precisions. This should not occur.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); res = 0; } } } } variableNumber++; comingFormat = producedFormat; /* Issue the buffers to memory */ c = sollya_snprintf(codeIssue,CODESIZE-issuedCode,"%s\n",buffer1); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedCode) { res = 0; c = CODESIZE-issuedCode; } issuedCode += c; codeIssue += c; c = sollya_snprintf(variablesIssue,CODESIZE-issuedVariables,"%s\n",buffer2); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedVariables) { res = 0; c = CODESIZE-issuedVariables; } issuedVariables += c; variablesIssue += c; /* The evaluation is now complete, issue code for copying to the result variables */ if (comingFormat != resultType) { if (comingFormat == 3) { if (currOverlap < 52) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; tempVarNum[variableNumber-1]++; currOverlap = 52; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } switch (resultType) { case 3: /* If we are not renormalized, we renormalize, otherwise we copy */ if (currOverlap < 52) { c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(%s_resh,%s_resm,%s_resl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,name,name, name,variableNumber-1,tempVarNum[variableNumber-1], name,variableNumber-1,tempVarNum[variableNumber-1], name,variableNumber-1,tempVarNum[variableNumber-1]); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_res",name); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, 52, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { c = sollya_snprintf(buffer1,CODESIZE, "*%s_resh = %s_t_%d_%dh; *%s_resm = %s_t_%d_%dm; *%s_resl = %s_t_%d_%dl;", name,name,variableNumber-1,tempVarNum[variableNumber-1], name,name,variableNumber-1,tempVarNum[variableNumber-1], name,name,variableNumber-1,tempVarNum[variableNumber-1]); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_res",name); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_COPY, -1, 3, -1, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE," "); if ((c < 0) || (c >= CODESIZE)) res = 0; break; case 2: c = sollya_snprintf(buffer1,CODESIZE, "*%s_resh = %s_t_%d_%dh; *%s_resm = %s_t_%d_%dm;", name,name,variableNumber-1,tempVarNum[variableNumber-1], name,name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE," "); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_res",name); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_COPY, -1, 2, -1, resultName, 2, 2, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: c = sollya_snprintf(buffer1,CODESIZE, "*%s_resh = %s_t_%d_%dh;", name,name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE," "); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_res",name); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_COPY, -1, 1, -1, resultName, 1, 1, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } i = -1; } else { /* The evaluation is already complete, issue code for copying to the result variables */ if (comingFormat != resultType) { if (comingFormat == 3) { if (currOverlap < 52) { /* We must renormalize the temporary */ c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(&%s_t_%d_%dh,&%s_t_%d_%dm,&%s_t_%d_%dl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);\n", name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1,name,variableNumber-1,tempVarNum[variableNumber-1]+1, name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; tempVarNum[variableNumber-1]++; currOverlap = 52; c2 = sollya_snprintf(buffer2,CODESIZE, "double %s_t_%d_%dh, %s_t_%d_%dm, %s_t_%d_%dl;\n", name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1],name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c2 < 0) || (c2 >= CODESIZE)) res = 0; t = c; t2 = c2; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]-1); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, currOverlap, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } } switch (resultType) { case 3: /* If we are not renormalized, we renormalize, otherwise we copy */ if (currOverlap < 52) { c = sollya_snprintf(buffer1,CODESIZE, "Renormalize3(%s_resh,%s_resm,%s_resl,%s_t_%d_%dh,%s_t_%d_%dm,%s_t_%d_%dl);", name,name,name, name,variableNumber-1,tempVarNum[variableNumber-1], name,variableNumber-1,tempVarNum[variableNumber-1], name,variableNumber-1,tempVarNum[variableNumber-1]); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_res",name); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_RENORMALIZE, -1, 3, 52, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } else { c = sollya_snprintf(buffer1,CODESIZE, "*%s_resh = %s_t_%d_%dh; *%s_resm = %s_t_%d_%dm; *%s_resl = %s_t_%d_%dl;", name,name,variableNumber-1,tempVarNum[variableNumber-1], name,name,variableNumber-1,tempVarNum[variableNumber-1], name,name,variableNumber-1,tempVarNum[variableNumber-1]); if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_res",name); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_COPY, -1, 3, -1, resultName, 3, 3, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE," "); if ((c < 0) || (c >= CODESIZE)) res = 0; break; case 2: c = sollya_snprintf(buffer1,CODESIZE, "*%s_resh = %s_t_%d_%dh; *%s_resm = %s_t_%d_%dm;", name,name,variableNumber-1,tempVarNum[variableNumber-1], name,name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE," "); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_res",name); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_COPY, -1, 2, -1, resultName, 2, 2, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } break; default: c = sollya_snprintf(buffer1,CODESIZE, "*%s_resh = %s_t_%d_%dh;", name,name,variableNumber-1,tempVarNum[variableNumber-1]); if ((c < 0) || (c >= CODESIZE)) res = 0; c = sollya_snprintf(buffer2,CODESIZE," "); if ((c < 0) || (c >= CODESIZE)) res = 0; if (gappaAssign != NULL) { sollya_snprintf(resultName,CODESIZE,"%s_res",name); sollya_snprintf(operand1Name,CODESIZE,"%s_t_%d_%d",name,variableNumber-1,tempVarNum[variableNumber-1]); newAssign = newGappaOperation(GAPPA_COPY, -1, 1, -1, resultName, 1, 1, operand1Name, 0, 0, NULL); *gappaAssign = addElement(*gappaAssign,newAssign); } } } /* Issue the buffers to memory */ c = sollya_snprintf(codeIssue,CODESIZE-issuedCode,"%s\n",buffer1); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedCode) { res = 0; c = CODESIZE-issuedCode; } issuedCode += c; codeIssue += c; c = sollya_snprintf(variablesIssue,CODESIZE-issuedVariables,"%s\n",buffer2); if (c < 0) { res = 0; c = 0; } if (c >= CODESIZE-issuedVariables) { res = 0; c = CODESIZE-issuedVariables; } issuedVariables += c; variablesIssue += c; } /* End else to if normal or last step */ } /* End loop on degrees */ /* Issue the variable definitions and the code to the file */ if (sollyaFprintf(fd,"%s\n\n%s\n\n",variables,code) < 0) res = 0; safeFree(code); safeFree(variables); safeFree(buffer1); safeFree(buffer2); safeFree(tempVarNum); if (gappaAssign != NULL) { safeFree(resultName); safeFree(operand1Name); safeFree(operand2Name); safeFree(operand3Name); } return res; } int accurToVarType(mpfr_t accur) { mpfr_t temp; int res; mpfr_init2(temp,mpfr_get_prec(accur)); mpfr_set_d(temp,1.0,GMP_RNDN); mpfr_div_2ui(temp,temp,52,GMP_RNDN); res = 1; if (mpfr_less_p(accur,temp)) res++; mpfr_div_2ui(temp,temp,50,GMP_RNDN); if (mpfr_less_p(accur,temp)) res++; mpfr_clear(temp); return res; } node *implementpoly(node *func, rangetype range, mpfr_t *accur, int variablePrecision, FILE *fd, char *name, int honorCoeffPrec, mp_prec_t prec, FILE *gappaFD) { mpfr_t temp, tempValue; node *simplifiedFunc, *implementedPoly; int degree, i; node **coefficients; node *tempTree; mpfr_t *fpCoefficients; int *addPrec, *mulPrec, *powPrec, *overlapsPowers, *powVarNum; int *fpCoeffRoundAutomatically; int targetPrec; gappaProof *proof; chain *assignments, *tempChain; chain **assignmentsPtr; char resultnamebuf[80]; int resultType; proof = NULL; if (prec < 159) { printMessage(1,SOLLYA_MSG_CURRENT_PREC_INSUFFICIENT_FOR_TD_CODE,"Warning: the current tool's precision (%d bits) is not sufficient for implementing triple-double code.\n",prec); printMessage(1,SOLLYA_MSG_CONTINUATION,"Will temporarily increase the precision to 159 bits.\n"); prec = 159; } if (!isPolynomial(func)) { printMessage(1,SOLLYA_MSG_GIVEN_FUNCTION_IS_NO_POLYNOMIAL,"Warning: the function given is not a polynomial.\n"); return NULL; } mpfr_init2(temp,prec); mpfr_set_d(temp,1.0,GMP_RNDN); if (mpfr_greaterequal_p(*accur,temp)) { printMessage(1,SOLLYA_MSG_TARGET_ACCURACY_GREATER_OR_EQUAL_THAN_ONE,"Warning: the target accuracy is greater or equal to 1 = 2^0.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Implementation of a such a function makes no sense.\n"); mpfr_clear(temp); return NULL; } mpfr_div_2ui(temp,temp,140,GMP_RNDN); if (mpfr_less_p(*accur,temp)) { printMessage(1,SOLLYA_MSG_TARGET_ACCURACY_LESS_THAN_140_BITS,"Warning: the target accuracy is less than 2^(-140).\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Implementation is currently restrained to maximally triple-double precision.\n"); mpfr_clear(temp); return NULL; } mpfr_div_2ui(*accur,*accur,1,GMP_RNDN); if (accurToVarType(*accur) < variablePrecision) { printMessage(1,SOLLYA_MSG_INFERED_OUTPUT_PREC_LESS_THAN_VARIABLE_PREC,"Warning: the inferred output expansion type is less from the given variable type.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Implementation cannot handle this case.\n"); mpfr_clear(temp); return NULL; } simplifiedFunc = simplifyTreeErrorfree(func); if (gappaFD != NULL) { proof = (gappaProof *) safeCalloc(1,sizeof(gappaProof)); proof->variableName = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+1,sizeof(char)); strcpy(proof->variableName,((variablename == NULL) ? "_x_" : variablename)); sprintf(resultnamebuf,"%s_res",name); proof->resultName = (char *) safeCalloc(strlen(resultnamebuf)+1,sizeof(char)); strcpy(proof->resultName,resultnamebuf); proof->variableType = variablePrecision; proof->polynomToImplement = copyTree(simplifiedFunc); mpfr_init2(proof->a,mpfr_get_prec(*(range.a))); mpfr_init2(proof->b,mpfr_get_prec(*(range.b))); mpfr_set(proof->a,*(range.a),GMP_RNDD); mpfr_set(proof->b,*(range.b),GMP_RNDU); mpfr_init2(proof->eps, mpfr_get_prec(*accur)); mpfr_set(proof->eps, *accur, GMP_RNDN); assignments = NULL; assignmentsPtr = &assignments; } else { assignmentsPtr = NULL; } getCoefficients(°ree,&coefficients,simplifiedFunc); if (degree < 0) { sollyaFprintf(stderr,"Error: implementpoly: an error occurred. Could not extract the coefficients of the given polynomial.\n"); exit(1); } fpCoefficients = (mpfr_t *) safeCalloc(degree+1,sizeof(mpfr_t)); fpCoeffRoundAutomatically = (int *) safeCalloc(degree+1,sizeof(int)); mpfr_init2(tempValue,prec); mpfr_set_d(tempValue,1.0,GMP_RNDN); for (i=0;i<=degree;i++) { mpfr_init2(fpCoefficients[i],prec); fpCoeffRoundAutomatically[i] = 0; if (coefficients[i] != NULL) { tempTree = simplifyTreeErrorfree(coefficients[i]); free_memory(coefficients[i]); if (!isConstant(tempTree)) { sollyaFprintf(stderr,"Error: implementpoly: an error occurred. A polynomial coefficient is not constant.\n"); exit(1); } if (accessThruMemRef(tempTree)->nodeType != CONSTANT) { printMessage(1,SOLLYA_MSG_COEFF_DOES_NOT_HOLD_ON_TD_USING_FAITHFUL_EVAL,"Warning: the %dth coefficient of the polynomial to implement is neither a floating point\n",i); printMessage(1,SOLLYA_MSG_CONTINUATION,"constant nor is able to be evaluated without rounding to a floating point constant.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Will evaluate it in round-to-nearest with the current precision (%d bits) before rounding to\n",prec); printMessage(1,SOLLYA_MSG_CONTINUATION,"the target precision. A double rounding issue may occur.\n"); evaluateFaithful(fpCoefficients[i], tempTree, tempValue, prec); fpCoeffRoundAutomatically[i] = 1; } else { if (mpfr_set(fpCoefficients[i],*(accessThruMemRef(tempTree)->value),GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_INTERNAL_HANDLING_OF_A_COEFFICIENT,"Warning: rounding occurred on internal handling of a coefficient of the given polynomial.\n"); } fpCoeffRoundAutomatically[i] = 1; } } free_memory(tempTree); } else { mpfr_set_d(fpCoefficients[i],0.0,GMP_RNDN); } } safeFree(coefficients); mpfr_clear(tempValue); if (honorCoeffPrec) { for (i=0;i<=degree;i++) { if (mpfr_round_to_tripledouble(temp, fpCoefficients[i]) != 0) { if (!noRoundingWarnings) { printMessage(2,SOLLYA_MSG_COEFF_DOES_NOT_HOLD_ON_TD_USING_FAITHFUL_EVAL,"Information: the %dth coefficient of the polynomial given cannot even be stored without rounding on a\n",i); printMessage(2,SOLLYA_MSG_CONTINUATION,"triple-double floating point variable. Automatic rounding will be used for maximally triple-double precision.\n"); } fpCoeffRoundAutomatically[i] = 1; } } } else { for (i=0;i<=degree;i++) { fpCoeffRoundAutomatically[i] = 1; } } addPrec = (int *) safeCalloc(degree+1,sizeof(int)); mulPrec = (int *) safeCalloc(degree+1,sizeof(int)); if (!determinePrecisions(fpCoefficients, fpCoeffRoundAutomatically, degree, addPrec, mulPrec, *accur, range, prec)) { printMessage(1,SOLLYA_MSG_ERROR_ON_DETERMINING_THE_REQUIRED_PRECISIONS,"Warning: a problem has been encountered during the determination of the precisions needed.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The produced implementation may be incorrect.\n"); } implementedPoly = makePolynomial(fpCoefficients,degree); printMessage(2,SOLLYA_MSG_THE_POLY_THAT_GETS_IMPLEMENTED_IS,"Information: the polynomial that will be implemented is:\n%b\n",implementedPoly); powPrec = (int *) safeCalloc(degree,sizeof(int)); overlapsPowers = (int *) safeCalloc(degree+1,sizeof(int)); powVarNum = (int *) safeCalloc(degree+1,sizeof(int)); if (!determinePowers(fpCoefficients, degree, mulPrec, powPrec)) { printMessage(1,SOLLYA_MSG_ERROR_ON_DETERMINING_THE_REQUIRED_POWERS,"Warning: a problem has been encountered during the determination of the powers needed.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The produced implementation may be incorrect.\n"); } emitLegalNoticeAndDisclaimer(fd); if (!implementCoefficients(fpCoefficients, degree, fd, name, prec, assignmentsPtr)) { printMessage(1,SOLLYA_MSG_ERROR_ON_CODE_GENERATION_FOR_COEFFICIENTS,"Warning: a problem has been encountered during the generation of the code for the coefficients.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The produced implementation may be incorrect.\n"); } sollyaFprintf(fd,"void %s(",name); mpfr_log2(temp,*accur,GMP_RNDD); targetPrec = -mpfr_get_si(temp,GMP_RNDN); if (targetPrec >= 102) { if (sollyaFprintf(fd,"double *%s_resh, double *%s_resm, double *%s_resl, ",name,name,name) < 0) printMessage(1,SOLLYA_MSG_COULD_NOT_WRITE_TO_THE_IMPLEMENTATION_FILE,"Warning: could not write to the file for the implementation.\n"); if (gappaFD != NULL) proof->resultType = 3; resultType = 3; } else { if (targetPrec >= 54) { if (sollyaFprintf(fd,"double *%s_resh, double *%s_resm, ",name,name) < 0) printMessage(1,SOLLYA_MSG_COULD_NOT_WRITE_TO_THE_IMPLEMENTATION_FILE,"Warning: could not write to the file for the implementation.\n"); if (gappaFD != NULL) proof->resultType = 2; resultType = 2; } else { if (sollyaFprintf(fd,"double *%s_resh, ",name) < 0) printMessage(1,SOLLYA_MSG_COULD_NOT_WRITE_TO_THE_IMPLEMENTATION_FILE,"Warning: could not write to the file for the implementation.\n"); if (gappaFD != NULL) proof->resultType = 1; resultType = 1; } } switch (variablePrecision) { case 3: if (sollyaFprintf(fd,"double %sh, double %sm, double %sl) {\n",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)) < 0) printMessage(1,SOLLYA_MSG_COULD_NOT_WRITE_TO_THE_IMPLEMENTATION_FILE,"Warning: could not write to the file for the implementation.\n"); break; case 2: if (sollyaFprintf(fd,"double %sh, double %sm) {\n",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)) < 0) printMessage(1,SOLLYA_MSG_COULD_NOT_WRITE_TO_THE_IMPLEMENTATION_FILE,"Warning: could not write to the file for the implementation.\n"); break; case 1: if (sollyaFprintf(fd,"double %s) {\n",((variablename == NULL) ? "_x_" : variablename)) < 0) printMessage(1,SOLLYA_MSG_COULD_NOT_WRITE_TO_THE_IMPLEMENTATION_FILE,"Warning: could not write to the file for the implementation.\n"); break; default: printMessage(1,SOLLYA_MSG_IMPLEMENTPOLY_FREE_VAR_HAS_UNKNOWN_FORMAT,"Warning: the variable %s has an unknown format. This should not occur.\n",((variablename == NULL) ? "_x_" : variablename)); printMessage(1,SOLLYA_MSG_CONTINUATION,"The implementation will be wrong.\n"); } if (!implementPowers(powPrec, degree, variablePrecision, fd, name, overlapsPowers, powVarNum, assignmentsPtr)) { printMessage(1,SOLLYA_MSG_ERROR_ON_CODE_GENERATION_FOR_POWERS_OF_FREE_VAR,"Warning: a problem has been encountered during the generation of the code for the powers of %s.\n", ((variablename == NULL) ? "_x_" : variablename)); printMessage(1,SOLLYA_MSG_CONTINUATION,"The produced implementation may be incorrect.\n"); } if (!implementHorner(fpCoefficients, addPrec, mulPrec, degree, variablePrecision, fd, name, overlapsPowers, powVarNum, assignmentsPtr, resultType)) { printMessage(1,SOLLYA_MSG_ERROR_ON_CODE_GENERATION_FOR_HORNER_SCHEME,"Warning: a problem has been encountered during the generation of the code for the horner scheme.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The produced implementation may be incorrect.\n"); } if (sollyaFprintf(fd,"}\n") < 0) printMessage(1,SOLLYA_MSG_COULD_NOT_WRITE_TO_THE_IMPLEMENTATION_FILE,"Warning: could not write to the file for the implementation.\n"); if (gappaFD != NULL) { proof->polynomImplemented = copyTree(implementedPoly); proof->assignmentsNumber = lengthChain(assignments); proof->assignments = (gappaAssignment **) safeCalloc(proof->assignmentsNumber,sizeof(gappaAssignment *)); i = proof->assignmentsNumber - 1; while (assignments != NULL) { proof->assignments[i] = ((gappaAssignment *) (assignments->value)); i--; tempChain = assignments->next; safeFree(assignments); assignments = tempChain; } fprintGappaProof(gappaFD, proof); freeGappaProof(proof); } for (i=0;i<=degree;i++) mpfr_clear(fpCoefficients[i]); safeFree(fpCoefficients); safeFree(fpCoeffRoundAutomatically); safeFree(addPrec); safeFree(mulPrec); safeFree(powPrec); safeFree(overlapsPowers); safeFree(powVarNum); free_memory(simplifiedFunc); mpfr_clear(temp); return implementedPoly; } sollya-6.0+ds/implement.h000066400000000000000000000052631300174114700154330ustar00rootroot00000000000000/* Copyright 2006-2013 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef IMPLEMENT_H #define IMPLEMENT_H #include #include #include "expression.h" #include "general.h" #define CODESIZE 4000000 node *implementpoly(node *func, rangetype range, mpfr_t *accur, int variablePrecision, FILE *fd, char *name, int honorCoeffPrec, mp_prec_t prec, FILE *gappaFD); void emitLegalNoticeAndDisclaimer(FILE *fd); #endif /* ifdef IMPLEMENT_H*/ sollya-6.0+ds/implementconst.c000066400000000000000000001406201300174114700164720ustar00rootroot00000000000000/* Copyright 2010-2015 by LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France, and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors S. Chevillard, Ch. Lauter sylvain.chevillard@ens-lyon.org christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include #include "expression.h" #include "infnorm.h" #include "general.h" #include "implement.h" #define BUFFERSIZE 64 /* A program is given by a list of instructions, the index number of the first unused temporary variable in the program, the number of temporary variables used by the program and a list giving, for each temporary variable, the maximum of the precision that it takes. */ struct implementCsteProgram { chain *instructions; int counter; int maxcounter; chain *precisions; }; typedef struct implementCsteCouple { int var; long int prec; } couple; couple *makeCouple(int var, long int prec) { couple *res = safeMalloc(sizeof(couple)); res->var=var; res->prec=prec; return res; } void *copyCouple(void *c) { couple *ptr, *newCouple; ptr = (couple *)c; newCouple = safeMalloc(sizeof(couple)); newCouple->var = ptr->var; newCouple->prec = ptr->prec; return (void *)ptr; } /* This functions looks for the variable var in program. If it is absent, it adds the couple (var, prec) to program->precisions. If there already is an occurence (var, prec2) in program->precisions, it compares prec and prec2 and keeps the largest. */ void appendPrecisionProg(int var, long int prec, struct implementCsteProgram *program) { chain *curr; int test = 0; curr = program->precisions; while ( (curr != NULL) && (!test) ) { if ( ((couple *)(curr->value))->var == var) { test = 1; if (prec > ((couple *)(curr->value))->prec) ((couple *)(curr->value))->prec = prec; } else curr = curr->next; } if (!test) program->precisions = addElement(program->precisions, makeCouple(var, prec)); return; } void incrementProgramCounter(struct implementCsteProgram *program) { program->counter++; if (program->counter >= program->maxcounter) program->maxcounter = program->counter; return; } /* Possible instructions: - mpfr_init2(var1, prec) - mpfr_set_prec(var1, prec) - 0ary function: name(var1, MPFR_RNDN) - unary function: name(var1, var2, MPFR_RNDN) - binary function: name(var1, var2, var3, MPFR_RNDN) - mpfr_set_ui(var1, valui, MPFR_RNDN) - mpfr_set_si(var1, valsi, MPFR_RNDN) - mpfr_set_str(var1, valstr, 2, MPFR_RNDN) - mpfr_ui_pow_ui(var1, valui, valui2, MPFR_RNDN); - mpfr_pow_ui(var1, var2, valui, MPFR_RNDN); - mpfr_root(var1, var2, valui, MPFR_RNDN); - valstr(var1, prec); for a library constant - if(valstr) {prog1} else {prog2} */ #define INIT2 0 #define SETPREC 1 #define CONSTANTFUNC 2 #define UNARYFUNC 3 #define BINARYFUNC 4 #define SETUI 5 #define SETSI 6 #define SETSTR 7 #define UIPOWUI 8 #define POWUI 9 #define ROOT 10 #define LIBRARYCONST 11 #define IFTHENELSE 12 /* Good practice: an instruction should always be created with a function appendSomeInstructionProg. Moreover strval, prog1.instructions, prog1.precisions, prog2.instructions and prog2.precisions must be initialized with NULL: hence this value can be tested when freeing memory, in order to know if the char * has been malloced or not. This implies modifying all the append*Prog, when a new kind of instruction is added with such a malloced parameter. WARNING: in the implementation of if-then-else, the main program and the branch programs share the same precisions list. In order to avoid double freeing, one must explicitely set the precisions list of prog1 and prog2 to NULL after the construction of the if-then-else statement. */ struct implementCsteInstruction { int type; char var1[BUFFERSIZE]; char var2[BUFFERSIZE]; char var3[BUFFERSIZE]; char name[BUFFERSIZE]; long int prec; unsigned long int uival; unsigned long int uival2; long sival; char *strval; struct implementCsteProgram prog1; struct implementCsteProgram prog2; }; void free_implementCsteInstruction(void *instr) { struct implementCsteInstruction *ptr; ptr = (struct implementCsteInstruction *)instr; if (ptr->strval != NULL ) safeFree(ptr->strval); freeChain(ptr->prog1.instructions, free_implementCsteInstruction); freeChain(ptr->prog1.precisions, safeFree); freeChain(ptr->prog2.instructions, free_implementCsteInstruction); freeChain(ptr->prog2.precisions, safeFree); safeFree(ptr); return; } void *copy_implementCsteInstructions(void *instr) { struct implementCsteInstruction *ptr, *newInstr; ptr = (struct implementCsteInstruction *)instr; newInstr = safeMalloc(sizeof(struct implementCsteInstruction)); newInstr->type = ptr->type; strcpy(newInstr->var1, ptr->var1); strcpy(newInstr->var2, ptr->var2); strcpy(newInstr->var3, ptr->var3); strcpy(newInstr->name, ptr->name); newInstr->prec = ptr->prec; newInstr->uival = ptr->uival; newInstr->uival2 = ptr->uival2; newInstr->sival = ptr->sival; if(ptr->strval != NULL) { newInstr->strval = safeCalloc(1+strlen(ptr->strval) , sizeof(char)); strcpy(newInstr->strval, ptr->strval); } else newInstr->strval = NULL; newInstr->prog1.instructions = copyChainWithoutReversal(ptr->prog1.instructions, copy_implementCsteInstructions); newInstr->prog1.counter = ptr->prog1.counter; newInstr->prog1.maxcounter = ptr->prog1.maxcounter; newInstr->prog1.precisions = copyChainWithoutReversal(ptr->prog1.precisions, copyCouple); newInstr->prog2.instructions = copyChainWithoutReversal(ptr->prog2.instructions, copy_implementCsteInstructions); newInstr->prog2.counter = ptr->prog2.counter; newInstr->prog2.maxcounter = ptr->prog2.maxcounter; newInstr->prog2.precisions = copyChainWithoutReversal(ptr->prog2.precisions, copyCouple); return (void *)newInstr; } void fprintInstruction(FILE *output, struct implementCsteInstruction instr, int indentlevel) { const char init_string[]="mpfr_init2"; const char setprec_string[]="mpfr_set_prec"; const char *ptr; chain * curr; char *indent; int i; indent = safeCalloc(indentlevel*2+1, sizeof(char)); for(i=0;i 0) sollyaFprintf(output, "%s%s (%s, prec+%d);\n", indent, ptr, instr.var1, instr.prec); else if (instr.prec == 0) sollyaFprintf(output, "%s%s (%s, prec);\n", indent, ptr, instr.var1); else { sollyaFprintf(output, "%sif (prec >= %d+MPFR_PREC_MIN)\n", indent, -instr.prec); sollyaFprintf(output, "%s{\n", indent); sollyaFprintf(output, "%s %s (%s, prec-%d);\n", indent, ptr, instr.var1, -instr.prec); sollyaFprintf(output, "%s}\n", indent); sollyaFprintf(output, "%selse\n", indent); sollyaFprintf(output, "%s{\n", indent); sollyaFprintf(output, "%s %s (%s, MPFR_PREC_MIN);\n", indent, ptr, instr.var1); sollyaFprintf(output, "%s}\n", indent); } break; case CONSTANTFUNC: sollyaFprintf(output, "%s%s (%s, MPFR_RNDN);\n", indent, instr.name, instr.var1); break; case UNARYFUNC: sollyaFprintf(output, "%s%s (%s, %s, MPFR_RNDN);\n", indent, instr.name, instr.var1, instr.var2); break; case BINARYFUNC: sollyaFprintf(output, "%s%s (%s, %s, %s, MPFR_RNDN);\n", indent, instr.name, instr.var1, instr.var2, instr.var3); break; case SETUI: sollyaFprintf(output, "%smpfr_set_ui (%s, %lu, MPFR_RNDN);\n", indent, instr.var1, instr.uival); break; case SETSI: sollyaFprintf(output, "%smpfr_set_si (%s, %ld, MPFR_RNDN);\n", indent, instr.var1, instr.sival); break; case SETSTR: sollyaFprintf(output, "%smpfr_set_str (%s, \"%s\", 2, MPFR_RNDN);\n", indent, instr.var1, instr.strval); break; case UIPOWUI: sollyaFprintf(output, "%smpfr_ui_pow_ui (%s, %lu, %lu, MPFR_RNDN);\n", indent, instr.var1, instr.uival, instr.uival2); break; case POWUI: sollyaFprintf(output, "%smpfr_pow_ui (%s, %s, %lu, MPFR_RNDN);\n", indent, instr.var1, instr.var2, instr.uival); break; case ROOT: sollyaFprintf(output, "%smpfr_root (%s, %s, %lu, MPFR_RNDN);\n", indent, instr.var1, instr.var2, instr.uival); break; case IFTHENELSE: sollyaFprintf(output, "%sif (%s)\n", indent, instr.strval); sollyaFprintf(output, "%s{\n", indent); curr = instr.prog1.instructions; while(curr!=NULL) { fprintInstruction(output, *(struct implementCsteInstruction *)(curr->value), indentlevel+1); curr = curr->next; } sollyaFprintf(output, "%s}\n", indent); sollyaFprintf(output, "%selse\n", indent); sollyaFprintf(output, "%s{\n", indent); curr = instr.prog2.instructions; while(curr!=NULL) { fprintInstruction(output, *(struct implementCsteInstruction *)(curr->value), indentlevel+1); curr = curr->next; } sollyaFprintf(output, "%s}\n", indent); break; default: sollyaFprintf(stderr, "Unknown instruction %d\n", instr.type); } safeFree(indent); return; } void constructName(char *res, int counter) { if (counter==0) strcpy(res, "y"); else sprintf(res, "tmp%d", counter); return; } /* These constructors allow one for adding an instruction to the end of a */ /* give program. */ void appendInit2Prog(int var1, long int prec, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = INIT2; constructName(instr->var1, var1); strcpy(instr->var2, ""); strcpy(instr->var3, ""); strcpy(instr->name, ""); instr->prec = prec; instr->strval = NULL; instr->prog1.instructions = NULL; instr->prog1.precisions = NULL; instr->prog2.instructions = NULL; instr->prog2.precisions = NULL; program->instructions = addElement(program->instructions, instr); return; } void appendSetprecProg(int var1, long int prec, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = SETPREC; constructName(instr->var1, var1); strcpy(instr->var2, ""); strcpy(instr->var3, ""); strcpy(instr->name, ""); instr->prec = prec; instr->strval = NULL; instr->prog1.instructions = NULL; instr->prog1.precisions = NULL; instr->prog2.instructions = NULL; instr->prog2.precisions = NULL; program->instructions = addElement(program->instructions, instr); appendPrecisionProg(var1, prec, program); return; } void appendConstantfuncProg(char *name, int var1, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = CONSTANTFUNC; constructName(instr->var1, var1); strcpy(instr->var2, ""); strcpy(instr->var3, ""); strcpy(instr->name, name); instr->strval = NULL; instr->prog1.instructions = NULL; instr->prog1.precisions = NULL; instr->prog2.instructions = NULL; instr->prog2.precisions = NULL; program->instructions = addElement(program->instructions, instr); return; } void appendUnaryfuncProg(char *name, int var1, int var2, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = UNARYFUNC; constructName(instr->var1, var1); constructName(instr->var2, var2); strcpy(instr->var3, ""); strcpy(instr->name, name); instr->strval = NULL; instr->prog1.instructions = NULL; instr->prog1.precisions = NULL; instr->prog2.instructions = NULL; instr->prog2.precisions = NULL; program->instructions = addElement(program->instructions, instr); return; } void appendBinaryfuncProg(char *name, int var1, int var2, int var3, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = BINARYFUNC; constructName(instr->var1, var1); constructName(instr->var2, var2); constructName(instr->var3, var3); strcpy(instr->name, name); instr->strval = NULL; instr->prog1.instructions = NULL; instr->prog1.precisions = NULL; instr->prog2.instructions = NULL; instr->prog2.precisions = NULL; program->instructions = addElement(program->instructions, instr); return; } void appendSetuiProg(int var1, unsigned long int val, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = SETUI; constructName(instr->var1, var1); strcpy(instr->var2, ""); strcpy(instr->var3, ""); strcpy(instr->name, ""); instr->uival = val; instr->strval = NULL; instr->prog1.instructions = NULL; instr->prog1.precisions = NULL; instr->prog2.instructions = NULL; instr->prog2.precisions = NULL; program->instructions = addElement(program->instructions, instr); return; } void appendSetsiProg(int var1, long int val, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = SETSI; constructName(instr->var1, var1); strcpy(instr->var2, ""); strcpy(instr->var3, ""); strcpy(instr->name, ""); instr->sival = val; instr->strval = NULL; instr->prog1.instructions = NULL; instr->prog1.precisions = NULL; instr->prog2.instructions = NULL; instr->prog2.precisions = NULL; program->instructions = addElement(program->instructions, instr); return; } void appendSetstrProg(int var1, mpfr_t val, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = SETSTR; constructName(instr->var1, var1); strcpy(instr->var2, ""); strcpy(instr->var3, ""); strcpy(instr->name, ""); instr->prog1.instructions = NULL; instr->prog1.precisions = NULL; instr->prog2.instructions = NULL; instr->prog2.precisions = NULL; instr->strval = mpfr_to_binary_str(val); program->instructions = addElement(program->instructions, instr); return; } void appendUipowui(int var1, unsigned long int val1, unsigned long int val2, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = UIPOWUI; constructName(instr->var1, var1); strcpy(instr->var2, ""); strcpy(instr->var3, ""); strcpy(instr->name, ""); instr->uival = val1; instr->uival2 = val2; instr->strval = NULL; instr->prog1.instructions = NULL; instr->prog1.precisions = NULL; instr->prog2.instructions = NULL; instr->prog2.precisions = NULL; program->instructions = addElement(program->instructions, instr); return; } void appendPowuiProg(int var1, int var2, unsigned long int val, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = POWUI; constructName(instr->var1, var1); constructName(instr->var2, var2); strcpy(instr->var3, ""); strcpy(instr->name, ""); instr->uival = val; instr->strval = NULL; instr->prog1.instructions = NULL; instr->prog1.precisions = NULL; instr->prog2.instructions = NULL; instr->prog2.precisions = NULL; program->instructions = addElement(program->instructions, instr); return; } void appendRootProg(int var1, int var2, unsigned long int val, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = ROOT; constructName(instr->var1, var1); constructName(instr->var2, var2); strcpy(instr->var3, ""); strcpy(instr->name, ""); instr->uival = val; instr->strval = NULL; instr->prog1.instructions = NULL; instr->prog1.precisions = NULL; instr->prog2.instructions = NULL; instr->prog2.precisions = NULL; program->instructions = addElement(program->instructions, instr); return; } void appendLibraryConstantProg(node *c, int gamma0, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = LIBRARYCONST; constructName(instr->var1, program->counter); instr->prec = gamma0; strcpy(instr->var2, ""); strcpy(instr->var3, ""); strcpy(instr->name, ""); instr->strval = safeCalloc(strlen(accessThruMemRef(c)->libFun->functionName)+1, sizeof(char)); strcpy(instr->strval, accessThruMemRef(c)->libFun->functionName); instr->prog1.instructions = NULL; instr->prog1.precisions = NULL; instr->prog2.instructions = NULL; instr->prog2.precisions = NULL; program->instructions = addElement(program->instructions, instr); return; } void appendIfThenElseProg(char *cond, struct implementCsteProgram prog1, struct implementCsteProgram prog2, struct implementCsteProgram *program) { struct implementCsteInstruction *instr; instr = safeMalloc(sizeof(struct implementCsteInstruction)); instr->type = IFTHENELSE; strcpy(instr->var1, ""); strcpy(instr->var2, ""); strcpy(instr->var3, ""); strcpy(instr->name, ""); instr->strval = NULL; instr->prog1.counter = -1; instr->prog1.maxcounter = -1; instr->prog1.precisions = NULL; instr->prog1.instructions = copyChain(prog1.instructions, copy_implementCsteInstructions); /* Note: it reverses the list, but it is what we want since the programs are created with instructions in reversed order */ instr->prog2.counter = -1; instr->prog2.maxcounter = -1; instr->prog2.precisions = NULL; instr->prog2.instructions = copyChain(prog2.instructions, copy_implementCsteInstructions); /* Note: it reverses the list, but it is what we want since the programs are created with instructions in reversed order */ instr->strval = safeCalloc(strlen(cond)+1, sizeof(char)); strcpy(instr->strval, cond); program->counter = (prog1.counter > prog2.counter)?prog1.counter:prog2.counter; program->maxcounter = (prog1.maxcounter > prog2.maxcounter)?prog1.maxcounter:prog2.maxcounter; if(prog1.precisions != prog2.precisions) { sollyaFprintf(stderr, "Unexpected error: in an if-then-else statement, both branches must share the same pointer of precisions\n"); exit(1); } program->precisions = copyChainWithoutReversal(prog2.precisions, copyCouple); program->instructions = addElement(program->instructions, instr); return; } /* Prototype of the recursive function */ /* Returns 0 in case of success and non-zero otherwise */ int constantImplementer(node *c, int gamma0, struct implementCsteProgram *program); /* Main function */ /* Returns 0 in case of success and non-zero otherwise */ int implementconst(node *c, FILE *fd, char *name) { int i, test, res; FILE *output = fd; struct implementCsteProgram program; chain *curr; program.instructions = NULL; program.counter = 0; program.maxcounter = 0; program.precisions = NULL; res = constantImplementer(c, 0, &program); if (res) { /* Something went wrong */ freeChain(program.instructions, free_implementCsteInstruction); freeChain(program.precisions, safeFree); return res; } /* reverse the chain */ curr = copyChain(program.instructions, copy_implementCsteInstructions); freeChain(program.instructions, free_implementCsteInstruction); program.instructions = curr; curr = program.precisions; while(curr != NULL) { if( ((couple *)(curr->value))->var != 0 ) appendInit2Prog( ((couple *)(curr->value))->var, ((couple *)(curr->value))->prec, &program); curr = curr->next; } emitLegalNoticeAndDisclaimer(output); sollyaFprintf(output, "#include \n\n"); sollyaFprintf(output, "void\n"); sollyaFprintf(output, "%s (mpfr_ptr y, mp_prec_t prec)\n", name); sollyaFprintf(output, "{\n"); if(program.maxcounter>=2) sollyaFprintf(output, " /* Declarations */\n"); for(i=1; i<=program.maxcounter-1; i++) sollyaFprintf(output, " mpfr_t tmp%d;\n", i); if(program.maxcounter>=2) sollyaFprintf(output, "\n"); sollyaFprintf(output, " /* Initializations */\n"); test = 1; curr=program.instructions; while(curr!=NULL) { if (test && ( ((struct implementCsteInstruction *)(curr->value))->type != INIT2 ) ) { sollyaFprintf(output, "\n"); sollyaFprintf(output, " /* Core */\n"); test = 0; } fprintInstruction(output, *(struct implementCsteInstruction *)(curr->value), 1); curr = curr->next; } if(program.maxcounter>=2) { sollyaFprintf(output, "\n"); sollyaFprintf(output, " /* Cleaning stuff */\n"); } for(i=1; i<=program.maxcounter-1; i++) sollyaFprintf(output, " mpfr_clear(tmp%d);\n", i); sollyaFprintf(output, "}\n"); freeChain(program.instructions, free_implementCsteInstruction); freeChain(program.precisions, safeFree); return 0; } int ceil_log2n(int p) { int n,log2p, test; n = p; log2p = 0; test = 1; /* Compute log2p such that 2^(log2p-1) <= p < 2^(log2p) */ while (n>=1) { log2p++; if ((n%2)!=0) test=0; n = n/2;} /* Adjust log2p in order to have 2^(log2p-1) < n <= 2^(log2p) */ if(test) log2p--; return log2p; } /* Returns the maximal exponent of a number among those contained in x */ static mp_exp_t sollya_mpfi_max_exp_implementconstant(sollya_mpfi_t x) { mpfr_t u,v; mp_exp_t Eu, Ev, E; mp_prec_t prec; prec = sollya_mpfi_get_prec(x); mpfr_init2(u, prec); mpfr_init2(v, prec); sollya_mpfi_get_left(u, x); sollya_mpfi_get_right(v, x); if (mpfr_zero_p(u)) E = mpfr_get_exp(v); else { if (mpfr_zero_p(v)) E = mpfr_get_exp(u); else { Eu = mpfr_get_exp(u); Ev = mpfr_get_exp(v); E = (Eu<=Ev) ? Ev : Eu; } } mpfr_clear(u); mpfr_clear(v); return E; } /* Return the smallest exponent among the exponents of the numbers contained in x. If 0 \in x, it returns NULL, else it returns a valid pointer E such that *E is the minimal exponent. */ mp_exp_t *sollya_mpfi_min_exp(sollya_mpfi_t x) { mpfr_t u,v; mp_exp_t Eu, Ev; mp_exp_t *E = NULL; mp_prec_t prec; prec = sollya_mpfi_get_prec(x); mpfr_init2(u, prec); mpfr_init2(v, prec); sollya_mpfi_get_left(u, x); sollya_mpfi_get_right(v, x); if (mpfr_sgn(u)*mpfr_sgn(v)>0) { E = safeMalloc(sizeof(mp_exp_t)); Eu = mpfr_get_exp(u); Ev = mpfr_get_exp(v); *E = (Eu<=Ev) ? Eu : Ev; } mpfr_clear(u); mpfr_clear(v); return E; } /* Let a be the constant given by the expression cste and f the function with */ /* node type nodeType. This functions generates code for the implementation */ /* of f(a) in precision prec+gamma0, the result being stored in resName. */ int unaryFunctionCase(int nodeType, node *cste, char *functionName, int gamma0, struct implementCsteProgram *program) { sollya_mpfi_t a, b, u, v, tmp; mpfr_t alpha, beta; mp_prec_t prec = getToolPrecision(); node *func, *deriv; int gamma; int counter; int res; sollya_mpfi_init2(a, prec); sollya_mpfi_init2(b, prec); sollya_mpfi_init2(u, prec); sollya_mpfi_init2(v, prec); sollya_mpfi_init2(tmp, prec); mpfr_init2(alpha, prec); mpfr_init2(beta, prec); func = makeUnary(makeVariable(), nodeType); deriv = differentiate(func); evaluateInterval(a, cste, NULL, a); evaluateInterval(b, func, deriv, a); if (sollya_mpfi_has_zero(b)) { sollya_mpfi_clear(a); sollya_mpfi_clear(b); sollya_mpfi_clear(u); sollya_mpfi_clear(v); sollya_mpfi_clear(tmp); mpfr_clear(alpha); mpfr_clear(beta); free_memory(func); free_memory(deriv); func = makeUnary(copyTree(cste), nodeType); printMessage(1,SOLLYA_MSG_EXPR_SEEMS_TO_BE_ZERO_INCREASE_PREC,"Error in implementconstant: the following expression seems to be exactly zero: \n%b\nIf it is not exactly zero, increasing prec should solve the issue.\nAbort.\n",func); free_memory(func); return 2; } sollya_mpfi_div(u, a, b); evaluateInterval(tmp, deriv, NULL, a); sollya_mpfi_mul(v, u, tmp); gamma = 2+sollya_mpfi_max_exp_implementconstant(v)-1; do { gamma++; mpfr_set_ui(beta, 1, GMP_RNDU); mpfr_div_2si(beta, beta, gamma+gamma0, GMP_RNDU); mpfr_ui_sub(alpha, 1, beta, GMP_RNDD); mpfr_add_ui(beta, beta, 1, GMP_RNDU); sollya_mpfi_interv_fr(tmp, alpha, beta); sollya_mpfi_mul(tmp, a, tmp); evaluateInterval(tmp, deriv, NULL, tmp); sollya_mpfi_mul(v, u, tmp); } while (gamma < 2+sollya_mpfi_max_exp_implementconstant(v)); counter = program->counter; incrementProgramCounter(program); res = constantImplementer(cste, gamma0+gamma, program); program->counter = counter; appendSetprecProg(counter, gamma0+2, program); appendUnaryfuncProg(functionName, counter, counter+1, program); sollya_mpfi_clear(a); sollya_mpfi_clear(b); sollya_mpfi_clear(u); sollya_mpfi_clear(v); sollya_mpfi_clear(tmp); mpfr_clear(alpha); mpfr_clear(beta); free_memory(func); free_memory(deriv); return res; } void normalizeDivMul(node *c, chain **numerator, chain **denominator) { chain *num1 = NULL; chain *denom1 = NULL; chain *num2 = NULL; chain *denom2 = NULL; if (accessThruMemRef(c)->nodeType == MUL) { normalizeDivMul(accessThruMemRef(c)->child1, &num1, &denom1); normalizeDivMul(accessThruMemRef(c)->child2, &num2, &denom2); *numerator = concatChains(num1, num2); *denominator = concatChains(denom1, denom2); } else if (accessThruMemRef(c)->nodeType == DIV) { normalizeDivMul(accessThruMemRef(c)->child1, &num1, &denom1); normalizeDivMul(accessThruMemRef(c)->child2, &denom2, &num2); *numerator = concatChains(num1, num2); *denominator = concatChains(denom1, denom2); } else *numerator = addElement(*numerator, copyTree(c)); } int implementDivMul(node *c, int gamma0, struct implementCsteProgram *program) { chain *numerator = NULL; chain *denominator = NULL; chain *curr; chain *bufferNum, *bufferDenom; int log2n, n; int *tmp; int counter; int res = 0; normalizeDivMul(c, &numerator, &denominator); n = lengthChain(numerator) + lengthChain(denominator); log2n = ceil_log2n(n); counter = program->counter; incrementProgramCounter(program); curr = numerator; bufferNum = NULL; while ( (curr!=NULL) && (!res) ) { tmp = safeMalloc(sizeof(int)); *tmp = program->counter; bufferNum = addElement(bufferNum, tmp); res = constantImplementer(curr->value, gamma0+2+log2n, program); curr = curr->next; } if (res) { /* Something went wrong */ freeChain(bufferNum, freeIntPtr); freeChain(numerator, (void (*)(void *))free_memory); freeChain(denominator, (void (*)(void *))free_memory); return res; } curr = denominator; bufferDenom = NULL; while ( (curr!=NULL) && (!res) ) { tmp = safeMalloc(sizeof(int)); *tmp = program->counter; bufferDenom = addElement(bufferDenom, tmp); res = constantImplementer(curr->value, gamma0+2+log2n, program); curr = curr->next; } if (res) { /* Something went wrong */ freeChain(bufferNum, freeIntPtr); freeChain(bufferDenom, freeIntPtr); freeChain(numerator, (void (*)(void *))free_memory); freeChain(denominator, (void (*)(void *))free_memory); return res; } program->counter = counter; if ( (lengthChain(numerator)==1) && (lengthChain(denominator)==1) ) { appendSetprecProg(counter, gamma0+2+log2n, program); appendBinaryfuncProg("mpfr_div", counter, *((int *)(bufferNum->value)), *((int *)(bufferDenom->value)), program); } else if (lengthChain(numerator)==1) { appendSetprecProg(counter, gamma0+2+log2n, program); appendBinaryfuncProg("mpfr_mul", counter, *((int *)(bufferDenom->value)), *((int *)(bufferDenom->next->value)), program); curr = bufferDenom->next->next; while(curr!=NULL) { appendBinaryfuncProg("mpfr_mul", counter, counter, *((int *)(curr->value)), program); curr = curr->next; } appendBinaryfuncProg("mpfr_div", counter, *((int *)(bufferNum->value)), counter, program); } else if (lengthChain(denominator)<=1) { appendSetprecProg(counter, gamma0+2+log2n, program); appendBinaryfuncProg("mpfr_mul", counter, *((int *)(bufferNum->value)), *((int *)(bufferNum->next->value)), program); curr = bufferNum->next->next; while(curr!=NULL) { appendBinaryfuncProg("mpfr_mul", counter, counter, *((int *)(curr->value)), program); curr = curr->next; } if (lengthChain(denominator)==1) appendBinaryfuncProg("mpfr_div", counter, counter, *((int *)(bufferDenom->value)), program); } else { incrementProgramCounter(program); appendSetprecProg(counter, gamma0+2+log2n, program); appendBinaryfuncProg("mpfr_mul", counter, *((int *)(bufferNum->value)), *((int *)(bufferNum->next->value)), program); curr = bufferNum->next->next; while(curr!=NULL) { appendBinaryfuncProg("mpfr_mul", counter, counter, *((int *)(curr->value)), program); curr = curr->next; } appendSetprecProg(program->counter, gamma0+2+log2n, program); appendBinaryfuncProg("mpfr_mul", program->counter, *((int *)(bufferDenom->value)), *((int *)(bufferDenom->next->value)), program); curr = bufferDenom->next->next; while(curr!=NULL) { appendBinaryfuncProg("mpfr_mul", program->counter, program->counter, *((int *)(curr->value)), program); curr = curr->next; } appendBinaryfuncProg("mpfr_div", counter, counter, program->counter, program); } program->counter = counter; freeChain(bufferNum, freeIntPtr); freeChain(bufferDenom, freeIntPtr); freeChain(numerator, (void (*)(void *))free_memory); freeChain(denominator, (void (*)(void *))free_memory); return res; } int summation_weight(node *c) { if ( (accessThruMemRef(c)->nodeType == ADD) || (accessThruMemRef(c)->nodeType == SUB) ) return (summation_weight(accessThruMemRef(c)->child1) + summation_weight(accessThruMemRef(c)->child2) + 1); else if (accessThruMemRef(c)->nodeType == NEG) return summation_weight(accessThruMemRef(c)->child1); else return 1; } int implementAddSub(node *c, int gamma0, struct implementCsteProgram *program) { sollya_mpfi_t y, a, b, tmp, tmp2; mp_exp_t *Ea, *Eb, *Ey; int na, nb, n; int tmpa, tmpb; mp_prec_t prec; int counter; int res; struct implementCsteProgram prog1, prog2; char *str; prec = getToolPrecision(); sollya_mpfi_init2(y, prec); sollya_mpfi_init2(a, prec); sollya_mpfi_init2(b, prec); sollya_mpfi_init2(tmp, prec); sollya_mpfi_init2(tmp2, prec); evaluateInterval(y, c, NULL, y); if (sollya_mpfi_has_zero(y)) { sollya_mpfi_clear(y); sollya_mpfi_clear(a); sollya_mpfi_clear(b); sollya_mpfi_clear(tmp); sollya_mpfi_clear(tmp2); printMessage(1,SOLLYA_MSG_EXPR_SEEMS_TO_BE_ZERO_INCREASE_PREC,"Error in implementconstant: the following expression seems to be exactly zero:\n%b\nIf it is not exactly zero, increasing prec should solve the issue.\nAbort.\n",c); return 2; } evaluateInterval(a, accessThruMemRef(c)->child1, NULL, a); evaluateInterval(b, accessThruMemRef(c)->child2, NULL, b); na = 2*summation_weight(accessThruMemRef(c)->child1)-1; nb = 2*summation_weight(accessThruMemRef(c)->child2)-1; n = na+nb+1; sollya_mpfi_div(tmp, y, a); sollya_mpfi_mul_ui(tmp, tmp, na); sollya_mpfi_div_ui(tmp, tmp, n); Ea = sollya_mpfi_min_exp(tmp); if (Ea==NULL) { sollyaFprintf(stderr, "Unexpected error. Aborting\n"); exit(1); } sollya_mpfi_div(tmp, y, b); sollya_mpfi_mul_ui(tmp, tmp, nb); sollya_mpfi_div_ui(tmp, tmp, n); Eb = sollya_mpfi_min_exp(tmp); if (Eb==NULL) { sollyaFprintf(stderr, "Unexpected error. Aborting\n"); exit(1); } sollya_mpfi_abs(tmp, a); sollya_mpfi_abs(tmp2, b); sollya_mpfi_add(tmp, tmp, tmp2); sollya_mpfi_div(tmp, y, tmp); sollya_mpfi_div_ui(tmp, tmp, n); Ey = sollya_mpfi_min_exp(tmp); if (Ey==NULL) { sollyaFprintf(stderr, "Unexpected error. Aborting\n"); exit(1); } counter = program->counter; incrementProgramCounter(program); if( gamma0+1-*Ea>=0 ) { /* No need to perform a test inside the generated code */ tmpa = program->counter; res = constantImplementer(accessThruMemRef(c)->child1, gamma0+1-*Ea, program); } else { prog1.instructions = NULL; prog1.counter = program->counter; prog1.maxcounter = program->maxcounter; prog1.precisions = program->precisions; prog2.instructions = NULL; prog2.counter = program->counter; prog2.maxcounter = program->maxcounter; tmpa = program->counter; appendSetuiProg(tmpa, 0, &prog1); incrementProgramCounter(&prog1); prog2.precisions = prog1.precisions; res = constantImplementer(accessThruMemRef(c)->child1, gamma0+1-*Ea, &prog2); prog1.precisions = prog2.precisions; str = safeCalloc(32 , sizeof(char)); sprintf(str, "prec <= %d", (int)(*Ea-gamma0)); appendIfThenElseProg(str, prog1, prog2, program); safeFree(str); /* No need to free progi.precisions: program.precisions now on it. */ freeChain(prog1.instructions, free_implementCsteInstruction); freeChain(prog2.instructions, free_implementCsteInstruction); } if (res) { /* Something went wrong */ safeFree(Ea); safeFree(Eb); safeFree(Ey); sollya_mpfi_clear(y); sollya_mpfi_clear(a); sollya_mpfi_clear(b); sollya_mpfi_clear(tmp); sollya_mpfi_clear(tmp2); return res; } if( gamma0+1-*Eb>=0 ) { /* No need to perform a test inside the generated code */ tmpb = program->counter; res = constantImplementer(accessThruMemRef(c)->child2, gamma0+1-*Eb, program); } else { prog1.instructions = NULL; prog1.counter = program->counter; prog1.maxcounter = program->maxcounter; prog1.precisions = program->precisions; prog2.instructions = NULL; prog2.counter = program->counter; prog2.maxcounter = program->maxcounter; tmpb = program->counter; appendSetuiProg(tmpb, 0, &prog1); incrementProgramCounter(&prog1); prog2.precisions = prog1.precisions; res = constantImplementer(c->child2, gamma0+1-*Eb, &prog2); prog1.precisions = prog2.precisions; str = safeCalloc(32 , sizeof(char)); sprintf(str, "prec <= %d", (int)(*Eb-gamma0)); appendIfThenElseProg(str, prog1, prog2, program); safeFree(str); /* No need to free progi.precisions: program.precisions now on it. */ freeChain(prog1.instructions, free_implementCsteInstruction); freeChain(prog2.instructions, free_implementCsteInstruction); } if (res) { /* Something went wrong */ safeFree(Ea); safeFree(Eb); safeFree(Ey); sollya_mpfi_clear(y); sollya_mpfi_clear(a); sollya_mpfi_clear(b); sollya_mpfi_clear(tmp); sollya_mpfi_clear(tmp2); return res; } appendSetprecProg(counter, gamma0+2-*Ey, program); if (accessThruMemRef(c)->nodeType==ADD) appendBinaryfuncProg("mpfr_add", counter, tmpa, tmpb, program); else if (accessThruMemRef(c)->nodeType==SUB) appendBinaryfuncProg("mpfr_sub", counter, tmpa, tmpb, program); else { sollyaFprintf(stderr, "Unexpected error: an addition/subtraction must have nodeType=ADD or nodeType=SUB\n"); exit(1); } program->counter = counter; safeFree(Ea); safeFree(Eb); safeFree(Ey); sollya_mpfi_clear(y); sollya_mpfi_clear(a); sollya_mpfi_clear(b); sollya_mpfi_clear(tmp); sollya_mpfi_clear(tmp2); return res; } int implementPow(node *c, int gamma0, struct implementCsteProgram *program) { int log2p, p, counter; node *tmpNode; mpfr_t tmp; int res; counter = program->counter; if ( (accessThruMemRef(accessThruMemRef(c)->child1)->nodeType==CONSTANT) && mpfr_integer_p(*(accessThruMemRef(accessThruMemRef(c)->child1)->value)) && mpfr_fits_ulong_p(*(accessThruMemRef(accessThruMemRef(c)->child1)->value), GMP_RNDN) && (accessThruMemRef(accessThruMemRef(c)->child2)->nodeType==CONSTANT) && mpfr_integer_p(*(accessThruMemRef(accessThruMemRef(c)->child2)->value)) && mpfr_fits_ulong_p(*(accessThruMemRef(accessThruMemRef(c)->child2)->value), GMP_RNDN)) { /* Case n^p */ appendSetprecProg(counter, gamma0, program); appendUipowui(counter, mpfr_get_ui(*(accessThruMemRef(accessThruMemRef(c)->child1)->value), GMP_RNDN), mpfr_get_ui(*(accessThruMemRef(accessThruMemRef(c)->child2)->value), GMP_RNDN), program); program->counter = counter; return 0; } if ( (accessThruMemRef(accessThruMemRef(c)->child2)->nodeType==CONSTANT) && mpfr_integer_p(*(accessThruMemRef(accessThruMemRef(c)->child2)->value)) && mpfr_fits_ulong_p(*(accessThruMemRef(accessThruMemRef(c)->child2)->value), GMP_RNDN) ) { /* Case x^p */ p = mpfr_get_ui(*(accessThruMemRef(accessThruMemRef(c)->child2)->value), GMP_RNDN); log2p = ceil_log2n(p); incrementProgramCounter(program); res = constantImplementer(accessThruMemRef(c)->child1, gamma0+log2p+3, program); appendSetprecProg(counter, gamma0+2, program); appendPowuiProg(counter, counter+1, p, program); program->counter = counter; return res; } if ( (accessThruMemRef(accessThruMemRef(c)->child2)->nodeType==DIV) && (accessThruMemRef(accessThruMemRef(accessThruMemRef(c)->child2)->child1)->nodeType==CONSTANT) && (mpfr_cmp_ui(*(accessThruMemRef(accessThruMemRef(accessThruMemRef(c)->child2)->child1)->value), 1)==0) && (accessThruMemRef(accessThruMemRef(accessThruMemRef(c)->child2)->child2)->nodeType==CONSTANT) && mpfr_integer_p(*(accessThruMemRef(accessThruMemRef(accessThruMemRef(c)->child2)->child2)->value)) && mpfr_fits_ulong_p(*(accessThruMemRef(accessThruMemRef(accessThruMemRef(c)->child2)->child2)->value), GMP_RNDN) ) { /* Case x^(1/p) (note that this does not handle the case when p=2^k */ p = mpfr_get_ui(*(accessThruMemRef(accessThruMemRef(accessThruMemRef(c)->child2)->child2)->value), GMP_RNDN); log2p = ceil_log2n(p); incrementProgramCounter(program); res = constantImplementer(accessThruMemRef(c)->child1, gamma0-log2p+3, program); appendSetprecProg(counter, gamma0+2, program); appendRootProg(counter, counter+1, p, program); program->counter = counter; return res; } if (accessThruMemRef(accessThruMemRef(c)->child2)->nodeType==CONSTANT) { mpfr_init2(tmp, 64); if ( (mpfr_ui_div(tmp, 1, *(accessThruMemRef(accessThruMemRef(c)->child2)->value), GMP_RNDN) == 0) && mpfr_integer_p(tmp) && mpfr_fits_ulong_p(tmp, GMP_RNDN) ) { /* Case x^(1/p) where p is a power of 2 */ p = mpfr_get_ui(tmp, GMP_RNDN); log2p = ceil_log2n(p); incrementProgramCounter(program); res = constantImplementer(accessThruMemRef(c)->child1, gamma0-log2p+3, program); appendSetprecProg(counter, gamma0+2, program); appendRootProg(counter, counter+1, p, program); program->counter = counter; mpfr_clear(tmp); return res; } mpfr_clear(tmp); } /* else... case x^y with x possibly integer. Handled as exp(y*ln(x)) */ tmpNode = makeExp(makeMul(copyTree(accessThruMemRef(c)->child2), makeLog(copyTree(accessThruMemRef(c)->child1)))); res = constantImplementer(tmpNode, gamma0, program); free_memory(tmpNode); program->counter = counter; return res; } int implementCsteCase(node *c, int gamma0, struct implementCsteProgram *program) { appendSetprecProg(program->counter, gamma0, program); if (mpfr_integer_p(*(accessThruMemRef(c)->value)) && mpfr_fits_ulong_p(*(accessThruMemRef(c)->value), GMP_RNDN)) { appendSetuiProg(program->counter, mpfr_get_ui(*(accessThruMemRef(c)->value), GMP_RNDN), program); } else if (mpfr_integer_p(*(accessThruMemRef(c)->value)) && mpfr_fits_slong_p(*(accessThruMemRef(c)->value), GMP_RNDN)) { appendSetsiProg(program->counter, mpfr_get_si(*(accessThruMemRef(c)->value), GMP_RNDN), program); } else { appendSetstrProg(program->counter, *(accessThruMemRef(c)->value), program); } return 0; } int constantImplementer(node *c, int gamma0, struct implementCsteProgram *program) { int res; switch (accessThruMemRef(c)->nodeType) { case ADD: case SUB: res = implementAddSub(c, gamma0, program); break; case MUL: case DIV: res = implementDivMul(c, gamma0, program); break; case POW: res = implementPow(c, gamma0, program); break; case CONSTANT: res = implementCsteCase(c, gamma0, program); break; case NEG: res = constantImplementer(accessThruMemRef(c)->child1, gamma0, program); appendUnaryfuncProg("mpfr_neg", program->counter, program->counter, program); break; case ABS: res = constantImplementer(accessThruMemRef(c)->child1, gamma0, program); appendUnaryfuncProg("mpfr_abs", program->counter, program->counter, program); break; case DOUBLE: printMessage(1,SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST,"implementconstant: error: the double function is not supported by this command.\nNo code will be produced.\n"); res = 1; break; case DOUBLEDOUBLE: printMessage(1,SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST,"implementconstant: error: the doubledouble function is not supported by this command.\nNo code will be produced.\n"); res = 1; break; case TRIPLEDOUBLE: printMessage(1,SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST,"implementconstant: error: the tripledouble function is not supported by this command.\nNo code will be produced.\n"); res = 1; break; case DOUBLEEXTENDED: printMessage(1,SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST,"implementconstant: error: the doubleextended function is not supported by this command.\nNo code will be produced.\n"); res = 1; break; case SINGLE: printMessage(1,SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST,"implementconstant: error: the single function is not supported by this command.\nNo code will be produced.\n"); res = 1; break; case HALFPRECISION: printMessage(1,SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST,"implementconstant: error: the half-precision function is not supported by this command.\nNo code will be produced.\n"); res = 1; break; case QUAD: printMessage(1,SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST,"implementconstant: error: the quad function is not supported by this command.\nNo code will be produced.\n"); res = 1; break; case NEARESTINT: printMessage(1,SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST,"implementconstant: error: the nearestint function is not supported by this command.\nNo code will be produced.\n"); res = 1; break; case CEIL: printMessage(1,SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST,"implementconstant: error: the ceil function is not supported by this command.\nNo code will be produced.\n"); res = 1; break; case FLOOR: printMessage(1,SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST,"implementconstant: error: the floor function is not supported by this command.\nNo code will be produced.\n"); res = 1; break; case PI_CONST: appendSetprecProg(program->counter, gamma0, program); appendConstantfuncProg("mpfr_const_pi", program->counter, program); res = 0; break; case LIBRARYCONSTANT: appendPrecisionProg(program->counter, gamma0, program); appendLibraryConstantProg(c, gamma0, program); res = 0; break; case SQRT: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_sqrt", gamma0, program); break; case EXP: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_exp", gamma0, program); break; case LOG: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_log", gamma0, program); break; case LOG_2: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_log2", gamma0, program); break; case LOG_10: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_log10", gamma0, program); break; case SIN: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_sin", gamma0, program); break; case COS: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_cos", gamma0, program); break; case TAN: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_tan", gamma0, program); break; case ASIN: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_asin", gamma0, program); break; case ACOS: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_acos", gamma0, program); break; case ATAN: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_atan", gamma0, program); break; case SINH: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_sinh", gamma0, program); break; case COSH: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_cosh", gamma0, program); break; case TANH: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_tanh", gamma0, program); break; case ASINH: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_asinh", gamma0, program); break; case ACOSH: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_acosh", gamma0, program); break; case ATANH: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_atanh", gamma0, program); break; case ERF: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_erf", gamma0, program); break; case ERFC: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_erfc", gamma0, program); break; case LOG_1P: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_log1p", gamma0, program); break; case EXP_M1: res = unaryFunctionCase(accessThruMemRef(c)->nodeType, accessThruMemRef(c)->child1, "mpfr_expm1", gamma0, program); break; case LIBRARYFUNCTION: printMessage(1,SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST,"implementconstant: error: library functions are not supported by this command.\nNo code will be produced.\n"); res = 1; break; case PROCEDUREFUNCTION: printMessage(1,SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST,"implementconstant: error: procedure functions are not supported by this command.\nNo code will be produced.\n"); res = 1; break; default: sollyaFprintf(stderr, "Unknown identifier (%d) in the tree\n", c->nodeType); exit(1); res = 1; } incrementProgramCounter(program); return res; } sollya-6.0+ds/implementconst.h000066400000000000000000000045071300174114700165020ustar00rootroot00000000000000/* Copyright 2010-2011 by LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2) and Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors S. Chevillard sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef IMPLEMENTCONST_H #define IMPLEMENTCONST_H #include "expression.h" int implementconst(node *, FILE *, char*); #endif /* ifdef IMPLEMENTCONST_H*/ sollya-6.0+ds/infnorm.c000066400000000000000000010724741300174114700151150ustar00rootroot00000000000000/* Copyright 2006-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include "mpfi-compat.h" #include "expression.h" #include "infnorm.h" #include "chain.h" #include "double.h" #include "general.h" #include "proof.h" #include "remez.h" #include "execute.h" #include "hooks.h" #include #include /* fprintf, fopen, fclose, */ #include /* exit, free, mktemp */ #include #define DIFFSIZE 5000000 void printInterval(sollya_mpfi_t interval); int sollya_mpfr_max(mpfr_t z, mpfr_t x, mpfr_t y, mp_rnd_t rnd) { int res = 2; if (mpfr_nan_p(x) || mpfr_nan_p(y)) mpfr_set_nan(z); else res = mpfr_max(z, x, y, rnd); return res; } int sollya_mpfr_min(mpfr_t z, mpfr_t x, mpfr_t y, mp_rnd_t rnd) { int res = 2; if (mpfr_nan_p(x) || mpfr_nan_p(y)) mpfr_set_nan(z); else res = mpfr_min(z, x, y, rnd); return res; } void sollya_mpfi_pow_ulong(sollya_mpfi_t z, sollya_mpfi_t x, unsigned long t) { /* Check for NaN. The case Inf will be handled by MPFR. HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if (mpfr_nan_p(&(x->left)) || mpfr_nan_p(&(x->right))) { sollya_mpfi_set_nan(z); return; } /* Handle the case when t is zero */ if (t == 0ul) { if (sollya_mpfi_is_infinity(x)) { sollya_mpfi_set_nan(z); } else { mpfr_set_si(&(z->left),1,GMP_RNDD); mpfr_set_si(&(z->right),1,GMP_RNDU); } return; } /* If t is odd, x^t is a monotone increasing function We return [RD(inf(x)^t);RU(sup(x)^t)] */ if ((t & 1ul) != 0ul) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_pow_ui(&(z->left),&(x->left),t,GMP_RNDD); mpfr_pow_ui(&(z->right),&(x->right),t,GMP_RNDU); return; } /* Here, t is even. This means x^t is monotone decreasing for x < 0 and monotone increasing for x > 0. So we must distinguish two main cases: * if 0 in the interior of x, we must return [0; RU(max(-inf(x),sup(x))^t)] * otherwise, see below. */ /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if (mpfr_sgn(&(x->left)) * mpfr_sgn(&(x->right)) < 0) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if (mpfr_cmpabs(&(x->left), &(x->right)) >= 0) { /* In this case, max(-inf(x),sup(x)) = -inf(x) */ /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_pow_ui(&(z->right),&(x->left),t,GMP_RNDU); } else { /* In this case, max(-inf(x),sup(x)) = sup(x) */ /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_pow_ui(&(z->right),&(x->right),t,GMP_RNDU); } /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_set_ui(&(z->left),0u,GMP_RNDN); /* exact */ return; } /* Here, t is even and 0 not in the interior of x In this case, we have two subcases: * If inf(x) >= 0, we must return [RD(inf(x)^t);RU(sup(x)^t)] * Otherwise, we must return [RD(sup(x)^t);RU(inf(x)^t)] */ /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if (mpfr_sgn(&(x->left)) >= 0) { /* We return [RD(inf(x)^t);RU(sup(x)^t)] */ /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_pow_ui(&(z->left),&(x->left),t,GMP_RNDD); mpfr_pow_ui(&(z->right),&(x->right),t,GMP_RNDU); return; } /* Here, t is even, 0 not in x and inf(x) <= 0 We return [RD(sup(x)^t);RU(inf(x)^t)] */ mpfr_pow_ui(&(z->right),&(x->right),t,GMP_RNDD); mpfr_pow_ui(&(z->left),&(x->left),t,GMP_RNDU); mpfr_swap(&(z->left), &(z->right)); } void sollya_mpfi_pow(sollya_mpfi_t z, sollya_mpfi_t x, sollya_mpfi_t y) { mpfr_t l,r,lx,rx; mp_prec_t prec, precx; int must_divide; sollya_mpfi_t res; unsigned long t; if (sollya_mpfi_has_nan(x) ||sollya_mpfi_has_nan(y)) { sollya_mpfi_set_nan(z); return; } if (sollya_mpfi_is_empty(x) || sollya_mpfi_is_empty(y)) { sollya_mpfi_set_empty(z); return; } /* The following if and possible call to sollya_mpfi_pow_uint is a performance optimization for common (all practical?) cases of input. */ /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if (mpfr_equal_p(&(y->left), &(y->right)) && mpfr_integer_p(&(y->left)) && (mpfr_sgn(&(y->left)) >= 0) && mpfr_fits_ulong_p(&(y->left), GMP_RNDN) ) { t = mpfr_get_ui(&(y->left), GMP_RNDN); /* exact */ sollya_mpfi_pow_ulong(z, x, t); return; } /* Same case when y is a negative integer */ if (mpfr_equal_p(&(y->left), &(y->right)) && mpfr_integer_p(&(y->left)) && (mpfr_sgn(&(y->left)) < 0) && mpfr_fits_slong_p(&(y->left), GMP_RNDN) ) { t = -mpfr_get_si(&(y->left), GMP_RNDN); /* exact */ prec = sollya_mpfi_get_prec(z); sollya_mpfi_prec_round(z, prec + 10); sollya_mpfi_pow_ulong(z, x, t); sollya_mpfi_inv(z, z); sollya_mpfi_prec_round(z, prec); return; } prec = sollya_mpfi_get_prec(y); mpfr_init2(l,prec); sollya_mpfi_get_left(l,y); mpfr_init2(r,prec); sollya_mpfi_get_right(r,y); sollya_mpfi_init2(res,sollya_mpfi_get_prec(z) + 64 + 2); /* 64 because we know that the MPFR exponent width is less than 64 */ /* Case x^k, k an integer */ if ((mpfr_cmp(l,r) == 0) && (mpfr_integer_p(l))) { if (mpfr_zero_p(l)) { /* Case k=0 -> 1 except if x=+/-Inf */ /* Note, if x contains an infinity, but is not equal to infinity, we return 1 also, by continuity */ if (sollya_mpfi_is_infinity(x)) sollya_mpfi_set_nan(z); else sollya_mpfi_set_d(z,1.0); mpfr_clear(l); mpfr_clear(r); sollya_mpfi_clear(res); return; } else { precx = sollya_mpfi_get_prec(x); if (sollya_mpfi_get_prec(res) > precx) precx = sollya_mpfi_get_prec(res); mpfr_init2(lx,precx); mpfr_init2(rx,precx); sollya_mpfi_get_right(rx,x); sollya_mpfi_get_left(lx,x); if (mpfr_sgn(l) < 0) { must_divide = 1; mpfr_neg(l,l,GMP_RNDN); } else { must_divide = 0; } mpfr_div_2ui(r,l,1,GMP_RNDN); if (sollya_mpfi_is_nonneg(x) || (!mpfr_integer_p(r))) { /* x-> x^k is increasing monotonic when x>=0 or when k is odd */ mpfr_pow(lx,lx,l,GMP_RNDD); mpfr_pow(rx,rx,l,GMP_RNDU); sollya_mpfi_interv_fr(res,lx,rx); } else if (sollya_mpfi_is_nonpos(x)) { /* x^k is decreasing when x<=0 and k is even */ mpfr_pow(rx,rx,l,GMP_RNDD); mpfr_pow(lx,lx,l,GMP_RNDU); sollya_mpfi_interv_fr(res,rx,lx); } else { /* when x contains 0 and k is even, return [0, max(lx^k, rx^k)] */ mpfr_pow(lx,lx,l,GMP_RNDU); mpfr_pow(rx,rx,l,GMP_RNDU); sollya_mpfr_max(rx,lx,rx,GMP_RNDU); mpfr_set_d(lx,0.0,GMP_RNDD); sollya_mpfi_interv_fr(res,lx,rx); } if (must_divide) sollya_mpfi_inv(res,res); mpfr_clear(lx); mpfr_clear(rx); } } else { sollya_mpfi_log(res,x); sollya_mpfi_mul(res,res,y); sollya_mpfi_exp(res,res); } mpfr_clear(l); mpfr_clear(r); sollya_mpfi_set(z,res); sollya_mpfi_clear(res); } void sollya_mpfi_round_to_double(sollya_mpfi_t rop, sollya_mpfi_t op) { mpfr_t l,r, lres, rres; mp_prec_t prec, p, pp; prec = sollya_mpfi_get_prec(op) + 10; pp = sollya_mpfi_get_prec(rop); p = prec; if (pp > p) p = pp; if (64 > p) p = 64; mpfr_init2(l,prec); mpfr_init2(r,prec); mpfr_init2(lres,p); mpfr_init2(rres,p); sollya_mpfi_get_left(l,op); sollya_mpfi_get_right(r,op); mpfr_round_to_double(lres,l); mpfr_round_to_double(rres,r); sollya_mpfi_interv_fr(rop,lres,rres); mpfr_clear(l); mpfr_clear(r); mpfr_clear(lres); mpfr_clear(rres); } void sollya_mpfi_round_to_single(sollya_mpfi_t rop, sollya_mpfi_t op) { mpfr_t l,r, lres, rres; mp_prec_t prec, p, pp; prec = sollya_mpfi_get_prec(op) + 10; pp = sollya_mpfi_get_prec(rop); p = prec; if (pp > p) p = pp; if (64 > p) p = 64; mpfr_init2(l,prec); mpfr_init2(r,prec); mpfr_init2(lres,p); mpfr_init2(rres,p); sollya_mpfi_get_left(l,op); sollya_mpfi_get_right(r,op); mpfr_round_to_single(lres,l); mpfr_round_to_single(rres,r); sollya_mpfi_interv_fr(rop,lres,rres); mpfr_clear(l); mpfr_clear(r); mpfr_clear(lres); mpfr_clear(rres); } void sollya_mpfi_round_to_quad(sollya_mpfi_t rop, sollya_mpfi_t op) { mpfr_t l,r, lres, rres; mp_prec_t prec, p, pp; prec = sollya_mpfi_get_prec(op) + 10; pp = sollya_mpfi_get_prec(rop); p = prec; if (pp > p) p = pp; if (128 > p) p = 128; mpfr_init2(l,prec); mpfr_init2(r,prec); mpfr_init2(lres,p); mpfr_init2(rres,p); sollya_mpfi_get_left(l,op); sollya_mpfi_get_right(r,op); mpfr_round_to_quad(lres,l); mpfr_round_to_quad(rres,r); sollya_mpfi_interv_fr(rop,lres,rres); mpfr_clear(l); mpfr_clear(r); mpfr_clear(lres); mpfr_clear(rres); } void sollya_mpfi_round_to_halfprecision(sollya_mpfi_t rop, sollya_mpfi_t op) { mpfr_t l,r, lres, rres; mp_prec_t prec, p, pp; prec = sollya_mpfi_get_prec(op) + 10; pp = sollya_mpfi_get_prec(rop); p = prec; if (pp > p) p = pp; if (64 > p) p = 64; mpfr_init2(l,prec); mpfr_init2(r,prec); mpfr_init2(lres,p); mpfr_init2(rres,p); sollya_mpfi_get_left(l,op); sollya_mpfi_get_right(r,op); mpfr_round_to_halfprecision(lres,l); mpfr_round_to_halfprecision(rres,r); sollya_mpfi_interv_fr(rop,lres,rres); mpfr_clear(l); mpfr_clear(r); mpfr_clear(lres); mpfr_clear(rres); } void sollya_mpfi_round_to_doubledouble(sollya_mpfi_t rop, sollya_mpfi_t op) { mpfr_t l,r, lres, rres; mp_prec_t prec, p, pp; prec = sollya_mpfi_get_prec(op) + 10; pp = sollya_mpfi_get_prec(rop); p = prec; if (pp > p) p = pp; if (129 > p) p = 129; mpfr_init2(l,prec); mpfr_init2(r,prec); mpfr_init2(lres,p); mpfr_init2(rres,p); sollya_mpfi_get_left(l,op); sollya_mpfi_get_right(r,op); mpfr_round_to_doubledouble(lres,l); mpfr_round_to_doubledouble(rres,r); sollya_mpfi_interv_fr(rop,lres,rres); mpfr_clear(l); mpfr_clear(r); mpfr_clear(lres); mpfr_clear(rres); } void sollya_mpfi_round_to_tripledouble(sollya_mpfi_t rop, sollya_mpfi_t op) { mpfr_t l,r, lres, rres; mp_prec_t prec, p, pp; prec = sollya_mpfi_get_prec(op) + 10; pp = sollya_mpfi_get_prec(rop); p = prec; if (pp > p) p = pp; if (200 > p) p = 200; mpfr_init2(l,prec); mpfr_init2(r,prec); mpfr_init2(lres,p); mpfr_init2(rres,p); sollya_mpfi_get_left(l,op); sollya_mpfi_get_right(r,op); mpfr_round_to_tripledouble(lres,l); mpfr_round_to_tripledouble(rres,r); sollya_mpfi_interv_fr(rop,lres,rres); mpfr_clear(l); mpfr_clear(r); mpfr_clear(lres); mpfr_clear(rres); } void sollya_mpfi_round_to_doubleextended(sollya_mpfi_t rop, sollya_mpfi_t op) { mpfr_t l,r, lres, rres; mp_prec_t prec, p, pp; prec = sollya_mpfi_get_prec(op) + 10; pp = sollya_mpfi_get_prec(rop); p = prec; if (pp > p) p = pp; if (128 > p) p = 128; mpfr_init2(l,prec); mpfr_init2(r,prec); mpfr_init2(lres,p); mpfr_init2(rres,p); sollya_mpfi_get_left(l,op); sollya_mpfi_get_right(r,op); mpfr_round_to_doubleextended(lres,l); mpfr_round_to_doubleextended(rres,r); sollya_mpfi_interv_fr(rop,lres,rres); mpfr_clear(l); mpfr_clear(r); mpfr_clear(lres); mpfr_clear(rres); } void sollya_mpfi_erf(sollya_mpfi_t rop, sollya_mpfi_t op) { mpfr_t opl, opr, ropl, ropr; mpfr_init2(opl,sollya_mpfi_get_prec(op)); mpfr_init2(opr,sollya_mpfi_get_prec(op)); mpfr_init2(ropl,sollya_mpfi_get_prec(rop)); mpfr_init2(ropr,sollya_mpfi_get_prec(rop)); sollya_mpfi_get_left(opl,op); sollya_mpfi_get_right(opr,op); mpfr_erf(ropl,opl,GMP_RNDD); mpfr_erf(ropr,opr,GMP_RNDU); sollya_mpfi_interv_fr(rop,ropl,ropr); mpfr_clear(opl); mpfr_clear(opr); mpfr_clear(ropl); mpfr_clear(ropr); } void sollya_mpfi_erfc(sollya_mpfi_t rop, sollya_mpfi_t op) { mpfr_t opl, opr, ropl, ropr; mpfr_init2(opl,sollya_mpfi_get_prec(op)); mpfr_init2(opr,sollya_mpfi_get_prec(op)); mpfr_init2(ropl,sollya_mpfi_get_prec(rop)); mpfr_init2(ropr,sollya_mpfi_get_prec(rop)); sollya_mpfi_get_left(opl,op); sollya_mpfi_get_right(opr,op); mpfr_erfc(ropl,opr,GMP_RNDD); mpfr_erfc(ropr,opl,GMP_RNDU); sollya_mpfi_interv_fr(rop,ropl,ropr); mpfr_clear(opl); mpfr_clear(opr); mpfr_clear(ropl); mpfr_clear(ropr); } void sollya_mpfi_ceil(sollya_mpfi_t rop, sollya_mpfi_t op) { mpfr_t opl, opr, ropl, ropr; mpfr_init2(opl,sollya_mpfi_get_prec(op)); mpfr_init2(opr,sollya_mpfi_get_prec(op)); mpfr_init2(ropl,sollya_mpfi_get_prec(rop)); mpfr_init2(ropr,sollya_mpfi_get_prec(rop)); sollya_mpfi_get_left(opl,op); sollya_mpfi_get_right(opr,op); mpfr_rint_ceil(ropl,opl,GMP_RNDD); mpfr_rint_ceil(ropr,opr,GMP_RNDU); sollya_mpfi_interv_fr(rop,ropl,ropr); mpfr_clear(opl); mpfr_clear(opr); mpfr_clear(ropl); mpfr_clear(ropr); } void sollya_mpfi_floor(sollya_mpfi_t rop, sollya_mpfi_t op) { mpfr_t opl, opr, ropl, ropr; mpfr_init2(opl,sollya_mpfi_get_prec(op)); mpfr_init2(opr,sollya_mpfi_get_prec(op)); mpfr_init2(ropl,sollya_mpfi_get_prec(rop)); mpfr_init2(ropr,sollya_mpfi_get_prec(rop)); sollya_mpfi_get_left(opl,op); sollya_mpfi_get_right(opr,op); mpfr_rint_floor(ropl,opl,GMP_RNDD); mpfr_rint_floor(ropr,opr,GMP_RNDU); sollya_mpfi_interv_fr(rop,ropl,ropr); mpfr_clear(opl); mpfr_clear(opr); mpfr_clear(ropl); mpfr_clear(ropr); } void sollya_mpfi_nearestint(sollya_mpfi_t rop, sollya_mpfi_t op) { mpfr_t opl, opr, ropl, ropr; mpfr_init2(opl,sollya_mpfi_get_prec(op)); mpfr_init2(opr,sollya_mpfi_get_prec(op)); mpfr_init2(ropl,sollya_mpfi_get_prec(rop)); mpfr_init2(ropr,sollya_mpfi_get_prec(rop)); sollya_mpfi_get_left(opl,op); sollya_mpfi_get_right(opr,op); sollya_mpfr_rint_nearestint(ropl,opl,GMP_RNDD); sollya_mpfr_rint_nearestint(ropr,opr,GMP_RNDU); sollya_mpfi_interv_fr(rop,ropl,ropr); mpfr_clear(opl); mpfr_clear(opr); mpfr_clear(ropl); mpfr_clear(ropr); } /* Evaluate a library constant function into an interval */ void libraryConstantToInterval(sollya_mpfi_t res, node *tree) { mpfr_t approx, lbound, rbound; mp_prec_t prec = sollya_mpfi_get_prec(res); mpfr_init2(approx, prec + 20); /* some guard bits may avoid reinit in tree->libFun */ if (accessThruMemRef(tree)->libFun->hasData) { ((void (*)(mpfr_t, mp_prec_t, void *)) (accessThruMemRef(tree)->libFun->code))(approx, prec, accessThruMemRef(tree)->libFun->data); } else { ((void (*)(mpfr_t, mp_prec_t)) (accessThruMemRef(tree)->libFun->code))(approx, prec); } mpfr_init2(lbound, prec-2); mpfr_init2(rbound, prec-2); mpfr_set(lbound, approx, GMP_RNDD); mpfr_set(rbound, approx, GMP_RNDU); mpfr_nextbelow(lbound); mpfr_nextabove(rbound); sollya_mpfi_interv_fr(res, lbound, rbound); mpfr_clear(approx); mpfr_clear(lbound); mpfr_clear(rbound); return; } void evaluateNewtonMPFRWithStartPoint(mpfr_t result, node *tree, mpfr_t x, mp_prec_t prec, mpfr_t a, mpfr_t b) { mp_prec_t p; mpfr_t myX; if ((mpfr_number_p(x) && mpfr_number_p(a) && mpfr_number_p(b)) && ((mpfr_cmp(a, x) <= 0) && (mpfr_cmp(x, b) <= 0))) { evaluate(result, tree, x, prec); } p = mpfr_get_prec(a); if (mpfr_get_prec(b) > p) p = mpfr_get_prec(b); if (mpfr_get_prec(x) > p) p = mpfr_get_prec(x); mpfr_init2(myX, p); if (mpfr_cmp(x, a) < 0) { mpfr_set(myX, a, GMP_RNDN); } else { if (mpfr_cmp(b, x) < 0) { mpfr_set(myX, b, GMP_RNDN); } else { mpfr_set(myX, x, GMP_RNDN); } } evaluate(result, tree, myX, prec); mpfr_clear(myX); } int newtonMPFRWithStartPoint(mpfr_t res, node *tree, node *diff_tree, mpfr_t a, mpfr_t b, mpfr_t start, mp_prec_t prec) { mpfr_t x, x2, temp1, temp2, am, bm, tempX, tempY; unsigned long int n=1; int okay, lucky, hasZero, i, freeTrees; node *myTree, *myDiffTree; if (mpfr_sgn(a) * mpfr_sgn(b) <= 0) { mpfr_init2(tempX, 12); mpfr_init2(tempY, 12); mpfr_set_si(tempX, 0, GMP_RNDN); evaluateNewtonMPFRWithStartPoint(tempY, tree, tempX, prec, a, b); if (mpfr_zero_p(tempY)) { mpfr_set(res,tempY,GMP_RNDN); mpfr_clear(tempY); mpfr_clear(tempX); return 1; } mpfr_clear(tempY); mpfr_clear(tempX); } freeTrees = 0; if (accessThruMemRef(tree)->nodeType == DIV) { freeTrees = 1; myTree = copyTree(accessThruMemRef(tree)->child1); myDiffTree = differentiate(myTree); } else { myTree = tree; myDiffTree = diff_tree; } mpfr_init2(x,prec); mpfr_init2(x2,prec); mpfr_init2(temp1,prec); mpfr_init2(temp2,prec); mpfr_init2(am,prec/2); mpfr_init2(bm,prec/2); mpfr_set(am,a,GMP_RNDN); mpfr_nextbelow(am); mpfr_nextbelow(am); mpfr_set(bm,b,GMP_RNDN); mpfr_nextabove(am); mpfr_nextabove(bm); okay = 0; if (mpfr_sgn(a) != mpfr_sgn(b)) { mpfr_set_d(x,0.0,GMP_RNDN); evaluateNewtonMPFRWithStartPoint(temp1, myTree, x, prec, a, b); if (mpfr_zero_p(temp1)) { mpfr_set(res,x,GMP_RNDN); okay = 1; } } if (!okay) { evaluateNewtonMPFRWithStartPoint(temp1, myTree, a, prec, a, b); if (mpfr_zero_p(temp1)) { mpfr_set(res,a,GMP_RNDN); okay = 1; } else { evaluateNewtonMPFRWithStartPoint(temp2, myTree, b, prec, a, b); if (mpfr_zero_p(temp2)) { mpfr_set(res,b,GMP_RNDN); okay = 1; } else { mpfr_mul(temp1,temp1,temp2,GMP_RNDN); hasZero = (mpfr_sgn(temp1) <= 0); mpfr_set(x,start,GMP_RNDN); lucky = 0; i = 5000; while((n<=(unsigned long int) prec+25) && (mpfr_cmp(am,x) <= 0) && (mpfr_cmp(x,bm) <= 0) && (i > 0)) { evaluateNewtonMPFRWithStartPoint(temp1, myTree, x, prec, a, b); if (mpfr_zero_p(temp1)) { lucky = 1; break; } evaluateNewtonMPFRWithStartPoint(temp2, myDiffTree, x, prec, a, b); mpfr_div(temp1, temp1, temp2, GMP_RNDN); mpfr_sub(x2, x, temp1, GMP_RNDN); if (mpfr_cmp(x2,x) == 0) break; if (mpfr_zero_p(x) || mpfr_zero_p(x2)) { n *= 2; } else { if (mpfr_get_exp(x) == mpfr_get_exp(x2)) { n *= 2; } else { i--; } } mpfr_set(x,x2,GMP_RNDN); } if (mpfr_cmp(x,a) < 0) { mpfr_set(res,a,GMP_RNDN); if (hasZero) { okay = 1; } else { evaluateNewtonMPFRWithStartPoint(temp1, myTree, x, prec, a, b); evaluateNewtonMPFRWithStartPoint(temp2, myDiffTree, x, prec, a, b); mpfr_div(temp1, temp1, temp2, GMP_RNDN); mpfr_sub(x, x, temp1, GMP_RNDN); if (mpfr_cmp(x,a) >= 0) { okay = 1; } else { okay = 0; } } } else { if (mpfr_cmp(b,x) < 0) { mpfr_set(res,b,GMP_RNDN); if (hasZero) { okay = 1; } else { evaluateNewtonMPFRWithStartPoint(temp1, myTree, x, prec, a, b); evaluateNewtonMPFRWithStartPoint(temp2, myDiffTree, x, prec, a, b); mpfr_div(temp1, temp1, temp2, GMP_RNDN); mpfr_sub(x, x, temp1, GMP_RNDN); if (mpfr_cmp(b,x) >= 0) { okay = 1; } else { okay = 0; } } } else { mpfr_set(res,x,GMP_RNDN); if (!lucky) { evaluateNewtonMPFRWithStartPoint(temp1, myTree, x, prec, a, b); evaluateNewtonMPFRWithStartPoint(temp2, myDiffTree, x, prec, a, b); mpfr_div(temp1, temp1, temp2, GMP_RNDN); mpfr_abs(temp1,temp1,GMP_RNDN); mpfr_abs(x,x,GMP_RNDN); mpfr_div_ui(x,x,1,GMP_RNDN); okay = (mpfr_cmp(temp1,x) <= 0); } else { okay = 1; } } } } } } if (freeTrees) { free_memory(myTree); free_memory(myDiffTree); } mpfr_clear(x); mpfr_clear(temp1); mpfr_clear(temp2); mpfr_clear(x2); mpfr_clear(am); mpfr_clear(bm); return okay; } int newtonMPFR(mpfr_t res, node *tree, node *diff_tree, mpfr_t a, mpfr_t b, mp_prec_t prec) { mpfr_t start; int result; mpfr_init2(start,prec); mpfr_add(start,a,b,GMP_RNDN); mpfr_div_2ui(start,start,1,GMP_RNDN); result = newtonMPFRWithStartPoint(res, tree, diff_tree, a, b, start, prec); mpfr_clear(start); return result; } void makeMpfiAroundMpfr(sollya_mpfi_t res, mpfr_t x, unsigned int thousandUlps) { mpfr_t xp, xs; mp_prec_t prec; sollya_mpfi_t xI; prec = mpfr_get_prec(x); mpfr_init2(xp,prec); mpfr_init2(xs,prec); sollya_mpfi_init2(xI,prec); mpfr_set(xp,x,GMP_RNDD); mpfr_set(xs,x,GMP_RNDU); mpfr_nextbelow(xp); mpfr_nextabove(xs); sollya_mpfi_interv_fr(xI,xp,xs); sollya_mpfi_blow(xI,xI,(((double) thousandUlps) * 250.0)); /* THIS CAST IS DANGEROUS ON SYSTEMS WHERE INTS ARE 64 BITS */ sollya_mpfi_set(res,xI); sollya_mpfi_clear(xI); mpfr_clear(xp); mpfr_clear(xs); } static inline sollya_mpfi_t *chooseAndInitMpfiPtr(sollya_mpfi_t *localPtr, mp_prec_t prec) { sollya_mpfi_t *ptr; ptr = getReusedGlobalMPFIVars(1, prec); if (ptr == NULL) { sollya_mpfi_init2(*localPtr, prec); ptr = localPtr; } return ptr; } static inline void clearChosenMpfiPtr(sollya_mpfi_t *ptr, sollya_mpfi_t *localPtr) { if (ptr == localPtr) { sollya_mpfi_clear(*localPtr); return; } returnReusedGlobalMPIVars(1); } static inline chain* evaluateIRec(sollya_mpfi_t result, node *tree, sollya_mpfi_t x, mp_prec_t prec, int simplifiesA, int simplifiesB, mpfr_t *hopitalPoint, exprBoundTheo *theo, int noExcludes, int fastAddSub, int workForThinArg, int noLazyHooks, mp_exp_t *cutoff, int *lazyHookUsed) { sollya_mpfi_t stack1, stack2, tempI, tempI2; sollya_mpfi_t stack3, zI, numeratorInZI, denominatorInZI, newExcludeTemp, xMXZ, temp1, temp2, tempA, tempB; sollya_mpfi_t *newExclude; sollya_mpfi_t leftConstantTerm, rightConstantTerm; sollya_mpfi_t leftLinearTerm, rightLinearTerm; mpfr_t al, ar, bl, br, xl, xr, z, z2; mpfr_t *newHopitalPoint; node *derivNumerator, *derivDenominator, *tempNode; node *derivLeft, *derivRight; chain *leftExcludes, *rightExcludes, *excludes, *t1, *t2; chain *leftExcludesConstant, *rightExcludesConstant; chain *leftExcludesLinear, *rightExcludesLinear; exprBoundTheo *leftTheo, *rightTheo, *internalTheo; exprBoundTheo *leftTheoConstant, *rightTheoConstant, *leftTheoLinear, *rightTheoLinear; int isPolynom; int xIsPoint; sollya_mpfi_t tempInterval; mp_prec_t *precPtr; sollya_mpfi_t *intervalPtr; sollya_mpfi_t *reusedVars; node *tC1, *tC2, *temp; int workForThin; mp_prec_t pxppp, ppppp; int leftRecursionDone, rightRecursionDone; sollya_mpfi_t leftRecursionResult, rightRecursionResult; leftRecursionDone = 0; rightRecursionDone = 0; workForThin = workForThinArg; if (tree->nodeType == MEMREF) { if ((theo != NULL) || (!noExcludes)) return evaluateIRec(result, getMemRefChild(tree), x, prec, simplifiesA, simplifiesB, hopitalPoint, theo, noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); if ((tree->arguments != NULL) && (*((mp_prec_t *) tree->arguments->value) >= prec)) { sollya_mpfi_set(result, *((sollya_mpfi_t *) tree->arguments->next->value)); if (!(sollya_mpfi_has_nan(result) || sollya_mpfi_has_infinity(result))) return NULL; } if ((tree->evalCacheX != NULL) && (tree->evalCacheY != NULL) && (tree->evalCachePrec >= prec) && (sollya_mpfi_get_prec(*(tree->evalCacheY)) >= sollya_mpfi_get_prec(result)) && (sollya_mpfi_equal_p(*(tree->evalCacheX), x))) { sollya_mpfi_set(result, *(tree->evalCacheY)); if (!(sollya_mpfi_has_nan(result) || sollya_mpfi_has_infinity(result))) return NULL; } if (evaluateWithEvaluationHook(result, x, prec, 1, tree->evaluationHook)) { excludes = NULL; } else { if ((!noLazyHooks) && (evaluateWithEvaluationHook(result, x, prec, 0, tree->evaluationHook))) { excludes = NULL; if (lazyHookUsed != NULL) { *lazyHookUsed |= 1; *lazyHookUsed = !!*lazyHookUsed; } } else { if (tree->polynomialRepresentation != NULL) { polynomialEvalMpfi(result, tree->polynomialRepresentation, x); excludes = NULL; } else { excludes = evaluateIRec(result, getMemRefChild(tree), x, prec, simplifiesA, simplifiesB, hopitalPoint, theo, noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } } } if ((excludes == NULL) && (!(sollya_mpfi_has_nan(result) || sollya_mpfi_has_infinity(result)))) { if (tree->evalCacheX == NULL) { tree->evalCacheX = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); tree->evalCacheY = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(tree->evalCacheX),sollya_mpfi_get_prec(x)); sollya_mpfi_init2(*(tree->evalCacheY),sollya_mpfi_get_prec(result)); sollya_mpfi_set(*(tree->evalCacheX), x); sollya_mpfi_set(*(tree->evalCacheY), result); tree->evalCachePrec = prec; } else { sollya_mpfi_set_prec(*(tree->evalCacheX),sollya_mpfi_get_prec(x)); sollya_mpfi_set_prec(*(tree->evalCacheY),sollya_mpfi_get_prec(result)); sollya_mpfi_set(*(tree->evalCacheX), x); sollya_mpfi_set(*(tree->evalCacheY), result); tree->evalCachePrec = prec; } if (tree->arguments != NULL) { if (prec > *((mp_prec_t *) tree->arguments->value)) { *((mp_prec_t *) tree->arguments->value) = prec; sollya_mpfi_init2(tempInterval, sollya_mpfi_get_prec(*((sollya_mpfi_t *) tree->arguments->next->value))); sollya_mpfi_set(tempInterval, *((sollya_mpfi_t *) tree->arguments->next->value)); sollya_mpfi_set_prec(*((sollya_mpfi_t *) tree->arguments->next->value), sollya_mpfi_get_prec(result)); sollya_mpfi_intersect(*((sollya_mpfi_t *) tree->arguments->next->value), tempInterval, result); sollya_mpfi_clear(tempInterval); } } else { if (isConstant(tree)) { precPtr = (mp_prec_t *) safeMalloc(sizeof(mp_prec_t)); *precPtr = prec; intervalPtr = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*intervalPtr, sollya_mpfi_get_prec(result)); sollya_mpfi_set(*intervalPtr, result); tree->arguments = addElement(addElement(NULL, intervalPtr), precPtr); } } } return excludes; } excludes = NULL; if (theo != NULL) nullifyExprBoundTheo(theo); isPolynom = 0; internalTheo = NULL; if (theo != NULL) { isPolynom = isPolynomial(tree); if (isPolynom) { theo->functionType = POLYNOMIAL; leftTheo = NULL; rightTheo = NULL; } else { internalTheo = theo; internalTheo->functionType = tree->nodeType; switch (arity(tree)) { case 1: leftTheo = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); rightTheo = NULL; internalTheo->boundLeft = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundLeft),prec); break; case 2: leftTheo = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); rightTheo = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); internalTheo->boundLeft = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundLeft),prec); internalTheo->boundRight = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundRight),prec); break; default: leftTheo = NULL; rightTheo = NULL; break; } internalTheo->theoLeft = leftTheo; internalTheo->theoRight = rightTheo; } theo->x = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->x),sollya_mpfi_get_prec(x)); sollya_mpfi_set(*(theo->x),x); theo->function = copyTree(tree); } else { leftTheo = NULL; rightTheo = NULL; } if ((theo == NULL) && noExcludes) { switch (tree->nodeType) { case MUL: case DIV: if ((tree->child1->nodeType == MEMREF) && (tree->child2->nodeType == MEMREF)) { if ((tree->child1->evalCacheX != NULL) && (tree->child1->evalCacheY != NULL) && (tree->child2->evalCacheX != NULL) && (tree->child2->evalCacheY != NULL)) { if (sollya_mpfi_equal_p(*(tree->child1->evalCacheX), x) && sollya_mpfi_equal_p(*(tree->child2->evalCacheX), x)) { switch (tree->nodeType) { case MUL: if ((sollya_mpfi_is_zero(*(tree->child1->evalCacheY)) || sollya_mpfi_is_zero(*(tree->child2->evalCacheY))) && (!(sollya_mpfi_has_infinity(*(tree->child1->evalCacheY)) || sollya_mpfi_has_infinity(*(tree->child2->evalCacheY)) || sollya_mpfi_has_nan(*(tree->child1->evalCacheY)) || sollya_mpfi_has_nan(*(tree->child2->evalCacheY))))) { sollya_mpfi_set_si(result, 0); return NULL; } break; case DIV: if ((sollya_mpfi_is_zero(*(tree->child1->evalCacheY)) && (!sollya_mpfi_has_zero(*(tree->child2->evalCacheY)))) && (!(sollya_mpfi_has_infinity(*(tree->child1->evalCacheY)) || sollya_mpfi_has_infinity(*(tree->child2->evalCacheY)) || sollya_mpfi_has_nan(*(tree->child1->evalCacheY)) || sollya_mpfi_has_nan(*(tree->child2->evalCacheY))))) { sollya_mpfi_set_si(result, 0); return NULL; } break; } } } } } } if ((theo == NULL) && noExcludes && (sollya_mpfi_get_prec(result) >= prec)) { switch (tree->nodeType) { case VARIABLE: sollya_mpfi_set(result, x); return NULL; break; case CONSTANT: sollya_mpfi_set_fr(result,*(tree->value)); return NULL; break; case PI_CONST: sollya_mpfi_const_pi(result); return NULL; break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case DOUBLE: case SINGLE: case HALFPRECISION: case QUAD: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case CEIL: case FLOOR: case NEARESTINT: evaluateIRec(result, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, NULL, 1, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); switch (tree->nodeType) { case SQRT: sollya_mpfi_sqrt(result, result); break; case EXP: sollya_mpfi_exp(result, result); break; case LOG: sollya_mpfi_log(result, result); break; case LOG_2: sollya_mpfi_log2(result, result); break; case LOG_10: sollya_mpfi_log10(result, result); break; case SIN: sollya_mpfi_sin(result, result); break; case COS: sollya_mpfi_cos(result, result); break; case TAN: sollya_mpfi_tan(result, result); break; case ASIN: sollya_mpfi_asin(result, result); break; case ACOS: sollya_mpfi_acos(result, result); break; case ATAN: sollya_mpfi_atan(result, result); break; case SINH: sollya_mpfi_sinh(result, result); break; case COSH: sollya_mpfi_cosh(result, result); break; case TANH: sollya_mpfi_tanh(result, result); break; case ASINH: sollya_mpfi_asinh(result, result); break; case ACOSH: sollya_mpfi_acosh(result, result); break; case ATANH: sollya_mpfi_atanh(result, result); break; case NEG: sollya_mpfi_neg(result, result); break; case ABS: sollya_mpfi_abs(result, result); break; case DOUBLE: sollya_mpfi_round_to_double(result, result); break; case SINGLE: sollya_mpfi_round_to_single(result, result); break; case HALFPRECISION: sollya_mpfi_round_to_halfprecision(result, result); break; case QUAD: sollya_mpfi_round_to_quad(result, result); break; case DOUBLEDOUBLE: sollya_mpfi_round_to_doubledouble(result, result); break; case TRIPLEDOUBLE: sollya_mpfi_round_to_tripledouble(result, result); break; case ERF: sollya_mpfi_erf(result, result); break; case ERFC: sollya_mpfi_erfc(result, result); break; case LOG_1P: sollya_mpfi_log1p(result, result); break; case EXP_M1: sollya_mpfi_expm1(result, result); break; case DOUBLEEXTENDED: sollya_mpfi_round_to_doubleextended(result, result); break; case CEIL: sollya_mpfi_ceil(result, result); break; case FLOOR: sollya_mpfi_floor(result, result); break; case NEARESTINT: sollya_mpfi_nearestint(result, result); break; } return NULL; break; default: break; } } if ((theo == NULL) && noExcludes && (!(sollya_mpfi_has_nan(x) || sollya_mpfi_has_infinity(x)))) { switch (tree->nodeType) { case VARIABLE: sollya_mpfi_set(result, x); return NULL; break; case CONSTANT: sollya_mpfi_set_fr(result,*(tree->value)); return NULL; break; case PI_CONST: sollya_mpfi_const_pi(result); return NULL; break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case DOUBLE: case SINGLE: case HALFPRECISION: case QUAD: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case CEIL: case FLOOR: case NEARESTINT: reusedVars = getReusedGlobalMPFIVars(1, prec); if (reusedVars == NULL) break; evaluateIRec(reusedVars[0], tree->child1, x, prec, simplifiesA, simplifiesB, NULL, NULL,1, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); if (sollya_mpfi_has_nan(reusedVars[0]) || sollya_mpfi_has_infinity(reusedVars[0])) { leftRecursionDone = 1; sollya_mpfi_init2(leftRecursionResult, sollya_mpfi_get_prec(reusedVars[0])); sollya_mpfi_set(leftRecursionResult, reusedVars[0]); returnReusedGlobalMPIVars(1); break; } switch (tree->nodeType) { case SQRT: sollya_mpfi_sqrt(result, reusedVars[0]); break; case EXP: sollya_mpfi_exp(result, reusedVars[0]); break; case LOG: sollya_mpfi_log(result, reusedVars[0]); break; case LOG_2: sollya_mpfi_log2(result, reusedVars[0]); break; case LOG_10: sollya_mpfi_log10(result, reusedVars[0]); break; case SIN: sollya_mpfi_sin(result, reusedVars[0]); break; case COS: sollya_mpfi_cos(result, reusedVars[0]); break; case TAN: sollya_mpfi_tan(result, reusedVars[0]); break; case ASIN: sollya_mpfi_asin(result, reusedVars[0]); break; case ACOS: sollya_mpfi_acos(result, reusedVars[0]); break; case ATAN: sollya_mpfi_atan(result, reusedVars[0]); break; case SINH: sollya_mpfi_sinh(result, reusedVars[0]); break; case COSH: sollya_mpfi_cosh(result, reusedVars[0]); break; case TANH: sollya_mpfi_tanh(result, reusedVars[0]); break; case ASINH: sollya_mpfi_asinh(result, reusedVars[0]); break; case ACOSH: sollya_mpfi_acosh(result, reusedVars[0]); break; case ATANH: sollya_mpfi_atanh(result, reusedVars[0]); break; case NEG: sollya_mpfi_neg(result, reusedVars[0]); break; case ABS: sollya_mpfi_abs(result, reusedVars[0]); break; case DOUBLE: sollya_mpfi_round_to_double(result, reusedVars[0]); break; case SINGLE: sollya_mpfi_round_to_single(result, reusedVars[0]); break; case HALFPRECISION: sollya_mpfi_round_to_halfprecision(result, reusedVars[0]); break; case QUAD: sollya_mpfi_round_to_quad(result, reusedVars[0]); break; case DOUBLEDOUBLE: sollya_mpfi_round_to_doubledouble(result, reusedVars[0]); break; case TRIPLEDOUBLE: sollya_mpfi_round_to_tripledouble(result, reusedVars[0]); break; case ERF: sollya_mpfi_erf(result, reusedVars[0]); break; case ERFC: sollya_mpfi_erfc(result, reusedVars[0]); break; case LOG_1P: sollya_mpfi_log1p(result, reusedVars[0]); break; case EXP_M1: sollya_mpfi_expm1(result, reusedVars[0]); break; case DOUBLEEXTENDED: sollya_mpfi_round_to_doubleextended(result, reusedVars[0]); break; case CEIL: sollya_mpfi_ceil(result, reusedVars[0]); break; case FLOOR: sollya_mpfi_floor(result, reusedVars[0]); break; case NEARESTINT: sollya_mpfi_nearestint(result, reusedVars[0]); break; } returnReusedGlobalMPIVars(1); return NULL; break; case ADD: /* Fall-through */ case SUB: if (!fastAddSub) break; /* The fall-through is intended */ case MUL: case POW: reusedVars = getReusedGlobalMPFIVars(2, prec); if (reusedVars != NULL) { evaluateIRec(reusedVars[0], tree->child1, x, prec, simplifiesA, simplifiesB, NULL, NULL,1, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); evaluateIRec(reusedVars[1], tree->child2, x, prec, simplifiesA, simplifiesB, NULL, NULL,1, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); if (sollya_mpfi_has_nan(reusedVars[0]) || sollya_mpfi_has_infinity(reusedVars[0]) || sollya_mpfi_has_nan(reusedVars[1]) || sollya_mpfi_has_infinity(reusedVars[1])) { leftRecursionDone = 1; sollya_mpfi_init2(leftRecursionResult, sollya_mpfi_get_prec(reusedVars[0])); sollya_mpfi_set(leftRecursionResult, reusedVars[0]); rightRecursionDone = 1; sollya_mpfi_init2(rightRecursionResult, sollya_mpfi_get_prec(reusedVars[1])); sollya_mpfi_set(rightRecursionResult, reusedVars[1]); returnReusedGlobalMPIVars(2); } else { switch (tree->nodeType) { case ADD: sollya_mpfi_add(result, reusedVars[0], reusedVars[1]); break; case SUB: sollya_mpfi_sub(result, reusedVars[0], reusedVars[1]); break; case MUL: sollya_mpfi_mul(result, reusedVars[0], reusedVars[1]); break; case POW: sollya_mpfi_pow(result, reusedVars[0], reusedVars[1]); break; } returnReusedGlobalMPIVars(2); return NULL; } } else { sollya_mpfi_init2(stack1, prec); sollya_mpfi_init2(stack2, prec); evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, NULL,1, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); evaluateIRec(stack2, tree->child2, x, prec, simplifiesA, simplifiesB, NULL, NULL,1, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); if (sollya_mpfi_has_nan(stack1) || sollya_mpfi_has_infinity(stack1) || sollya_mpfi_has_nan(stack2) || sollya_mpfi_has_infinity(stack2)) { leftRecursionDone = 1; sollya_mpfi_init2(leftRecursionResult, sollya_mpfi_get_prec(stack1)); sollya_mpfi_set(leftRecursionResult, stack1); rightRecursionDone = 1; sollya_mpfi_init2(rightRecursionResult, sollya_mpfi_get_prec(stack2)); sollya_mpfi_set(rightRecursionResult, stack2); sollya_mpfi_clear(stack2); sollya_mpfi_clear(stack1); } else { switch (tree->nodeType) { case ADD: sollya_mpfi_add(result, stack1, stack2); break; case SUB: sollya_mpfi_sub(result, stack1, stack2); break; case MUL: sollya_mpfi_mul(result, stack1, stack2); break; case POW: sollya_mpfi_pow(result, stack1, stack2); break; } sollya_mpfi_clear(stack2); sollya_mpfi_clear(stack1); return NULL; } } break; default: break; } } sollya_mpfi_init2(stack1, prec); sollya_mpfi_init2(stack2, prec); sollya_mpfi_init2(stack3, prec); mpfr_init2(al,prec); mpfr_init2(ar,prec); mpfr_init2(bl,prec); mpfr_init2(br,prec); sollya_mpfi_diam_abs(al,x); if (mpfr_zero_p(al)) xIsPoint = 1; else xIsPoint = 0; switch (tree->nodeType) { case VARIABLE: sollya_mpfi_set(stack3,x); excludes = NULL; break; case CONSTANT: sollya_mpfi_set_fr(stack3,*(tree->value)); excludes = NULL; break; case ADD: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); leftExcludes = NULL; } else { leftExcludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } if (noExcludes && rightRecursionDone) { sollya_mpfi_set(stack2, rightRecursionResult); rightExcludes = NULL; } else { rightExcludes = evaluateIRec(stack2, tree->child2, x, prec, simplifiesA, simplifiesB, NULL, rightTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_add(stack3, stack1, stack2); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); sollya_mpfi_set(*(internalTheo->boundRight),stack2); } if ((simplifiesA > 0) && (sollya_mpfi_has_zero(stack3)) && (!sollya_mpfi_has_zero(stack1)) && (!sollya_mpfi_has_zero(stack2)) && !xIsPoint) { if (internalTheo != NULL) { internalTheo->simplificationUsed = DECORRELATE; leftTheoConstant = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(leftTheoConstant); rightTheoConstant = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(rightTheoConstant); leftTheoLinear = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(leftTheoLinear); rightTheoLinear = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(rightTheoLinear); internalTheo->theoLeftConstant = leftTheoConstant; internalTheo->theoRightConstant = rightTheoConstant; internalTheo->theoLeftLinear = leftTheoLinear; internalTheo->theoRightLinear = rightTheoLinear; } else { leftTheoConstant = NULL; rightTheoConstant = NULL; leftTheoLinear = NULL; rightTheoLinear = NULL; } mpfr_init2(z,prec); sollya_mpfi_init2(zI,prec); sollya_mpfi_init2(leftConstantTerm,prec); sollya_mpfi_init2(rightConstantTerm,prec); sollya_mpfi_init2(leftLinearTerm,prec); sollya_mpfi_init2(rightLinearTerm,prec); sollya_mpfi_init2(xMXZ,prec); sollya_mpfi_init2(temp1,prec); sollya_mpfi_init2(temp2,prec); sollya_mpfi_init2(tempA,prec); sollya_mpfi_init2(tempB,prec); sollya_mpfi_mid(z,x); sollya_mpfi_set_fr(zI,z); leftExcludesConstant = evaluateIRec(leftConstantTerm, tree->child1, zI, prec, simplifiesA-1, simplifiesB, NULL, leftTheoConstant,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); rightExcludesConstant = evaluateIRec(rightConstantTerm, tree->child2, zI, prec, simplifiesA-1, simplifiesB, NULL, rightTheoConstant,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); printMessage(12,SOLLYA_MSG_DIFFERENTIATING_FOR_DECORRELATION,"Information: Differentiating while evaluating for decorrelation.\n"); derivLeft = differentiate(tree->child1); derivRight = differentiate(tree->child2); leftExcludesLinear = evaluateIRec(leftLinearTerm, derivLeft, x, prec, simplifiesA-1, simplifiesB, NULL, leftTheoLinear,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); rightExcludesLinear = evaluateIRec(rightLinearTerm, derivRight, x, prec, simplifiesA-1, simplifiesB, NULL, rightTheoLinear,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); sollya_mpfi_add(tempA,leftConstantTerm,rightConstantTerm); sollya_mpfi_add(tempB,leftLinearTerm,rightLinearTerm); sollya_mpfi_sub(xMXZ,x,zI); sollya_mpfi_mul(temp2,xMXZ,tempB); sollya_mpfi_add(temp1,tempA,temp2); sollya_mpfi_get_left(al,temp1); sollya_mpfi_get_right(ar,temp1); if (mpfr_number_p(al) && mpfr_number_p(ar)) { printMessage(8,SOLLYA_MSG_DECORRELATION_INTERVAL_ADDITION_OR_SUBTRACTION,"Information: decorrelating an interval addition.\n"); sollya_mpfi_intersect(stack3,stack3,temp1); if (!noExcludes) { excludes = concatChains(leftExcludes,rightExcludes); excludes = concatChains(excludes,leftExcludesConstant); excludes = concatChains(excludes,rightExcludesConstant); excludes = concatChains(excludes,leftExcludesLinear); excludes = concatChains(excludes,rightExcludesLinear); } if (internalTheo != NULL) { internalTheo->boundLeftConstant = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundLeftConstant),prec); internalTheo->boundRightConstant = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundRightConstant),prec); internalTheo->boundLeftLinear = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundLeftLinear),prec); internalTheo->boundRightLinear = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundRightLinear),prec); internalTheo->xZ = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->xZ),prec); internalTheo->xMXZ = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->xMXZ),prec); internalTheo->leftDerivative = copyTree(derivLeft); internalTheo->rightDerivative = copyTree(derivRight); sollya_mpfi_set(*(internalTheo->boundLeftConstant),leftConstantTerm); sollya_mpfi_set(*(internalTheo->boundRightConstant),rightConstantTerm); sollya_mpfi_set(*(internalTheo->boundLeftLinear),leftLinearTerm); sollya_mpfi_set(*(internalTheo->boundRightLinear),rightLinearTerm); sollya_mpfi_set(*(internalTheo->xZ),zI); sollya_mpfi_set(*(internalTheo->xMXZ),xMXZ); } } else { if (internalTheo != NULL) { internalTheo->simplificationUsed = 0; freeExprBoundTheo(internalTheo->theoLeftConstant); internalTheo->theoLeftConstant = NULL; freeExprBoundTheo(internalTheo->theoRightConstant); internalTheo->theoRightConstant = NULL; freeExprBoundTheo(internalTheo->theoLeftLinear); internalTheo->theoLeftLinear = NULL; freeExprBoundTheo(internalTheo->theoRightLinear); internalTheo->theoRightLinear = NULL; } excludes = concatChains(leftExcludes,rightExcludes); freeChain(leftExcludesLinear,freeMpfiPtr); freeChain(rightExcludesLinear,freeMpfiPtr); freeChain(leftExcludesConstant,freeMpfiPtr); freeChain(rightExcludesConstant,freeMpfiPtr); } free_memory(derivLeft); free_memory(derivRight); mpfr_clear(z); sollya_mpfi_clear(zI); sollya_mpfi_clear(xMXZ); sollya_mpfi_clear(temp1); sollya_mpfi_clear(temp2); sollya_mpfi_clear(tempA); sollya_mpfi_clear(tempB); sollya_mpfi_clear(leftConstantTerm); sollya_mpfi_clear(rightConstantTerm); sollya_mpfi_clear(leftLinearTerm); sollya_mpfi_clear(rightLinearTerm); } else { excludes = concatChains(leftExcludes,rightExcludes); } break; case SUB: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); leftExcludes = NULL; } else { leftExcludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } if (noExcludes && rightRecursionDone) { sollya_mpfi_set(stack2, rightRecursionResult); rightExcludes = NULL; } else { rightExcludes = evaluateIRec(stack2, tree->child2, x, prec, simplifiesA, simplifiesB, NULL, rightTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_sub(stack3, stack1, stack2); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); sollya_mpfi_set(*(internalTheo->boundRight),stack2); } if ((simplifiesA > 0) && (sollya_mpfi_has_zero(stack3)) && (!sollya_mpfi_has_zero(stack1)) && (!sollya_mpfi_has_zero(stack2)) && !xIsPoint) { if (internalTheo != NULL) { internalTheo->simplificationUsed = DECORRELATE; leftTheoConstant = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(leftTheoConstant); rightTheoConstant = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(rightTheoConstant); leftTheoLinear = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(leftTheoLinear); rightTheoLinear = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(rightTheoLinear); internalTheo->theoLeftConstant = leftTheoConstant; internalTheo->theoRightConstant = rightTheoConstant; internalTheo->theoLeftLinear = leftTheoLinear; internalTheo->theoRightLinear = rightTheoLinear; } else { leftTheoConstant = NULL; rightTheoConstant = NULL; leftTheoLinear = NULL; rightTheoLinear = NULL; } mpfr_init2(z,prec); sollya_mpfi_init2(zI,prec); sollya_mpfi_init2(leftConstantTerm,prec); sollya_mpfi_init2(rightConstantTerm,prec); sollya_mpfi_init2(leftLinearTerm,prec); sollya_mpfi_init2(rightLinearTerm,prec); sollya_mpfi_init2(xMXZ,prec); sollya_mpfi_init2(temp1,prec); sollya_mpfi_init2(temp2,prec); sollya_mpfi_init2(tempA,prec); sollya_mpfi_init2(tempB,prec); sollya_mpfi_mid(z,x); sollya_mpfi_set_fr(zI,z); leftExcludesConstant = evaluateIRec(leftConstantTerm, tree->child1, zI, prec, simplifiesA-1, simplifiesB, NULL, leftTheoConstant,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); rightExcludesConstant = evaluateIRec(rightConstantTerm, tree->child2, zI, prec, simplifiesA-1, simplifiesB, NULL, rightTheoConstant,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); printMessage(12,SOLLYA_MSG_DIFFERENTIATING_FOR_DECORRELATION,"Information: Differentiating while evaluating for decorrelation.\n"); derivLeft = differentiate(tree->child1); derivRight = differentiate(tree->child2); leftExcludesLinear = evaluateIRec(leftLinearTerm, derivLeft, x, prec, simplifiesA-1, simplifiesB, NULL, leftTheoLinear,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); rightExcludesLinear = evaluateIRec(rightLinearTerm, derivRight, x, prec, simplifiesA-1, simplifiesB, NULL, rightTheoLinear,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); sollya_mpfi_sub(tempA,leftConstantTerm,rightConstantTerm); sollya_mpfi_sub(tempB,leftLinearTerm,rightLinearTerm); sollya_mpfi_sub(xMXZ,x,zI); sollya_mpfi_mul(temp2,xMXZ,tempB); sollya_mpfi_add(temp1,tempA,temp2); sollya_mpfi_get_left(al,temp1); sollya_mpfi_get_right(ar,temp1); if (mpfr_number_p(al) && mpfr_number_p(ar)) { printMessage(8,SOLLYA_MSG_DECORRELATION_INTERVAL_ADDITION_OR_SUBTRACTION,"Information: decorrelating an interval subtraction.\n"); sollya_mpfi_intersect(stack3,stack3,temp1); if (!noExcludes) { excludes = concatChains(leftExcludes,rightExcludes); excludes = concatChains(excludes,leftExcludesConstant); excludes = concatChains(excludes,rightExcludesConstant); excludes = concatChains(excludes,leftExcludesLinear); excludes = concatChains(excludes,rightExcludesLinear); } if (internalTheo != NULL) { internalTheo->boundLeftConstant = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundLeftConstant),prec); internalTheo->boundRightConstant = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundRightConstant),prec); internalTheo->boundLeftLinear = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundLeftLinear),prec); internalTheo->boundRightLinear = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundRightLinear),prec); internalTheo->xZ = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->xZ),prec); internalTheo->xMXZ = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->xMXZ),prec); internalTheo->leftDerivative = copyTree(derivLeft); internalTheo->rightDerivative = copyTree(derivRight); sollya_mpfi_set(*(internalTheo->boundLeftConstant),leftConstantTerm); sollya_mpfi_set(*(internalTheo->boundRightConstant),rightConstantTerm); sollya_mpfi_set(*(internalTheo->boundLeftLinear),leftLinearTerm); sollya_mpfi_set(*(internalTheo->boundRightLinear),rightLinearTerm); sollya_mpfi_set(*(internalTheo->xZ),zI); sollya_mpfi_set(*(internalTheo->xMXZ),xMXZ); } } else { if (internalTheo != NULL) { internalTheo->simplificationUsed = 0; freeExprBoundTheo(internalTheo->theoLeftConstant); internalTheo->theoLeftConstant = NULL; freeExprBoundTheo(internalTheo->theoRightConstant); internalTheo->theoRightConstant = NULL; freeExprBoundTheo(internalTheo->theoLeftLinear); internalTheo->theoLeftLinear = NULL; freeExprBoundTheo(internalTheo->theoRightLinear); internalTheo->theoRightLinear = NULL; } excludes = concatChains(leftExcludes,rightExcludes); freeChain(leftExcludesLinear,freeMpfiPtr); freeChain(rightExcludesLinear,freeMpfiPtr); freeChain(leftExcludesConstant,freeMpfiPtr); freeChain(rightExcludesConstant,freeMpfiPtr); } free_memory(derivLeft); free_memory(derivRight); mpfr_clear(z); sollya_mpfi_clear(zI); sollya_mpfi_clear(xMXZ); sollya_mpfi_clear(temp1); sollya_mpfi_clear(temp2); sollya_mpfi_clear(tempA); sollya_mpfi_clear(tempB); sollya_mpfi_clear(leftConstantTerm); sollya_mpfi_clear(rightConstantTerm); sollya_mpfi_clear(leftLinearTerm); sollya_mpfi_clear(rightLinearTerm); } else { excludes = concatChains(leftExcludes,rightExcludes); } break; case MUL: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); leftExcludes = NULL; } else { leftExcludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } if (noExcludes && rightRecursionDone) { sollya_mpfi_set(stack2, rightRecursionResult); rightExcludes = NULL; } else { rightExcludes = evaluateIRec(stack2, tree->child2, x, prec, simplifiesA, simplifiesB, NULL, rightTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } if (xIsPoint && (theo == NULL) && ((sollya_mpfi_has_infinity(stack1) && sollya_mpfi_is_zero(stack2)) || (sollya_mpfi_has_infinity(stack2) && sollya_mpfi_is_zero(stack1)))) { /* We have [0] times something that contains infinity */ if (sollya_mpfi_has_infinity(stack1)) { tC1 = tree->child1; tC2 = tree->child2; } else { tC2 = tree->child1; tC1 = tree->child2; } /* Here, the problem is always with tC1 */ if (accessThruMemRef(tC1)->nodeType == DIV) { temp = addMemRef(makeDiv(makeMul(copyTree(tC2), copyTree(accessThruMemRef(tC1)->child1)), copyTree(accessThruMemRef(tC1)->child2))); freeChain(leftExcludes,freeMpfiPtr); freeChain(rightExcludes,freeMpfiPtr); excludes = evaluateIRec(stack3, temp, x, prec, simplifiesA, simplifiesB, NULL, theo, noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); free_memory(temp); } else { /* There's nothing we can do */ sollya_mpfi_mul(stack3, stack1, stack2); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); sollya_mpfi_set(*(internalTheo->boundRight),stack2); } excludes = concatChains(leftExcludes,rightExcludes); } } else { sollya_mpfi_mul(stack3, stack1, stack2); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); sollya_mpfi_set(*(internalTheo->boundRight),stack2); } excludes = concatChains(leftExcludes,rightExcludes); } break; case DIV: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); leftExcludes = NULL; } else { leftExcludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } if (noExcludes && rightRecursionDone) { sollya_mpfi_set(stack2, rightRecursionResult); rightExcludes = NULL; } else { rightExcludes = evaluateIRec(stack2, tree->child2, x, prec, simplifiesA, simplifiesB, NULL, rightTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); sollya_mpfi_set(*(internalTheo->boundRight),stack2); } sollya_mpfi_get_left(al,stack1); sollya_mpfi_get_right(ar,stack1); sollya_mpfi_get_left(bl,stack2); sollya_mpfi_get_right(br,stack2); if (mpfr_zero_p(al) && mpfr_zero_p(ar)) { if (mpfr_zero_p(bl) && mpfr_zero_p(br) && (simplifiesB > 0)) { /* [0;0] / [0;0] */ printMessage(12,SOLLYA_MSG_DIFFERENTIATING_FOR_HOPITALS_RULE,"Information: Differentiating while evaluating for Hopital's rule.\n"); derivNumerator = differentiate(tree->child1); derivDenominator = differentiate(tree->child2); freeChain(leftExcludes,freeMpfiPtr); freeChain(rightExcludes,freeMpfiPtr); printMessage(8,SOLLYA_MSG_USING_HOPITALS_RULE_ON_POINT_DIVISION,"Information: using Hopital's rule on point division.\n"); if (internalTheo != NULL) { internalTheo->simplificationUsed = HOPITAL_ON_POINT; internalTheo->leftDerivative = copyTree(derivNumerator); internalTheo->rightDerivative = copyTree(derivDenominator); leftTheoLinear = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); rightTheoLinear = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); internalTheo->theoLeftLinear = leftTheoLinear; internalTheo->theoRightLinear = rightTheoLinear; } else { leftTheoLinear = NULL; rightTheoLinear = NULL; } leftExcludes = evaluateIRec(stack1, derivNumerator, x, prec, simplifiesA, simplifiesB-1, NULL, leftTheoLinear,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); rightExcludes = evaluateIRec(stack2, derivDenominator, x, prec, simplifiesA, simplifiesB-1, NULL, rightTheoLinear,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); free_memory(derivNumerator); free_memory(derivDenominator); sollya_mpfi_div(stack3, stack1, stack2); excludes = concatChains(leftExcludes,rightExcludes); } else { /* [0;0] / [bl;br], bl,br != 0 */ freeChain(rightExcludes,freeMpfiPtr); printMessage(8,SOLLYA_MSG_SIMPLIFYING_INTERVAL_DIV_WITH_ZERO_POINT_NUMERA, "Information: simplifying an interval division with 0 point numerator.\n"); printMessage(12,SOLLYA_MSG_CONTINUATION,"Simplification on function\n%b\n",tree); if (sollya_mpfi_has_nan(stack2)) { sollya_mpfi_set(stack3, stack2); } else { sollya_mpfi_interv_d(stack3,0.0,0.0); } excludes = leftExcludes; if (internalTheo != NULL) { internalTheo->simplificationUsed = NUMERATOR_IS_ZERO; freeExprBoundTheo(internalTheo->theoRight); internalTheo->theoRight = NULL; freeMpfiPtr(internalTheo->boundRight); internalTheo->boundRight = NULL; } } } else { if (sollya_mpfi_has_zero(stack2) && (simplifiesB > 0)) { ppppp = prec; pxppp = sollya_mpfi_get_prec(x); if (pxppp > ppppp) ppppp = pxppp; mpfr_init2(xl,ppppp); mpfr_init2(xr,ppppp); sollya_mpfi_get_left(xl,x); sollya_mpfi_get_right(xr,x); if ((mpfr_cmp(xl,xr) != 0) || ((mpfr_sgn(xl) == 0) && (mpfr_sgn(xr) == 0))) { printMessage(12,SOLLYA_MSG_DIFFERENTIATING_FOR_HOPITALS_RULE,"Information: Differentiating while evaluating for Hopital's rule.\n"); derivDenominator = differentiate(tree->child2); if ((simplifiesB == (hopitalrecursions + 1)) || (hopitalPoint == NULL)){ mpfr_init2(z,prec); newtonMPFR(z,tree->child2,derivDenominator,xl,xr,prec); newHopitalPoint = &z; } else { mpfr_init2(z,mpfr_get_prec(*hopitalPoint)); mpfr_set(z,*hopitalPoint,GMP_RNDN); newHopitalPoint = hopitalPoint; } if (mpfr_number_p(z)) { sollya_mpfi_init2(zI,prec); sollya_mpfi_set_fr(zI,z); sollya_mpfi_init2(numeratorInZI,prec); sollya_mpfi_init2(denominatorInZI,prec); if (internalTheo != NULL) { leftTheoConstant = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); rightTheoConstant = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); } else { leftTheoConstant = NULL; rightTheoConstant = NULL; } t1 = evaluateIRec(numeratorInZI, tree->child1, zI, prec, simplifiesA, simplifiesB-1, newHopitalPoint, leftTheoConstant,1, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); t2 = evaluateIRec(denominatorInZI, tree->child2, zI, prec, simplifiesA, simplifiesB-1, newHopitalPoint, rightTheoConstant,1, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); freeChain(t1,freeMpfiPtr); freeChain(t2,freeMpfiPtr); sollya_mpfi_get_left(al,numeratorInZI); sollya_mpfi_get_right(ar,numeratorInZI); sollya_mpfi_get_left(bl,denominatorInZI); sollya_mpfi_get_right(br,denominatorInZI); if (mpfr_zero_p(al) && mpfr_zero_p(ar) && mpfr_zero_p(bl) && mpfr_zero_p(br)) { /* Hopital's rule can be applied */ printMessage(12,SOLLYA_MSG_DIFFERENTIATING_FOR_HOPITALS_RULE,"Information: Differentiating while evaluating for Hopital's rule.\n"); derivNumerator = differentiate(tree->child1); tempNode = (node *) safeMalloc(sizeof(node)); tempNode->nodeType = DIV; tempNode->child1 = derivNumerator; tempNode->child2 = copyTree(derivDenominator); freeChain(leftExcludes,freeMpfiPtr); freeChain(rightExcludes,freeMpfiPtr); if (internalTheo != NULL) { leftTheoLinear = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(leftTheoLinear); internalTheo->simplificationUsed = HOPITAL; internalTheo->leftDerivative = copyTree(tempNode->child1); internalTheo->rightDerivative = copyTree(tempNode->child2); internalTheo->theoLeftConstant = leftTheoConstant; internalTheo->theoRightConstant = rightTheoConstant; internalTheo->theoLeftLinear = leftTheoLinear; internalTheo->boundLeftLinear = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundLeftLinear),prec); internalTheo->boundLeftConstant = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundLeftConstant),prec); internalTheo->boundRightConstant = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundRightConstant),prec); sollya_mpfi_set(*(internalTheo->boundLeftConstant),numeratorInZI); sollya_mpfi_set(*(internalTheo->boundRightConstant),denominatorInZI); internalTheo->xZ = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->xZ),prec); sollya_mpfi_set(*(internalTheo->xZ),zI); } else { leftTheoLinear = NULL; } if (simplifiesB == (hopitalrecursions + 1)) { printMessage(8,SOLLYA_MSG_USING_HOPITALS_RULE_IN_GENERAL_CASE,"Information: using Hopital's rule (general case) on denominator zero.\n"); } if (simplifiesB != (hopitalrecursions + 1)) { printMessage(8,SOLLYA_MSG_RECURSION_ON_USE_OF_HOPITALS_RULE,"Information: recursion on use of Hopital's rule\n"); } excludes = evaluateIRec(stack3, tempNode, x, prec, simplifiesA, simplifiesB-1, newHopitalPoint, leftTheoLinear,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); if (internalTheo != NULL) sollya_mpfi_set(*(internalTheo->boundLeftLinear),stack3); free_memory(tempNode); } else { if (internalTheo != NULL) { freeExprBoundTheo(leftTheoConstant); freeExprBoundTheo(rightTheoConstant); } printMessage(12,SOLLYA_MSG_DIFFERENTIATING_FOR_HOPITALS_RULE,"Information: Differentiating while evaluating for Hopital's rule.\n"); derivNumerator = differentiate(tree->child1); if ((simplifiesB == (hopitalrecursions + 1)) || (hopitalPoint == NULL)) { mpfr_init2(z2,prec); newtonMPFR(z2,tree->child1,derivNumerator,xl,xr,prec); newHopitalPoint = &z2; } else { mpfr_init2(z2,mpfr_get_prec(*hopitalPoint)); mpfr_set(z2,*hopitalPoint,GMP_RNDN); newHopitalPoint = hopitalPoint; } if (mpfr_number_p(z2)) { sollya_mpfi_set_fr(zI,z2); if (internalTheo != NULL) { leftTheoConstant = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); rightTheoConstant = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); } else { leftTheoConstant = NULL; rightTheoConstant = NULL; } t1 = evaluateIRec(numeratorInZI, tree->child1, zI, prec, simplifiesA, simplifiesB-1, newHopitalPoint, leftTheoConstant,1, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); t2 = evaluateIRec(denominatorInZI, tree->child2, zI, prec, simplifiesA, simplifiesB-1, newHopitalPoint, rightTheoConstant,1, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); freeChain(t1,freeMpfiPtr); freeChain(t2,freeMpfiPtr); sollya_mpfi_get_left(al,numeratorInZI); sollya_mpfi_get_right(ar,numeratorInZI); sollya_mpfi_get_left(bl,denominatorInZI); sollya_mpfi_get_right(br,denominatorInZI); if (mpfr_zero_p(al) && mpfr_zero_p(ar) && mpfr_zero_p(bl) && mpfr_zero_p(br)) { tempNode = (node *) safeMalloc(sizeof(node)); tempNode->nodeType = DIV; tempNode->child1 = derivNumerator; tempNode->child2 = copyTree(derivDenominator); freeChain(leftExcludes,freeMpfiPtr); freeChain(rightExcludes,freeMpfiPtr); if (internalTheo != NULL) { leftTheoLinear = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(leftTheoLinear); internalTheo->simplificationUsed = HOPITAL; internalTheo->leftDerivative = copyTree(tempNode->child1); internalTheo->rightDerivative = copyTree(tempNode->child2); internalTheo->theoLeftConstant = leftTheoConstant; internalTheo->theoRightConstant = rightTheoConstant; internalTheo->theoLeftLinear = leftTheoLinear; internalTheo->boundLeftLinear = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundLeftLinear),prec); internalTheo->boundLeftConstant = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundLeftConstant),prec); internalTheo->boundRightConstant = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->boundRightConstant),prec); sollya_mpfi_set(*(internalTheo->boundLeftConstant),numeratorInZI); sollya_mpfi_set(*(internalTheo->boundRightConstant),denominatorInZI); internalTheo->xZ = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(internalTheo->xZ),prec); sollya_mpfi_set(*(internalTheo->xZ),zI); } else { leftTheoLinear = NULL; } if (simplifiesB == (hopitalrecursions + 1)) { printMessage(8,SOLLYA_MSG_USING_HOPITALS_RULE_IN_GENERAL_CASE,"Information: using Hopital's rule (general case) on numerator zero.\n"); } if (simplifiesB != (hopitalrecursions + 1)) { printMessage(8,SOLLYA_MSG_RECURSION_ON_USE_OF_HOPITALS_RULE,"Information: recursion on use of Hopital's rule\n"); } excludes = evaluateIRec(stack3, tempNode, x, prec, simplifiesA, simplifiesB-1, newHopitalPoint, leftTheoLinear,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); if (internalTheo != NULL) sollya_mpfi_set(*(internalTheo->boundLeftLinear),stack3); free_memory(tempNode); } else { if (internalTheo != NULL) { freeExprBoundTheo(leftTheoConstant); freeExprBoundTheo(rightTheoConstant); } if (!noExcludes) { newExclude = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*newExclude,prec); makeMpfiAroundMpfr(*newExclude,z,16777216); sollya_mpfi_init2(newExcludeTemp,prec); makeMpfiAroundMpfr(newExcludeTemp,z2,16777216); sollya_mpfi_union(*newExclude,*newExclude,newExcludeTemp); sollya_mpfi_clear(newExcludeTemp); excludes = concatChains(leftExcludes,rightExcludes); excludes = addElement(excludes,newExclude); } free_memory(derivNumerator); mpfr_clear(z2); sollya_mpfi_div(stack3, stack1, stack2); } } else { free_memory(derivNumerator); mpfr_clear(z2); if (!noExcludes) { newExclude = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*newExclude,prec); makeMpfiAroundMpfr(*newExclude,z,16777216); excludes = concatChains(leftExcludes,rightExcludes); excludes = addElement(excludes,newExclude); } sollya_mpfi_div(stack3, stack1, stack2); } } sollya_mpfi_clear(numeratorInZI); sollya_mpfi_clear(denominatorInZI); sollya_mpfi_clear(zI); } else { sollya_mpfi_div(stack3, stack1, stack2); excludes = concatChains(leftExcludes,rightExcludes); } free_memory(derivDenominator); mpfr_clear(z); } else { sollya_mpfi_div(stack3, stack1, stack2); excludes = concatChains(leftExcludes,rightExcludes); } mpfr_clear(xl); mpfr_clear(xr); } else { sollya_mpfi_div(stack3, stack1, stack2); excludes = concatChains(leftExcludes,rightExcludes); } } break; case SQRT: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_sqrt(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case EXP: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_exp(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case LOG: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_log(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case LOG_2: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_log2(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case LOG_10: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_log10(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case SIN: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_sin(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case COS: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_cos(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case TAN: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_tan(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case ASIN: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_asin(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case ACOS: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_acos(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case ATAN: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_atan(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case SINH: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_sinh(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case COSH: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_cosh(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case TANH: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_tanh(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case ASINH: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_asinh(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case ACOSH: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_acosh(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case ATANH: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_atanh(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case POW: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); leftExcludes = NULL; } else { leftExcludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } if (noExcludes && rightRecursionDone) { sollya_mpfi_set(stack2, rightRecursionResult); rightExcludes = NULL; } else { rightExcludes = evaluateIRec(stack2, tree->child2, x, prec, simplifiesA, simplifiesB, NULL, rightTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_pow(stack3, stack1, stack2); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); sollya_mpfi_set(*(internalTheo->boundRight),stack2); } excludes = concatChains(leftExcludes,rightExcludes); break; case NEG: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_neg(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case ABS: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_abs(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case DOUBLE: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_round_to_double(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case SINGLE: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_round_to_single(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case HALFPRECISION: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_round_to_halfprecision(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case QUAD: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_round_to_quad(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case DOUBLEDOUBLE: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_round_to_doubledouble(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case TRIPLEDOUBLE: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_round_to_tripledouble(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case ERF: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_erf(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case ERFC: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_erfc(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case LOG_1P: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_log1p(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case EXP_M1: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_expm1(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case DOUBLEEXTENDED: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_round_to_doubleextended(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case LIBRARYFUNCTION: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } mpfi_init2(tempI, sollya_mpfi_get_prec(stack3)); if (tree->libFun->hasData) { ((int (*)(mpfi_t, mpfi_t, int, void *)) (tree->libFun->code))(tempI, stack1, tree->libFunDeriv, tree->libFun->data); } else { ((int (*)(mpfi_t, mpfi_t, int)) (tree->libFun->code))(tempI, stack1, tree->libFunDeriv); } sollya_init_and_convert_interval(tempI2, tempI); sollya_mpfi_set(stack3, tempI2); sollya_mpfi_clear(tempI2); mpfi_clear(tempI); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case PROCEDUREFUNCTION: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } computeFunctionWithProcedure(stack3, tree->child2, stack1, (unsigned int) tree->libFunDeriv, tree); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case CEIL: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_ceil(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case FLOOR: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_floor(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case NEARESTINT: if (noExcludes && leftRecursionDone) { sollya_mpfi_set(stack1, leftRecursionResult); excludes = NULL; } else { excludes = evaluateIRec(stack1, tree->child1, x, prec, simplifiesA, simplifiesB, NULL, leftTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } sollya_mpfi_nearestint(stack3, stack1); if (internalTheo != NULL) { sollya_mpfi_set(*(internalTheo->boundLeft),stack1); } break; case PI_CONST: sollya_mpfi_const_pi(stack3); excludes = NULL; break; case LIBRARYCONSTANT: libraryConstantToInterval(stack3, tree); excludes = NULL; break; default: sollyaFprintf(stderr,"Error: evaluateIRec: unknown identifier in the tree\n"); exit(1); } sollya_mpfi_set(result,stack3); if (theo != NULL) { theo->y = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->y),sollya_mpfi_get_prec(result)); sollya_mpfi_set(*(theo->y),result); } sollya_mpfi_clear(stack1); sollya_mpfi_clear(stack2); sollya_mpfi_clear(stack3); mpfr_clear(al); mpfr_clear(ar); mpfr_clear(bl); mpfr_clear(br); if (leftRecursionDone) { sollya_mpfi_clear(leftRecursionResult); } if (rightRecursionDone) { sollya_mpfi_clear(rightRecursionResult); } return excludes; } static inline chain* evaluateI(sollya_mpfi_t result, node *tree, sollya_mpfi_t x, mp_prec_t prec, int simplifiesA, int simplifiesB, mpfr_t *hopitalPoint, exprBoundTheo *theo, int noExcludes, int fastAddSub, int workForThinArg, int noLazyHooks, mp_exp_t *cutoff, int *lazyHookUsed) { chain *res; res = evaluateIRec(result, tree, x, prec, simplifiesA, simplifiesB, hopitalPoint, theo, noExcludes, fastAddSub, workForThinArg, noLazyHooks, cutoff, lazyHookUsed); return res; } static inline chain* evaluateITaylor(sollya_mpfi_t result, node *func, node *deriv, sollya_mpfi_t x, mp_prec_t prec, int recurse, exprBoundTheo *theo, int noExcludes, int fastAddSub, int workForThin, int noLazyHooks, mp_exp_t *cutoff, int *lazyHookUsed); static inline chain* evaluateITaylorOnDiv(sollya_mpfi_t result, node *func, sollya_mpfi_t x, mp_prec_t prec, int recurse, exprBoundTheo *theo, int noExcludes, int fastAddSub, int workForThin, int noLazyHooks, mp_exp_t *cutoff, int *lazyHookUsed) { node *numerator, *denominator, *derivNumerator, *derivDenominator; chain *excludes, *numeratorExcludes, *denominatorExcludes; exprBoundTheo *numeratorTheo, *denominatorTheo; sollya_mpfi_t resultNumerator, resultDenominator, resultIndirect; mpfr_t tempNaN; mpfr_init2(tempNaN, prec); if (accessThruMemRef(func)->nodeType == DIV) { numerator = accessThruMemRef(func)->child1; denominator = accessThruMemRef(func)->child2; derivNumerator = differentiate(numerator); derivDenominator = differentiate(denominator); sollya_mpfi_init2(resultNumerator, prec); sollya_mpfi_init2(resultDenominator, prec); sollya_mpfi_init2(resultIndirect, prec); if (theo != NULL) { numeratorTheo = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); denominatorTheo = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); } else { numeratorTheo = NULL; denominatorTheo = NULL; } numeratorExcludes = evaluateITaylor(resultNumerator, numerator, derivNumerator, x, prec, recurse, numeratorTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); denominatorExcludes = evaluateITaylor(resultDenominator, denominator, derivDenominator, x, prec, recurse, denominatorTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); excludes = concatChains(numeratorExcludes,denominatorExcludes); sollya_mpfi_div(resultIndirect, resultNumerator, resultDenominator); if (sollya_mpfi_bounded_p(resultIndirect)) { sollya_mpfi_set(result, resultIndirect); sollya_mpfi_nan_normalize(result); if (theo != NULL) { theo->functionType = func->nodeType; theo->boundLeft = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->boundLeft),prec); theo->boundRight = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->boundRight),prec); theo->theoLeft = numeratorTheo; theo->theoRight = denominatorTheo; theo->x = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->x),sollya_mpfi_get_prec(x)); sollya_mpfi_set(*(theo->x),x); theo->function = copyTree(func); theo->y = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->y),sollya_mpfi_get_prec(result)); sollya_mpfi_set(*(theo->y),result); } } else { freeChain(excludes,freeMpfiPtr); if (theo != NULL) { freeExprBoundTheo(numeratorTheo); freeExprBoundTheo(denominatorTheo); } excludes = evaluateI(result, func, x, prec, 0, hopitalrecursions+1, NULL, theo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); sollya_mpfi_nan_normalize(result); } sollya_mpfi_clear(resultNumerator); sollya_mpfi_clear(resultDenominator); sollya_mpfi_clear(resultIndirect); free_memory(derivNumerator); free_memory(derivDenominator); mpfr_clear(tempNaN); return excludes; } else { excludes = evaluateI(result, func, x, prec, 0, hopitalrecursions+1, NULL, theo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); sollya_mpfi_nan_normalize(result); mpfr_clear(tempNaN); return excludes; } } static inline chain* evaluateITaylorInner(sollya_mpfi_t, node *, node *, sollya_mpfi_t, mp_prec_t, int, exprBoundTheo *, int, int, int, int, mp_exp_t *, int *); static inline chain* evaluateITaylorWrapped(sollya_mpfi_t result, node *func, node *deriv, sollya_mpfi_t x, mp_prec_t prec, int recurse, exprBoundTheo *theo, int noExcludes, int fastAddSub, int workForThin, int noLazyHooks, mp_exp_t *cutoff, int *lazyHookUsed) { chain *excludes; mp_prec_t *precPtr; sollya_mpfi_t *intervalPtr; sollya_mpfi_t tempInterval; if ((theo != NULL) || (!noExcludes)) return evaluateITaylorInner(result, func, deriv, x, prec, recurse, theo, noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); if ((func->nodeType == MEMREF) && (func->arguments != NULL) && (*((mp_prec_t *) func->arguments->value) >= prec)) { sollya_mpfi_set(result, *((sollya_mpfi_t *) func->arguments->next->value)); if (!(sollya_mpfi_has_nan(result) || sollya_mpfi_has_infinity(result))) return NULL; } if ((func->nodeType == MEMREF) && (func->evaluationHook != NULL) && evaluateWithEvaluationHook(result, x, prec, 1, func->evaluationHook)) { excludes = NULL; } else { if ((func->nodeType == MEMREF) && (func->evaluationHook != NULL) && (!noLazyHooks) && evaluateWithEvaluationHook(result, x, prec, 0, func->evaluationHook)) { excludes = NULL; if (lazyHookUsed != NULL) { *lazyHookUsed |= 1; *lazyHookUsed = !!*lazyHookUsed; } } else { excludes = evaluateITaylorInner(result, func, deriv, x, prec, recurse, theo, noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } } if ((excludes == NULL) && (func->nodeType == MEMREF) && (!(sollya_mpfi_has_nan(result) || sollya_mpfi_has_infinity(result)))) { if (func->arguments != NULL) { if (prec > *((mp_prec_t *) func->arguments->value)) { *((mp_prec_t *) func->arguments->value) = prec; sollya_mpfi_init2(tempInterval, sollya_mpfi_get_prec(*((sollya_mpfi_t *) func->arguments->next->value))); sollya_mpfi_set(tempInterval, *((sollya_mpfi_t *) func->arguments->next->value)); sollya_mpfi_set_prec(*((sollya_mpfi_t *) func->arguments->next->value), sollya_mpfi_get_prec(result)); sollya_mpfi_intersect(*((sollya_mpfi_t *) func->arguments->next->value), tempInterval, result); sollya_mpfi_clear(tempInterval); } } else { if (isConstant(func)) { precPtr = (mp_prec_t *) safeMalloc(sizeof(mp_prec_t)); *precPtr = prec; intervalPtr = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*intervalPtr, sollya_mpfi_get_prec(result)); sollya_mpfi_set(*intervalPtr, result); func->arguments = addElement(addElement(NULL, intervalPtr), precPtr); } } } return excludes; } static inline chain* evaluateITaylor(sollya_mpfi_t result, node *func, node *deriv, sollya_mpfi_t x, mp_prec_t prec, int recurse, exprBoundTheo *theo, int noExcludes, int fastAddSub, int workForThin, int noLazyHooks, mp_exp_t *cutoff, int *lazyHookUsed) { if (deriv == NULL) { return evaluateITaylorWrapped(result, func, deriv, x, prec, recurse, theo, noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } if (containsNonDifferentiableSubfunctions(func)) { return evaluateITaylorWrapped(result, func, NULL, x, prec, recurse, theo, noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } return evaluateITaylorWrapped(result, func, deriv, x, prec, recurse, theo, noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } static inline chain* evaluateITaylorStart(sollya_mpfi_t result, node *func, node *deriv, sollya_mpfi_t x, mp_prec_t prec, int recurse, exprBoundTheo *theo, int noExcludes, int fastAddSub, int workForThin, int noLazyHooks, mp_exp_t *cutoff, int *lazyHookUsed) { if (deriv == NULL) { return evaluateITaylor(result, func, deriv, x, prec, recurse, theo, noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } if (accessThruMemRef(func)->nodeType == DIV) { return evaluateITaylorOnDiv(result, func, x, prec, recurse, theo, noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } return evaluateITaylor(result, func, deriv, x, prec, recurse, theo, noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } static inline chain* evaluateITaylorInner(sollya_mpfi_t result, node *func, node *deriv, sollya_mpfi_t x, mp_prec_t prec, int recurse, exprBoundTheo *theo, int noExcludes, int fastAddSub, int workForThin, int noLazyHooks, mp_exp_t *cutoff, int *lazyHookUsed) { mpfr_t xZ, rTl, rTr, leftX, rightX; sollya_mpfi_t xZI, xZI2, constantTerm, linearTerm, resultTaylor, resultDirect, temp, temp2; chain *excludes, *directExcludes, *taylorExcludes, *taylorExcludesLinear, *taylorExcludesConstant; exprBoundTheo *constantTheo, *linearTheo, *directTheo; node *nextderiv; int size; /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ((deriv == NULL) || (mpfr_cmp(&(x->left),&(x->right)) == 0)) { if (deriv != NULL) printMessage(25,SOLLYA_MSG_AVOIDING_TAYLOR_EVALUATION_ON_POINT_INTERVAL,"Information: avoiding using Taylor's formula on a point interval.\n"); else printMessage(25,SOLLYA_MSG_NO_TAYLOR_EVALUATION_AS_NO_DERIVATIVE_GIVEN,"Warning: no Taylor evaluation is possible because no derivative has been given.\n"); excludes = evaluateI(result, func, x, prec, 1, hopitalrecursions+1, NULL, theo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); sollya_mpfi_nan_normalize(result); return excludes; } mpfr_init2(leftX,sollya_mpfi_get_prec(x)); mpfr_init2(rightX,sollya_mpfi_get_prec(x)); sollya_mpfi_get_left(leftX,x); sollya_mpfi_get_right(rightX,x); printMessage(13,SOLLYA_MSG_USING_TAYLOR_EVALUATION,"Information: evaluating a function in interval arithmetic using Taylor's formula.\n"); if (theo != NULL) { nullifyExprBoundTheo(theo); if (!isPolynomial(func)) { constantTheo = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(constantTheo); linearTheo = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(linearTheo); directTheo = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(directTheo); theo->functionType = func->nodeType; } else { constantTheo = NULL; linearTheo = NULL; directTheo = NULL; theo->functionType = POLYNOMIAL; } theo->function = copyTree(func); theo->x = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->x),prec); sollya_mpfi_set(*(theo->x),x); theo->y = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->y),prec); } else { constantTheo = NULL; linearTheo = NULL; directTheo = NULL; } mpfr_init2(xZ,prec); sollya_mpfi_init2(xZI,prec); sollya_mpfi_init2(temp,prec); sollya_mpfi_init2(temp2,prec); sollya_mpfi_init2(constantTerm,prec); sollya_mpfi_init2(linearTerm,prec); sollya_mpfi_init2(resultTaylor,prec); sollya_mpfi_init2(resultDirect,prec); mpfr_init2(rTl,prec); mpfr_init2(rTr,prec); sollya_mpfi_mid(xZ,x); sollya_mpfi_set_fr(xZI,xZ); if ((recurse > 0) && (accessThruMemRef(func)->nodeType != DIV)) { nextderiv = differentiate(deriv); size = treeSize(nextderiv); if (size > DIFFSIZE) { printMessage(1,SOLLYA_MSG_NO_TAYLOR_EVALUATION_AS_NO_DERIVATIVE_GETS_HUGE,"Waring: during recursive Taylor evaluation the expression of a derivative has become\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"as great that it contains more than %d nodes.\n",DIFFSIZE); printMessage(1,SOLLYA_MSG_CONTINUATION,"Will now stop recursive Taylor evaluation on this expression.\n"); printMessage(2,SOLLYA_MSG_CONTINUATION,"Information: the size of the derivative is %d, we had %d recursion(s) left.\n",size,recurse-1); taylorExcludesLinear = evaluateI(linearTerm, deriv, x, prec, 1, hopitalrecursions+1, NULL, linearTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } else { taylorExcludesLinear = evaluateITaylor(linearTerm, deriv, nextderiv, x, prec, recurse - 1, linearTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } free_memory(nextderiv); } else { taylorExcludesLinear = evaluateI(linearTerm, deriv, x, prec, 1, hopitalrecursions+1, NULL, linearTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); } if ((sollya_mpfi_is_nonneg(linearTerm) || sollya_mpfi_is_nonpos(linearTerm)) && sollya_mpfi_bounded_p(linearTerm)) { printMessage(12,SOLLYA_MSG_DERIVATIVE_DOES_NOT_CHANGE_SIGN_ON_TAYLOR_EVAL,"Information: the linear term during Taylor evaluation does not change its sign.\n"); printMessage(12,SOLLYA_MSG_CONTINUATION,"Simplifying by taking the convex hull of the evaluations on the endpoints.\n"); sollya_mpfi_init2(xZI2,prec); sollya_mpfi_set_fr(xZI,leftX); sollya_mpfi_set_fr(xZI2,rightX); directExcludes = evaluateI(resultDirect, func, xZI, prec, 0, hopitalrecursions+1, NULL, directTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); taylorExcludesConstant = evaluateI(constantTerm, func, xZI2, prec, 1, hopitalrecursions+1, NULL, constantTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); sollya_mpfi_union(result,resultDirect,constantTerm); if (theo != NULL) { if (theo->functionType != POLYNOMIAL) { theo->simplificationUsed = MONOTONOCITY; theo->theoLeft = directTheo; theo->theoRight = constantTheo; theo->theoLeftLinear = linearTheo; theo->leftDerivative = copyTree(deriv); theo->boundLeft = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->boundLeft),prec); sollya_mpfi_set(*(theo->boundLeft),resultDirect); theo->theoRight = constantTheo; theo->boundRight = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->boundRight),prec); sollya_mpfi_set(*(theo->boundRight),constantTerm); theo->boundLeftLinear = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->boundLeftLinear),prec); sollya_mpfi_set(*(theo->boundLeftLinear),linearTerm); } } excludes = concatChains(directExcludes,taylorExcludesConstant); excludes = concatChains(taylorExcludesLinear,excludes); sollya_mpfi_clear(xZI2); } else { taylorExcludesConstant = evaluateI(constantTerm, func, xZI, prec, 1, hopitalrecursions+1, NULL, constantTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); sollya_mpfi_sub(temp, x, xZI); sollya_mpfi_mul(temp2, temp, linearTerm); sollya_mpfi_add(resultTaylor, constantTerm, temp2); taylorExcludes = concatChains(taylorExcludesConstant, taylorExcludesLinear); if (deriv != NULL) directExcludes = evaluateITaylorOnDiv(resultDirect, func, x, prec, recurse, directTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); else directExcludes = evaluateI(resultDirect, func, x, prec, 0, hopitalrecursions+1, NULL, directTheo,noExcludes, fastAddSub, workForThin, noLazyHooks, cutoff, lazyHookUsed); sollya_mpfi_get_left(rTl,resultTaylor); sollya_mpfi_get_right(rTr,resultTaylor); if (mpfr_number_p(rTl) && mpfr_number_p(rTr)) { sollya_mpfi_intersect(result,resultTaylor,resultDirect); excludes = concatChains(directExcludes,taylorExcludes); if (theo != NULL) { if (theo->functionType != POLYNOMIAL) { theo->simplificationUsed = TAYLORPROOF; theo->theoLeft = directTheo; theo->theoLeftConstant = constantTheo; theo->theoLeftLinear = linearTheo; theo->leftDerivative = copyTree(deriv); theo->boundLeft = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->boundLeft),prec); sollya_mpfi_set(*(theo->boundLeft),resultDirect); theo->boundRight = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->boundRight),prec); sollya_mpfi_set(*(theo->boundRight),resultTaylor); theo->boundLeftConstant = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->boundLeftConstant),prec); sollya_mpfi_set(*(theo->boundLeftConstant),constantTerm); theo->boundLeftLinear = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->boundLeftLinear),prec); sollya_mpfi_set(*(theo->boundLeftLinear),linearTerm); theo->xZ = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->xZ),prec); sollya_mpfi_set(*(theo->xZ),xZI); theo->xMXZ = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->xMXZ),prec); sollya_mpfi_set(*(theo->xMXZ),temp); } } } else { sollya_mpfi_set(result,resultDirect); freeChain(taylorExcludes,freeMpfiPtr); excludes = directExcludes; if (theo != NULL) { if (theo->functionType != POLYNOMIAL) { theo->simplificationUsed = IMPLICATION; theo->theoLeft = directTheo; theo->boundLeft = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*(theo->boundLeft),prec); sollya_mpfi_set(*(theo->boundLeft),resultDirect); freeExprBoundTheo(constantTheo); freeExprBoundTheo(linearTheo); } } } } sollya_mpfi_nan_normalize(result); if (theo != NULL) sollya_mpfi_set(*(theo->y),result); mpfr_clear(xZ); mpfr_clear(rTl); mpfr_clear(rTr); sollya_mpfi_clear(xZI); sollya_mpfi_clear(temp); sollya_mpfi_clear(temp2); sollya_mpfi_clear(constantTerm); sollya_mpfi_clear(linearTerm); sollya_mpfi_clear(resultTaylor); sollya_mpfi_clear(resultDirect); mpfr_clear(leftX); mpfr_clear(rightX); return excludes; } chain *findZerosUnsimplified(node *func, node *deriv, sollya_mpfi_t range, mp_prec_t prec, mpfr_t diam, chain **noZeroProofs) { mpfr_t rangeDiam, l,m,r; chain *res, *leftchain, *rightchain; sollya_mpfi_t *temp; sollya_mpfi_t lI, rI, y; chain *excludes; chain *leftProofs, *rightProofs; chain **leftProofsPtr, **rightProofsPtr; exprBoundTheo *theo; leftProofs = NULL; rightProofs = NULL; if (noZeroProofs != NULL) { leftProofsPtr = &leftProofs; rightProofsPtr = &rightProofs; theo = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); } else { leftProofsPtr = NULL; rightProofsPtr = NULL; theo = NULL; } mpfr_init2(rangeDiam,prec); sollya_mpfi_diam_abs(rangeDiam,range); mpfr_init2(l,prec); mpfr_init2(r,prec); sollya_mpfi_get_left(l,range); sollya_mpfi_get_right(r,range); mpfr_nextabove(l); mpfr_nextabove(l); mpfr_nextabove(l); mpfr_nextabove(l); if ((mpfr_cmp(rangeDiam,diam) <= 0) || (mpfr_cmp(l,r) >= 0)) { res = (chain *) safeMalloc(sizeof(chain)); res->next = NULL; temp = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*temp,prec); sollya_mpfi_set(*temp,range); res->value = temp; if (theo != NULL) freeExprBoundTheo(theo); } else { sollya_mpfi_init2(y,prec); excludes = evaluateITaylor(y, func, deriv, range, prec, taylorrecursions, theo,1,0,0,0,NULL,NULL); freeChain(excludes,freeMpfiPtr); if (!sollya_mpfi_bounded_p(y)) { printMessage(1,SOLLYA_MSG_NAN_OR_INF_ON_DERIVATIVE,"Warning: during zero-search the derivative of the function evaluated to NaN or Inf in the interval %w.\nThe function might not be continuously differentiable in this interval.\n",range); } if ((!sollya_mpfi_bounded_p(y)) || sollya_mpfi_has_zero(y)) { mpfr_init2(m,prec); sollya_mpfi_get_left(l,range); sollya_mpfi_mid(m,range); sollya_mpfi_init2(lI,prec); sollya_mpfi_init2(rI,prec); if (mpfr_cmp(l, m)<=0) sollya_mpfi_interv_fr(lI,l,m); else sollya_mpfi_interv_fr(lI,m,l); if (mpfr_cmp(m, r)<=0) sollya_mpfi_interv_fr(rI,m,r); else sollya_mpfi_interv_fr(rI,r,m); if (theo != NULL) freeExprBoundTheo(theo); leftchain = findZerosUnsimplified(func,deriv,lI,prec,diam,leftProofsPtr); rightchain = findZerosUnsimplified(func,deriv,rI,prec,diam,rightProofsPtr); res = concatChains(leftchain,rightchain); if (noZeroProofs != NULL) { *noZeroProofs = concatChains(leftProofs,rightProofs); } mpfr_clear(m); sollya_mpfi_clear(lI); sollya_mpfi_clear(rI); } else { res = NULL; if (noZeroProofs != NULL) *noZeroProofs = addElement(*noZeroProofs,theo); } sollya_mpfi_clear(y); } mpfr_clear(l); mpfr_clear(r); mpfr_clear(rangeDiam); return res; } chain *findZeros(node *func, node *deriv, sollya_mpfi_t range, mp_prec_t prec, mpfr_t diam, noZeroTheo *theo) { node *funcSimplified, *derivSimplified; chain *temp; chain **noZeroProofs; funcSimplified = horner(func); derivSimplified = horner(deriv); if (theo != NULL) { theo->function = copyTree(func); theo->derivative = copyTree(deriv); theo->funcEqual = (equalityTheo *) safeMalloc(sizeof(equalityTheo)); theo->funcEqual->expr1 = copyTree(func); theo->funcEqual->expr2 = copyTree(funcSimplified); theo->derivEqual = (equalityTheo *) safeMalloc(sizeof(equalityTheo)); theo->derivEqual->expr1 = copyTree(deriv); theo->derivEqual->expr2 = copyTree(derivSimplified); noZeroProofs = &(theo->exprBoundTheos); } else { noZeroProofs = NULL; } printMessage(3,SOLLYA_MSG_INVOKING_RECURSIVE_INTERVAL_ZERO_SEARCH,"Information: invoking the recursive interval zero search.\n"); temp = findZerosUnsimplified(funcSimplified,derivSimplified,range,prec,diam,noZeroProofs); printMessage(3,SOLLYA_MSG_RECURSIVE_INTERVAL_ZERO_SEARCH_HAS_FINISHED,"Information: the recursive interval zero search has finished.\n"); free_memory(funcSimplified); free_memory(derivSimplified); return temp; } void printInterval(sollya_mpfi_t interval) { mpfr_t l,r; mp_prec_t prec; char *temp_string; prec = sollya_mpfi_get_prec(interval); mpfr_init2(l,prec); mpfr_init2(r,prec); sollya_mpfi_get_left(l,interval); sollya_mpfi_get_right(r,interval); if ((dyadic == 0) && (midpointMode == 1)) { temp_string = sprintMidpointMode(l, r); if (temp_string != NULL) { sollyaPrintf("%s ",temp_string); safeFree(temp_string); } else { sollyaPrintf("["); printValue(&l); sollyaPrintf(";"); printValue(&r); sollyaPrintf("]"); } } else { sollyaPrintf("["); printValue(&l); sollyaPrintf(";"); printValue(&r); sollyaPrintf("]"); } mpfr_clear(l); mpfr_clear(r); } char *sprintInterval(sollya_mpfi_t interval) { mpfr_t l,r; mp_prec_t prec; char *temp_string, *temp_string2; char *res; prec = sollya_mpfi_get_prec(interval); mpfr_init2(l,prec); mpfr_init2(r,prec); sollya_mpfi_get_left(l,interval); sollya_mpfi_get_right(r,interval); if ((dyadic == 0) && (midpointMode == 1)) { temp_string = sprintMidpointMode(l, r); if (temp_string != NULL) { res = temp_string; } else { temp_string = sprintValue(&l); temp_string2 = sprintValue(&r); res = safeCalloc(strlen(temp_string) + strlen(temp_string2) + 3 + 1, sizeof(char)); sprintf(res,"[%s;%s]",temp_string,temp_string2); safeFree(temp_string); safeFree(temp_string2); } } else { temp_string = sprintValue(&l); temp_string2 = sprintValue(&r); res = safeCalloc(strlen(temp_string) + strlen(temp_string2) + 3 + 1, sizeof(char)); sprintf(res,"[%s;%s]",temp_string,temp_string2); safeFree(temp_string); safeFree(temp_string2); } mpfr_clear(l); mpfr_clear(r); return res; } void fprintInterval(FILE *fd, sollya_mpfi_t interval) { mpfr_t l,r; mp_prec_t prec; prec = sollya_mpfi_get_prec(interval); mpfr_init2(l,prec); mpfr_init2(r,prec); sollya_mpfi_get_left(l,interval); sollya_mpfi_get_right(r,interval); sollyaFprintf(fd,"["); fprintValue(fd,l); sollyaFprintf(fd,";"); fprintValue(fd,r); sollyaFprintf(fd,"]"); mpfr_clear(l); mpfr_clear(r); } chain *joinAdjacentIntervals(chain *intervals, mpfr_t diam) { chain *newChain, *curr; sollya_mpfi_t *tempI; mp_prec_t prec, p; mpfr_t newLeft, newRight, l,r, mpfr_temp; if (intervals == NULL) return NULL; if (intervals->next == NULL) { tempI = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*tempI,sollya_mpfi_get_prec(*((sollya_mpfi_t *) (intervals->value)))); sollya_mpfi_set(*tempI,*((sollya_mpfi_t *) (intervals->value))); newChain = addElement(NULL,tempI); return newChain; } prec = sollya_mpfi_get_prec(*((sollya_mpfi_t *) (intervals->value))); curr = intervals->next; while (curr != NULL) { p = sollya_mpfi_get_prec(*((sollya_mpfi_t *) (curr->value))); if (p > prec) prec = p; curr = curr->next; } mpfr_init2(newLeft,prec); mpfr_init2(newRight,prec); sollya_mpfi_get_left(newLeft,*((sollya_mpfi_t *) (intervals->value))); sollya_mpfi_get_right(newRight,*((sollya_mpfi_t *) (intervals->value))); mpfr_init2(l,prec); mpfr_init2(r,prec); mpfr_init2(mpfr_temp,prec); newChain = NULL; curr = intervals->next; while (curr != NULL) { sollya_mpfi_get_left(l,*((sollya_mpfi_t *) (curr->value))); sollya_mpfi_get_right(r,*((sollya_mpfi_t *) (curr->value))); mpfr_sub(mpfr_temp,r,newLeft,GMP_RNDN); if ((mpfr_cmp(l,newRight) == 0) && (mpfr_cmp(mpfr_temp,diam) < 0)) { mpfr_set(newRight,r,GMP_RNDN); } else { tempI = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*tempI,prec); sollya_mpfi_interv_fr(*tempI,newLeft,newRight); newChain = addElement(newChain,tempI); mpfr_set(newLeft,l,GMP_RNDN); mpfr_set(newRight,r,GMP_RNDN); } curr = curr->next; } tempI = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*tempI,prec); sollya_mpfi_interv_fr(*tempI,newLeft,newRight); newChain = addElement(newChain,tempI); mpfr_clear(l); mpfr_clear(r); mpfr_clear(newLeft); mpfr_clear(newRight); mpfr_clear(mpfr_temp); return newChain; } chain *joinAdjacentIntervalsMaximally(chain *intervals) { chain *newChain, *curr; sollya_mpfi_t *tempI; mp_prec_t prec, p; mpfr_t newLeft, newRight, l,r, mpfr_temp; if (intervals == NULL) return NULL; if (intervals->next == NULL) { tempI = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*tempI,sollya_mpfi_get_prec(*((sollya_mpfi_t *) (intervals->value)))); sollya_mpfi_set(*tempI,*((sollya_mpfi_t *) (intervals->value))); newChain = addElement(NULL,tempI); return newChain; } prec = sollya_mpfi_get_prec(*((sollya_mpfi_t *) (intervals->value))); curr = intervals->next; while (curr != NULL) { p = sollya_mpfi_get_prec(*((sollya_mpfi_t *) (curr->value))); if (p > prec) prec = p; curr = curr->next; } mpfr_init2(newLeft,prec); mpfr_init2(newRight,prec); sollya_mpfi_get_left(newLeft,*((sollya_mpfi_t *) (intervals->value))); sollya_mpfi_get_right(newRight,*((sollya_mpfi_t *) (intervals->value))); mpfr_init2(l,prec); mpfr_init2(r,prec); mpfr_init2(mpfr_temp,prec); newChain = NULL; curr = intervals->next; while (curr != NULL) { sollya_mpfi_get_left(l,*((sollya_mpfi_t *) (curr->value))); sollya_mpfi_get_right(r,*((sollya_mpfi_t *) (curr->value))); mpfr_sub(mpfr_temp,r,newLeft,GMP_RNDN); if (mpfr_cmp(l,newRight) == 0) { mpfr_set(newRight,r,GMP_RNDN); } else { tempI = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*tempI,prec); sollya_mpfi_interv_fr(*tempI,newLeft,newRight); newChain = addElement(newChain,tempI); mpfr_set(newLeft,l,GMP_RNDN); mpfr_set(newRight,r,GMP_RNDN); } curr = curr->next; } tempI = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*tempI,prec); sollya_mpfi_interv_fr(*tempI,newLeft,newRight); newChain = addElement(newChain,tempI); mpfr_clear(l); mpfr_clear(r); mpfr_clear(newLeft); mpfr_clear(newRight); mpfr_clear(mpfr_temp); return newChain; } chain *excludeIntervals(chain *mainIntervals, chain *excludeIntervals) { chain *curr, *previous, *curr2, *temp; sollya_mpfi_t *interval, *exclude; mp_prec_t prec, p; mpfr_t il, ir, el, er; if (mainIntervals == NULL) return NULL; if (excludeIntervals == NULL) return mainIntervals; prec = 1; curr = mainIntervals; while (curr != NULL) { p = sollya_mpfi_get_prec(*((sollya_mpfi_t *) curr->value)); if (p > prec) prec = p; curr = curr->next; } curr = excludeIntervals; while (curr != NULL) { p = sollya_mpfi_get_prec(*((sollya_mpfi_t *) curr->value)); if (p > prec) prec = p; curr = curr->next; } prec += 5; mpfr_init2(il,prec); mpfr_init2(ir,prec); mpfr_init2(el,prec); mpfr_init2(er,prec); curr2 = excludeIntervals; while (curr2 != NULL) { exclude = (sollya_mpfi_t *) (curr2->value); sollya_mpfi_get_left(el,*exclude); sollya_mpfi_get_right(er,*exclude); curr = mainIntervals; previous = NULL; while (curr != NULL) { interval = (sollya_mpfi_t *) (curr->value); sollya_mpfi_get_left(il,*interval); sollya_mpfi_get_right(ir,*interval); if ((mpfr_cmp(el,ir) < 0) && (mpfr_cmp(il,er) < 0)) { /* [il;ir] inter [el;er] != empty */ if ((mpfr_cmp(il,el) < 0) && (mpfr_cmp(er,ir) < 0)) { /* We must produce two intervals [il;el] and [er;ir] */ sollya_mpfi_interv_fr(*interval,il,el); interval = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*interval,prec); sollya_mpfi_interv_fr(*interval,er,ir); temp = (chain *) safeMalloc(sizeof(chain)); temp->value = interval; temp->next = curr->next; curr->next = temp; } else { if (mpfr_cmp(il,el) < 0) { /* We must produce one interval [il;el] */ sollya_mpfi_interv_fr(*interval,il,el); } else { if (mpfr_cmp(er,ir) < 0) { /* We must produce one interval [er;ir] */ sollya_mpfi_interv_fr(*interval,er,ir); } else { /* We must remove the interval completely */ if (previous != NULL) { /* We are not the first interval in the chain */ previous->next = curr->next; sollya_mpfi_clear(*interval); safeFree(interval); safeFree(curr); curr = previous; } else { /* We are the first interval in the chain */ if (curr->next != NULL) { /* We have a successor that will become the head of the chain */ mainIntervals = curr->next; sollya_mpfi_clear(*interval); safeFree(interval); safeFree(curr); curr = mainIntervals; } else { /* We are the first and the last element in the chain, which will be empty */ sollya_mpfi_clear(*interval); safeFree(interval); safeFree(curr); mpfr_clear(il); mpfr_clear(ir); mpfr_clear(el); mpfr_clear(er); return NULL; } } } } } } previous = curr; curr = curr->next; } curr2 = curr2->next; } mpfr_clear(il); mpfr_clear(ir); mpfr_clear(el); mpfr_clear(er); return mainIntervals; } void infnormI(sollya_mpfi_t infnormval, node *func, node *deriv, node *numeratorDeriv, node *derivNumeratorDeriv, sollya_mpfi_t range, mp_prec_t prec, mpfr_t diam, chain *intervalsToExclude, chain **mightExcludes, infnormTheo *theo) { chain *curr, *zeros, *tempChain, *tempChain2, *tempChain3; sollya_mpfi_t *currInterval; sollya_mpfi_t evalFuncOnInterval, lInterv, rInterv; mpfr_t innerLeft, innerRight, outerLeft, outerRight, l, r, tl, tr; mpfr_t diamJoin; mp_prec_t rangePrec; chain *excludes, *excludesTemp; int i; noZeroTheo *noZeros; exprBoundTheo *evalLeftBound, *evalRightBound, *currZeroTheo; currZeroTheo = NULL; if (theo != NULL) { theo->function = copyTree(func); theo->derivative = copyTree(deriv); theo->numeratorOfDerivative = copyTree(numeratorDeriv); theo->derivativeOfNumeratorOfDerivative = copyTree(derivNumeratorDeriv); theo->excludedIntervals = copyChain(intervalsToExclude,copyMpfiPtr); noZeros = (noZeroTheo *) safeCalloc(1,sizeof(noZeroTheo)); theo->noZeros = noZeros; evalLeftBound = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(evalLeftBound); evalRightBound = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(evalRightBound); theo->evalLeftBound = evalLeftBound; theo->evalRightBound = evalRightBound; theo->domain = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); theo->infnorm = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); theo->evalOnZeros = NULL; sollya_mpfi_init2(*(theo->domain),sollya_mpfi_get_prec(range)); sollya_mpfi_init2(*(theo->infnorm),sollya_mpfi_get_prec(infnormval)); sollya_mpfi_set(*(theo->domain),range); } else { noZeros = NULL; evalLeftBound = NULL; evalRightBound = NULL; } mpfr_init2(innerLeft, prec); mpfr_init2(innerRight, prec); mpfr_init2(outerLeft, prec); mpfr_init2(outerRight, prec); mpfr_init2(tl, prec); mpfr_init2(tr, prec); sollya_mpfi_init2(evalFuncOnInterval,prec); rangePrec = sollya_mpfi_get_prec(range); mpfr_init2(l,rangePrec); mpfr_init2(r,rangePrec); sollya_mpfi_get_left(l,range); sollya_mpfi_get_right(r,range); sollya_mpfi_init2(rInterv, rangePrec); sollya_mpfi_init2(lInterv, rangePrec); sollya_mpfi_set_fr(rInterv,r); sollya_mpfi_set_fr(lInterv,l); excludes = evaluateITaylor(evalFuncOnInterval, func, deriv, lInterv, prec, taylorrecursions, evalLeftBound,0,0,0,0,NULL,NULL); sollya_mpfi_get_left(outerLeft,evalFuncOnInterval); sollya_mpfi_get_right(outerRight,evalFuncOnInterval); mpfr_set(innerLeft,outerRight,GMP_RNDU); mpfr_set(innerRight,outerLeft,GMP_RNDD); excludesTemp = evaluateITaylor(evalFuncOnInterval, func, deriv, rInterv, prec, taylorrecursions, evalRightBound,0,0,0,0,NULL,NULL); excludes = concatChains(excludes,excludesTemp); sollya_mpfi_get_left(tl,evalFuncOnInterval); sollya_mpfi_get_right(tr,evalFuncOnInterval); sollya_mpfr_min(outerLeft,outerLeft,tl,GMP_RNDD); sollya_mpfr_max(outerRight,outerRight,tr,GMP_RNDU); sollya_mpfr_min(innerLeft,innerLeft,tr,GMP_RNDU); sollya_mpfr_max(innerRight,innerRight,tl,GMP_RNDD); printMessage(3,SOLLYA_MSG_INVOKING_RECURSIVE_INTERVAL_ZERO_SEARCH,"Information: invoking interval zero search.\n"); tempChain = findZeros(numeratorDeriv,derivNumeratorDeriv,range,prec,diam,noZeros); printMessage(3,SOLLYA_MSG_RECURSIVE_INTERVAL_ZERO_SEARCH_HAS_FINISHED,"Information: interval zero search is done.\n"); mpfr_init2(diamJoin,prec); mpfr_mul_2ui(diamJoin,diam,3,GMP_RNDN); tempChain2 = joinAdjacentIntervals(tempChain,diamJoin); tempChain3 = copyChain(tempChain2,copyMpfiPtr); mpfr_mul_2ui(diamJoin,diamJoin,2,GMP_RNDN); zeros = joinAdjacentIntervals(tempChain3,diamJoin); mpfr_clear(diamJoin); zeros = excludeIntervals(zeros,intervalsToExclude); i = 0; for (curr=zeros;curr!=NULL;curr=curr->next) i++; printMessage(2,SOLLYA_MSG_CERTAIN_NUM_OF_INTVALS_ENCLOSING_ZEROS_OF_DERIV, "Information: %d interval(s) have (has) been found that possibly contain(s) the zeros of the derivative.\n",i); curr = zeros; while (curr != NULL) { if (theo != NULL) { currZeroTheo = (exprBoundTheo *) safeCalloc(1,sizeof(exprBoundTheo)); nullifyExprBoundTheo(currZeroTheo); } else { currZeroTheo = NULL; } currInterval = ((sollya_mpfi_t *) (curr->value)); excludesTemp = evaluateITaylor(evalFuncOnInterval, func, deriv, *currInterval, prec, taylorrecursions, currZeroTheo,0,0,0,0,NULL,NULL); excludes = concatChains(excludes,excludesTemp); sollya_mpfi_get_left(tl,evalFuncOnInterval); sollya_mpfi_get_right(tr,evalFuncOnInterval); if (theo != NULL) { theo->evalOnZeros = addElement(theo->evalOnZeros,currZeroTheo); } if (mpfr_nan_p(tl) || mpfr_nan_p(tr)) { printMessage(1,SOLLYA_MSG_NAN_OR_INF_ON_DERIVATIVE,"Warning: NaNs occurred during the interval evaluation of the zeros of the derivative.\n"); } sollya_mpfr_min(outerLeft,outerLeft,tl,GMP_RNDD); sollya_mpfr_max(outerRight,outerRight,tr,GMP_RNDU); sollya_mpfr_min(innerLeft,innerLeft,tr,GMP_RNDU); sollya_mpfr_max(innerRight,innerRight,tl,GMP_RNDD); curr = curr->next; } freeChain(zeros,freeMpfiPtr); freeChain(tempChain,freeMpfiPtr); freeChain(tempChain2,freeMpfiPtr); freeChain(tempChain3,freeMpfiPtr); if (mpfr_cmp(innerLeft,innerRight) >= 0) { mpfr_neg(outerLeft,outerLeft,GMP_RNDN); sollya_mpfr_max(tr,outerLeft,outerRight,GMP_RNDU); mpfr_set_d(tl,0.0,GMP_RNDD); if (mpfr_cmp(tl, tr)<=0) sollya_mpfi_interv_fr(infnormval,tl,tr); else sollya_mpfi_interv_fr(infnormval,tr,tl); } else { mpfr_neg(innerLeft,innerLeft,GMP_RNDN); mpfr_neg(outerLeft,outerLeft,GMP_RNDN); sollya_mpfr_max(tl,innerLeft,innerRight,GMP_RNDD); sollya_mpfr_max(tr,outerLeft,outerRight,GMP_RNDU); if (mpfr_cmp(tl, tr)<=0) sollya_mpfi_interv_fr(infnormval,tl,tr); else sollya_mpfi_interv_fr(infnormval,tr,tl); } if (mightExcludes == NULL) { freeChain(excludes,freeMpfiPtr); } else { *mightExcludes = excludes; } if (theo != NULL) { sollya_mpfi_set(*(theo->infnorm),infnormval); } mpfr_clear(tl); mpfr_clear(tr); sollya_mpfi_clear(lInterv); sollya_mpfi_clear(rInterv); mpfr_clear(l); mpfr_clear(r); sollya_mpfi_clear(evalFuncOnInterval); mpfr_clear(innerLeft); mpfr_clear(innerRight); mpfr_clear(outerLeft); mpfr_clear(outerRight); } int isTrivialInfnormCase(rangetype result, node *func) { int isTrivial; node *simplifiedFunc, *numerator, *denominator; isTrivial = 0; simplifiedFunc = horner(func); if (accessThruMemRef(simplifiedFunc)->nodeType == CONSTANT) { mpfr_set(*(result.a),*(accessThruMemRef(simplifiedFunc)->value),GMP_RNDD); mpfr_set(*(result.b),*(accessThruMemRef(simplifiedFunc)->value),GMP_RNDU); isTrivial = 1; } else { if (accessThruMemRef(simplifiedFunc)->nodeType == SUB) { if (isSyntacticallyEqual(accessThruMemRef(simplifiedFunc)->child1,accessThruMemRef(simplifiedFunc)->child2)) { mpfr_set_d(*(result.a),0.0,GMP_RNDN); mpfr_set_d(*(result.b),0.0,GMP_RNDN); isTrivial = 1; } } else { if (getNumeratorDenominator(&numerator, &denominator, simplifiedFunc)) { if ((accessThruMemRef(numerator)->nodeType == CONSTANT) && mpfr_zero_p(*(accessThruMemRef(numerator)->value))) { mpfr_set_d(*(result.a),0.0,GMP_RNDN); mpfr_set_d(*(result.b),0.0,GMP_RNDN); isTrivial = 1; } else { if (isSyntacticallyEqual(numerator, denominator)) { mpfr_set_d(*(result.a),1.0,GMP_RNDN); mpfr_set_d(*(result.b),1.0,GMP_RNDN); isTrivial = 1; } } free_memory(denominator); } free_memory(numerator); } } free_memory(simplifiedFunc); return isTrivial; } /* If x_result != NULL, the mpfr_t it points to is used to store the value of a point where the infnorm is reached. It is supposed to be already initialized. */ void uncertifiedInfnorm(mpfr_t result, mpfr_t *x_result, node *f, mpfr_t a, mpfr_t b, unsigned long int points, mp_prec_t prec) { mpfr_t current_x, argmax, x1, x2, x3, step, y1, y2, y3, max, cutoff; mpfr_t ystar, y1diff, y3diff, xstar; mpfr_t zero_mpfr; mpfr_t perturb; mp_prec_t prec_bound = prec; node *f_diff, *f_diff2; int r; int count=0; int stop_algo = 0; const mp_prec_t INIT_PREC = 20; gmp_randstate_t random_state; if (mpfr_get_prec(a) > prec_bound) prec_bound = mpfr_get_prec(a); if (mpfr_get_prec(b) > prec_bound) prec_bound = mpfr_get_prec(b); /**************************** Dealing with special cases ****************************/ if ( (!mpfr_number_p(a)) || (!mpfr_number_p(b)) ) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_NO_CLOSED_INTERVAL_ON_THE_REALS,"Warning: a bound of the interval is infinite or NaN.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"This command cannot handle such intervals.\n"); mpfr_set_nan(result); return; } if (mpfr_equal_p(a,b)) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_REDUCED_TO_A_POINT_WILL_SIMPLY_EVAL,"Warning: the given interval is reduced to one point.\n"); evaluateFaithful(result,f,a,prec); mpfr_abs(result,result,GMP_RNDU); return; } if (mpfr_greater_p(a,b)) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_EMPTY,"Warning: the interval is empty.\n"); mpfr_set_d(result,0.,GMP_RNDN); return; } if (isConstant(f)) { printMessage(1,SOLLYA_MSG_EXPRESSION_IS_CONSTANT,"Warning: the expression is constant.\n"); evaluateFaithful(result,f,a,prec); mpfr_abs(result,result,GMP_RNDU); return; } /************************************************************************************/ gmp_randinit_default(random_state); gmp_randseed_ui(random_state, 65845285); mpfr_init2(perturb, prec); mpfr_init2(zero_mpfr, 53); mpfr_set_d(zero_mpfr, 0., GMP_RNDN); mpfr_init2(step, prec); mpfr_sub(step, b, a, GMP_RNDU); /* since aO */ mpfr_div_ui(step, step, points, GMP_RNDN); mpfr_init2(current_x, prec_bound); mpfr_init2(x1, prec_bound); mpfr_init2(x2, prec_bound); mpfr_init2(x3, prec_bound); mpfr_init2(argmax, prec_bound); mpfr_init2(y1, prec); mpfr_init2(y2, prec); mpfr_init2(y3, prec); mpfr_init2(ystar, prec); mpfr_init2(y1diff, prec); mpfr_init2(y3diff, prec); mpfr_init2(xstar, prec_bound); mpfr_init2(max, prec); mpfr_set_d(max, 0., GMP_RNDN); mpfr_init2(cutoff, prec); mpfr_set_d(cutoff, 0., GMP_RNDN); f_diff = differentiate(f); f_diff2 = NULL; /* Initial value of x1 */ mpfr_set(x1, a, GMP_RNDN); /* exact */ mpfr_set(current_x, a, GMP_RNDN); do { count++; if (mpfr_greaterequal_p(x1,b)) { mpfr_set(x1, b, GMP_RNDN); /* exact */ stop_algo = 1; } r = evaluateFaithfulWithCutOffFast(y1, f, f_diff, x1, cutoff, INIT_PREC); if (r==0) mpfr_set_d(y1, 0. , GMP_RNDN); if (!mpfr_number_p(y1)) { printMessage(1,SOLLYA_MSG_EVALUATION_AT_POINT_GIVES_NAN_EXCLUDING_POINT,"Warning: the evaluation of the given function %b in %v gives NaN.\nThis (possibly maximum) point will be excluded from the infnorm result.\n",f,x1); mpfr_add(current_x, current_x, step, GMP_RNDU); /* rounding up ensures that x1(new) > x1(old) */ mpfr_urandomb(perturb, random_state); mpfr_mul_2ui(perturb, perturb, 1, GMP_RNDN); mpfr_sub_ui(perturb, perturb, 1, GMP_RNDN); mpfr_div_2ui(perturb, perturb, 2, GMP_RNDN); mpfr_mul(perturb, perturb, step, GMP_RNDN); /* perturb \in [-step/4; step/4] */ mpfr_add(x1, current_x, perturb, GMP_RNDU); } } while ( (!mpfr_number_p(y1)) && (!stop_algo) ); mpfr_abs(max, y1, GMP_RNDU); mpfr_set(argmax, x1, GMP_RNDN); printMessage(3,SOLLYA_MSG_THE_CURRENT_MAXIMUM_IS_A_CERTAIN_VALUE,"Information: current max is %v and is reached at %v\n",max,argmax); mpfr_div_2ui(cutoff, max, 1, GMP_RNDU); /* Initial value of x2 */ do { count++; mpfr_add(current_x, current_x, step, GMP_RNDU); /* rounding up ensures that x2 > x1 */ mpfr_urandomb(perturb, random_state); mpfr_mul_2ui(perturb, perturb, 1, GMP_RNDN); mpfr_sub_ui(perturb, perturb, 1, GMP_RNDN); mpfr_div_2ui(perturb, perturb, 2, GMP_RNDN); mpfr_mul(perturb, perturb, step, GMP_RNDN); /* perturb \in [-step/4; step/4] */ mpfr_add(x2, current_x, perturb, GMP_RNDU); if (mpfr_greaterequal_p(x2,b)) { mpfr_set(x2, b, GMP_RNDN); /* exact */ stop_algo = 1; } r = evaluateFaithfulWithCutOffFast(y2, f, f_diff, x2, cutoff, INIT_PREC); if (r==2) mpfr_set_d(y2, 0. , GMP_RNDN); /* under the cutoff */ if (!mpfr_number_p(y2)) { printMessage(1,SOLLYA_MSG_EVALUATION_AT_POINT_GIVES_NAN_EXCLUDING_POINT,"Warning: the evaluation of the given function %b in %v gives NaN.\nThis (possibly maximum) point will be excluded from the infnorm result.\n",f,x2); } } while ( ( (!mpfr_number_p(y2)) || mpfr_equal_p(y1,y2) ) && (!stop_algo) ); if (mpfr_cmpabs(y2, max) > 0) { /* evaluates to false when y2=NaN */ mpfr_abs(max, y2, GMP_RNDU); mpfr_set(argmax, x2, GMP_RNDN); printMessage(3,SOLLYA_MSG_THE_CURRENT_MAXIMUM_IS_A_CERTAIN_VALUE,"Information: current max is %v and is reached at %v\n",max,argmax); mpfr_div_2ui(cutoff, max, 1, GMP_RNDU); } /* Remark: at this point, it is possible that y1=y2 and stop_algo is true. */ /* In this case, it means that f is constant over the interval and it is */ /* hence not necessary to run Newton's algorithm anyway. */ /* Main loop */ while(!stop_algo) { do { count++; if (verbosity >= 2) { if( count % 100 == 0) printMessage(2,SOLLYA_MSG_CERTAIN_AMOUNT_OF_CASES_HANDLED,"Information: %d out of %d points have been handled.\n",count,points); } mpfr_add(current_x, current_x, step, GMP_RNDU); /* rounding up ensures that x3 > x2 */ mpfr_urandomb(perturb, random_state); mpfr_mul_2ui(perturb, perturb, 1, GMP_RNDN); mpfr_sub_ui(perturb, perturb, 1, GMP_RNDN); mpfr_div_2ui(perturb, perturb, 2, GMP_RNDN); mpfr_mul(perturb, perturb, step, GMP_RNDN); /* perturb \in [-step/4; step/4] */ mpfr_add(x3, current_x, perturb, GMP_RNDU); if (mpfr_greaterequal_p(x3,b)) { mpfr_set(x3, b, GMP_RNDN); /* exact */ stop_algo = 1; } r = evaluateFaithfulWithCutOffFast(y3, f, f_diff, x3, cutoff, INIT_PREC); if (r==2) mpfr_set_d(y3, 0. , GMP_RNDN); /* under the cutoff */ if (!mpfr_number_p(y3)) { printMessage(1,SOLLYA_MSG_EVALUATION_AT_POINT_GIVES_NAN_EXCLUDING_POINT,"Warning: the evaluation of the given function %b in %v gives NaN.\nThis (possibly maximum) point will be excluded from the infnorm result.\n",f,x3); } } while ( ( (!mpfr_number_p(y3))|| mpfr_equal_p(y2,y3) ) && (!stop_algo) ); if (mpfr_cmpabs(y3, max) > 0) { /* evaluates to false when y3=NaN */ mpfr_abs(max, y3, GMP_RNDU); mpfr_set(argmax, x3, GMP_RNDN); printMessage(3,SOLLYA_MSG_THE_CURRENT_MAXIMUM_IS_A_CERTAIN_VALUE,"Information: current max is %v and is reached at %v\n",max,argmax); mpfr_div_2ui(cutoff, max, 1, GMP_RNDU); } /* Call to Newton's algorithm if necessary */ if ( (mpfr_cmpabs(y2,y1)>=0) && (mpfr_cmpabs(y2,y3)>=0) && (mpfr_cmp_d(y2,0.)!=0) ) { if (f_diff2 == NULL) f_diff2 = differentiate(f_diff); r = evaluateFaithfulWithCutOffFast(y1diff, f_diff, f_diff2, x1, zero_mpfr, prec+10); if (r==0) mpfr_set_d(y1diff, 0. , GMP_RNDN); r = evaluateFaithfulWithCutOffFast(y3diff, f_diff, f_diff2, x3, zero_mpfr, prec+10); if (r==0) mpfr_set_d(y3diff, 0. , GMP_RNDN); if ( (!mpfr_number_p(y1diff)) || (!mpfr_number_p(y3diff)) ) { printMessage(1,SOLLYA_MSG_EVALUATION_OF_DERIVATIVE_GIVES_NAN_NO_NEWTON,"Warning: the evaluation of the derivative %b of the given function in %v or %v gives NaN.\nNewton's algorithm will not be used on this interval.\n",f_diff,x1,x3); } else if(mpfr_sgn(y1diff)*mpfr_sgn(y3diff)<0) { /* If y1diff=0 or y3diff=0, there is no need to */ /* use Newton's algorithm since we already have */ /* the zero. Moreover, note that y1 and y3 have */ /* already been taken into account in max. */ findZero(xstar, f_diff, f_diff2, x1, x3, mpfr_sgn(y1diff), NULL, 0, (prec_bound >> 1) + 10); /* If xstar = NaN, a warning has already been produced by Newton's algorithm. */ /* There is no need to print a warning again here. */ if(mpfr_number_p(xstar)) { r = evaluateFaithfulWithCutOffFast(ystar, f, f_diff, xstar, cutoff, prec+10); if (r==2) mpfr_set_d(ystar, 0. , GMP_RNDN); /* under the cutoff */ if (!mpfr_number_p(ystar)) { printMessage(1,SOLLYA_MSG_EVALUATION_AT_POINT_GIVES_NAN_EXCLUDING_POINT,"Warning: the evaluation of the given function %b in %v gives NaN.\nThis (possibly maximum) point will be excluded from the infnorm result.\n",f,xstar); } if (mpfr_cmpabs(ystar, max) > 0) { /* evaluates to false when ystar=NaN */ mpfr_abs(max, ystar, GMP_RNDU); mpfr_set(argmax, xstar, GMP_RNDN); printMessage(3,SOLLYA_MSG_THE_CURRENT_MAXIMUM_IS_A_CERTAIN_VALUE,"Information: current max is %v and is reached at %v\n",max,argmax); mpfr_div_2ui(cutoff, max, 1, GMP_RNDU); } } } } mpfr_set(x1,x2,GMP_RNDN); /* exact */ mpfr_set(y1,y2,GMP_RNDN); /* exact */ mpfr_set(x2,x3,GMP_RNDN); /* exact */ mpfr_set(y2,y3,GMP_RNDN); /* exact */ } mpfr_set(result, max, GMP_RNDU); if (x_result != NULL) mpfr_set(*x_result, argmax, GMP_RNDN); free_memory(f_diff); free_memory(f_diff2); gmp_randclear(random_state); mpfr_clear(perturb); mpfr_clear(current_x); mpfr_clear(x1); mpfr_clear(x2); mpfr_clear(x3); mpfr_clear(argmax); mpfr_clear(step); mpfr_clear(y1); mpfr_clear(y2); mpfr_clear(y3); mpfr_clear(ystar); mpfr_clear(y1diff); mpfr_clear(y3diff); mpfr_clear(xstar); mpfr_clear(zero_mpfr); mpfr_clear(max); mpfr_clear(cutoff); } rangetype infnorm(node *func, rangetype range, chain *excludes, mp_prec_t prec, mpfr_t diam, FILE *proof) { rangetype res; sollya_mpfi_t rangeI, resI; sollya_mpfi_t *excludeI; node *deriv, *numeratorDeriv, *derivNumeratorDeriv, *denominatorDeriv, *derivDenominatorDeriv; mpfr_t rangeDiameter, z, ya,yb; chain *mightExcludes, *curr, *secondMightExcludes, *initialExcludes; int newtonWorked; mp_prec_t p, p2; infnormTheo *theo; int freeInitialExcludes; freeInitialExcludes = 1; res.a = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); res.b = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(res.a),prec); mpfr_init2(*(res.b),prec); if ((!mpfr_number_p(*(range.a))) || (!mpfr_number_p(*(range.b)))) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_NO_CLOSED_INTERVAL_ON_THE_REALS,"Warning: the bounds of the range an infinity norm is to be computed on are not numbers.\n"); if (proof != NULL) { printMessage(1,SOLLYA_MSG_NO_PROOF_WILL_BE_GENERATED,"Warning: no proof will be generated.\n"); } mpfr_set_d(*(res.a),0.0,GMP_RNDN); mpfr_set_inf(*(res.b),1); return res; } if ((mpfr_cmp(*(range.a),*(range.b)) == 0) && (proof == NULL)) { evaluateRangeFunctionFast(res, func, NULL, range, prec); mpfr_abs(*(res.a),*(res.a),GMP_RNDN); mpfr_abs(*(res.b),*(res.b),GMP_RNDN); if (mpfr_cmp(*(res.a),*(res.b)) > 0) { mpfr_init2(z,prec); mpfr_set(z,*(res.b),GMP_RNDN); mpfr_set(*(res.b),*(res.a),GMP_RNDN); mpfr_set(*(res.a),z,GMP_RNDN); mpfr_clear(z); } return res; } if (isTrivialInfnormCase(res, func)) { if (proof != NULL) { printMessage(1,SOLLYA_MSG_INFNORM_RESULT_IS_TRIVIAL,"Warning: the infnorm on the given function is trivially calculable.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"No proof will be generated.\n"); } return res; } curr = excludes; initialExcludes = NULL; while (curr != NULL) { excludeI = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); p = mpfr_get_prec(*(((rangetype *) curr->value)->a)); p2 = mpfr_get_prec(*(((rangetype *) curr->value)->b)); if (p2 > p) p = p2; if (prec > p) p = prec; sollya_mpfi_init2(*excludeI,p); sollya_mpfi_interv_fr(*excludeI,*(((rangetype *) curr->value)->a),*(((rangetype *) curr->value)->b)); initialExcludes = addElement(initialExcludes,(void *) excludeI); curr = curr->next; } sollya_mpfi_init2(rangeI,prec); sollya_mpfi_init2(resI,prec); mpfr_init2(rangeDiameter,prec); mpfr_sub(rangeDiameter,*(range.b),*(range.a),GMP_RNDD); mpfr_mul(rangeDiameter,rangeDiameter,diam,GMP_RNDD); sollya_mpfi_interv_fr(rangeI,*(range.a),*(range.b)); deriv = differentiate(func); if (getNumeratorDenominator(&numeratorDeriv,&denominatorDeriv,deriv)) { printMessage(1,SOLLYA_MSG_DERIVATIVE_IS_QUOTIENT,"Warning: the derivative of the function is a quotient, thus possibly not continuous in the interval.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Only the zeros of the numerator will be searched and pole detection may fail.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Be sure that the function is twice continuously differentiable if trusting the infnorm result.\n"); mpfr_init2(z,prec); mpfr_init2(ya,prec); mpfr_init2(yb,prec); derivDenominatorDeriv = differentiate(denominatorDeriv); newtonWorked = newtonMPFR(z, denominatorDeriv, derivDenominatorDeriv, *(range.a), *(range.b), prec); if (newtonWorked && mpfr_number_p(z)) { evaluate(ya,numeratorDeriv,z,prec); evaluate(yb,denominatorDeriv,z,prec); mpfr_abs(ya,ya,GMP_RNDN); mpfr_abs(yb,yb,GMP_RNDN); mpfr_mul_ui(yb,yb,2,GMP_RNDN); if (mpfr_cmp(ya,yb) <= 0) { printMessage(1,SOLLYA_MSG_DERIVATIVE_SEEMS_TO_HAVE_EXTENSIBLE_SINGULARITY,"Warning: the derivative of the function seems to have a extensible singularity in %v.\nThe infnorm result might not be trustful if the derivative cannot actually\nbe extended in this point.\n",z); } else { printMessage(1,SOLLYA_MSG_DERIVATIVE_SEEMS_TO_HAVE_SINGULARITY,"Warning: the derivative of the function seems to have a singularity in %v.\nThe infnorm result is likely to be wrong.\n",z); } } else { evaluate(ya,denominatorDeriv,*(range.a),prec); evaluate(yb,denominatorDeriv,*(range.b),prec); if (mpfr_sgn(ya) != mpfr_sgn(yb)) { printMessage(1,SOLLYA_MSG_DERIVATIVE_SEEMS_TO_HAVE_EXTENSIBLE_SINGULARITY,"Warning: the derivative of the function seems to have a (extensible) singularity in the considered interval.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The infnorm result might be not trustful if the function is not continuously differentiable.\n"); } else { printMessage(2,SOLLYA_MSG_DERIVATIVE_SEEMS_NOT_TO_HAVE_ANY_POLE,"Information: the derivative seems to have no (false) pole in the considered interval.\n"); } } mpfr_clear(z); mpfr_clear(ya); mpfr_clear(yb); free_memory(derivDenominatorDeriv); free_memory(denominatorDeriv); } derivNumeratorDeriv = differentiate(numeratorDeriv); mightExcludes = NULL; if (proof != NULL) { theo = (infnormTheo *) safeCalloc(1,sizeof(infnormTheo)); } else { theo = NULL; } printMessage(3,SOLLYA_MSG_INVOKING_INFNORM_SUBFUNCTION,"Information: invoking the interval infnorm subfunction.\n"); infnormI(resI,func,deriv,numeratorDeriv,derivNumeratorDeriv,rangeI, prec,rangeDiameter,initialExcludes,&mightExcludes,theo); printMessage(3,SOLLYA_MSG_INFNORM_SUBFUNCTION_HAS_FINISHED,"Information: interval infnorm subfunction has finished.\n"); secondMightExcludes = NULL; if (mightExcludes != NULL) { mightExcludes = concatChains(mightExcludes,initialExcludes); freeInitialExcludes = 0; if (theo != NULL) freeInfnormTheo(theo); if (proof != NULL) { theo = (infnormTheo *) safeCalloc(1,sizeof(infnormTheo)); } else { theo = NULL; } printMessage(3,SOLLYA_MSG_INVOKING_INFNORM_SUBFUNCTION,"Information: invoking the interval infnorm subfunction on additional excludes.\n"); infnormI(resI,func,deriv,numeratorDeriv,derivNumeratorDeriv,rangeI, 2*prec,rangeDiameter,mightExcludes,&secondMightExcludes,theo); printMessage(3,SOLLYA_MSG_INFNORM_SUBFUNCTION_HAS_FINISHED,"Information: interval infnorm subfunction on additional excludes has finished.\n"); } if (proof != NULL) { printMessage(2,SOLLYA_MSG_STARTING_TO_WRITE_THE_PROOF,"Information: started writing the proof.\n"); fprintInfnormTheo(proof,theo,1); printMessage(2,SOLLYA_MSG_THE_PROOF_HAS_BEEN_WRITTEN,"Information: proof written.\n"); } if (theo != NULL) freeInfnormTheo(theo); freeChain(mightExcludes,freeMpfiPtr); freeChain(secondMightExcludes,freeMpfiPtr); if (freeInitialExcludes) freeChain(initialExcludes,freeMpfiPtr); sollya_mpfi_get_left(*(res.a),resI); sollya_mpfi_get_right(*(res.b),resI); free_memory(deriv); free_memory(numeratorDeriv); free_memory(derivNumeratorDeriv); sollya_mpfi_clear(rangeI); sollya_mpfi_clear(resI); mpfr_clear(rangeDiameter); return res; } void evaluateRangeFunctionFast(rangetype yrange, node *func, node *deriv, rangetype xrange, mp_prec_t prec) { sollya_mpfi_t x, y; chain *tempChain; mp_prec_t p, p2; p = prec; p2 = mpfr_get_prec(*(xrange.a)); if (p2 > p) p = p2; p2 = mpfr_get_prec(*(xrange.b)); if (p2 > p) p = p2; sollya_mpfi_init2(x,p); sollya_mpfi_init2(y,prec); sollya_mpfi_interv_fr(x,*(xrange.a),*(xrange.b)); tempChain = evaluateITaylorStart(y, func, deriv, x, prec, taylorrecursions, NULL, 1,0,0,0,NULL,NULL); sollya_mpfi_get_left(*(yrange.a),y); sollya_mpfi_get_right(*(yrange.b),y); freeChain(tempChain,freeMpfiPtr); sollya_mpfi_clear(x); sollya_mpfi_clear(y); } void evaluateInterval(sollya_mpfi_t y, node *func, node *deriv, sollya_mpfi_t x) { mp_prec_t prec; prec = sollya_mpfi_get_prec(y); /* We need more precision in the first steps to get the precision in the end. */ prec += 10; evaluateITaylorStart(y, func, deriv, x, prec, taylorrecursions, NULL, 1,0,0,0,NULL,NULL); } void evaluateIntervalPlain(sollya_mpfi_t y, node *func, sollya_mpfi_t x) { evaluateITaylorStart(y, func, NULL, x, sollya_mpfi_get_prec(y), taylorrecursions, NULL, 1,0,0,0,NULL,NULL); } static inline void evaluateIntervalInternalFast(sollya_mpfi_t y, node *func, node *deriv, sollya_mpfi_t x, int adaptPrecision, int noLazyHooks, mp_exp_t *cutoff, int *lazyHookUsed) { mp_prec_t prec; prec = sollya_mpfi_get_prec(y); /* We need more precision in the first steps to get the precision in the end. */ prec += 10; evaluateITaylorStart(y, func, deriv, x, prec, taylorrecursions, NULL, 1,1,adaptPrecision,noLazyHooks,cutoff,lazyHookUsed); } void evaluateConstantExpressionToInterval(sollya_mpfi_t y, node *func) { sollya_mpfi_t x; if (!isConstant(func)) { printMessage(1,SOLLYA_MSG_THE_EXPRESSION_IS_NOT_CONSTANT,"Warning: the given expression is not constant. Evaluating it at 1.\n"); } sollya_mpfi_init2(x,12); sollya_mpfi_set_si(x,1); evaluateInterval(y, func, NULL, x); sollya_mpfi_clear(x); } void evaluateConstantExpressionToSharpInterval(sollya_mpfi_t y, node *func) { sollya_mpfi_t x, myY, myY2; mpfr_t X, Y, Y2; mp_prec_t prec; if (!isConstant(func)) { printMessage(1,SOLLYA_MSG_THE_EXPRESSION_IS_NOT_CONSTANT,"Warning: the given expression is not constant. Evaluating it at 1.\n"); } sollya_mpfi_init2(x,12); sollya_mpfi_set_si(x,1); mpfr_init2(X, 12); mpfr_set_si(X, 1,GMP_RNDN); prec = sollya_mpfi_get_prec(y); mpfr_init2(Y, prec + 5); if (evaluateFaithful(Y, func, X, prec + 10)) { mpfr_init2(Y2, mpfr_get_prec(Y)); sollya_mpfi_init2(myY, prec + 1); sollya_mpfi_init2(myY2, prec + 1); mpfr_set(Y2, Y, GMP_RNDN); /* exact */ mpfr_nextabove(Y); mpfr_nextbelow(Y2); sollya_mpfi_interv_fr(myY, Y2, Y); evaluateInterval(myY2, func, NULL, x); sollya_mpfi_intersect(myY, myY, myY2); sollya_mpfi_set(y,myY); sollya_mpfi_clear(myY); sollya_mpfi_clear(myY2); mpfr_clear(Y2); } else { sollya_mpfi_init2(myY, prec * 256); evaluateInterval(myY, func, NULL, x); sollya_mpfi_set(y,myY); sollya_mpfi_clear(myY); } sollya_mpfi_clear(x); mpfr_clear(X); mpfr_clear(Y); } void evaluateRangeFunction(rangetype yrange, node *func, rangetype xrange, mp_prec_t prec) { node *deriv, *temp, *temp2, *numerator, *denominator, *f; rangetype myrange; node *myderiv; if (containsNonDifferentiableSubfunctions(func)) { evaluateRangeFunctionFast(yrange,func,NULL,xrange,prec); return; } temp = differentiate(func); deriv = horner(temp); if ((accessThruMemRef(func)->nodeType == POW) && (accessThruMemRef(accessThruMemRef(func)->child1)->nodeType == VARIABLE) && (accessThruMemRef(accessThruMemRef(func)->child2)->nodeType == CONSTANT) && mpfr_zero_p(*(accessThruMemRef(accessThruMemRef(func)->child2)->value))) { temp2 = copyTree(func); } else { temp2 = horner(func); } f = NULL; if (getNumeratorDenominator(&numerator,&denominator,temp2)) { if (isSyntacticallyEqual(numerator, denominator)) { if (!isConstant(numerator)) { myderiv = differentiate(numerator); myrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); myrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(myrange.a),mpfr_get_prec(*(yrange.a))); mpfr_init2(*(myrange.b),mpfr_get_prec(*(yrange.b))); evaluateRangeFunctionFast(myrange,numerator,myderiv,xrange,prec); free_memory(myderiv); if (mpfr_sgn(*(myrange.a)) * mpfr_sgn(*(myrange.b)) == 1) { mpfr_clear(*(myrange.a)); mpfr_clear(*(myrange.b)); safeFree(myrange.a); safeFree(myrange.b); mpfr_set_d(*(yrange.a),1.0,GMP_RNDD); mpfr_set_d(*(yrange.b),1.0,GMP_RNDU); free_memory(numerator); free_memory(denominator); free_memory(deriv); free_memory(temp); free_memory(temp2); return; } else { f = copyTree(temp2); } } else { myderiv = differentiate(numerator); myrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); myrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(myrange.a),mpfr_get_prec(*(yrange.a))); mpfr_init2(*(myrange.b),mpfr_get_prec(*(yrange.b))); evaluateRangeFunctionFast(myrange,numerator,myderiv,xrange,prec); free_memory(myderiv); if (mpfr_sgn(*(myrange.a)) * mpfr_sgn(*(myrange.b)) == 1) { mpfr_clear(*(myrange.a)); mpfr_clear(*(myrange.b)); safeFree(myrange.a); safeFree(myrange.b); mpfr_set_d(*(yrange.a),1.0,GMP_RNDD); mpfr_set_d(*(yrange.b),1.0,GMP_RNDU); free_memory(numerator); free_memory(denominator); free_memory(deriv); free_memory(temp); free_memory(temp2); return; } else { if (mpfr_zero_p(*(myrange.a)) && mpfr_zero_p(*(myrange.b))) { mpfr_clear(*(myrange.a)); mpfr_clear(*(myrange.b)); safeFree(myrange.a); safeFree(myrange.b); mpfr_set_nan(*(yrange.a)); mpfr_set_nan(*(yrange.b)); free_memory(numerator); free_memory(denominator); free_memory(deriv); free_memory(temp); free_memory(temp2); return; } else { mpfr_clear(*(myrange.a)); mpfr_clear(*(myrange.b)); safeFree(myrange.a); safeFree(myrange.b); f = copyTree(temp2); } } } } else { f = copyTree(temp2); } free_memory(numerator); free_memory(denominator); } else { free_memory(numerator); f = copyTree(temp2); } evaluateRangeFunctionFast(yrange,f,deriv,xrange,prec); free_memory(deriv); free_memory(temp); free_memory(temp2); free_memory(f); } chain* findZerosFunction(node *func, rangetype range, mp_prec_t prec, mpfr_t diam) { sollya_mpfi_t rangeI; node *deriv, *numerator, *denominator; mpfr_t rangeDiameter, diamJoin; chain *zerosI, *zeros, *curr; rangetype *tempRange; chain *tempChain, *tempChain2, *tempChain3; sollya_mpfi_init2(rangeI,prec); mpfr_init2(rangeDiameter,prec); mpfr_sub(rangeDiameter,*(range.b),*(range.a),GMP_RNDD); mpfr_mul(rangeDiameter,rangeDiameter,diam,GMP_RNDD); sollya_mpfi_interv_fr(rangeI,*(range.a),*(range.b)); if (getNumeratorDenominator(&numerator,&denominator,func)) free_memory(denominator); deriv = differentiate(numerator); tempChain = findZeros(numerator,deriv,rangeI,prec,rangeDiameter,NULL); mpfr_init2(diamJoin,prec); mpfr_mul_2ui(diamJoin,diam,3,GMP_RNDN); tempChain2 = joinAdjacentIntervals(tempChain,diamJoin); tempChain3 = copyChain(tempChain2,copyMpfiPtr); mpfr_mul_2ui(diamJoin,diamJoin,2,GMP_RNDN); zerosI = joinAdjacentIntervals(tempChain3,diamJoin); mpfr_clear(diamJoin); zeros = NULL; curr = zerosI; while (curr != NULL) { tempRange = (rangetype *) safeMalloc(sizeof(rangetype)); tempRange->a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); tempRange->b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(tempRange->a),prec); mpfr_init2(*(tempRange->b),prec); sollya_mpfi_get_left(*(tempRange->a),*((sollya_mpfi_t *) (curr->value))); sollya_mpfi_get_right(*(tempRange->b),*((sollya_mpfi_t *) (curr->value))); zeros = addElement(zeros,tempRange); curr = curr->next; } freeChain(zerosI,freeMpfiPtr); freeChain(tempChain,freeMpfiPtr); freeChain(tempChain2,freeMpfiPtr); freeChain(tempChain3,freeMpfiPtr); free_memory(numerator); free_memory(deriv); sollya_mpfi_clear(rangeI); mpfr_clear(rangeDiameter); return zeros; } int checkInfnormI(node *func, node *deriv, sollya_mpfi_t infnormval, sollya_mpfi_t range, mpfr_t diam, mp_prec_t prec) { sollya_mpfi_t evaluateOnRange, rangeLeft, rangeRight; chain *tempChain; mpfr_t l,m,r, diamRange; int resultLeft, resultRight; sollya_mpfi_init2(evaluateOnRange,prec); tempChain = evaluateITaylorStart(evaluateOnRange, func, deriv, range, prec, taylorrecursions, NULL, 1,0,0,0,NULL,NULL); freeChain(tempChain,freeMpfiPtr); if (sollya_mpfi_is_inside(evaluateOnRange, infnormval)) { /* Simple end case: the interval evaluation is contained in the given interval for infnorm */ sollya_mpfi_clear(evaluateOnRange); return 1; } mpfr_init2(diamRange,prec); sollya_mpfi_diam_abs(diamRange,range); if (mpfr_cmp(diamRange,diam) <= 0) { /* Simple end case: the range to test is already smaller than diam but we could not check */ printMessage(2,SOLLYA_MSG_COULD_NOT_CHECK_INFNORM_ON_A_CERTAIN_INTERVAL,"Information: could not check the infinity norm on the domain\n%w\nThe function evaluates here to\n%w.\n",range,evaluateOnRange); sollya_mpfi_clear(evaluateOnRange); mpfr_clear(diamRange); return 0; } mpfr_init2(l,prec); mpfr_init2(m,prec); mpfr_init2(r,prec); sollya_mpfi_init2(rangeLeft,prec); sollya_mpfi_init2(rangeRight,prec); sollya_mpfi_get_left(l,range); sollya_mpfi_mid(m,range); sollya_mpfi_get_right(r,range); sollya_mpfi_interv_fr(rangeLeft,l,m); sollya_mpfi_interv_fr(rangeRight,m,r); /* Recurse on half the range */ resultLeft = 0; resultRight = 0; resultLeft = checkInfnormI(func, deriv, infnormval, rangeLeft, diam, prec); if (resultLeft) resultRight = checkInfnormI(func, deriv, infnormval, rangeRight, diam, prec); sollya_mpfi_clear(rangeRight); sollya_mpfi_clear(rangeLeft); mpfr_clear(r); mpfr_clear(m); mpfr_clear(l); sollya_mpfi_clear(evaluateOnRange); mpfr_clear(diamRange); return (resultLeft && resultRight); } int checkInfnorm(node *func, rangetype range, mpfr_t infnormval, mpfr_t diam, mp_prec_t prec) { node *deriv; sollya_mpfi_t rangeI, infnormvalI; mpfr_t rangeDiameter, tempLeft, tempRight; int result; sollya_mpfi_init2(rangeI,prec); sollya_mpfi_init2(infnormvalI,prec); mpfr_init2(rangeDiameter,prec); mpfr_init2(tempLeft,prec); mpfr_init2(tempRight,prec); mpfr_sub(rangeDiameter,*(range.b),*(range.a),GMP_RNDD); mpfr_mul(rangeDiameter,rangeDiameter,diam,GMP_RNDD); sollya_mpfi_interv_fr(rangeI,*(range.a),*(range.b)); mpfr_abs(tempRight,infnormval,GMP_RNDU); mpfr_neg(tempLeft,tempRight,GMP_RNDD); sollya_mpfi_interv_fr(infnormvalI,tempLeft,tempRight); deriv = differentiate(func); result = checkInfnormI(func, deriv, infnormvalI, rangeI, rangeDiameter, prec); free_memory(deriv); mpfr_clear(tempLeft); mpfr_clear(tempRight); mpfr_clear(rangeDiameter); sollya_mpfi_clear(infnormvalI); sollya_mpfi_clear(rangeI); return result; } void evaluateConstantWithErrorEstimate(mpfr_t res, mpfr_t err, node *func, mpfr_t x, mp_prec_t prec) { rangetype xrange, yrange; mpfr_t temp; xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a), prec); mpfr_init2(*(xrange.b), prec); mpfr_init2(*(yrange.a), prec); mpfr_init2(*(yrange.b), prec); mpfr_init2(temp,prec + 10); mpfr_set(*(xrange.a),x,GMP_RNDD); mpfr_set(*(xrange.b),x,GMP_RNDU); evaluateRangeFunction(yrange, func, xrange, prec); mpfr_add(temp,*(yrange.a),*(yrange.b),GMP_RNDN); mpfr_div_2ui(temp,temp,1,GMP_RNDN); mpfr_set(res,temp,GMP_RNDN); if (mpfr_zero_p(res)) { if (mpfr_zero_p(*(yrange.a)) && mpfr_zero_p(*(yrange.b))) { mpfr_set_d(err,0.0,GMP_RNDN); } else { mpfr_set_d(temp,1.0,GMP_RNDN); mpfr_div(temp,temp,res,GMP_RNDN); mpfr_set(err,temp,GMP_RNDU); } } else { mpfr_abs(*(yrange.a),*(yrange.a),GMP_RNDN); mpfr_abs(*(yrange.b),*(yrange.b),GMP_RNDN); if (mpfr_cmp(*(yrange.b),*(yrange.a)) > 0) { mpfr_set(*(yrange.a),*(yrange.b),GMP_RNDN); } mpfr_abs(temp,temp,GMP_RNDN); mpfr_sub(*(yrange.a),*(yrange.a),temp,GMP_RNDU); mpfr_div(err,*(yrange.a),temp,GMP_RNDU); } mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); mpfr_init2(temp,prec); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); } chain* findZerosByNewton(node *func, mpfr_t a, mpfr_t b, mp_prec_t prec) { node *deriv; mpfr_t resNewtonStep, ap, bp, step, yAp, yBp; int newtonOkay; mpfr_t *newZero; chain *fpZeros; fpZeros = NULL; deriv = differentiate(func); mpfr_init2(resNewtonStep,prec); mpfr_init2(ap,prec); mpfr_init2(bp,prec); mpfr_init2(step,prec); mpfr_init2(yAp,prec); mpfr_init2(yBp,prec); mpfr_sub(step,b,a,GMP_RNDU); if (mpfr_zero_p(step)) { evaluate(resNewtonStep,func,a,prec); newZero = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*newZero,prec); mpfr_set(*newZero,resNewtonStep,GMP_RNDN); fpZeros = addElement(fpZeros,newZero); } else { mpfr_div_ui(step,step,defaultpoints,GMP_RNDU); mpfr_set(ap,a,GMP_RNDD); while (mpfr_cmp(ap,b) < 0) { mpfr_add(bp,ap,step,GMP_RNDN); sollya_mpfr_min(bp,bp,b,GMP_RNDU); newtonOkay = newtonMPFR(resNewtonStep, func, deriv, ap, bp, prec); if (newtonOkay) { newZero = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*newZero,prec); mpfr_set(*newZero,resNewtonStep,GMP_RNDN); fpZeros = addElement(fpZeros,newZero); } else { evaluateFaithful(yAp, func, ap, prec); evaluateFaithful(yBp, func, bp, prec); if (mpfr_number_p(yAp) && mpfr_number_p(yBp) && (mpfr_sgn(yAp) != mpfr_sgn(yBp))) { newZero = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*newZero,prec); mpfr_set(*newZero,ap,GMP_RNDN); mpfr_add(*newZero,*newZero,bp,GMP_RNDN); mpfr_div_2ui(*newZero,*newZero,1,GMP_RNDN); fpZeros = addElement(fpZeros,newZero); } } mpfr_set(ap,bp,GMP_RNDN); } } mpfr_clear(step); mpfr_clear(bp); mpfr_clear(ap); mpfr_clear(yAp); mpfr_clear(yBp); mpfr_clear(resNewtonStep); free_memory(deriv); return fpZeros; } chain* fpFindZerosFunction(node *func, rangetype range, mp_prec_t prec) { mpfr_t diam; chain *intervalZeros, *fpZeros, *temp, *fpZerosOnInterval, *fpZeros2, *curr; mpfr_t *newZero; mpfr_t before, after, yBefore, yAfter, y, compare; int addToList, removedFromList; unsigned int oldDefaultPoints; oldDefaultPoints = defaultpoints; defaultpoints = defaultpoints >> 4; mpfr_init2(diam,prec+50); mpfr_set_d(diam,DEFAULTDIAM2,GMP_RNDN); intervalZeros = findZerosFunction(func, range, prec, diam); mpfr_clear(diam); fpZeros = NULL; while (intervalZeros != NULL) { fpZerosOnInterval = findZerosByNewton(func, *(((rangetype *) (intervalZeros->value))->a), *(((rangetype *) (intervalZeros->value))->b), 4*prec); fpZeros = concatChains(fpZeros, fpZerosOnInterval); mpfr_clear(*(((rangetype *) (intervalZeros->value))->a)); mpfr_clear(*(((rangetype *) (intervalZeros->value))->b)); safeFree(((rangetype *) (intervalZeros->value))->a); safeFree(((rangetype *) (intervalZeros->value))->b); safeFree(intervalZeros->value); temp = intervalZeros->next; safeFree(intervalZeros); intervalZeros = temp; } mpfr_init2(compare,prec); mpfr_set_d(compare,1.0,GMP_RNDN); mpfr_div_ui(compare,compare,prec,GMP_RNDN); fpZeros2 = NULL; curr = fpZeros; while (curr != NULL) { while ((curr->next != NULL) && (mpfr_cmp(*((mpfr_t *) (curr->value)),*((mpfr_t *) (curr->next->value))) == 0)) curr = curr->next; newZero = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*newZero,prec); mpfr_set(*newZero,*((mpfr_t *) (curr->value)),GMP_RNDN); fpZeros2 = addElement(fpZeros2,newZero); if ((!mpfr_zero_p(*newZero)) && (mpfr_cmpabs(*newZero,compare) <= 0)) { newZero = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*newZero,prec); mpfr_set_d(*newZero,0.0,GMP_RNDN); fpZeros2 = addElement(fpZeros2,newZero); } curr = curr->next; } mpfr_clear(compare); while (fpZeros != NULL) { mpfr_clear(*((mpfr_t*) (fpZeros->value))); safeFree((fpZeros->value)); temp = fpZeros->next; safeFree(fpZeros); fpZeros = temp; } mpfr_init2(before,prec); mpfr_init2(after,prec); mpfr_init2(yAfter,prec); mpfr_init2(yBefore,prec); mpfr_init2(y,prec); removedFromList = 0; fpZeros = NULL; while (fpZeros2 != NULL) { addToList = 0; evaluateFaithful(y, func, *((mpfr_t *) (fpZeros2->value)), prec); if (mpfr_zero_p(y) || (!mpfr_number_p(y)) || mpfr_zero_p(*((mpfr_t *) (fpZeros2->value)))) { addToList = 1; } else { mpfr_set(before,*((mpfr_t *) (fpZeros2->value)),GMP_RNDN); mpfr_set(after,*((mpfr_t *) (fpZeros2->value)),GMP_RNDN); mpfr_nextabove(after); mpfr_nextbelow(before); evaluateFaithful(yAfter, func, after, prec); evaluateFaithful(yBefore, func, before, prec); if ((!mpfr_number_p(yAfter)) || (!mpfr_number_p(yBefore))) { addToList = 1; } else { if (mpfr_sgn(yAfter) != mpfr_sgn(yBefore)) { addToList = 1; } else { if (mpfr_number_p(y)) { if (mpfr_sgn(y) != mpfr_sgn(yAfter)) { addToList = 1; } else { removedFromList = 1; printMessage(2,SOLLYA_MSG_REMOVING_A_POSSIBLE_ZERO_AT_SOME_POINT,"Information: removing possible zero in %v.\nInformation: removing because all signs are equal.\n",*((mpfr_t *) (fpZeros2->value))); } } else { removedFromList = 1; printMessage(2,SOLLYA_MSG_REMOVING_A_POSSIBLE_ZERO_AT_SOME_POINT,"Information: removing possible zero in %v.\nInformation: removing because predecessor and successor signs are equal.\n",*((mpfr_t *) (fpZeros2->value))); } } } } if (addToList) { fpZeros = addElement(fpZeros,fpZeros2->value); } temp = fpZeros2->next; safeFree(fpZeros2); fpZeros2 = temp; } if (removedFromList) { printMessage(1,SOLLYA_MSG_ZERO_FILTER_HAS_REMOVED_AT_LEAST_ONE_ZERO,"Warning: actual zero filter has removed at least one possible zero of higher order.\n"); } mpfr_clear(before); mpfr_clear(after); mpfr_clear(yBefore); mpfr_clear(yAfter); mpfr_clear(y); sortChain(fpZeros, cmpMpfrPtr); fpZeros2 = NULL; curr = fpZeros; while (curr != NULL) { while ((curr->next != NULL) && (mpfr_cmp(*((mpfr_t *) (curr->value)),*((mpfr_t *) (curr->next->value))) == 0)) curr = curr->next; newZero = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*newZero,mpfr_get_prec(*((mpfr_t *) (curr->value)))); mpfr_set(*newZero,*((mpfr_t *) (curr->value)),GMP_RNDN); fpZeros2 = addElement(fpZeros2,newZero); curr = curr->next; } while (fpZeros != NULL) { mpfr_clear(*((mpfr_t*) (fpZeros->value))); safeFree((fpZeros->value)); temp = fpZeros->next; safeFree(fpZeros); fpZeros = temp; } defaultpoints = oldDefaultPoints; return fpZeros2; } chain *uncertifiedZeroDenominators(node *tree, mpfr_t a, mpfr_t b, mp_prec_t prec) { chain *leftPoles, *rightPoles, *newZeros; rangetype range; if (tree == NULL) return NULL; if (tree->nodeType == MEMREF) return uncertifiedZeroDenominators(getMemRefChild(tree), a, b, prec); switch (tree->nodeType) { case VARIABLE: return NULL; break; case CONSTANT: case PI_CONST: case LIBRARYCONSTANT: return NULL; break; case ADD: leftPoles = uncertifiedZeroDenominators(tree->child1,a,b,prec); rightPoles = uncertifiedZeroDenominators(tree->child2,a,b,prec); return concatChains(leftPoles,rightPoles); break; case SUB: leftPoles = uncertifiedZeroDenominators(tree->child1,a,b,prec); rightPoles = uncertifiedZeroDenominators(tree->child2,a,b,prec); return concatChains(leftPoles,rightPoles); break; case MUL: leftPoles = uncertifiedZeroDenominators(tree->child1,a,b,prec); rightPoles = uncertifiedZeroDenominators(tree->child2,a,b,prec); return concatChains(leftPoles,rightPoles); break; case DIV: leftPoles = uncertifiedZeroDenominators(tree->child1,a,b,prec); rightPoles = uncertifiedZeroDenominators(tree->child2,a,b,prec); range.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); range.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(range.a),prec); mpfr_init2(*(range.b),prec); mpfr_set(*(range.a),a,GMP_RNDD); mpfr_set(*(range.b),b,GMP_RNDU); newZeros = fpFindZerosFunction(tree->child2, range, prec); mpfr_clear(*(range.a)); mpfr_clear(*(range.b)); safeFree(range.a); safeFree(range.b); leftPoles = concatChains(leftPoles,rightPoles); return concatChains(leftPoles,newZeros); break; case SQRT: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case EXP: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case LOG: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case LOG_2: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case LOG_10: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case SIN: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case COS: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case TAN: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case ASIN: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case ACOS: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case ATAN: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case SINH: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case COSH: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case TANH: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case ASINH: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case ACOSH: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case ATANH: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case POW: leftPoles = uncertifiedZeroDenominators(tree->child1,a,b,prec); rightPoles = uncertifiedZeroDenominators(tree->child2,a,b,prec); return concatChains(leftPoles,rightPoles); break; case NEG: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case ABS: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case DOUBLE: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case SINGLE: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case QUAD: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case HALFPRECISION: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case DOUBLEDOUBLE: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case TRIPLEDOUBLE: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case ERF: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case ERFC: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case LOG_1P: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case EXP_M1: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case DOUBLEEXTENDED: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case LIBRARYFUNCTION: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case PROCEDUREFUNCTION: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case CEIL: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case FLOOR: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; case NEARESTINT: return uncertifiedZeroDenominators(tree->child1,a,b,prec); break; default: sollyaFprintf(stderr,"Error: uncertifiedZeroDenominators: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return NULL; } int isEvaluable(node *func, mpfr_t x, mpfr_t *y, mp_prec_t prec) { mpfr_t val; rangetype xrange, yrange; mpfr_init2(val,prec); evaluate(val,func,x,prec); if (mpfr_number_p(val)) { if (y != NULL) { mpfr_set(*y,val,GMP_RNDN); } mpfr_clear(val); return ISFLOATINGPOINTEVALUABLE; } xrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); xrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.a = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); yrange.b = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(xrange.a),prec); mpfr_init2(*(xrange.b),prec); mpfr_init2(*(yrange.a),prec); mpfr_init2(*(yrange.b),prec); mpfr_set(*(xrange.a),x,GMP_RNDD); mpfr_set(*(xrange.b),x,GMP_RNDU); evaluateRangeFunction(yrange, func, xrange, prec); if (mpfr_number_p(*(yrange.a)) && mpfr_number_p(*(yrange.b))) { mpfr_add(val,*(yrange.a),*(yrange.b),GMP_RNDN); mpfr_div_2ui(val,val,1,GMP_RNDN); if (!mpfr_number_p(val)) { mpfr_clear(val); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); return ISNOTEVALUABLE; } if (y != NULL) { mpfr_set(*y,val,GMP_RNDN); } mpfr_clear(val); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); return ISHOPITALEVALUABLE; } mpfr_clear(val); mpfr_clear(*(xrange.a)); mpfr_clear(*(xrange.b)); mpfr_clear(*(yrange.a)); mpfr_clear(*(yrange.b)); safeFree(xrange.a); safeFree(xrange.b); safeFree(yrange.a); safeFree(yrange.b); return ISNOTEVALUABLE; } int evaluateFaithful(mpfr_t result, node *tree, mpfr_t x, mp_prec_t prec) { mp_prec_t startPrec, p; mpfr_t cutoff; int res; p = mpfr_get_prec(result); startPrec = p + 10; if (prec > startPrec) startPrec = prec; mpfr_init2(cutoff,startPrec); mpfr_set_si(cutoff,0,GMP_RNDN); res = evaluateFaithfulWithCutOffFast(result, tree, NULL, x, cutoff, startPrec); if (res==3) res=0; mpfr_clear(cutoff); if (!res) { printMessage(4,SOLLYA_MSG_FAITHFUL_EVALUATION_RETURNS_NAN,"Warning: evaluateFaithful returned NaN.\n"); mpfr_set_nan(result); } return res; } int determineHeuristicTaylorRecursions(node *func) { int highestDegree, sizeOfFunc, sizeOfCurrDeriv, i; node *temp, *temp2; highestDegree = highestDegreeOfPolynomialSubexpression(func); sizeOfFunc = treeSize(func); temp = differentiate(func); sizeOfCurrDeriv = treeSize(temp); i = -1; while ((highestDegree >= 0) && (((double) sizeOfCurrDeriv) <= ((double) 4) * ((double) sizeOfFunc))) { temp2 = differentiate(temp); free_memory(temp); temp = temp2; sizeOfCurrDeriv = treeSize(temp); i++; highestDegree--; } free_memory(temp); return i < 0 ? 0 : i; } int accurateInfnorm(mpfr_t result, node *func, rangetype range, chain *excludes, mp_prec_t startPrec) { rangetype res; sollya_mpfi_t rangeI, resI; sollya_mpfi_t *excludeI; node *deriv, *numeratorDeriv, *derivNumeratorDeriv, *denominatorDeriv, *derivDenominatorDeriv; mpfr_t rangeDiameter, z, ya,yb; chain *curr, *initialExcludes; int newtonWorked; mp_prec_t p, p2, prec; mpfr_t startDiam, currDiameter, resultUp, resultDown, stopDiameter; int okay, oldtaylorrecursions, t; prec = startPrec; p = mpfr_get_prec(result); mpfr_init2(resultUp,p); mpfr_init2(resultDown,p); if (p > prec) { prec = p; printMessage(1,SOLLYA_MSG_INTERMEDIATE_PRECISION_HAS_BEEN_INCREASED,"Warning: starting intermediate precision increased to %d bits.\n",prec); } res.a = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); res.b = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(res.a),prec); mpfr_init2(*(res.b),prec); if (isTrivialInfnormCase(res, func)) { printMessage(2,SOLLYA_MSG_INFNORM_RESULT_IS_TRIVIAL,"Information: the infnorm on the given function is trivially calculable.\n"); mpfr_set(result,*(res.a),GMP_RNDU); mpfr_clear(*(res.a)); mpfr_clear(*(res.b)); safeFree(res.a); safeFree(res.b); return 1; } oldtaylorrecursions = taylorrecursions; t = determineHeuristicTaylorRecursions(func); if ((t > oldtaylorrecursions) && (t < ((oldtaylorrecursions + 1) * 2))) { taylorrecursions = t; printMessage(3,SOLLYA_MSG_TAYLOR_RECURSION_TEMPORARILY_SET_TO_A_VALUE,"Information: the number of Taylor recursions has temporarily been set to %d.\n",taylorrecursions); } curr = excludes; initialExcludes = NULL; while (curr != NULL) { excludeI = (sollya_mpfi_t *) safeMalloc(sizeof(sollya_mpfi_t)); p = mpfr_get_prec(*(((rangetype *) curr->value)->a)); p2 = mpfr_get_prec(*(((rangetype *) curr->value)->b)); if (p2 > p) p = p2; if (prec > p) p = prec; sollya_mpfi_init2(*excludeI,p); sollya_mpfi_interv_fr(*excludeI,*(((rangetype *) curr->value)->a),*(((rangetype *) curr->value)->b)); initialExcludes = addElement(initialExcludes,(void *) excludeI); curr = curr->next; } sollya_mpfi_init2(rangeI,prec); sollya_mpfi_init2(resI,prec); mpfr_init2(rangeDiameter,prec); mpfr_sub(rangeDiameter,*(range.b),*(range.a),GMP_RNDD); mpfr_init2(startDiam,prec); mpfr_set_d(startDiam,DEFAULTDIAM,GMP_RNDD); mpfr_mul(rangeDiameter,rangeDiameter,startDiam,GMP_RNDD); mpfr_clear(startDiam); sollya_mpfi_interv_fr(rangeI,*(range.a),*(range.b)); deriv = differentiate(func); if (getNumeratorDenominator(&numeratorDeriv,&denominatorDeriv,deriv)) { printMessage(1,SOLLYA_MSG_DERIVATIVE_IS_QUOTIENT,"Warning: the derivative of the function is a quotient, thus possibly not continuous in the interval.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Only the zeros of the numerator will be searched and pole detection may fail.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Be sure that the function is twice continuously differentiable if trusting the infnorm result.\n"); mpfr_init2(z,prec); mpfr_init2(ya,prec); mpfr_init2(yb,prec); derivDenominatorDeriv = differentiate(denominatorDeriv); newtonWorked = newtonMPFR(z, denominatorDeriv, derivDenominatorDeriv, *(range.a), *(range.b), prec); if (newtonWorked && mpfr_number_p(z)) { evaluate(ya,numeratorDeriv,z,prec); evaluate(yb,denominatorDeriv,z,prec); mpfr_abs(ya,ya,GMP_RNDN); mpfr_abs(yb,yb,GMP_RNDN); mpfr_mul_ui(yb,yb,2,GMP_RNDN); if (mpfr_cmp(ya,yb) <= 0) { printMessage(1,SOLLYA_MSG_DERIVATIVE_SEEMS_TO_HAVE_EXTENSIBLE_SINGULARITY,"Warning: the derivative of the function seems to have a extensible singularity in %v.\nThe infnorm result might not be trustful if the derivative cannot actually\nbe extended in this point.\n",z); } else { printMessage(1,SOLLYA_MSG_DERIVATIVE_SEEMS_TO_HAVE_SINGULARITY,"Warning: the derivative of the function seems to have a singularity in %v.\nThe infnorm result is likely to be wrong.\n",z); } } else { evaluate(ya,denominatorDeriv,*(range.a),prec); evaluate(yb,denominatorDeriv,*(range.b),prec); if (mpfr_sgn(ya) != mpfr_sgn(yb)) { printMessage(1,SOLLYA_MSG_DERIVATIVE_SEEMS_TO_HAVE_EXTENSIBLE_SINGULARITY,"Warning: the derivative of the function seems to have a (extensible) singularity in the considered interval.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"The infnorm result might be not trustful if the function is not continuously differentiable.\n"); } else { printMessage(2,SOLLYA_MSG_DERIVATIVE_SEEMS_NOT_TO_HAVE_ANY_POLE,"Information: the derivative seems to have no (false) pole in the considered interval.\n"); } } mpfr_clear(z); mpfr_clear(ya); mpfr_clear(yb); free_memory(derivDenominatorDeriv); free_memory(denominatorDeriv); } derivNumeratorDeriv = differentiate(numeratorDeriv); mpfr_init2(currDiameter, prec); mpfr_init2(stopDiameter, prec); mpfr_div_2ui(stopDiameter,rangeDiameter,20,GMP_RNDD); okay = 0; while (prec <= 512 * startPrec) { mpfr_set(currDiameter,rangeDiameter,GMP_RNDD); while (mpfr_cmp(currDiameter,stopDiameter) >= 0) { infnormI(resI,func,deriv,numeratorDeriv,derivNumeratorDeriv,rangeI, prec,currDiameter,initialExcludes,NULL,NULL); sollya_mpfi_get_left(resultDown,resI); sollya_mpfi_get_right(resultUp,resI); if (mpfr_cmp(resultDown,resultUp) == 0) { okay = 1; break; } mpfr_nextabove(resultDown); if (mpfr_cmp(resultDown,resultUp) == 0) { okay = 1; break; } mpfr_div_2ui(currDiameter,currDiameter,2,GMP_RNDD); printMessage(4,SOLLYA_MSG_ABS_DIAM_AND_PREC_SET_TO_CERTAIN_VALUES,"Information: the absolute diameter is now %v.\nThe current intermediate precision is %d bits.\n",currDiameter,(int) prec); } if (okay) break; prec *= 2; printMessage(4,SOLLYA_MSG_INTERMEDIATE_PRECISION_HAS_BEEN_INCREASED,"Information: the intermediate precision is now %d bits.\n",(int) prec); } if (okay) mpfr_set(result,resultUp,GMP_RNDU); mpfr_clear(*(res.a)); mpfr_clear(*(res.b)); safeFree(res.a); safeFree(res.b); mpfr_clear(stopDiameter); mpfr_clear(currDiameter); free_memory(deriv); free_memory(numeratorDeriv); free_memory(derivNumeratorDeriv); sollya_mpfi_clear(rangeI); sollya_mpfi_clear(resI); mpfr_clear(rangeDiameter); mpfr_clear(resultUp); mpfr_clear(resultDown); taylorrecursions = oldtaylorrecursions; return okay; } int sollya_mpfi_have_common_real_point(sollya_mpfi_t a, sollya_mpfi_t b) { mp_prec_t ap, bp; mpfr_t al, ar, bl, br; int res; ap = sollya_mpfi_get_prec(a); bp = sollya_mpfi_get_prec(b); mpfr_init2(al, ap); mpfr_init2(ar, ap); mpfr_init2(bl, bp); mpfr_init2(br, bp); sollya_mpfi_get_left(al, a); sollya_mpfi_get_right(ar, a); sollya_mpfi_get_left(bl, b); sollya_mpfi_get_right(br, b); if (mpfr_number_p(al) && mpfr_number_p(al) && mpfr_number_p(al) && mpfr_number_p(al)) { res = (mpfr_cmp(al, br) <= 0) && (mpfr_cmp(bl, ar) <= 0); } else { res = 0; } mpfr_clear(al); mpfr_clear(ar); mpfr_clear(bl); mpfr_clear(br); return res; } static inline mpfr_t *chooseAndInitMpfrPtr(mpfr_t *localPtr, mp_prec_t prec) { mpfr_t *ptr; ptr = getReusedGlobalMPFRVars(1, prec); if (ptr == NULL) { mpfr_init2(*localPtr, prec); ptr = localPtr; } return ptr; } static inline void clearChosenMpfrPtr(mpfr_t *ptr, mpfr_t *localPtr) { if (ptr == localPtr) { mpfr_clear(*localPtr); return; } returnReusedGlobalMPFRVars(1); } static inline point_eval_t __tryFaithEvaluationOptimizedDoIt(mpfr_t, node *, mpfr_t, mp_exp_t, mp_prec_t, mp_prec_t *, node *); static inline void __tryFaithEvaluationOptimizedUpdateMaxPrec(mp_prec_t *maxPrec, mp_prec_t prec) { if (maxPrec == NULL) return; if (prec > *maxPrec) *maxPrec = prec; } static inline point_eval_t __tryFaithEvaluationOptimizedAddSubInner(int *retry, int *newPrecSet, mp_prec_t *newPrec, mpfr_t y, int subtract, node *g, node *h, mpfr_t x, mp_exp_t cutoff, mp_prec_t prec, mp_prec_t minPrec, mp_prec_t *maxPrecUsed) { mpfr_t v_gy, v_hy, v_t; mpfr_t *gy, *hy, *t; point_eval_t resG, resH, res; int ternary, tern1, tern2; mp_exp_t recCutoff, recCutoffG, recCutoffH, recCutoffGP, recCutoffHP; mp_prec_t recMaxPrecUsedG, recMaxPrecUsedH; sollya_mpfi_t v_X, v_Y, v_Z; sollya_mpfi_t *X, *Y, *Z; int zeroG, zeroH; mp_exp_t expBeforeCancel, expAfterCancel; mp_prec_t lostPrec, newPrecCutoff, precG, precH; /* Make compiler happy */ X = NULL; Y = NULL; Z = NULL; /* End of compiler happiness */ *retry = 0; *newPrecSet = 0; if (cutoff <= mpfr_get_emin_min()) { recCutoff = mpfr_get_emin_min(); } else { recCutoff = cutoff - 3; if ((recCutoff >= 0) || (recCutoff < mpfr_get_emin_min())) { recCutoff = mpfr_get_emin_min(); } } recCutoffG = recCutoff; recCutoffH = recCutoff; precG = prec; precH = prec; gy = chooseAndInitMpfrPtr(&v_gy, precG); recMaxPrecUsedG = 0; resG = __tryFaithEvaluationOptimizedDoIt(*gy, g, x, recCutoffG, minPrec, &recMaxPrecUsedG, g); switch (resG) { case POINT_EVAL_EXACT: case POINT_EVAL_CORRECTLY_ROUNDED: case POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT: case POINT_EVAL_FAITHFULLY_ROUNDED: case POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT: if (mpfr_number_p(*gy) && (!mpfr_zero_p(*gy))) { recCutoffHP = mpfr_get_exp(*gy) - mpfr_get_prec(y) - 5; if (recCutoffHP >= 0) recCutoffHP = -1; if (recCutoffHP > recCutoffH) recCutoffH = recCutoffHP; } break; default: break; } hy = chooseAndInitMpfrPtr(&v_hy, precH); recMaxPrecUsedH = 0; resH = __tryFaithEvaluationOptimizedDoIt(*hy, h, x, recCutoffH, minPrec, &recMaxPrecUsedH, h); if (resG == POINT_EVAL_FAILURE) { switch (resH) { case POINT_EVAL_EXACT: case POINT_EVAL_CORRECTLY_ROUNDED: case POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT: case POINT_EVAL_FAITHFULLY_ROUNDED: case POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT: if (mpfr_number_p(*hy) && (!mpfr_zero_p(*hy))) { recCutoffGP = mpfr_get_exp(*hy) - mpfr_get_prec(y) - 5; if (recCutoffGP >= 0) recCutoffGP = -1; if (recCutoffGP > recCutoffG) { recCutoffG = recCutoffGP; recMaxPrecUsedH = 0; resG = __tryFaithEvaluationOptimizedDoIt(*gy, g, x, recCutoffG, minPrec, &recMaxPrecUsedG, g); } } break; default: break; } } __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsedG); __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsedH); if ((resG == POINT_EVAL_FAILURE) || (resH == POINT_EVAL_FAILURE)) { clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); *retry = 0; return POINT_EVAL_FAILURE; } if ((resG == POINT_EVAL_EXACT) && (resH == POINT_EVAL_EXACT)) { if (subtract) { ternary = mpfr_sub(y, *gy, *hy, GMP_RNDN); } else { ternary = mpfr_add(y, *gy, *hy, GMP_RNDN); } clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } if ((!mpfr_number_p(*gy)) || (!mpfr_number_p(*hy))) { clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); *retry = 0; return POINT_EVAL_FAILURE; } switch (resG) { case POINT_EVAL_FAILURE: clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); return POINT_EVAL_FAILURE; break; case POINT_EVAL_EXACT: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(*gy)); sollya_mpfi_set_fr(*X, *gy); break; case POINT_EVAL_CORRECTLY_ROUNDED: case POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(*gy) + 1); sollya_mpfi_set_fr(*X, *gy); sollya_mpfi_blow_1ulp(*X); break; case POINT_EVAL_FAITHFULLY_ROUNDED: case POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT: X = chooseAndInitMpfiPtr(&v_Y, mpfr_get_prec(*gy)); sollya_mpfi_set_fr(*X, *gy); sollya_mpfi_blow_1ulp(*X); break; case POINT_EVAL_BELOW_CUTOFF: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(*gy)); sollya_mpfi_interv_si_2exp(*X, -1, recCutoffG, 1, recCutoffG); break; } switch (resH) { case POINT_EVAL_FAILURE: clearChosenMpfiPtr(X, &v_X); clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); return POINT_EVAL_FAILURE; break; case POINT_EVAL_EXACT: Y = chooseAndInitMpfiPtr(&v_Y, mpfr_get_prec(*hy)); sollya_mpfi_set_fr(*Y, *hy); break; case POINT_EVAL_CORRECTLY_ROUNDED: case POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT: Y = chooseAndInitMpfiPtr(&v_Y, mpfr_get_prec(*hy) + 1); sollya_mpfi_set_fr(*Y, *hy); sollya_mpfi_blow_1ulp(*Y); break; case POINT_EVAL_FAITHFULLY_ROUNDED: case POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT: Y = chooseAndInitMpfiPtr(&v_Y, mpfr_get_prec(*hy)); sollya_mpfi_set_fr(*Y, *hy); sollya_mpfi_blow_1ulp(*Y); break; case POINT_EVAL_BELOW_CUTOFF: Y = chooseAndInitMpfiPtr(&v_Y, mpfr_get_prec(*hy)); sollya_mpfi_interv_si_2exp(*Y, -1, recCutoffH, 1, recCutoffH); break; } Z = chooseAndInitMpfiPtr(&v_Z, (mpfr_get_prec(*gy) > mpfr_get_prec(*hy)? mpfr_get_prec(*gy) : mpfr_get_prec(*hy)) + 10); if (subtract) { sollya_mpfi_sub(*Z, *X, *Y); } else { sollya_mpfi_add(*Z, *X, *Y); } t = chooseAndInitMpfrPtr(&v_t, mpfr_get_prec(y)); /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ tern1 = mpfr_set(y, &((*Z)->left), GMP_RNDN); /* rounds to final precision */ tern2 = mpfr_set(*t, &((*Z)->right), GMP_RNDN); /* rounds to final precision */ if (mpfr_number_p(*t) && mpfr_number_p(y)) { if (mpfr_equal_p(*t, y)) { if ((tern1 == 0) && (tern2 == 0)) { res = POINT_EVAL_EXACT; } else { if ((tern1 != 0) && (tern1 == tern2)) { res = POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } else { res = POINT_EVAL_CORRECTLY_ROUNDED; } } } else { if (mpfr_cmp(y, *t) < 0) { mpfr_nextbelow(*t); if (mpfr_equal_p(*t, y)) { if (!sollya_mpfi_fr_in_interval(y, *Z)) { res = POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT; } else { res = POINT_EVAL_FAITHFULLY_ROUNDED; } } else { if ((!(sollya_mpfi_has_nan(*Z) || sollya_mpfi_has_infinity(*Z))) && (sollya_mpfi_max_exp(*Z) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } } else { if ((!(sollya_mpfi_has_nan(*Z) || sollya_mpfi_has_infinity(*Z))) && (sollya_mpfi_max_exp(*Z) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } } } else { if ((!(sollya_mpfi_has_nan(*Z) || sollya_mpfi_has_infinity(*Z))) && (sollya_mpfi_max_exp(*Z) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } /* If we couldn't compute an answer, try find a precision at which we might be able to compute an answer */ if ((res == POINT_EVAL_FAILURE) && (resG != POINT_EVAL_FAILURE) && (resH != POINT_EVAL_FAILURE) && mpfr_number_p(*gy) && mpfr_number_p(*hy) && (!(sollya_mpfi_has_nan(*Z) || sollya_mpfi_has_infinity(*Z)))) { zeroG = mpfr_zero_p(*gy); zeroH = mpfr_zero_p(*hy); if (zeroG && zeroH) { /* f(x) = g(x) + h(x), g(x) and h(x) both cancel, cutoff not yet met. */ *retry = 1; *newPrecSet = 0; } else { if (!(zeroG || zeroH)) { /* Got exponent of both terms g(x) and h(x) */ if (sollya_mpfi_is_zero(*Z)) { /* Cancels out completely, need at least all cancelled bits plus the bits of y to get the bits of y */ *newPrec = mpfr_get_prec(y) + sollya_mpfi_get_prec(*Z) + 5; *newPrecSet = 1; *retry = 1; } else { /* Does not cancel out completely; estimate the number of bits that cancelled. */ if (zeroG) { expBeforeCancel = mpfr_get_exp(*hy); } else { if (zeroH) { expBeforeCancel = mpfr_get_exp(*gy); } else { expBeforeCancel = mpfr_get_exp(*gy); if (mpfr_get_exp(*hy) > expBeforeCancel) expBeforeCancel = mpfr_get_exp(*hy); } } expAfterCancel = sollya_mpfi_max_exp(*Z); lostPrec = expBeforeCancel - expAfterCancel + 4; *newPrec = prec + lostPrec + 10; if (*newPrec < 12) *newPrec = 12; if (*newPrec < minPrec) *newPrec = minPrec; if (*newPrec < (prec + 10)) *newPrec = prec + 10; if ((lostPrec < 1) || (*newPrec > 2 * prec + 10)) *newPrec = 2 * prec + 10; if ((expBeforeCancel > mpfr_get_emin_min() + 10 + 2 * prec) && (expBeforeCancel - (2 * prec + 10) <= cutoff) && (expBeforeCancel > cutoff)) { newPrecCutoff = expBeforeCancel - cutoff; if (newPrecCutoff > *newPrec) { *newPrec = newPrecCutoff; } } *newPrecSet = 1; *retry = 1; } } } } clearChosenMpfrPtr(t, &v_t); clearChosenMpfiPtr(Z, &v_Z); clearChosenMpfiPtr(Y, &v_Y); clearChosenMpfiPtr(X, &v_X); clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); return res; } static inline point_eval_t __tryFaithEvaluationOptimizedAddSubMain(mpfr_t y, int subtract, node *g, node *h, mpfr_t x, mp_exp_t cutoff, mp_prec_t minPrec, mp_prec_t *maxPrecUsed) { mp_prec_t prec, newPrec; point_eval_t res; int retry, newPrecSet; mp_prec_t recMaxPrecUsed; prec = mpfr_get_prec(y) + 20; if (prec < minPrec) prec = minPrec; /* 1st try */ retry = 0; newPrecSet = 0; newPrec = prec; recMaxPrecUsed = 0; res = __tryFaithEvaluationOptimizedAddSubInner(&retry, &newPrecSet, &newPrec, y, subtract, g, h, x, cutoff, prec, minPrec, &recMaxPrecUsed); if (res != POINT_EVAL_FAILURE) { __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); return res; } if (!retry) { __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); return POINT_EVAL_FAILURE; } if (!newPrecSet) { newPrec = prec * 2; } prec = newPrec; if (prec < minPrec) prec = minPrec; /* 2nd try */ retry = 0; newPrecSet = 0; newPrec = prec; recMaxPrecUsed = 0; res = __tryFaithEvaluationOptimizedAddSubInner(&retry, &newPrecSet, &newPrec, y, subtract, g, h, x, cutoff, prec, minPrec, &recMaxPrecUsed); if (res != POINT_EVAL_FAILURE) { __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); return res; } if (!retry) { __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); return POINT_EVAL_FAILURE; } if (!newPrecSet) { newPrec = prec * 2; } prec = newPrec; if (prec < minPrec) prec = minPrec; /* 3rd and last try */ retry = 0; newPrecSet = 0; newPrec = prec; recMaxPrecUsed = 0; res = __tryFaithEvaluationOptimizedAddSubInner(&retry, &newPrecSet, &newPrec, y, subtract, g, h, x, cutoff, prec, minPrec, &recMaxPrecUsed); __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); return res; } static inline point_eval_t __tryFaithEvaluationOptimizedAddSub(mpfr_t y, int subtract, node *g, node *h, mpfr_t x, mp_exp_t cutoff, mp_prec_t minPrec, mp_prec_t *maxPrecUsed) { node *myG, *myH; int swapped; point_eval_t res; int ternary; if ((accessThruMemRef(g)->nodeType == CONSTANT) && (accessThruMemRef(h)->nodeType == CONSTANT)) { if (subtract) { ternary = mpfr_sub(y, *(accessThruMemRef(g)->value), *(accessThruMemRef(h)->value), GMP_RNDN); } else { ternary = mpfr_add(y, *(accessThruMemRef(g)->value), *(accessThruMemRef(h)->value), GMP_RNDN); } if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } if ((accessThruMemRef(g)->nodeType == CONSTANT) && (accessThruMemRef(h)->nodeType == VARIABLE)) { if (subtract) { ternary = mpfr_sub(y, *(accessThruMemRef(g)->value), x, GMP_RNDN); } else { ternary = mpfr_add(y, *(accessThruMemRef(g)->value), x, GMP_RNDN); } if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } if ((accessThruMemRef(g)->nodeType == VARIABLE) && (accessThruMemRef(h)->nodeType == CONSTANT)) { if (subtract) { ternary = mpfr_sub(y, x, *(accessThruMemRef(h)->value), GMP_RNDN); } else { ternary = mpfr_add(y, x, *(accessThruMemRef(h)->value), GMP_RNDN); } if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } if ((accessThruMemRef(g)->nodeType == VARIABLE) && (accessThruMemRef(h)->nodeType == VARIABLE)) { if (subtract) { ternary = mpfr_sub(y, x, x, GMP_RNDN); } else { ternary = mpfr_add(y, x, x, GMP_RNDN); } if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } myG = g; myH = h; swapped = 0; switch (accessThruMemRef(h)->nodeType) { case CONSTANT: case VARIABLE: myG = h; myH = g; swapped = 1; default: break; } res = __tryFaithEvaluationOptimizedAddSubMain(y, subtract, myG, myH, x, cutoff, minPrec, maxPrecUsed); if (swapped && subtract && (res != POINT_EVAL_FAILURE)) { mpfr_neg(y, y, GMP_RNDN); /* exact */ } return res; } static inline point_eval_t __tryFaithEvaluationOptimizedMulDivInner(int *retry, mpfr_t y, int divide, node *g, node *h, mpfr_t x, mp_exp_t cutoff, mp_prec_t minPrec, mp_prec_t *maxPrecUsed) { mp_prec_t precG, precH; mpfr_t v_gy, v_hy; mpfr_t *gy, *hy; point_eval_t resG, resH; int ternary; mp_exp_t recCutoff; mp_prec_t recMaxPrecUsed; if (cutoff >= mpfr_get_emin_min() + 64) { recCutoff = cutoff - 64; if ((recCutoff >= 0) || (recCutoff < mpfr_get_emin_min())) recCutoff = mpfr_get_emin_min(); } else { recCutoff = mpfr_get_emin_min(); } if (accessThruMemRef(g)->nodeType == CONSTANT) { precG = mpfr_get_prec(*(accessThruMemRef(g)->value)); } else { if (accessThruMemRef(g)->nodeType == VARIABLE) { precG = mpfr_get_prec(x); } else { precG = mpfr_get_prec(y) + 4; } } if (accessThruMemRef(h)->nodeType == CONSTANT) { precH = mpfr_get_prec(*(accessThruMemRef(h)->value)); } else { if (accessThruMemRef(h)->nodeType == VARIABLE) { precH = mpfr_get_prec(x); } else { precH = mpfr_get_prec(y) + 4; } } if (precG < minPrec) precG = minPrec; if (precH < minPrec) precH = minPrec; gy = chooseAndInitMpfrPtr(&v_gy, precG); hy = chooseAndInitMpfrPtr(&v_hy, precH); recMaxPrecUsed = 0; resG = __tryFaithEvaluationOptimizedDoIt(*gy, g, x, recCutoff, minPrec, &recMaxPrecUsed, g); __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); if (resG == POINT_EVAL_FAILURE) { clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); *retry = 0; __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); return POINT_EVAL_FAILURE; } recMaxPrecUsed = 0; resH = __tryFaithEvaluationOptimizedDoIt(*hy, h, x, (divide ? mpfr_get_emin_min() : recCutoff), minPrec, &recMaxPrecUsed, h); __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); if (resH == POINT_EVAL_FAILURE) { clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); *retry = 0; return POINT_EVAL_FAILURE; } if ((resG == POINT_EVAL_EXACT) && (resH == POINT_EVAL_EXACT)) { if (divide) { ternary = mpfr_div(y, *gy, *hy, GMP_RNDN); } else { ternary = mpfr_mul(y, *gy, *hy, GMP_RNDN); } clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } if ((resG == POINT_EVAL_EXACT) && mpfr_zero_p(*gy)) { mpfr_set_si(y, 0, GMP_RNDN); clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); return POINT_EVAL_EXACT; } if ((resH == POINT_EVAL_EXACT) && mpfr_zero_p(*hy) && (!divide)) { mpfr_set_si(y, 0, GMP_RNDN); clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); return POINT_EVAL_EXACT; } if ((resG == POINT_EVAL_BELOW_CUTOFF) || (resH == POINT_EVAL_BELOW_CUTOFF)) { if ((resH == POINT_EVAL_BELOW_CUTOFF) && divide) { /* This case should never happen */ clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); *retry = 0; return POINT_EVAL_FAILURE; } if ((resG == POINT_EVAL_BELOW_CUTOFF) && (resH == POINT_EVAL_BELOW_CUTOFF)) { clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); mpfr_set_si(y, 0, GMP_RNDN); /* exact */ return POINT_EVAL_BELOW_CUTOFF; } if (cutoff <= mpfr_get_emin_min() + 32) { clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); *retry = 1; return POINT_EVAL_FAILURE; } if (resG == POINT_EVAL_BELOW_CUTOFF) { if (divide) { if (mpfr_number_p(*hy) && (!mpfr_zero_p(*hy)) && (((mp_exp_t) 2) - mpfr_get_exp(*hy) < cutoff - recCutoff)) { clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); mpfr_set_si(y, 0, GMP_RNDN); /* exact */ return POINT_EVAL_BELOW_CUTOFF; } } else { if (mpfr_number_p(*hy) && (mpfr_zero_p(*hy) || (mpfr_get_exp(*hy) + ((mp_exp_t) 2) < cutoff - recCutoff))) { clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); mpfr_set_si(y, 0, GMP_RNDN); /* exact */ return POINT_EVAL_BELOW_CUTOFF; } } } if (resH == POINT_EVAL_BELOW_CUTOFF) { if (!divide) { if (mpfr_number_p(*gy) && (mpfr_zero_p(*gy) || (mpfr_get_exp(*gy) + ((mp_exp_t) 2) < cutoff - recCutoff))) { clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); mpfr_set_si(y, 0, GMP_RNDN); /* exact */ return POINT_EVAL_BELOW_CUTOFF; } } } clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); *retry = 1; return POINT_EVAL_FAILURE; } /* TODO: Proof required */ if (divide) { ternary = mpfr_div(y, *gy, *hy, GMP_RNDN); } else { ternary = mpfr_mul(y, *gy, *hy, GMP_RNDN); } clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); /* TODO: work for exactness predicates */ if (ternary == 0) return POINT_EVAL_CORRECTLY_ROUNDED; return POINT_EVAL_FAITHFULLY_ROUNDED; } static inline point_eval_t __tryFaithEvaluationOptimizedMulDiv(mpfr_t y, int divide, node *g, node *h, mpfr_t x, mp_exp_t cutoff, mp_prec_t minPrec, mp_prec_t *maxPrecUsed) { int retry; point_eval_t res; mp_prec_t recMaxPrecUsed; int ternary; if ((accessThruMemRef(g)->nodeType == CONSTANT) && (accessThruMemRef(h)->nodeType == CONSTANT)) { if (divide) { ternary = mpfr_div(y, *(accessThruMemRef(g)->value), *(accessThruMemRef(h)->value), GMP_RNDN); } else { ternary = mpfr_mul(y, *(accessThruMemRef(g)->value), *(accessThruMemRef(h)->value), GMP_RNDN); } if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } if ((accessThruMemRef(g)->nodeType == CONSTANT) && (accessThruMemRef(h)->nodeType == VARIABLE)) { if (divide) { ternary = mpfr_div(y, *(accessThruMemRef(g)->value), x, GMP_RNDN); } else { ternary = mpfr_mul(y, *(accessThruMemRef(g)->value), x, GMP_RNDN); } if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } if ((accessThruMemRef(g)->nodeType == VARIABLE) && (accessThruMemRef(h)->nodeType == CONSTANT)) { if (divide) { ternary = mpfr_div(y, x, *(accessThruMemRef(h)->value), GMP_RNDN); } else { ternary = mpfr_mul(y, x, *(accessThruMemRef(h)->value), GMP_RNDN); } if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } if ((accessThruMemRef(g)->nodeType == VARIABLE) && (accessThruMemRef(h)->nodeType == VARIABLE)) { if (divide) { ternary = mpfr_div(y, x, x, GMP_RNDN); } else { ternary = mpfr_mul(y, x, x, GMP_RNDN); } if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } retry = 0; recMaxPrecUsed = 0; res = __tryFaithEvaluationOptimizedMulDivInner(&retry, y, divide, g, h, x, cutoff, minPrec, &recMaxPrecUsed); if (res != POINT_EVAL_FAILURE) { __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); return res; } if (!retry) { __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); return POINT_EVAL_FAILURE; } retry = 0; recMaxPrecUsed = 0; res = __tryFaithEvaluationOptimizedMulDivInner(&retry, y, divide, g, h, x, mpfr_get_emin_min(), minPrec, &recMaxPrecUsed); __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); return res; } static inline point_eval_t __tryFaithEvaluationOptimizedPow(mpfr_t y, node *g, node *h, mpfr_t x, mp_exp_t cutoff, mp_prec_t minPrec, mp_prec_t *maxPrecUsed) { mp_prec_t precG, precH; mpfr_t v_gy, v_hy; mpfr_t *gy, *hy; point_eval_t resG, resH; int ternary, tern1, tern2; sollya_mpfi_t v_X, v_Y, v_Z; sollya_mpfi_t *X, *Y, *Z; point_eval_t res; mp_exp_t cutoffH; mp_prec_t recMaxPrecUsed; /* Make compiler happy */ X = NULL; Y = NULL; /* End of compiler happiness */ if ((accessThruMemRef(g)->nodeType == CONSTANT) && (accessThruMemRef(h)->nodeType == CONSTANT)) { ternary = mpfr_pow(y, *(accessThruMemRef(g)->value), *(accessThruMemRef(h)->value), GMP_RNDN); if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } if ((accessThruMemRef(g)->nodeType == CONSTANT) && (accessThruMemRef(h)->nodeType == VARIABLE)) { ternary = mpfr_pow(y, *(accessThruMemRef(g)->value), x, GMP_RNDN); if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } if ((accessThruMemRef(g)->nodeType == VARIABLE) && (accessThruMemRef(h)->nodeType == CONSTANT)) { ternary = mpfr_pow(y, x, *(accessThruMemRef(h)->value), GMP_RNDN); if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } if ((accessThruMemRef(g)->nodeType == VARIABLE) && (accessThruMemRef(h)->nodeType == VARIABLE)) { ternary = mpfr_pow(y, x, x, GMP_RNDN); if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } if (accessThruMemRef(g)->nodeType == CONSTANT) { precG = mpfr_get_prec(*(accessThruMemRef(g)->value)); } else { if (accessThruMemRef(g)->nodeType == VARIABLE) { precG = mpfr_get_prec(x); } else { precG = mpfr_get_prec(y) + 25; } } if (accessThruMemRef(h)->nodeType == CONSTANT) { precH = mpfr_get_prec(*(accessThruMemRef(h)->value)); } else { if (accessThruMemRef(h)->nodeType == VARIABLE) { precH = mpfr_get_prec(x); } else { precH = mpfr_get_prec(y) + 25; } } if (precG < minPrec) precG = minPrec; if (precH < minPrec) precH = minPrec; gy = chooseAndInitMpfrPtr(&v_gy, precG); hy = chooseAndInitMpfrPtr(&v_hy, precH); recMaxPrecUsed = 0; resG = __tryFaithEvaluationOptimizedDoIt(*gy, g, x, mpfr_get_emin_min(), minPrec, &recMaxPrecUsed, g); __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); if ((resG == POINT_EVAL_FAILURE) || (resG == POINT_EVAL_BELOW_CUTOFF)) { clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); return POINT_EVAL_FAILURE; } cutoffH = -(2 * mpfr_get_prec(y) + 25); if ((cutoffH >= 0) || (cutoffH < mpfr_get_emin_min())) cutoffH = mpfr_get_emin_min(); recMaxPrecUsed = 0; resH = __tryFaithEvaluationOptimizedDoIt(*hy, h, x, cutoffH, minPrec, &recMaxPrecUsed, h); __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); if (resH == POINT_EVAL_FAILURE) { clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); return POINT_EVAL_FAILURE; } if ((resG == POINT_EVAL_EXACT) && (resH == POINT_EVAL_EXACT)) { ternary = mpfr_pow(y, *gy, *hy, GMP_RNDN); clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } switch (resG) { case POINT_EVAL_FAILURE: case POINT_EVAL_BELOW_CUTOFF: clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); return POINT_EVAL_FAILURE; break; case POINT_EVAL_EXACT: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(*gy)); sollya_mpfi_set_fr(*X, *gy); break; case POINT_EVAL_CORRECTLY_ROUNDED: case POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(*gy) + 1); sollya_mpfi_set_fr(*X, *gy); sollya_mpfi_blow_1ulp(*X); break; case POINT_EVAL_FAITHFULLY_ROUNDED: case POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(*gy)); sollya_mpfi_set_fr(*X, *gy); sollya_mpfi_blow_1ulp(*X); break; } switch (resH) { case POINT_EVAL_FAILURE: clearChosenMpfiPtr(X, &v_X); clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); return POINT_EVAL_FAILURE; break; case POINT_EVAL_EXACT: Y = chooseAndInitMpfiPtr(&v_Y, mpfr_get_prec(*hy)); sollya_mpfi_set_fr(*Y, *hy); break; case POINT_EVAL_CORRECTLY_ROUNDED: case POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT: Y = chooseAndInitMpfiPtr(&v_Y, mpfr_get_prec(*hy) + 1); sollya_mpfi_set_fr(*Y, *hy); sollya_mpfi_blow_1ulp(*Y); break; case POINT_EVAL_FAITHFULLY_ROUNDED: case POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT: Y = chooseAndInitMpfiPtr(&v_Y, mpfr_get_prec(*hy)); sollya_mpfi_set_fr(*Y, *hy); sollya_mpfi_blow_1ulp(*Y); break; case POINT_EVAL_BELOW_CUTOFF: Y = chooseAndInitMpfiPtr(&v_Y, mpfr_get_prec(*hy)); sollya_mpfi_interv_si_2exp(*Y, -1, cutoffH, 1, cutoffH); break; } Z = chooseAndInitMpfiPtr(&v_Z, mpfr_get_prec(y) + 15); sollya_mpfi_pow(*Z, *X, *Y); /* Reuse hy */ mpfr_set_prec(*hy, mpfr_get_prec(y)); /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ tern1 = mpfr_set(y, &((*Z)->left), GMP_RNDN); /* rounds to final precision */ tern2 = mpfr_set(*hy, &((*Z)->right), GMP_RNDN); /* rounds to final precision */ if (mpfr_number_p(*hy) && mpfr_number_p(y)) { if (mpfr_equal_p(*hy, y)) { if ((tern1 == 0) && (tern2 == 0)) { res = POINT_EVAL_EXACT; } else { if ((tern1 != 0) && (tern1 == tern2)) { res = POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } else { res = POINT_EVAL_CORRECTLY_ROUNDED; } } } else { if (mpfr_cmp(y, *hy) < 0) { mpfr_nextbelow(*hy); if (mpfr_equal_p(*hy, y)) { if (!sollya_mpfi_fr_in_interval(y, *Z)) { res = POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT; } else { res = POINT_EVAL_FAITHFULLY_ROUNDED; } } else { if ((!(sollya_mpfi_has_nan(*Z) || sollya_mpfi_has_infinity(*Z))) && (sollya_mpfi_max_exp(*Z) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } } else { if ((!(sollya_mpfi_has_nan(*Z) || sollya_mpfi_has_infinity(*Z))) && (sollya_mpfi_max_exp(*Z) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } } } else { if ((!(sollya_mpfi_has_nan(*Z) || sollya_mpfi_has_infinity(*Z))) && (sollya_mpfi_max_exp(*Z) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } clearChosenMpfiPtr(Z, &v_Z); clearChosenMpfiPtr(Y, &v_Y); clearChosenMpfiPtr(X, &v_X); clearChosenMpfrPtr(hy, &v_hy); clearChosenMpfrPtr(gy, &v_gy); return res; } static inline mp_exp_t __tryFaithEvaluationOptimizedUnivariateGetRecurseCutoff(int nodeType, mp_exp_t cutoff, mp_prec_t prec) { mp_exp_t res, temp; /* Check that incoming cutoff and precision are within resonable range */ if ((cutoff > -1) || (prec < 1)) { return mpfr_get_emin_min(); } switch (nodeType) { case SQRT: /* Zero at zero, x < 2^(c * 2) implies sqrt(x) < 2^c */ temp = mpfr_get_emin_min(); temp >>= 1; temp++; if (cutoff <= temp) return mpfr_get_emin_min(); res = cutoff << 2; return res; break; case EXP: /* No zero at zero, take Taylor development around zero and precision */ return -(prec + 3); break; case LOG: case LOG_2: case LOG_10: /* Infinite slope at zero, reset cutoff to smallest possible value */ return mpfr_get_emin_min(); break; case SIN: /* Zero at zero, first Taylor coefficient 1, series has alternating sign */ return cutoff; break; case COS: /* No zero at zero, take Taylor development around zero and precision */ return -((prec >> 1) + 4); break; case TAN: /* Zero at zero, first Taylor coefficient 1, series does not have alternating sign */ res = cutoff - 1; if ((res >= 0) || (res < mpfr_get_emin_min())) res = mpfr_get_emin_min(); return res; break; case ASIN: /* Zero at zero, first Taylor coefficient 1, series does not have alternating sign */ res = cutoff - 1; if ((res >= 0) || (res < mpfr_get_emin_min())) res = mpfr_get_emin_min(); return res; break; case ACOS: /* No zero at zero, take Taylor development around zero and precision */ return -(prec + 3); break; case ATAN: /* Zero at zero, first Taylor coefficient 1, series has alternating sign */ return cutoff; break; case SINH: /* Zero at zero, first Taylor coefficient 1, series does not have alternating sign */ res = cutoff - 1; if ((res >= 0) || (res < mpfr_get_emin_min())) res = mpfr_get_emin_min(); return res; break; case COSH: /* No zero at zero, take Taylor development around zero and precision */ return -(prec + 3); break; case TANH: /* Zero at zero, first Taylor coefficient 1, series has alternating sign */ return cutoff; break; case ASINH: /* Zero at zero, first Taylor coefficient 1, series has alternating sign */ return cutoff; break; case ACOSH: /* Not defined around zero, cutoff = -1 suffices to sees that */ return -1; break; case ATANH: /* Zero at zero, first Taylor coefficient 1, series does not have alternating sign */ res = cutoff - 1; if ((res >= 0) || (res < mpfr_get_emin_min())) res = mpfr_get_emin_min(); return res; break; case ERF: /* Zero at zero, first Taylor coefficient less than 2, series has alternating sign */ res = cutoff - 1; if ((res >= 0) || (res < mpfr_get_emin_min())) res = mpfr_get_emin_min(); return res; break; case ERFC: /* No zero at zero, take Taylor development around zero and precision */ return -(prec + 3); break; case LOG_1P: /* Zero at zero, first Taylor coefficient 1, series has alternating sign */ return cutoff; break; case EXP_M1: /* Zero at zero, first Taylor coefficient 1, series does not have alternating sign */ res = cutoff - 1; if ((res >= 0) || (res < mpfr_get_emin_min())) res = mpfr_get_emin_min(); return res; break; case LIBRARYFUNCTION: case PROCEDUREFUNCTION: /* Actually, we have no idea how the function behaves */ res = cutoff - 1; if ((res >= 0) || (res < mpfr_get_emin_min())) res = mpfr_get_emin_min(); if (-(prec + 5) < res) res = -(prec + 5); if ((res >= 0) || (res < mpfr_get_emin_min())) res = mpfr_get_emin_min(); return res; break; default: return mpfr_get_emin_min(); break; } return mpfr_get_emin_min(); } static inline mp_prec_t __tryFaithEvaluationOptimizedUnivariateGetRecursePrec(int nodeType, mp_prec_t prec, mp_exp_t cutoff) { int considerCutoff; mp_prec_t cutoffPrec; /* Make compiler happy */ cutoffPrec = 12; /* End of compiler happiness */ /* Consider log2(abs(x * diff(f)/f)) over some reasonable range Consider cutoff if it implies precision in some reasonable range. */ considerCutoff = 0; if (cutoff >= -(2 * prec + 10)) { cutoffPrec = -cutoff + 10; if (cutoffPrec < 12) cutoffPrec = 12; if (cutoffPrec > 2 * prec + 10) cutoffPrec = 2 * prec + 10; considerCutoff = 1; } switch (nodeType) { case SQRT: /* Fine everywhere */ return prec; break; case EXP: /* Range: double precision range */ return prec + 12; break; case LOG: case LOG_2: case LOG_10: /* Fine everywhere but around 1 */ if (considerCutoff) return cutoffPrec; return prec + 10; break; case SIN: /* Fine everywhere but around zeros of sin */ if (considerCutoff) return cutoffPrec; return prec + 10; break; case COS: /* Fine everywhere but around zeros of cos */ if (considerCutoff) return cutoffPrec; return prec + 10; break; case TAN: /* Fine everywhere but around zeros and poles of tan */ if (considerCutoff) return cutoffPrec; return prec + 10; break; case ASIN: /* Fine everywhere but around +/- 1 */ return prec + 10; break; case ACOS: /* Fine everywhere but around + 1 */ if (considerCutoff) return cutoffPrec; return prec + 10; break; case ATAN: /* Fine everywhere */ return prec; break; case SINH: /* Range: double precision range */ return prec + 12; break; case COSH: /* Range: double precision range */ return prec + 12; break; case TANH: /* When x is large, very difficult function */ return prec + 50; break; case ASINH: /* Fine everywhere */ return prec; break; case ACOSH: /* Fine everywhere but around + 1 */ return prec + 10; break; case ATANH: /* Fine everywhere but around +/- 1 */ return prec + 10; break; case ERF: /* Fine everywhere */ return prec; break; case ERFC: /* Fine everywhere in negative range, okay up to x = 100 */ return prec + 15; break; case LOG_1P: /* Fine everywhere but around - 1 */ return prec + 10; break; case EXP_M1: /* Range: double precision range */ return prec + 12; break; case LIBRARYFUNCTION: case PROCEDUREFUNCTION: /* Actually, we have no idea how the function behaves */ return prec + 15; break; default: /* Some default answer */ return prec + 10; } /* Some default answer */ return prec + 10; } static inline point_eval_t __tryFaithEvaluationOptimizedUnivariateImpreciseArg(mpfr_t y, int nodeType, mpfr_t x, point_eval_t err, mp_exp_t cutoffY, mp_exp_t cutoffX, node *g, node *mr) { sollya_mpfi_t v_X, v_Y; sollya_mpfi_t *X, *Y; point_eval_t res; int tern1, tern2; mpfi_t temp; /* The type is not a mistake, we use a library function */ X = NULL; if (err == POINT_EVAL_FAILURE) return POINT_EVAL_FAILURE; if (!mpfr_number_p(x)) return POINT_EVAL_FAILURE; switch (err) { case POINT_EVAL_FAILURE: return POINT_EVAL_FAILURE; break; case POINT_EVAL_EXACT: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(x)); sollya_mpfi_set_fr(*X, x); break; case POINT_EVAL_CORRECTLY_ROUNDED: case POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(x) + 1); sollya_mpfi_set_fr(*X, x); sollya_mpfi_blow_1ulp(*X); break; case POINT_EVAL_FAITHFULLY_ROUNDED: case POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(x)); sollya_mpfi_set_fr(*X, x); sollya_mpfi_blow_1ulp(*X); break; case POINT_EVAL_BELOW_CUTOFF: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(x)); sollya_mpfi_interv_si_2exp(*X, -1, cutoffX, 1, cutoffX); break; } Y = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(y) + 8); switch (nodeType) { case SQRT: sollya_mpfi_sqrt(*Y, *X); break; case EXP: sollya_mpfi_exp(*Y, *X); break; case LOG: sollya_mpfi_log(*Y, *X); break; case LOG_2: sollya_mpfi_log2(*Y, *X); break; case LOG_10: sollya_mpfi_log10(*Y, *X); break; case SIN: sollya_mpfi_sin(*Y, *X); break; case COS: sollya_mpfi_cos(*Y, *X); break; case TAN: sollya_mpfi_tan(*Y, *X); break; case ASIN: sollya_mpfi_asin(*Y, *X); break; case ACOS: sollya_mpfi_acos(*Y, *X); break; case ATAN: sollya_mpfi_atan(*Y, *X); break; case SINH: sollya_mpfi_sinh(*Y, *X); break; case COSH: sollya_mpfi_cosh(*Y, *X); break; case TANH: sollya_mpfi_tanh(*Y, *X); break; case ASINH: sollya_mpfi_asinh(*Y, *X); break; case ACOSH: sollya_mpfi_acosh(*Y, *X); break; case ATANH: sollya_mpfi_atanh(*Y, *X); break; case ERF: sollya_mpfi_erf(*Y, *X); break; case ERFC: sollya_mpfi_erfc(*Y, *X); break; case LOG_1P: sollya_mpfi_log1p(*Y, *X); break; case EXP_M1: sollya_mpfi_expm1(*Y, *X); break; case LIBRARYFUNCTION: mpfi_init2(temp, sollya_mpfi_get_prec(*Y)); if (g->libFun->hasData) { ((int (*)(mpfi_t, mpfi_t, int, void *)) (g->libFun->code))(temp, *X, g->libFunDeriv, g->libFun->data); } else { ((int (*)(mpfi_t, mpfi_t, int)) (g->libFun->code))(temp, *X, g->libFunDeriv); } mpfi_to_sollya_mpfi(*Y, temp); mpfi_clear(temp); break; case PROCEDUREFUNCTION: computeFunctionWithProcedure(*Y, g->child2, *X, (unsigned int) g->libFunDeriv, mr); break; default: clearChosenMpfiPtr(Y, &v_Y); clearChosenMpfiPtr(X, &v_X); return POINT_EVAL_FAILURE; break; } /* This destroys x */ mpfr_set_prec(x, mpfr_get_prec(y)); /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ tern1 = mpfr_set(y, &((*Y)->left), GMP_RNDN); /* rounds to final precision */ tern2 = mpfr_set(x, &((*Y)->right), GMP_RNDN); /* rounds to final precision */ if (mpfr_number_p(x) && mpfr_number_p(y)) { if (mpfr_equal_p(x, y)) { if ((tern1 == 0) && (tern2 == 0)) { res = POINT_EVAL_EXACT; } else { if ((tern1 != 0) && (tern1 == tern2)) { res = POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } else { res = POINT_EVAL_CORRECTLY_ROUNDED; } } } else { if (mpfr_cmp(y, x) < 0) { mpfr_nextbelow(x); if (mpfr_equal_p(x, y)) { if (!sollya_mpfi_fr_in_interval(y, *Y)) { res = POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT; } else { res = POINT_EVAL_FAITHFULLY_ROUNDED; } } else { if ((!(sollya_mpfi_has_nan(*Y) || sollya_mpfi_has_infinity(*Y))) && (sollya_mpfi_max_exp(*Y) < cutoffY)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } } else { if ((!(sollya_mpfi_has_nan(*Y) || sollya_mpfi_has_infinity(*Y))) && (sollya_mpfi_max_exp(*Y) < cutoffY)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } } } else { if ((!(sollya_mpfi_has_nan(*Y) || sollya_mpfi_has_infinity(*Y))) && (sollya_mpfi_max_exp(*Y) < cutoffY)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } clearChosenMpfiPtr(Y, &v_Y); clearChosenMpfiPtr(X, &v_X); return res; } static inline point_eval_t __tryFaithEvaluationOptimizedUnivariate(mpfr_t y, int nodeType, node *g, mpfr_t x, mp_exp_t cutoff, mp_prec_t minPrec, mp_exp_t *maxPrecUsed, node *f, node *mr) { mpfr_srcptr gyptr; int ternary; mp_prec_t prec; mpfr_t v_t; mpfr_t *t; point_eval_t resG, res; mp_exp_t cutoffX; mp_prec_t recMaxPrecUsed; /* Make compiler happy */ gyptr = NULL; /* End of compiler happiness */ /* Handle the case when g(x) = c or g(x) = x */ if ((nodeType != LIBRARYFUNCTION) && (nodeType != PROCEDUREFUNCTION)) { switch (accessThruMemRef(g)->nodeType) { case CONSTANT: case VARIABLE: switch (accessThruMemRef(g)->nodeType) { case CONSTANT: gyptr = *(accessThruMemRef(g)->value); break; case VARIABLE: gyptr = x; } switch (nodeType) { case SQRT: ternary = mpfr_sqrt(y, gyptr, GMP_RNDN); break; case EXP: ternary = mpfr_exp(y, gyptr, GMP_RNDN); break; case LOG: ternary = mpfr_log(y, gyptr, GMP_RNDN); break; case LOG_2: ternary = mpfr_log2(y, gyptr, GMP_RNDN); break; case LOG_10: ternary = mpfr_log10(y, gyptr, GMP_RNDN); break; case SIN: ternary = mpfr_sin(y, gyptr, GMP_RNDN); break; case COS: ternary = mpfr_cos(y, gyptr, GMP_RNDN); break; case TAN: ternary = mpfr_tan(y, gyptr, GMP_RNDN); break; case ASIN: ternary = mpfr_asin(y, gyptr, GMP_RNDN); break; case ACOS: ternary = mpfr_acos(y, gyptr, GMP_RNDN); break; case ATAN: ternary = mpfr_atan(y, gyptr, GMP_RNDN); break; case SINH: ternary = mpfr_sinh(y, gyptr, GMP_RNDN); break; case COSH: ternary = mpfr_cosh(y, gyptr, GMP_RNDN); break; case TANH: ternary = mpfr_tanh(y, gyptr, GMP_RNDN); break; case ASINH: ternary = mpfr_asinh(y, gyptr, GMP_RNDN); break; case ACOSH: ternary = mpfr_acosh(y, gyptr, GMP_RNDN); break; case ATANH: ternary = mpfr_atanh(y, gyptr, GMP_RNDN); break; case ERF: ternary = mpfr_erf(y, gyptr, GMP_RNDN); break; case ERFC: ternary = mpfr_erfc(y, gyptr, GMP_RNDN); break; case LOG_1P: ternary = mpfr_log1p(y, gyptr, GMP_RNDN); break; case EXP_M1: ternary = mpfr_expm1(y, gyptr, GMP_RNDN); break; default: return POINT_EVAL_FAILURE; break; } __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, mpfr_get_prec(y)); if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; break; default: break; } } /* Handle the general case */ prec = __tryFaithEvaluationOptimizedUnivariateGetRecursePrec(nodeType, mpfr_get_prec(y), cutoff); if (prec < minPrec) prec = minPrec; cutoffX = __tryFaithEvaluationOptimizedUnivariateGetRecurseCutoff(nodeType, cutoff, mpfr_get_prec(y)); if ((cutoffX >= 0) || (cutoffX < mpfr_get_emin_min())) cutoffX = mpfr_get_emin_min(); t = chooseAndInitMpfrPtr(&v_t, prec); recMaxPrecUsed = 0; resG = __tryFaithEvaluationOptimizedDoIt(*t, g, x, cutoffX, minPrec, &recMaxPrecUsed, g); __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, recMaxPrecUsed); switch (resG) { case POINT_EVAL_FAILURE: clearChosenMpfrPtr(t, &v_t); return POINT_EVAL_FAILURE; break; case POINT_EVAL_EXACT: switch (nodeType) { case SQRT: ternary = mpfr_sqrt(y, *t, GMP_RNDN); break; case EXP: ternary = mpfr_exp(y, *t, GMP_RNDN); break; case LOG: ternary = mpfr_log(y, *t, GMP_RNDN); break; case LOG_2: ternary = mpfr_log2(y, *t, GMP_RNDN); break; case LOG_10: ternary = mpfr_log10(y, *t, GMP_RNDN); break; case SIN: ternary = mpfr_sin(y, *t, GMP_RNDN); break; case COS: ternary = mpfr_cos(y, *t, GMP_RNDN); break; case TAN: ternary = mpfr_tan(y, *t, GMP_RNDN); break; case ASIN: ternary = mpfr_asin(y, *t, GMP_RNDN); break; case ACOS: ternary = mpfr_acos(y, *t, GMP_RNDN); break; case ATAN: ternary = mpfr_atan(y, *t, GMP_RNDN); break; case SINH: ternary = mpfr_sinh(y, *t, GMP_RNDN); break; case COSH: ternary = mpfr_cosh(y, *t, GMP_RNDN); break; case TANH: ternary = mpfr_tanh(y, *t, GMP_RNDN); break; case ASINH: ternary = mpfr_asinh(y, *t, GMP_RNDN); break; case ACOSH: ternary = mpfr_acosh(y, *t, GMP_RNDN); break; case ATANH: ternary = mpfr_atanh(y, *t, GMP_RNDN); break; case ERF: ternary = mpfr_erf(y, *t, GMP_RNDN); break; case ERFC: ternary = mpfr_erfc(y, *t, GMP_RNDN); break; case LOG_1P: ternary = mpfr_log1p(y, *t, GMP_RNDN); break; case EXP_M1: ternary = mpfr_expm1(y, *t, GMP_RNDN); break; case LIBRARYFUNCTION: case PROCEDUREFUNCTION: res = __tryFaithEvaluationOptimizedUnivariateImpreciseArg(y, nodeType, *t, resG, cutoff, cutoffX, f, mr); clearChosenMpfrPtr(t, &v_t); return res; break; default: clearChosenMpfrPtr(t, &v_t); return POINT_EVAL_FAILURE; break; } clearChosenMpfrPtr(t, &v_t); if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; break; case POINT_EVAL_CORRECTLY_ROUNDED: case POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT: case POINT_EVAL_FAITHFULLY_ROUNDED: case POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT: case POINT_EVAL_BELOW_CUTOFF: res = __tryFaithEvaluationOptimizedUnivariateImpreciseArg(y, nodeType, *t, resG, cutoff, cutoffX, f, mr); clearChosenMpfrPtr(t, &v_t); return res; break; default: clearChosenMpfrPtr(t, &v_t); return POINT_EVAL_FAILURE; break; } return POINT_EVAL_FAILURE; } static inline int __tryFaithEvaluationOptimizedFuncSupported(node *f) { if (f == NULL) return 0; switch (f->nodeType) { case MEMREF: if (f->polynomialRepresentation != NULL) return 1; return __tryFaithEvaluationOptimizedFuncSupported(getMemRefChild(f)); break; case VARIABLE: case CONSTANT: case PI_CONST: return 1; break; case ADD: case SUB: case MUL: case DIV: case POW: return (__tryFaithEvaluationOptimizedFuncSupported(f->child1) && __tryFaithEvaluationOptimizedFuncSupported(f->child2)); break; case NEG: case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case ERF: case ERFC: case LOG_1P: case EXP_M1: case LIBRARYFUNCTION: case PROCEDUREFUNCTION: return __tryFaithEvaluationOptimizedFuncSupported(f->child1); break; default: return 0; } return 0; } static inline point_eval_t __tryFaithEvaluationOptimizedPolynomialRepresentation(mpfr_t y, polynomial_t p, mpfr_t x, mp_exp_t cutoff, mp_prec_t minPrec, mp_prec_t *maxPrecUsed) { sollya_mpfi_t v_Y, v_X; sollya_mpfi_t *Y, *X; mp_prec_t prec; point_eval_t res; mpfr_t v_t; mpfr_t *t; int tern1, tern2; prec = mpfr_get_prec(y) + 12; prec = prec + (prec >> 1); if (prec < minPrec) prec = minPrec; __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, prec); Y = chooseAndInitMpfiPtr(&v_Y, prec); X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(x)); sollya_mpfi_set_fr(*X, x); polynomialEvalMpfi(*Y, p, *X); t = chooseAndInitMpfrPtr(&v_t, mpfr_get_prec(y)); /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ tern1 = mpfr_set(y, &((*Y)->left), GMP_RNDN); /* rounds to final precision */ tern2 = mpfr_set(*t, &((*Y)->right), GMP_RNDN); /* rounds to final precision */ if (mpfr_number_p(*t) && mpfr_number_p(y)) { if (mpfr_equal_p(*t, y)) { if ((tern1 == 0) && (tern2 == 0)) { res = POINT_EVAL_EXACT; } else { if ((tern1 != 0) && (tern1 == tern2)) { res = POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } else { res = POINT_EVAL_CORRECTLY_ROUNDED; } } } else { if (mpfr_cmp(y, *t) < 0) { mpfr_nextbelow(*t); if (mpfr_equal_p(*t, y)) { if (!sollya_mpfi_fr_in_interval(y, *Y)) { res = POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT; } else { res = POINT_EVAL_FAITHFULLY_ROUNDED; } } else { if ((!(sollya_mpfi_has_nan(*Y) || sollya_mpfi_has_infinity(*Y))) && (sollya_mpfi_max_exp(*Y) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } } else { if ((!(sollya_mpfi_has_nan(*Y) || sollya_mpfi_has_infinity(*Y))) && (sollya_mpfi_max_exp(*Y) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } } } else { if ((!(sollya_mpfi_has_nan(*Y) || sollya_mpfi_has_infinity(*Y))) && (sollya_mpfi_max_exp(*Y) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } clearChosenMpfrPtr(t, &v_t); clearChosenMpfiPtr(X, &v_X); clearChosenMpfiPtr(Y, &v_Y); return res; } static inline point_eval_t __tryFaithEvaluationOptimizedHooksInner(mpfr_t y, eval_hook_t *hook, mpfr_t x, mp_exp_t cutoff, mp_prec_t minPrec, mp_prec_t *maxPrecUsed, int tight, mp_prec_t extraPrec, int *hookWorked, mp_prec_t *estimatePrec, int *knowEstimatePrec) { sollya_mpfi_t v_Y, v_X; sollya_mpfi_t *Y, *X; mp_prec_t prec; point_eval_t res; mpfr_t v_t; mpfr_t *t; int tern1, tern2; int hookRes; mp_exp_t mER, mEL, mE, tE; *hookWorked = 0; if (hook == NULL) return POINT_EVAL_FAILURE; prec = mpfr_get_prec(y) + 20; prec = prec + (prec >> 1); if (prec < minPrec) prec = minPrec; prec += extraPrec; __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, prec); Y = chooseAndInitMpfiPtr(&v_Y, (tight ? (mpfr_get_prec(y) + 10 + extraPrec) : ((prec > (mpfr_get_prec(y) + 10 + extraPrec)) ? prec : (mpfr_get_prec(y) + 10 + extraPrec)))); X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(x)); sollya_mpfi_set_fr(*X, x); hookRes = evaluateWithEvaluationHook(*Y, *X, prec, tight, hook); if (!hookRes) { clearChosenMpfiPtr(X, &v_X); clearChosenMpfiPtr(Y, &v_Y); return POINT_EVAL_FAILURE; } *hookWorked = 1; t = chooseAndInitMpfrPtr(&v_t, 12); /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ((estimatePrec != NULL) && (knowEstimatePrec != NULL)) { *knowEstimatePrec = 0; if (!(sollya_mpfi_has_zero(*Y) || sollya_mpfi_has_infinity(*Y) || sollya_mpfi_has_nan(*Y) || sollya_mpfi_is_empty(*Y))) { /* Try to get an idea of the accuracy of the result */ mpfr_sub(*t, &((*Y)->right), &((*Y)->left), GMP_RNDU); if (mpfr_number_p(*t) && (!mpfr_zero_p(*t))) { mEL = mpfr_get_exp(&((*Y)->left)); mER = mpfr_get_exp(&((*Y)->right)); mE = mEL; if (mER < mE) mE = mER; tE = mpfr_get_exp(*t); if (mE >= tE) { *estimatePrec = (mp_prec_t) (mE - tE); *knowEstimatePrec = 1; } } } } mpfr_set_prec(*t, mpfr_get_prec(y)); tern1 = mpfr_set(y, &((*Y)->left), GMP_RNDN); /* rounds to final precision */ tern2 = mpfr_set(*t, &((*Y)->right), GMP_RNDN); /* rounds to final precision */ if (mpfr_number_p(*t) && mpfr_number_p(y)) { if (mpfr_equal_p(*t, y)) { if ((tern1 == 0) && (tern2 == 0)) { res = POINT_EVAL_EXACT; } else { if ((tern1 != 0) && (tern1 == tern2)) { res = POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } else { res = POINT_EVAL_CORRECTLY_ROUNDED; } } } else { if (mpfr_cmp(y, *t) < 0) { mpfr_nextbelow(*t); if (mpfr_equal_p(*t, y)) { if (!sollya_mpfi_fr_in_interval(y, *Y)) { res = POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT; } else { res = POINT_EVAL_FAITHFULLY_ROUNDED; } } else { if ((!(sollya_mpfi_has_nan(*Y) || sollya_mpfi_has_infinity(*Y))) && (sollya_mpfi_max_exp(*Y) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } } else { if ((!(sollya_mpfi_has_nan(*Y) || sollya_mpfi_has_infinity(*Y))) && (sollya_mpfi_max_exp(*Y) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } } } else { if ((!(sollya_mpfi_has_nan(*Y) || sollya_mpfi_has_infinity(*Y))) && (sollya_mpfi_max_exp(*Y) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } clearChosenMpfrPtr(t, &v_t); clearChosenMpfiPtr(X, &v_X); clearChosenMpfiPtr(Y, &v_Y); return res; } static inline point_eval_t __tryFaithEvaluationOptimizedHooks(mpfr_t y, eval_hook_t *hook, mpfr_t x, mp_exp_t cutoff, mp_prec_t minPrec, mp_prec_t *maxPrecUsed, int *hookGivesSomeAccuracy) { int hookWorked; point_eval_t res; mp_prec_t extraPrec, estimatePrec, firstPrec; int knowEstimatePrec, knowFirstPrec; *hookGivesSomeAccuracy = 0; if (hook == NULL) return POINT_EVAL_FAILURE; extraPrec = 0; firstPrec = 0; hookWorked = 0; res = __tryFaithEvaluationOptimizedHooksInner(y, hook, x, cutoff, minPrec, maxPrecUsed, 1, extraPrec, &hookWorked, NULL, NULL); if (res != POINT_EVAL_FAILURE) return res; extraPrec = 0; hookWorked = 0; knowEstimatePrec = 0; res = __tryFaithEvaluationOptimizedHooksInner(y, hook, x, cutoff, minPrec, maxPrecUsed, 0, extraPrec, &hookWorked, &estimatePrec, &knowEstimatePrec); if (res != POINT_EVAL_FAILURE) return res; if (!hookWorked) return res; *hookGivesSomeAccuracy = 1; if (knowEstimatePrec) { knowFirstPrec = 1; firstPrec = estimatePrec; } extraPrec = 10; hookWorked = 0; knowEstimatePrec = 0; res = __tryFaithEvaluationOptimizedHooksInner(y, hook, x, cutoff, minPrec, maxPrecUsed, 0, extraPrec, &hookWorked, &estimatePrec, &knowEstimatePrec); if (res != POINT_EVAL_FAILURE) return res; if (!hookWorked) return res; if (knowEstimatePrec) { if (knowFirstPrec) { if (estimatePrec <= firstPrec) return res; firstPrec = estimatePrec; } else { knowFirstPrec = 1; firstPrec = estimatePrec; } } extraPrec = 20; hookWorked = 0; knowEstimatePrec = 0; res = __tryFaithEvaluationOptimizedHooksInner(y, hook, x, cutoff, minPrec, maxPrecUsed, 0, extraPrec, &hookWorked, &estimatePrec, &knowEstimatePrec); if (res != POINT_EVAL_FAILURE) return res; if (!hookWorked) return res; if (knowEstimatePrec) { if (knowFirstPrec) { if (estimatePrec <= firstPrec) return res; firstPrec = estimatePrec; } else { knowFirstPrec = 1; firstPrec = estimatePrec; } } extraPrec = 40; hookWorked = 0; knowEstimatePrec = 0; res = __tryFaithEvaluationOptimizedHooksInner(y, hook, x, cutoff, minPrec, maxPrecUsed, 0, extraPrec, &hookWorked, &estimatePrec, &knowEstimatePrec); if (res != POINT_EVAL_FAILURE) return res; if (!hookWorked) return res; if (knowEstimatePrec) { if (knowFirstPrec) { if (estimatePrec <= firstPrec) return res; firstPrec = estimatePrec; } else { knowFirstPrec = 1; firstPrec = estimatePrec; } } extraPrec = 60; hookWorked = 0; knowEstimatePrec = 0; res = __tryFaithEvaluationOptimizedHooksInner(y, hook, x, cutoff, minPrec, maxPrecUsed, 0, extraPrec, &hookWorked, &estimatePrec, &knowEstimatePrec); if (res != POINT_EVAL_FAILURE) return res; if (!hookWorked) return res; if (knowEstimatePrec) { if (knowFirstPrec) { if (estimatePrec <= firstPrec) return res; firstPrec = estimatePrec; } else { knowFirstPrec = 1; firstPrec = estimatePrec; } } extraPrec = mpfr_get_prec(y) + 10; if (extraPrec < 80) extraPrec = 80; while (extraPrec <= 5 * mpfr_get_prec(y)) { hookWorked = 0; knowEstimatePrec = 0; res = __tryFaithEvaluationOptimizedHooksInner(y, hook, x, cutoff, minPrec, maxPrecUsed, 0, extraPrec, &hookWorked, &estimatePrec, &knowEstimatePrec); if (res != POINT_EVAL_FAILURE) return res; if (!hookWorked) return res; if (knowEstimatePrec) { if (knowFirstPrec) { if (estimatePrec <= firstPrec) return res; firstPrec = estimatePrec; } else { knowFirstPrec = 1; firstPrec = estimatePrec; } } extraPrec += ((extraPrec >> 2) > 10 ? (extraPrec >> 2) : 10); } return res; } static inline point_eval_t __tryFaithEvaluationOptimizedDeducedLowerPrecResult(mpfr_t y, mpfr_t x, point_eval_t approx, mp_exp_t approxCutoff, mp_exp_t cutoff) { int ternary, tern1, tern2; sollya_mpfi_t v_X; sollya_mpfi_t *X; mpfr_t v_t; mpfr_t *t; point_eval_t res; /* Make compiler happy */ X = NULL; /* End of compiler happiness */ if (approx == POINT_EVAL_FAILURE) return POINT_EVAL_FAILURE; if (!mpfr_number_p(x)) return POINT_EVAL_FAILURE; if (approx == POINT_EVAL_EXACT) { ternary = mpfr_set(y, x, GMP_RNDN); if (ternary == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } switch (approx) { case POINT_EVAL_FAILURE: return POINT_EVAL_FAILURE; break; case POINT_EVAL_EXACT: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(x)); sollya_mpfi_set_fr(*X, x); break; case POINT_EVAL_CORRECTLY_ROUNDED: case POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(x) + 1); sollya_mpfi_set_fr(*X, x); sollya_mpfi_blow_1ulp(*X); break; case POINT_EVAL_FAITHFULLY_ROUNDED: case POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(x)); sollya_mpfi_set_fr(*X, x); sollya_mpfi_blow_1ulp(*X); break; case POINT_EVAL_BELOW_CUTOFF: X = chooseAndInitMpfiPtr(&v_X, mpfr_get_prec(x)); sollya_mpfi_interv_si_2exp(*X, -1, approxCutoff, 1, approxCutoff); break; } t = chooseAndInitMpfrPtr(&v_t, mpfr_get_prec(y)); /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ tern1 = mpfr_set(y, &((*X)->left), GMP_RNDN); /* rounds to final precision */ tern2 = mpfr_set(*t, &((*X)->right), GMP_RNDN); /* rounds to final precision */ if (mpfr_number_p(*t) && mpfr_number_p(y)) { if (mpfr_equal_p(*t, y)) { if ((tern1 == 0) && (tern2 == 0)) { res = POINT_EVAL_EXACT; } else { if ((tern1 != 0) && (tern1 == tern2)) { res = POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; } else { res = POINT_EVAL_CORRECTLY_ROUNDED; } } } else { if (mpfr_cmp(y, *t) < 0) { mpfr_nextbelow(*t); if (mpfr_equal_p(*t, y)) { if (!sollya_mpfi_fr_in_interval(y, *X)) { res = POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT; } else { res = POINT_EVAL_FAITHFULLY_ROUNDED; } } else { if ((!(sollya_mpfi_has_nan(*X) || sollya_mpfi_has_infinity(*X))) && (sollya_mpfi_max_exp(*X) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } } else { if ((!(sollya_mpfi_has_nan(*X) || sollya_mpfi_has_infinity(*X))) && (sollya_mpfi_max_exp(*X) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } } } else { if ((!(sollya_mpfi_has_nan(*X) || sollya_mpfi_has_infinity(*X))) && (sollya_mpfi_max_exp(*X) < cutoff)) { res = POINT_EVAL_BELOW_CUTOFF; } else { res = POINT_EVAL_FAILURE; } } clearChosenMpfrPtr(t, &v_t); clearChosenMpfiPtr(X, &v_X); return res; } static inline point_eval_t __tryFaithEvaluationOptimizedDoIt(mpfr_t y, node *f, mpfr_t x, mp_exp_t cutoff, mp_prec_t minPrec, mp_prec_t *maxPrecUsed, node *mr) { point_eval_t res; int hookGivesSomeAccuracy; switch (f->nodeType) { case MEMREF: if ((f->pointEvalCacheX != NULL) && (f->pointEvalCacheY != NULL) && (f->pointEvalCacheResultType != POINT_EVAL_FAILURE) && (f->pointEvalCacheCutoff <= cutoff) && (mpfr_get_prec(*(f->pointEvalCacheY)) >= mpfr_get_prec(y)) && mpfr_number_p(x) && mpfr_number_p(*(f->pointEvalCacheX)) && mpfr_number_p(*(f->pointEvalCacheY)) && mpfr_equal_p(*(f->pointEvalCacheX), x)) { if (mpfr_get_prec(*(f->pointEvalCacheY)) == mpfr_get_prec(y)) { mpfr_set(y, *(f->pointEvalCacheY), GMP_RNDN); /* exact */ return f->pointEvalCacheResultType; } else { res = __tryFaithEvaluationOptimizedDeducedLowerPrecResult(y, *(f->pointEvalCacheY), f->pointEvalCacheResultType, f->pointEvalCacheCutoff, cutoff); if (res != POINT_EVAL_FAILURE) return res; } } if ((f->polynomialRepresentation != NULL) && (f->child1 == NULL)) { res = __tryFaithEvaluationOptimizedPolynomialRepresentation(y, f->polynomialRepresentation, x, cutoff, minPrec, maxPrecUsed); } else { hookGivesSomeAccuracy = 0; res = __tryFaithEvaluationOptimizedHooks(y, f->evaluationHook, x, cutoff, minPrec, maxPrecUsed, &hookGivesSomeAccuracy); if (hookGivesSomeAccuracy) return res; if (res == POINT_EVAL_FAILURE) { res = __tryFaithEvaluationOptimizedDoIt(y, getMemRefChild(f), x, cutoff, minPrec, maxPrecUsed, f); } } if ((res != POINT_EVAL_FAILURE) && (f->libFunDeriv >= 2) && mpfr_number_p(y)) { if (f->pointEvalCacheX == NULL) { f->pointEvalCacheX = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(f->pointEvalCacheX), mpfr_get_prec(x)); } if (f->pointEvalCacheY == NULL) { f->pointEvalCacheY = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(f->pointEvalCacheY), mpfr_get_prec(y)); } mpfr_set_prec(*(f->pointEvalCacheX), mpfr_get_prec(x)); mpfr_set_prec(*(f->pointEvalCacheY), mpfr_get_prec(y)); mpfr_set(*(f->pointEvalCacheX), x, GMP_RNDN); /* exact */ mpfr_set(*(f->pointEvalCacheY), y, GMP_RNDN); /* exact */ f->pointEvalCacheCutoff = cutoff; f->pointEvalCacheResultType = res; } return res; break; case VARIABLE: __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, mpfr_get_prec(y)); if (mpfr_set(y, x, GMP_RNDN) == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; break; case CONSTANT: __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, mpfr_get_prec(y)); if (mpfr_set(y, *(f->value), GMP_RNDN) == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; break; case PI_CONST: __tryFaithEvaluationOptimizedUpdateMaxPrec(maxPrecUsed, mpfr_get_prec(y)); if (mpfr_const_pi(y, GMP_RNDN) == 0) return POINT_EVAL_EXACT; return POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT; break; case ADD: case SUB: return __tryFaithEvaluationOptimizedAddSub(y, (f->nodeType == SUB), f->child1, f->child2, x, cutoff, minPrec, maxPrecUsed); break; case MUL: case DIV: return __tryFaithEvaluationOptimizedMulDiv(y, (f->nodeType == DIV), f->child1, f->child2, x, cutoff, minPrec, maxPrecUsed); break; case POW: return __tryFaithEvaluationOptimizedPow(y, f->child1, f->child2, x, cutoff, minPrec, maxPrecUsed); break; case NEG: /* So terribly trivial that we do it here */ res = __tryFaithEvaluationOptimizedDoIt(y, f->child1, x, cutoff, minPrec, maxPrecUsed, f->child1); if (res != POINT_EVAL_FAILURE) { mpfr_neg(y, y, GMP_RNDN); /* exact */ } return res; break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case ERF: case ERFC: case LOG_1P: case EXP_M1: case LIBRARYFUNCTION: case PROCEDUREFUNCTION: return __tryFaithEvaluationOptimizedUnivariate(y, f->nodeType, f->child1, x, cutoff, minPrec, maxPrecUsed, f, mr); break; default: return POINT_EVAL_FAILURE; } return POINT_EVAL_FAILURE; } static inline int __tryFaithEvaluationOptimized(int *retVal, mpfr_t y, node *func, mpfr_t x, mp_exp_t cutoff, mp_prec_t minPrec, mp_prec_t *maxPrecUsed) { point_eval_t res; /* Refuse work if x and y are the same MPFR variable */ if (((void *) x) == ((void *) y)) return 0; /* Refuse work for func = NULL */ if (func == NULL) return 0; /* Refuse work if x is not a real */ if (!mpfr_number_p(x)) return 0; /* Call inner function and translate the success information */ res = __tryFaithEvaluationOptimizedDoIt(y, func, x, cutoff, minPrec, maxPrecUsed, func); switch (res) { case POINT_EVAL_FAILURE: return 0; break; case POINT_EVAL_EXACT: if (!mpfr_number_p(y)) return 0; *retVal = 4; return 1; break; case POINT_EVAL_CORRECTLY_ROUNDED: if (!mpfr_number_p(y)) return 0; *retVal = 6; return 1; break; case POINT_EVAL_CORRECTLY_ROUNDED_PROVEN_INEXACT: if (!mpfr_number_p(y)) return 0; *retVal = 7; return 1; break; case POINT_EVAL_FAITHFULLY_ROUNDED: if (!mpfr_number_p(y)) return 0; *retVal = 1; return 1; break; case POINT_EVAL_FAITHFULLY_ROUNDED_PROVEN_INEXACT: if (!mpfr_number_p(y)) return 0; *retVal = 5; return 1; break; case POINT_EVAL_BELOW_CUTOFF: if (!mpfr_number_p(y)) return 0; *retVal = 2; return 1; default: return 0; break; } return 0; } /* A performance optimized short-circuit variant to the function evaluateFaithfulWithCutOffFastInternalImplementation defined below. This function is not required to work in all cases. If it works, it has to return a non-zero value and assign the evaluation result to y and to set retVal to the "return values" defined (in comment) below. This function is supposed not to allocate memory when allocation can be avoided or amortized. */ static inline int firstTryEvaluateFaithfulWithCutOffFastInternalImplementation(int *retVal, mpfr_t y, node *func, mpfr_t x, mp_prec_t startprec, mp_exp_t *cutoff) { mp_prec_t pX, pY; int tern1, tern2; mp_exp_t myCutoff; mp_prec_t maxPrecUsed; /* Refuse work if x and y are the same MPFR variable */ if (((void *) x) == ((void *) y)) return 0; /* Try to use a still more optimized function */ if (__tryFaithEvaluationOptimizedFuncSupported(func)) { if (cutoff == NULL) { myCutoff = mpfr_get_emin_min(); } else { myCutoff = *cutoff; } maxPrecUsed = 0; if (__tryFaithEvaluationOptimized(retVal, y, func, x, myCutoff, startprec, &maxPrecUsed)) { return 1; } } /* Get the precisions of the x and y arguments */ pX = mpfr_get_prec(x); pY = mpfr_get_prec(y); /* Check if we have any chance to get a faithful rounding in y with evaluations at startprec bits */ if (pY > startprec) return 0; /* Initialize interval variables for x and for the evaluation of f over this interval x If we are in a recursive call, simply fail and let the usual evaluation function do the work. Recursive calls are only possible in funny cases when a procedure function or a library function uses pointwise faithfully rounded evaluations to evaluate itself. If we are not in a recursive call, get the token to prevent other recursive calls. */ if (__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_vars_used) return 0; __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_vars_used = 1; if (__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x_initialized) { sollya_mpfi_set_prec(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x, pX); } else { sollya_mpfi_init2(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x, pX); __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x_initialized = 1; } if (__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y_initialized) { sollya_mpfi_set_prec(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y, startprec); } else { sollya_mpfi_init2(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y, startprec); __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y_initialized = 1; } /* Set the interval x to the point x */ sollya_mpfi_set_fr(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x, x); /* exact, same precision */ /* Perform an interval evaluation of f over the interval x, yielding an interval y */ evaluateIntervalInternalFast(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y, func, NULL, __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_x, 1, 0, cutoff, NULL); /* If the interval we got is not bounded, we simply indicate failure and let the usual evaluation function do the work. */ if (!sollya_mpfi_bounded_p(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y)) { __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_vars_used = 0; return 0; } /* Here, the interval y bounding f(x) contains nothing but real numbers. We now check if correct rounding is already possible. We DO NOT check if faithful rounding is already possible as this might require reevaluation (see the strategy in the function evaluateFaithfulWithCutOffFastInternalImplementation below). The test whether or not correct rounding is possible requires a temporary MPFR variable with *exactly* the same precision as the MPFR y variable. */ if (__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp_initialized) { mpfr_set_prec(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp, pY); } else { mpfr_init2(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp, pY); __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp_initialized = 1; } /* Round both endpoints of the interval y to the nearest. If both roundings yield the same value and are real numbers, correct rounding is possible. */ /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ tern1 = mpfr_set(y, &(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y->left), GMP_RNDN); /* rounds to final precision */ tern2 = mpfr_set(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp, &(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_y->right), GMP_RNDN); /* rounds to final precision */ /* Check if both roundings are real and equal */ if (mpfr_number_p(y) && mpfr_number_p(__firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp) && mpfr_equal_p(y, __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_temp)) { /* Here, we could determine a correct rounding. The numerical result variable y has already been set. Set the "return value" to "correctly rounded proven inexact" (7), "correctly rounded might be exact" (6) or "exact" (4). Return "success". * The result is (proven) exact if none of the roundings was inexact. * The result is proven inexact if none of the roundings was exact and both roundings went in the same direction. * Otherwise, we don't know. */ if ((tern1 == 0) && (tern2 == 0)) { /* the result was "exact" */ *retVal = 4; } else { if (tern1 * tern2 > 0) { /* the result was proven "inexact" */ *retVal = 7; } else { /* We do not know if the result is exact or not. */ *retVal = 6; } } __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_vars_used = 0; return 1; } /* We could not easily determine a faithful (correct) rounding */ __firstTryEvaluateFaithfulWithCutOffFastInternalImplementation_vars_used = 0; return 0; } /* Return values: 0 -> evaluation did not allow for a faithful evaluation nor to get below the threshold but the proof interval was a closed subset of the reals or an exact infinity 1 -> evaluation gave a faithful result, we do not know if it is exact or inexact 2 -> evaluation got the proof interval below the cutoff 3 -> evaluation did not allow to conclude on a function as it evaluated to NaN or Inf 4 -> evaluation gave a faithfully resp. correctly rounded result and we know that it is exact 5 -> evaluation gave a faithful result and we know that it is inexact 6 -> evaluation gave a correctly rounded result, we do not know if it is inexact 7 -> evaluation gave a correctly rounded result and we know that it is inexact */ static inline int evaluateFaithfulWithCutOffFastInternalImplementation(mpfr_t result, node *func, node *deriv, mpfr_t x, mpfr_t cutoff, mp_prec_t startprecOrig, node *altX) { mp_prec_t p, prec, pTemp, pRes; sollya_mpfi_t yI, xI, cutoffI, dummyI; int okay; mpfr_t resUp, resDown, resUpFaith, resDownFaith, resDownTemp; mpfr_t cutoffLeft, cutoffRight; mpfr_t yILeft, yIRight, yILeftCheck, yIRightCheck; int testCutOff; int correctlyRounded; mp_prec_t startprec; int precisionIncreased; int res; int retry; mp_exp_t expoCutoff; int lazyHookUsed; /* Determine some sensible starting precision */ startprec = startprecOrig; pRes = mpfr_get_prec(result); if ((mpfr_sgn(cutoff) == 0) || (!mpfr_number_p(cutoff))) { /* The cutoff is zero or Nan */ expoCutoff = mpfr_get_emin_min(); /* If the cutoff is zero or NaN, we actually need at least as much working precision as the precision of the result we are to produce. */ if (startprec < pRes + 10) startprec = pRes + 10; } else { /* The cutoff is a real and not zero */ expoCutoff = mpfr_get_exp(cutoff); if (expoCutoff >= -1) { expoCutoff = -2; } expoCutoff--; if ((expoCutoff >= 0) || (expoCutoff < mpfr_get_emin_min())) expoCutoff = mpfr_get_emin_min(); } /* Try a short-circuit for common case evaluations */ if ((altX == NULL) && (((void *) x) != ((void *) result))) { if (firstTryEvaluateFaithfulWithCutOffFastInternalImplementation(&res, result, func, x, startprec, &expoCutoff)) { return res; } } /* Check if we have a constant expression to evaluate at and if so, check if it is constant */ if ((altX != NULL) && (!isConstant(altX))) { /* Here the alternate abscissa expression is not constant */ mpfr_set_nan(result); return 0; } /* We need a dummy interval for some evaluations */ sollya_mpfi_init2(dummyI,12); sollya_mpfi_set_ui(dummyI,1); /* We test the cutoff only if it is not zero */ testCutOff = 1; prec = mpfr_get_prec(cutoff); mpfr_init2(cutoffLeft, prec); mpfr_init2(cutoffRight, prec); sollya_mpfi_init2(cutoffI,prec); mpfr_abs(cutoffRight,cutoff,GMP_RNDU); /* We test the cutoff only if it is not zero */ mpfr_set_si(cutoffLeft,0,GMP_RNDN); if (mpfr_cmp(cutoffRight,cutoffLeft) == 0) testCutOff = 0; mpfr_neg(cutoffLeft,cutoffRight,GMP_RNDD); sollya_mpfi_interv_fr(cutoffI,cutoffLeft,cutoffRight); mpfr_clear(cutoffLeft); mpfr_clear(cutoffRight); /* Initialize the variables that hold the possible roundings */ prec = mpfr_get_prec(result); mpfr_init2(resUp,prec); mpfr_init2(resDown,prec); mpfr_init2(resUpFaith,prec); mpfr_init2(resDownFaith,prec); mpfr_init2(resDownTemp,prec); /* Determine a starting precision */ if (startprec > prec) prec = startprec; /* Use up a little more memory with the first malloc The starting subsequent mpf*_set_prec will not malloc */ sollya_mpfi_init2(yI,startprec*16); mpfr_init2(yILeft,startprec*16); mpfr_init2(yIRight,startprec*16); /* Initialize an interval for the abscissa point we evaluate at */ if (altX == NULL) { /* If we have no alternate abscissa point, copy x into an interval with its own precision */ p = mpfr_get_prec(x); sollya_mpfi_init2(xI,p); sollya_mpfi_interv_fr(xI,x,x); } else { /* Otherwise, initialize an interval with a little more than the starting precision and then set the precision to the starting precision. This allows for the first subsequent mpf*_set_prec not to malloc which saves a couple of mallocs and copies. */ sollya_mpfi_init2(xI,startprec * 16); sollya_mpfi_set_prec(xI,startprec); } /* Start the rounding loop */ p=startprec; okay = 0; retry = 0; while (p < prec * 512) { correctlyRounded = 0; lazyHookUsed = 0; sollya_mpfi_set_prec(yI,p); /* If we evaluate at a constant expression instead of a point, evaluate the constant expression to the current (loop) precision. */ if (altX != NULL) { sollya_mpfi_set_prec(xI,p); evaluateIntervalInternalFast(xI, altX, NULL, dummyI, (retry < 2), (retry < 4), &expoCutoff, &lazyHookUsed); } mpfr_set_prec(yILeft,p); mpfr_set_prec(yIRight,p); evaluateIntervalInternalFast(yI, func, deriv, xI, (retry < 2), (retry < 4), &expoCutoff, &lazyHookUsed); sollya_mpfi_get_left(yILeft,yI); sollya_mpfi_get_right(yIRight,yI); mpfr_set(resDown,yILeft,GMP_RNDN); mpfr_set(resUp,yIRight,GMP_RNDN); /* No, two sollya_mpfi_get_left/right on resDown and resUp directly do not work: ----|-----------|-----------|---- |--yI-| left RN right */ if ((mpfr_number_p(resDown)) && (mpfr_number_p(resUp)) && (sollya_mpfi_bounded_p(yI))) { /* Check if correct rounding is already possible */ if (mpfr_cmp(resDown,resUp) == 0) { /* Correct rounding is possible, resDown = resUp is that correct rounding */ okay = 1; correctlyRounded = 1; } else { /* Check if faithful rounding is already possible because the proof interval is between two consecutive floating-point numbers in the target format. */ sollya_mpfi_get_left(resDownFaith,yI); sollya_mpfi_get_right(resUpFaith,yI); mpfr_set(resDownTemp, resDownFaith, GMP_RNDN); /* exact, same precision */ mpfr_nextabove(resDownTemp); if (mpfr_number_p(resDownFaith) && mpfr_number_p(resUpFaith) && (mpfr_cmp(resDownTemp,resUpFaith) == 0)) { /* A faithful rounding is already possible because the proof interval is between two consecutive floating-point numbers in the target format. As the rounding process implemented here will start with some small precision (yielding large proof intervals at first) and increase that precision more and more until correct or faithful rounding becomes possible and since faithful rounding is easier than correct rounding, there are more chances to fall into this case of faithful rounding than into the case for correct rounding. In order to allow for correct rounding in most cases anyway, we are hence going to try to recompute the proof interval at a slightly higher precision to see if we can't get correct rounding "for just one dollar more." */ pTemp = p + 10; /* Recompute at that slightly higher precision */ sollya_mpfi_set_prec(yI,pTemp); /* If we evaluate at a constant expression instead of a point, evaluate the constant expression to the current (loop) precision. */ if (altX != NULL) { sollya_mpfi_set_prec(xI,pTemp); evaluateIntervalInternalFast(xI, altX, NULL, dummyI, (retry < 2), (retry < 4), &expoCutoff, &lazyHookUsed); } mpfr_set_prec(yILeft,pTemp); mpfr_set_prec(yIRight,pTemp); evaluateIntervalInternalFast(yI, func, deriv, xI, (retry < 2), (retry < 4), &expoCutoff, &lazyHookUsed); sollya_mpfi_get_left(yILeft,yI); sollya_mpfi_get_right(yIRight,yI); mpfr_set(resDown,yILeft,GMP_RNDN); mpfr_set(resUp,yIRight,GMP_RNDN); /* Check if we have a correct rounding now. */ if (mpfr_number_p(resDown) && mpfr_number_p(resUp) && sollya_mpfi_bounded_p(yI) && (mpfr_cmp(resDown,resUp) == 0)) { /* We did find a correct rounding now, which we're gonna use. */ okay = 1; correctlyRounded = 1; } else { /* We couldn't find a correct rounding with a recomputation at a slightly higher precision. So we'll go for our faithful rounding. */ okay = 1; mpfr_set(resDown, resDownFaith, GMP_RNDN); /* exact, same precision */ mpfr_set(resUp, resUpFaith, GMP_RNDN); /* exact, same precision */ } } else { /* Check if faithful rounding is already possible because the proof interval contains a single floating-point number in the target format. */ mpfr_set(resDownFaith,yILeft,GMP_RNDU); mpfr_set(resUpFaith,yIRight,GMP_RNDD); if (mpfr_number_p(resDownFaith) && mpfr_number_p(resUpFaith) && (mpfr_cmp(resDownFaith,resUpFaith) == 0)) { /* A faithful rounding is already possible because the proof interval contains a single floating-point number in the target format. As the rounding process implemented here will start with some small precision (yielding large proof intervals at first) and increase that precision more and more until correct or faithful rounding becomes possible and since faithful rounding is easier than correct rounding, there are more chances to fall into this case of faithful rounding than into the case for correct rounding. In order to allow for correct rounding in most cases anyway, we are hence going to try to recompute the proof interval at a slightly higher precision to see if we can't get correct rounding "for just one dollar more." */ pTemp = p + 10; /* Recompute at that slightly higher precision */ sollya_mpfi_set_prec(yI,pTemp); /* If we evaluate at a constant expression instead of a point, evaluate the constant expression to the current (loop) precision. */ if (altX != NULL) { sollya_mpfi_set_prec(xI,pTemp); evaluateIntervalInternalFast(xI, altX, NULL, dummyI, (retry < 2), (retry < 4), &expoCutoff, &lazyHookUsed); } mpfr_set_prec(yILeft,pTemp); mpfr_set_prec(yIRight,pTemp); evaluateIntervalInternalFast(yI, func, deriv, xI, (retry < 2), (retry < 4), &expoCutoff, &lazyHookUsed); sollya_mpfi_get_left(yILeft,yI); sollya_mpfi_get_right(yIRight,yI); mpfr_set(resDown,yILeft,GMP_RNDN); mpfr_set(resUp,yIRight,GMP_RNDN); /* Check if we have a correct rounding now. */ if (mpfr_number_p(resDown) && mpfr_number_p(resUp) && sollya_mpfi_bounded_p(yI) && (mpfr_cmp(resDown,resUp) == 0)) { /* We did find a correct rounding now, which we're gonna use. */ okay = 1; correctlyRounded = 1; } else { /* We couldn't find a correct rounding with a recomputation at a slightly higher precision. So we'll go for our faithful rounding. */ okay = 1; mpfr_set(resDown, resDownFaith, GMP_RNDN); /* exact, same precision */ mpfr_set(resUp, resUpFaith, GMP_RNDN); /* exact, same precision */ } } else { /* Check if the proof interval is already contained in the cutoff interval */ if (testCutOff && (okay == 0)) { if (sollya_mpfi_is_inside(yI,cutoffI)) { sollya_mpfi_mid(resUp,yI); mpfr_set(resDown, resUp, GMP_RNDN); /* exact, same precision */ okay = 2; } } } } } } else { if (accessThruMemRef(func)->nodeType == DIV) { if ((accessThruMemRef(func)->child1->nodeType == MEMREF) && (accessThruMemRef(func)->child2->nodeType == MEMREF)) { if ((accessThruMemRef(func)->child1->evalCacheX != NULL) && (accessThruMemRef(func)->child1->evalCacheY != NULL) && (accessThruMemRef(func)->child2->evalCacheX != NULL) && (accessThruMemRef(func)->child2->evalCacheY != NULL)) { if (sollya_mpfi_is_point_and_real(xI) && sollya_mpfi_equal_p(*(accessThruMemRef(func)->child1->evalCacheX), xI) && sollya_mpfi_equal_p(*(accessThruMemRef(func)->child2->evalCacheX), xI)) { if (sollya_mpfi_is_zero(*(accessThruMemRef(func)->child1->evalCacheY)) && sollya_mpfi_is_zero(*(accessThruMemRef(func)->child2->evalCacheY))) { break; } } } } } } if (okay > 0) break; /* Now sensibly increase the working precision for the next round */ retry++; precisionIncreased = 0; if (lazyHookUsed) { /* In the case when the result we got was computed with a lazy hook evaluation, it makes sense to increase the precision only in very small steps */ p += 7; precisionIncreased = 1; } else { if (p < pRes + 10) { /* The working precision is less than the precision of the result. This makes sense only if there is still hope that the final result may fall below the cutoff. There is still hope if the cutoff interval and the current evaluation interval have a point in common. When we loose faith that we still could do the cutoff with low precision, we can directly jump to the current working precision + precision of the result. The fact that we are here means that we could not achieve enough precision for the cutoff, hence that the expression cancelled on all bits (the current precision). */ if (testCutOff) { if (!sollya_mpfi_have_common_real_point(yI, cutoffI)) { p = (p + 10 > pRes + p + 10? p + 10 : pRes + p + 10); precisionIncreased = 1; } else { if ((p << 1) > (pRes + p + 10)) { p = (p + 10 > pRes + p + 10? p + 10 : pRes + p + 10); precisionIncreased = 1; } } } else { p = (p + 10 > pRes + p + 10? p + 10 : pRes + p + 10); precisionIncreased = 1; } } } if (!precisionIncreased) { /* Here, perform some default precision incrementation. The right way to do so might be a matter of religion. The formula below seems to be fine in practice. */ p <<= 1; } } sollya_mpfi_clear(xI); mpfr_clear(yILeft); mpfr_clear(yIRight); if (okay > 0) { /* Now compute the correct rounding wherever possible and the correct rounding of the midpoint of both possible answers otherwise To do so, compute the midpoint of resUp and resDown and round it to the target precision. There are 3 possible cases: a) The loop above has been left because both endpoints of the proof interval rounded to the same value, resUp = resDown. In this case, the midpoint of resUp and resDown is resUp = resDown, which is also the correct rounding. b) The loop above has been left because resUp was the next floating-point number above resDown. resDown and resUp are the two possible answers for a faithful rounding. Their midpoint is the point where the rounding changes. The proof interval contained that midpoint. Returning the correct rounding of the midpoint to the nearest floating-point value hence chooses the even of both possible faithful roundings. c) The loop above has been left because the proof interval was contained in [-cutoff,cutoff]. In this case, resUp and resDown have both been set to the midpoint of the proof interval, which is certainly less than cutoff in magnitude. Computing the midpoint of resUp and resDown and rounding to target precision does not change anything to that value. */ mpfr_div_2ui(resDown, resDown, 1, GMP_RNDN); /* exact, power of 2 */ mpfr_div_2ui(resUp, resUp, 1, GMP_RNDN); /* exact, power of 2 */ mpfr_add(result,resDown, resUp, GMP_RNDN); /* Computes the midpoint and rounds it to target precision */ /* Now check if we are in a case when we can tell if the result is an exact or inexact one. We do this check only if we had a correct or faithful result; we do nothing for the case when the proof interval was below the threshold. */ if (okay == 1) { /* We have a correctly or faithfully rounded result in result and we want to check if the proof interval we had, yI allows anything else to be said than just "it's a faithful rounding". We won't do the additional check if there are quantities involved that are no real numbers. */ p = sollya_mpfi_get_prec(yI); mpfr_init2(yILeftCheck, p); mpfr_init2(yIRightCheck, p); sollya_mpfi_get_left(yILeftCheck,yI); sollya_mpfi_get_right(yIRightCheck,yI); if (mpfr_number_p(result) && mpfr_number_p(yILeftCheck) && mpfr_number_p(yIRightCheck)) { /* Here, we have real numbers to work on */ if (mpfr_equal_p(yILeftCheck, yIRightCheck)) { /* Here, the proof interval is reduced to a point */ if (mpfr_equal_p(result, yILeftCheck)) { /* The result is exact as it is equal to both bounds of the proof interval. */ okay = 4; } else { /* The result is inexact as it is unequal to both bounds of the proof interval which are themselves equal one to another. */ okay = 5; } } else { /* Given the correctly or faithfully rounded result, check if the proof interval is sufficiently small to prove that the result is not in the proof interval, which means that the result must be inexact. */ if (!((mpfr_cmp(yILeftCheck, result) <= 0) && (mpfr_cmp(result, yIRightCheck) <= 0))) { /* Here, the result is not in the proof interval and therefore it is necessarily inexact. */ okay = 5; } } } mpfr_clear(yILeftCheck); mpfr_clear(yIRightCheck); } /* If we got a correctly rounded result, we can express this fact with the return code */ if (correctlyRounded) { if (okay == 1) { okay = 6; } else { if (okay == 5) { okay = 7; } } } } else { mpfr_set_nan(result); if( (!mpfr_number_p(resUp)) || (!mpfr_number_p(resDown))) okay=3; } sollya_mpfi_clear(yI); mpfr_clear(resUp); mpfr_clear(resDown); mpfr_clear(resUpFaith); mpfr_clear(resDownFaith); mpfr_clear(resDownTemp); sollya_mpfi_clear(cutoffI); sollya_mpfi_clear(dummyI); return okay; } int evaluateFaithfulWithCutOffFast(mpfr_t result, node *func, node *deriv, mpfr_t x, mpfr_t cutoff, mp_prec_t startprec) { return evaluateFaithfulWithCutOffFastInternalImplementation(result, func, deriv, x, cutoff, startprec, NULL); } int evaluateFaithfulAtConstantExpression(mpfr_t result, node *func, node *deriv, node *x, mpfr_t cutoff, mp_prec_t startprec) { mpfr_t dummy; if (x == NULL) { mpfr_set_nan(result); return 0; } return evaluateFaithfulWithCutOffFastInternalImplementation(result, func, deriv, dummy, cutoff, startprec, x); } int evaluateFaithfulWithCutOff(mpfr_t result, node *func, mpfr_t x, mpfr_t cutoff, mp_prec_t startprec) { node *deriv; int res; if ((2*startprec) < (mpfr_get_prec(result) + 10)) { printMessage(12,SOLLYA_MSG_DIFFERENTIATING_FOR_EVAL_AS_START_PREC_LOW,"Information: Differentiating while evaluating because start precision (%d bits) too low.\n", (int)startprec); deriv = differentiate(func); }else deriv = NULL; res = evaluateFaithfulWithCutOffFast(result, func, deriv, x, cutoff, startprec); if (res==3) res=0; if (deriv != NULL) free_memory(deriv); return res; } node *makeDoubleConstant(double d) { node *tempNode; tempNode = (node *) safeMalloc(sizeof(node)); tempNode->nodeType = CONSTANT; tempNode->value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(tempNode->value),64); mpfr_set_d(*(tempNode->value),d,GMP_RNDN); return tempNode; } int evaluateSign(int *s, node *func); node *convertConstantToFunctionInPiInner(node *tree) { node *res; int a; if (tree->nodeType == MEMREF) return convertConstantToFunctionInPiInner(getMemRefChild(tree)); if (tree->nodeType == PI_CONST) { res = (node *) safeMalloc(sizeof(node)); res->nodeType = VARIABLE; return res; } a = arity(tree); switch (a) { case 0: res = copyTree(tree); break; case 1: res = (node *) safeMalloc(sizeof(node)); res->nodeType = tree->nodeType; if (tree->nodeType == LIBRARYFUNCTION) { res->libFun = tree->libFun; res->libFunDeriv = tree->libFunDeriv; } if (tree->nodeType == PROCEDUREFUNCTION) { res->libFunDeriv = tree->libFunDeriv; res->child2 = copyThing(tree->child1); } res->child1 = convertConstantToFunctionInPiInner(tree->child1); break; case 2: res = (node *) safeMalloc(sizeof(node)); res->nodeType = tree->nodeType; res->child1 = convertConstantToFunctionInPiInner(tree->child1); res->child2 = convertConstantToFunctionInPiInner(tree->child2); break; default: sollyaFprintf(stderr,"Error: convertConstantToFunctionInPiInner: unknown arity (%d).\n",a); exit(1); } return res; } node *convertConstantToFunctionInPi(node *tree) { if (!isConstant(tree)) return NULL; return convertConstantToFunctionInPiInner(tree); } int containsPi(node *tree) { int a; if (tree->nodeType == MEMREF) return containsPi(getMemRefChild(tree)); if (tree->nodeType == PI_CONST) return 1; a = arity(tree); switch (a) { case 0: return 0; break; case 1: return containsPi(tree->child1); break; case 2: return (containsPi(tree->child1) || containsPi(tree->child2)); default: sollyaFprintf(stderr,"Error: containsPi: unknown arity (%d).\n",a); exit(1); } return 0; } int compareConstant(int *cmp, node *func1, node *func2, node *difference, int doNotEval) { node *diff, *rawDiff, *rawDiff2; int res, okay; mpfr_t value, dummyX; int okayA, okayB, signA, signB; node *tempNode; node **coefficients; int degree, i; int allZero, allOkay; int freeDiff = 1; okay = 0; res = -17; /* Makes compiler happy */ if (difference == NULL) { rawDiff = addMemRef(makeSub(copyTree(func1),copyTree(func2))); rawDiff2 = simplifyRationalErrorfree(rawDiff); diff = simplifyTreeErrorfree(rawDiff2); freeDiff = 1; free_memory(rawDiff); free_memory(rawDiff2); } else { diff = difference; freeDiff = 0; } mpfr_init2(value,12); mpfr_init2(dummyX,12); mpfr_set_ui(dummyX,1,GMP_RNDN); if ((!doNotEval) && evaluateFaithful(value, diff, dummyX, defaultprecision) && mpfr_number_p(value)) { res = mpfr_sgn(value); okay = 1; } else { if ((accessThruMemRef(func1)->nodeType == DIV) && evaluateSign(&signA,accessThruMemRef(func1)->child2) && (signA != 0)) { tempNode = makeMul(copyTree(accessThruMemRef(func1)->child2),copyTree(func2)); okayB = compareConstant(&signB, accessThruMemRef(func1)->child1, tempNode, NULL, 1); if (okayB) { okay = 1; res = signB; } free_memory(tempNode); } if (!okay) { if ((accessThruMemRef(func2)->nodeType == DIV) && evaluateSign(&signA,accessThruMemRef(func2)->child2) && (signA != 0)) { tempNode = makeMul(copyTree(accessThruMemRef(func2)->child2),copyTree(func1)); okayB = compareConstant(&signB, tempNode, accessThruMemRef(func2)->child1, NULL, 1); if (okayB) { okay = 1; res = signB; } free_memory(tempNode); } if (!okay) { if (((accessThruMemRef(func1)->nodeType == EXP) && (accessThruMemRef(func2)->nodeType == EXP)) || ((accessThruMemRef(func1)->nodeType == SINH) && (accessThruMemRef(func2)->nodeType == SINH)) || ((accessThruMemRef(func1)->nodeType == TANH) && (accessThruMemRef(func2)->nodeType == TANH)) || ((accessThruMemRef(func1)->nodeType == ASINH) && (accessThruMemRef(func2)->nodeType == ASINH)) || ((accessThruMemRef(func1)->nodeType == ERF) && (accessThruMemRef(func2)->nodeType == ERF)) || ((accessThruMemRef(func1)->nodeType == EXP_M1) && (accessThruMemRef(func2)->nodeType == EXP_M1))) { okayA = compareConstant(&signA, accessThruMemRef(func1)->child1, accessThruMemRef(func2)->child1, NULL, 0); if (okayA) { okay = 1; res = signA; } } if (!okay) { if (((accessThruMemRef(func1)->nodeType == ERFC) && (accessThruMemRef(func2)->nodeType == ERFC)) || ((accessThruMemRef(func1)->nodeType == NEG) && (accessThruMemRef(func2)->nodeType == NEG))) { okayA = compareConstant(&signA, accessThruMemRef(func1)->child1, accessThruMemRef(func2)->child1, NULL, 0); if (okayA) { okay = 1; res = -signA; } } if (!okay) { if (containsPi(diff)) { if ((tempNode = convertConstantToFunctionInPi(diff)) != NULL) { if (isPolynomial(tempNode)) { /* Here we have tempNode(pi) = diff and tempNode a polynomial */ getCoefficients(°ree, &coefficients, tempNode); if (degree >= 0) { allZero = 1; allOkay = 1; for (i=0;i<=degree;i++) { if (coefficients[i] != NULL) { if (evaluateSign(&signA, coefficients[i])) { if (signA != 0) { allZero = 0; break; } } else { allOkay = 0; break; } } } if (allOkay && allZero) { okay = 1; res = 0; } for (i=0;i<=degree;i++) if (coefficients[i] != NULL) free_memory(coefficients[i]); safeFree(coefficients); } } free_memory(tempNode); } } /* Put next case here */ } } } } } mpfr_clear(dummyX); mpfr_clear(value); if (freeDiff) free_memory(diff); if (okay) *cmp = res; return okay; } int evaluateSignTrigoUnsafe(int *s, node *child, int nodeType) { mpfr_t value, value2; mpfr_t piHalf; mpfr_t dummyX; int okay, res; node *tempNode; int signA; okay = 0; mpfr_init2(value,defaultprecision); mpfr_init2(piHalf,defaultprecision); mpfr_init2(dummyX,12); mpfr_set_ui(dummyX,1,GMP_RNDN); if (evaluateFaithful(value, child, dummyX, defaultprecision) && mpfr_number_p(value)) { mpfr_const_pi(piHalf,GMP_RNDN); mpfr_div_2ui(piHalf,piHalf,1,GMP_RNDN); mpfr_div(value,value,piHalf,GMP_RNDN); mpfr_rint(value,value,GMP_RNDN); mpfr_div_2ui(value,value,1,GMP_RNDN); /* Here, diff is approximately value * pi and value * 2 is an integer */ tempNode = makeMul(makeConstant(value),makePi()); if (compareConstant(&signA, child, tempNode, NULL, 0)) { if (signA == 0) { /* Here, we have proven that child is equal to value * pi */ mpfr_init2(value2,defaultprecision); mpfr_rint(value2,value,GMP_RNDN); /* exact, same precision */ mpfr_sub(value,value,value2,GMP_RNDN); /* exact, Sterbenz */ /* Here, we know that child is equal to (n + value) * pi for some integer n. We know that value can only be 0 or +/- 0.5 */ switch (nodeType) { case SIN: /* sin is zero for all n * pi, n in Z */ if (mpfr_zero_p(value)) { okay = 1; res = 0; } break; case COS: /* cos is zero for all (n + 1/2) * pi, n in Z */ if (!mpfr_zero_p(value)) { okay = 1; res = 0; } break; case TAN: /* tan is zero for all n * pi, n in Z */ if (mpfr_zero_p(value)) { okay = 1; res = 0; } break; default: sollyaFprintf(stderr,"Error: evaluateSignTrigoUnsafe: unknown identifier (%d) in the tree\n",nodeType); exit(1); } mpfr_clear(value2); } } free_memory(tempNode); } mpfr_clear(dummyX); mpfr_clear(piHalf); mpfr_clear(value); if (okay) *s = res; return okay; } int evaluateSignFast(int *s, node *constFunc) { int okay; sollya_mpfi_t y; if (!isConstant(constFunc)) return 0; if (accessThruMemRef(constFunc)->nodeType == CONSTANT) { if (!mpfr_number_p(*(accessThruMemRef(constFunc)->value))) return 0; *s = mpfr_sgn(*(accessThruMemRef(constFunc)->value)); return 1; } okay = 0; sollya_mpfi_init2(y, 12); evaluateConstantExpressionToInterval(y, constFunc); if (!sollya_mpfi_has_nan(y)) { if (sollya_mpfi_is_zero(y)) { okay = 1; *s = 0; } else { if (!sollya_mpfi_has_zero(y)) { okay = 1; if (sollya_mpfi_is_nonneg(y)) { *s = 1; } else { *s = -1; } } } } sollya_mpfi_clear(y); return okay; } int evaluateSign(int *s, node *rawFunc) { int sign, okay, okayA, okayB, okayC; mpfr_t value, dummyX; sollya_mpfi_t valueI; int signA, signB, signC; node *tempNode, *tempNode2; node *func, *rawFunc2; okay = 0; if (!isConstant(rawFunc)) return 0; if ((accessThruMemRef(rawFunc)->nodeType == CONSTANT) && (!mpfr_number_p(*(accessThruMemRef(rawFunc)->value)))) return 0; mpfr_init2(value,12); mpfr_init2(dummyX,12); mpfr_set_ui(dummyX,1,GMP_RNDN); if (evaluateFaithful(value, rawFunc, dummyX, defaultprecision) && mpfr_number_p(value)) { sign = mpfr_sgn(value); okay = 1; } else { rawFunc2 = simplifyRationalErrorfree(rawFunc); func = simplifyTreeErrorfree(rawFunc2); free_memory(rawFunc2); if (evaluateFaithful(value, func, dummyX, defaultprecision) && mpfr_number_p(value)) { sign = mpfr_sgn(value); okay = 1; } else { switch (accessThruMemRef(func)->nodeType) { case CONSTANT: sign = mpfr_sgn(*(accessThruMemRef(func)->value)); okay = 1; break; case ADD: tempNode = makeNeg(copyTree(accessThruMemRef(func)->child2)); okay = compareConstant(&sign, accessThruMemRef(func)->child1, tempNode, NULL, 0); free_memory(tempNode); break; case SUB: okay = compareConstant(&sign, accessThruMemRef(func)->child1, accessThruMemRef(func)->child2, func, 0); break; case MUL: signA = 0; signB = 0; okay = (evaluateSign(&signA, accessThruMemRef(func)->child1) && evaluateSign(&signB, accessThruMemRef(func)->child2)); sign = signA * signB; break; case DIV: okayA = (evaluateSign(&signA, accessThruMemRef(func)->child1) && evaluateSign(&signB, accessThruMemRef(func)->child2)); if (okayA && (signB != 0)) { okay = 1; sign = signA * signB; } break; case SQRT: okayA = evaluateSign(&signA, accessThruMemRef(func)->child1); if (okayA && (signA >= 0)) { okay = 1; sign = signA; } break; case EXP: okayA = evaluateSign(&signA, accessThruMemRef(func)->child1); if (okayA) { okay = 1; sign = 1; } break; case LOG: /* fall-through */ case LOG_2: /* fall-through */ case LOG_10: tempNode = makeDoubleConstant(1.0); okayA = compareConstant(&signA, accessThruMemRef(func)->child1, tempNode, NULL, 0); okayB = evaluateSign(&signB, accessThruMemRef(func)->child1); if (okayA && okayB && (signB > 0)) { okay = 1; sign = signA; } free_memory(tempNode); break; case SIN: /* fall-through */ case COS: /* fall-through */ case TAN: okayA = evaluateSign(&signA, accessThruMemRef(func)->child1); if (okayA && (signA == 0)) { okay = 1; sign = 0; } else { okay = evaluateSignTrigoUnsafe(&sign, accessThruMemRef(func)->child1, accessThruMemRef(func)->nodeType); } break; case ASIN: okayA = evaluateSign(&signA, accessThruMemRef(func)->child1); tempNode = makeAbs(copyTree(accessThruMemRef(func)->child1)); tempNode2 = makeDoubleConstant(1.0); okayB = compareConstant(&signB, tempNode, tempNode2, NULL, 0); if (okayA && okayB && (signB <= 0)) { okay = 1; sign = signA; } free_memory(tempNode); free_memory(tempNode2); break; case ACOS: okayA = evaluateSign(&signA, accessThruMemRef(func)->child1); tempNode = makeAbs(copyTree(accessThruMemRef(func)->child1)); tempNode2 = makeDoubleConstant(1.0); okayB = compareConstant(&signB, tempNode, tempNode2, NULL, 0); okayC = compareConstant(&signC, accessThruMemRef(func)->child1, tempNode2, NULL, 0); if (okayA && okayB && okayC && (signB <= 0)) { okay = 1; if (signC == 0) sign = 0; else sign = 1; } free_memory(tempNode); free_memory(tempNode2); break; case ATAN: okay = evaluateSign(&sign, accessThruMemRef(func)->child1); break; case SINH: okay = evaluateSign(&sign, accessThruMemRef(func)->child1); break; case COSH: okay = 1; sign = 1; break; case TANH: okay = evaluateSign(&sign, accessThruMemRef(func)->child1); break; case ASINH: okay = evaluateSign(&sign, accessThruMemRef(func)->child1); break; case ACOSH: tempNode = makeDoubleConstant(1.0); okayA = compareConstant(&signA, accessThruMemRef(func)->child1, tempNode, NULL, 0); if (okayA && (signA >= 0)) { okay = 1; sign = 1; } free_memory(tempNode); break; case ATANH: okayA = evaluateSign(&signA, accessThruMemRef(func)->child1); tempNode = makeAbs(copyTree(accessThruMemRef(func)->child1)); tempNode2 = makeDoubleConstant(1.0); okayB = compareConstant(&signB, tempNode, tempNode2, NULL, 0); if (okayA && okayB && (signB < 0)) { okay = 1; sign = signA; } free_memory(tempNode); free_memory(tempNode2); break; case POW: okayA = evaluateSign(&signA, accessThruMemRef(func)->child1); okayB = evaluateSign(&signB, accessThruMemRef(func)->child2); if (okayA && okayB) { if (signB == 0) { okay = 1; sign = 1; } else { if (signA == 0) { if (signB > 0) { okay = 1; sign = 0; } } else { if ((signA > 0) && (signB >= 0)) { okay = 1; sign = 1; } } } } break; case NEG: okay = evaluateSign(&signA, accessThruMemRef(func)->child1); sign = -1 * signA; break; case ABS: okayA = evaluateSign(&signA, accessThruMemRef(func)->child1); if (okayA) { okay = 1; if (signA == 0) sign = 0; else sign = 1; } break; case DOUBLE: break; case SINGLE: break; case QUAD: break; case HALFPRECISION: break; case DOUBLEDOUBLE: break; case TRIPLEDOUBLE: break; case ERF: okay = evaluateSign(&sign, accessThruMemRef(func)->child1); break; case ERFC: okay = 1; sign = 1; break; case LOG_1P: tempNode = makeDoubleConstant(-1.0); okayA = compareConstant(&signA, accessThruMemRef(func)->child1, tempNode, NULL, 0); okayB = evaluateSign(&signB, accessThruMemRef(func)->child1); if (okayA && okayB && (signA > 0)) { okay = 1; sign = signB; } free_memory(tempNode); break; case EXP_M1: okay = evaluateSign(&sign, accessThruMemRef(func)->child1); break; case DOUBLEEXTENDED: break; case LIBRARYFUNCTION: break; case PROCEDUREFUNCTION: break; case CEIL: okayA = evaluateSign(&signA, accessThruMemRef(func)->child1); tempNode = makeDoubleConstant(-1.0); if (okayA) okayB = compareConstant(&signB, accessThruMemRef(func)->child1, tempNode, NULL, 0); else okayB = 0; if (okayA && okayB) { okay = 1; if (signB <= 0) { sign = -1; } else { if (signA <= 0) { sign = 0; } else { sign = 1; } } } free_memory(tempNode); break; case FLOOR: okayA = evaluateSign(&signA, accessThruMemRef(func)->child1); tempNode = makeDoubleConstant(1.0); if (okayA) okayB = compareConstant(&signB, accessThruMemRef(func)->child1, tempNode, NULL, 0); else okayB = 0; if (okayA && okayB) { okay = 1; if (signA < 0) { sign = -1; } else { if (signB < 0) { sign = 0; } else { sign = 1; } } } free_memory(tempNode); break; case NEARESTINT: okayA = evaluateSign(&signA, accessThruMemRef(func)->child1); tempNode = makeDoubleConstant(1.0); if (okayA) okayB = compareConstant(&signB, accessThruMemRef(func)->child1, tempNode, NULL, 0); else okayB = 0; if (okayA && okayB) { okay = 1; if (signA < 0) { sign = -1; } else { if (signB < 0) { sign = 0; } else { sign = 1; } } } free_memory(tempNode); break; case PI_CONST: okay = 1; sign = 1; break; case LIBRARYCONSTANT: /* By definition, a library constant is known with a relative error smaller that ~ 2^(-prec). So we can decide the sign, based on low approximation of the constant. */ sollya_mpfi_init2(valueI, 12); libraryConstantToInterval(valueI, accessThruMemRef(func)); if (sollya_mpfi_is_zero(valueI)) { okay = 1; sign = 0; } else { if (sollya_mpfi_has_zero(valueI)) { okay = 0; sign = 0; } else { okay = 1; sign = (sollya_mpfi_is_nonneg(valueI))?1:(-1); } } break; default: sollyaFprintf(stderr,"Error: evaluateSign: unknown identifier (%d) in the tree\n",func->nodeType); exit(1); } } free_memory(func); } mpfr_clear(value); mpfr_clear(dummyX); if (okay) *s = sign; return okay; } sollya-6.0+ds/infnorm.h000066400000000000000000000140531300174114700151060ustar00rootroot00000000000000/* Copyright 2006-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France, and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef INFNORM_H #define INFNORM_H #include #include "mpfi-compat.h" #include #include "expression.h" #include "chain.h" #define ISFLOATINGPOINTEVALUABLE 0 #define ISHOPITALEVALUABLE 1 #define ISNOTEVALUABLE 2 rangetype infnorm(node *func, rangetype range, chain *excludes, mp_prec_t prec, mpfr_t diam, FILE *proof); chain* findZerosFunction(node *func, rangetype range, mp_prec_t prec, mpfr_t diam); void uncertifiedInfnorm(mpfr_t result, mpfr_t *x_result, node *tree, mpfr_t a, mpfr_t b, unsigned long int points, mp_prec_t prec); void evaluateRangeFunction(rangetype yrange, node *func, rangetype xrange, mp_prec_t prec); void evaluateRangeFunctionFast(rangetype yrange, node *func, node *deriv, rangetype xrange, mp_prec_t prec); void evaluateInterval(sollya_mpfi_t y, node *func, node *deriv, sollya_mpfi_t x); void evaluateIntervalPlain(sollya_mpfi_t y, node *func, sollya_mpfi_t x); void fprintInterval(FILE *fd, sollya_mpfi_t interval); void printInterval(sollya_mpfi_t interval); char *sprintInterval(sollya_mpfi_t interval); chain *joinAdjacentIntervalsMaximally(chain *intervals); int checkInfnorm(node *func, rangetype range, mpfr_t infnormval, mpfr_t diam, mp_prec_t prec); void evaluateConstantWithErrorEstimate(mpfr_t res, mpfr_t err, node *func, mpfr_t x, mp_prec_t prec); chain* fpFindZerosFunction(node *func, rangetype range, mp_prec_t prec); chain *uncertifiedZeroDenominators(node *tree, mpfr_t a, mpfr_t b, mp_prec_t prec); int isEvaluable(node *func, mpfr_t x, mpfr_t *y, mp_prec_t prec); int evaluateFaithful(mpfr_t result, node *tree, mpfr_t x, mp_prec_t prec); int accurateInfnorm(mpfr_t result, node *func, rangetype range, chain *excludes, mp_prec_t startPrec); int evaluateFaithfulWithCutOff(mpfr_t result, node *func, mpfr_t x, mpfr_t cutoff, mp_prec_t startprec); int evaluateFaithfulWithCutOffFast(mpfr_t result, node *func, node *deriv, mpfr_t x, mpfr_t cutoff, mp_prec_t startprec); int evaluateFaithfulAtConstantExpression(mpfr_t result, node *func, node *deriv, node *x, mpfr_t cutoff, mp_prec_t startprec); void evaluateConstantExpressionToInterval(sollya_mpfi_t y, node *func); void evaluateConstantExpressionToSharpInterval(sollya_mpfi_t y, node *func); int newtonMPFR(mpfr_t res, node *tree, node *diff_tree, mpfr_t a, mpfr_t b, mp_prec_t prec); int evaluateSign(int *s, node *rawFunc); int evaluateSignFast(int *s, node *constFunc); int compareConstant(int *cmp, node *func1, node *func2, node *difference, int doNotEval); void sollya_mpfi_pow(sollya_mpfi_t z, sollya_mpfi_t x, sollya_mpfi_t y); void sollya_mpfi_pow_ulong(sollya_mpfi_t z, sollya_mpfi_t x, unsigned long t); void sollya_mpfi_round_to_double(sollya_mpfi_t rop, sollya_mpfi_t op); void sollya_mpfi_round_to_single(sollya_mpfi_t rop, sollya_mpfi_t op); void sollya_mpfi_round_to_doubledouble(sollya_mpfi_t rop, sollya_mpfi_t op); void sollya_mpfi_round_to_tripledouble(sollya_mpfi_t rop, sollya_mpfi_t op); void sollya_mpfi_round_to_doubleextended(sollya_mpfi_t rop, sollya_mpfi_t op); void sollya_mpfi_round_to_quad(sollya_mpfi_t rop, sollya_mpfi_t op); void sollya_mpfi_round_to_halfprecision(sollya_mpfi_t rop, sollya_mpfi_t op); void sollya_mpfi_erf(sollya_mpfi_t rop, sollya_mpfi_t op); void sollya_mpfi_erfc(sollya_mpfi_t rop, sollya_mpfi_t op); void sollya_mpfi_ceil(sollya_mpfi_t rop, sollya_mpfi_t op); void sollya_mpfi_floor(sollya_mpfi_t rop, sollya_mpfi_t op); void sollya_mpfi_nearestint(sollya_mpfi_t rop, sollya_mpfi_t op); void libraryConstantToInterval(sollya_mpfi_t res, node *tree); int sollya_mpfr_max(mpfr_t z, mpfr_t x, mpfr_t y, mp_rnd_t rnd); int sollya_mpfr_min(mpfr_t z, mpfr_t x, mpfr_t y, mp_rnd_t rnd); #endif /* ifdef INFNORM_H*/ sollya-6.0+ds/integral.c000066400000000000000000000164021300174114700152360ustar00rootroot00000000000000/* Copyright 2006-2013 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include /* fprintf, fopen, fclose, */ #include /* exit, free, mktemp */ #include #include #include "mpfi-compat.h" #include "expression.h" #include "infnorm.h" #include "integral.h" #include "general.h" rangetype integral(node *func, rangetype interval, mp_prec_t prec, mpfr_t diam) { node *deriv; rangetype x,y; mpfr_t x1,x2,y1,y2,delta; sollya_mpfi_t temp, val; rangetype sum; deriv = differentiate(func); sum.a = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); sum.b = (mpfr_t*) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*(sum.a),prec); mpfr_init2(*(sum.b),prec); mpfr_set_d(*(sum.a),0.,GMP_RNDD); mpfr_set_d(*(sum.b),0.,GMP_RNDU); if (mpfr_equal_p(*(interval.a),*(interval.b))) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_REDUCED_TO_A_POINT_TRIVIAL_RESULT,"Warning: the given interval is reduced to one point.\n"); free_memory(deriv); return sum; } if (mpfr_less_p(*(interval.b),*(interval.a))) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_EMPTY,"Warning: the interval is empty.\n"); free_memory(deriv); return sum; } if ( (!mpfr_number_p(*(interval.a))) || (!mpfr_number_p(*(interval.b))) ) { printMessage(1, SOLLYA_MSG_DOMAIN_IS_NO_CLOSED_INTERVAL_ON_THE_REALS, "Warning: the given domain is not a closed interval on the reals.\n"); mpfr_set_inf(*(sum.a), -1); mpfr_set_inf(*(sum.b), 1); free_memory(deriv); return sum; } mpfr_init2(delta,53); mpfr_sub(delta, *(interval.b), *(interval.a), GMP_RNDN); mpfr_mul(delta, delta, diam, GMP_RNDN); sollya_mpfi_init2(temp,prec); sollya_mpfi_init2(val,prec); mpfr_init2(x1,prec); mpfr_init2(x2,prec); mpfr_set(x1, *(interval.a),GMP_RNDD); mpfr_add(x2, x1, delta, GMP_RNDN); x.a = &x1; x.b = &x2; mpfr_init2(y1,prec); mpfr_init2(y2,prec); y.a = &y1; y.b = &y2; while(mpfr_less_p(x2,*(interval.b))) { evaluateRangeFunctionFast(y, func, deriv, x, prec); sollya_mpfi_set_fr(temp, x1); sollya_mpfi_set_fr(val, x2); sollya_mpfi_sub(temp, val, temp); sollya_mpfi_interv_fr(val, *(y.a), *(y.b)); sollya_mpfi_mul(temp, temp, val); sollya_mpfi_get_left(y1, temp); sollya_mpfi_get_right(y2, temp); mpfr_add(*(sum.a), *(sum.a), y1, GMP_RNDD); mpfr_add(*(sum.b), *(sum.b), y2, GMP_RNDU); mpfr_set(x1,x2,GMP_RNDD); /* exact */ mpfr_add(x2, x1, delta, GMP_RNDN); } mpfr_set(x2,*(interval.b),GMP_RNDU); evaluateRangeFunction(y, func, x, prec); sollya_mpfi_set_fr(temp, x1); sollya_mpfi_set_fr(val, x2); sollya_mpfi_sub(temp, val, temp); sollya_mpfi_interv_fr(val, *(y.a), *(y.b)); sollya_mpfi_mul(temp, temp, val); sollya_mpfi_get_left(y1, temp); sollya_mpfi_get_right(y2, temp); mpfr_add(*(sum.a), *(sum.a), y1, GMP_RNDD); mpfr_add(*(sum.b), *(sum.b), y2, GMP_RNDU); free_memory(deriv); sollya_mpfi_clear(val); sollya_mpfi_clear(temp); mpfr_clear(x1); mpfr_clear(x2); mpfr_clear(y1); mpfr_clear(y2); mpfr_clear(delta); return sum; } void uncertifiedIntegral(mpfr_t result, node *tree, mpfr_t a, mpfr_t b, unsigned long int points, mp_prec_t prec) { mpfr_t sum, temp, x, y1, y2, step; mpfr_init2(step, prec); mpfr_sub(step, b, a, GMP_RNDN); mpfr_div_ui(step, step, points, GMP_RNDN); if (mpfr_sgn(step) == 0) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_REDUCED_TO_A_POINT_WILL_SIMPLY_EVAL,"Warning: the given interval is reduced to one point.\n"); mpfr_set_d(result,0.,GMP_RNDN); mpfr_clear(step); return; } if (mpfr_sgn(step) < 0) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_EMPTY,"Warning: the interval is empty.\n"); mpfr_set_d(result,0.,GMP_RNDN); mpfr_clear(step); return; } if (!mpfr_number_p(step)) { printMessage(1, SOLLYA_MSG_DOMAIN_IS_NO_CLOSED_INTERVAL_ON_THE_REALS, "Warning: the given domain is not a closed interval on the reals.\n"); mpfr_set_nan(result); mpfr_clear(step); return; } mpfr_init2(x, prec); mpfr_init2(y1, prec); mpfr_init2(y2, prec); mpfr_init2(temp, prec); mpfr_init2(sum, prec); mpfr_set_d(sum,0.,GMP_RNDN); mpfr_set(x,a,GMP_RNDN); evaluateFaithful(y1,tree,x,prec); mpfr_add(x,x,step,GMP_RNDU); if (mpfr_greater_p(x,b)) { mpfr_sub(x, x, step, GMP_RNDN); mpfr_sub(step, b, x, GMP_RNDN); mpfr_set(x,b,GMP_RNDN); } evaluateFaithful(y2,tree,x,prec); while(mpfr_lessequal_p(x,b)) { mpfr_add(temp, y1, y2, GMP_RNDN); mpfr_div_2ui(temp, temp, 1, GMP_RNDN); mpfr_mul(temp, temp, step, GMP_RNDN); mpfr_add(sum,sum,temp, GMP_RNDN); mpfr_set(y1, y2, GMP_RNDN); if (mpfr_equal_p(x,b)) break; mpfr_add(x,x,step,GMP_RNDU); if (mpfr_greater_p(x,b)) { mpfr_sub(x, x, step, GMP_RNDN); mpfr_sub(step, b, x, GMP_RNDN); mpfr_set(x,b,GMP_RNDN); } evaluateFaithful(y2,tree,x,prec); } mpfr_set(result,sum,GMP_RNDU); mpfr_clear(x); mpfr_clear(y1); mpfr_clear(y2); mpfr_clear(step); mpfr_clear(sum); mpfr_clear(temp); return; } sollya-6.0+ds/integral.h000066400000000000000000000047221300174114700152450ustar00rootroot00000000000000/* Copyright 2006-2009 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef INTEGRAL_H #define INTEGRAL_H #include #include "expression.h" rangetype integral(node *func, rangetype range, mp_prec_t prec, mpfr_t diam); void uncertifiedIntegral(mpfr_t result, node *tree, mpfr_t a, mpfr_t b, unsigned long int points, mp_prec_t prec); #endif /* ifdef INTEGRAL_H*/ sollya-6.0+ds/internlexer.l000066400000000000000000000655411300174114700160110ustar00rootroot00000000000000/* Copyright 2007-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2) and by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ %{ #include #include #include #include "expression.h" #include "internparser.h" #include "general.h" #include "chain.h" #define YY_NO_UNPUT 1 #define YY_NO_INPUT 1 /* Mess with the mallocs used by the lexer */ extern void *parserCalloc(size_t, size_t); extern void *parserMalloc(size_t); extern void *parserRealloc(void *, size_t); extern void parserFree(void *); #undef malloc #undef realloc #undef calloc #undef free #define malloc parserMalloc #define realloc parserRealloc #define calloc parserCalloc #define free UNUSED_PARAM(yyscanner); parserFree /* End of the malloc mess */ /* Mess with fprintf to use sollyaFprintf instead. */ #undef fprintf #define fprintf UNUSED_PARAM(yyscanner); sollyaFprintf /* End of fprintf mess */ /* Mess with getc... and fread to use sollya_getc, sollya_feof, sollya_ferror, sollya_fwrite and sollya_fread instead. */ #undef getc #undef fread #undef feof #undef ferror #undef fwrite #define getc sollya_getc #define fread sollya_fread #define feof sollya_feof #define ferror sollya_ferror #define fwrite sollya_fwrite /* End of getc, feof, ferror, fwrite and fread mess */ /* const mess */ #if defined(const) #undef const #endif /* End of the const mess */ %} %option noyyalloc noyyrealloc noyyfree %option noyywrap %option always-interactive %option prefix="internyy" %option reentrant %option bison-bridge %option nounput %x commentstate CHAR [a-zA-Z] NUMBER [0-9] HEXNUMBER (([0-9])|([ABCDEFabcdef])) SPECIAL [_$§] ACONSTANT ((({NUMBER}+|({NUMBER}*"."{NUMBER}+))(((((" ")*)(([eE]))([+-])?{NUMBER}+)?)))|("infty"|"nan"|"NAN"|"NaN"|"@Inf@"|"@NaN@")) CONSTANT ({ACONSTANT})|((("%")({NUMBER})({NUMBER}+)("%"))({ACONSTANT})) DYADICCONSTANT ({NUMBER}+)([bB])([+-]?)({NUMBER}+) HEXCONSTANT ("0x")({HEXNUMBER}{16}|{HEXNUMBER}{8}) HEXADECIMALCONSTANT ("0x"|"0X")(({HEXNUMBER}*"."{HEXNUMBER}+)|({HEXNUMBER}+((".")?)))(("p"|"P")(([+-])?)({NUMBER}*)) BINARYCONSTANT (([0-1])+|(([0-1])*"."([0-1])+))"_2" AMIDPOINTCONSTANT (({NUMBER}+|({NUMBER}*"."{NUMBER}+))(("~"({NUMBER})+("/")({NUMBER})+("~")))(((((" ")*)(([eE]))([+-])?{NUMBER}+)?))) MIDPOINTCONSTANT (({AMIDPOINTCONSTANT})|(("-")((" ")*)({AMIDPOINTCONSTANT}))) IDENTIFIER ({CHAR}|{SPECIAL})({CHAR}|{NUMBER}|{SPECIAL})* DOT "." LPAR "(" RPAR ")" LBRACKET "[" RBRACKET "]" PI ("pi")|("Pi") PLUS "+" MINUS "-" APPROX "~" MUL "*" DIV "/" POW "^" SQRT "sqrt" EXP "exp" FREEVAR "_x_" LOG "log" LOG2 "log2" LOG10 "log10" SIN "sin" COS "cos" TAN "tan" ASIN "asin" ACOS "acos" ATAN "atan" SINH "sinh" COSH "cosh" TANH "tanh" ASINH "asinh" ACOSH "acosh" ATANH "atanh" ABS "abs" ERF "erf" ERFC "erfc" LOG1P "log1p" EXPM1 "expm1" EQUAL "=" COMMA "," PREC "prec" POINTS "points" EXCLAMATION "!" DOUBLECOLON "::" COLON ":" DOTCOLON ".:" COLONDOT ":." ASSIGNEQUAL ":=" SEMICOLON ";" QUIT "quit" PRINT "print" SUPPRESSMESSAGE "suppressmessage" UNSUPPRESSMESSAGE "unsuppressmessage" DIFF "diff" DIRTYSIMPLIFY "dirtysimplify" CANONICAL "canonical" PLOT "plot" REMEZ "remez" ANNOTATEFUNCTION "annotatefunction" FPMINIMAX "fpminimax" INFNORM "infnorm" SUPNORM "supnorm" DIAM "diam" DOUBLELONG "double" SINGLELONG "single" QUADLONG "quad" HALFPRECISIONLONG "halfprecision" DOUBLEDOUBLELONG "doubledouble" TRIPLEDOUBLELONG "tripledouble" DOUBLEEXTENDEDLONG "doubleextended" DOUBLESHORT "D" SINGLESHORT "SG" QUADSHORT "QD" HALFPRECISIONSHORT "HP" DOUBLEDOUBLESHORT "DD" TRIPLEDOUBLESHORT "TD" DOUBLEEXTENDEDSHORT "DE" DOUBLE ({DOUBLELONG}|{DOUBLESHORT}) SINGLE ({SINGLELONG}|{SINGLESHORT}) QUAD ({QUADLONG}|{QUADSHORT}) HALFPRECISION ({HALFPRECISIONLONG}|{HALFPRECISIONSHORT}) DOUBLEDOUBLE ({DOUBLEDOUBLELONG}|{DOUBLEDOUBLESHORT}) TRIPLEDOUBLE ({TRIPLEDOUBLELONG}|{TRIPLEDOUBLESHORT}) DOUBLEEXTENDED ({DOUBLEEXTENDEDLONG}|{DOUBLEEXTENDEDSHORT}) HORNER "horner" DEGREE "degree" EXPAND "expand" SIMPLIFYSAFE1 "simplify" SIMPLIFYSAFE2 "simplifysafe" SIMPLIFYSAFE ({SIMPLIFYSAFE1}|{SIMPLIFYSAFE2}) TAYLOR "taylor" TAYLORFORM "taylorform" CHEBYSHEVFORM "chebyshevform" AUTODIFF "autodiff" FINDZEROS "findzeros" FPFINDZEROS "fpfindzeros" DIRTYINFNORM "dirtyinfnorm" NUMBERROOTS "numberroots" EVALUATE "evaluate" NUMERATOR "numerator" DENOMINATOR "denominator" DYADIC "dyadic" DISPLAY "display" ON "on" OFF "off" POWERS "powers" BINARY "binary" HEXADECIMAL "hexadecimal" INTEGRAL "integral" DIRTYINTEGRAL "dirtyintegral" STRINGDELIMITER [\"] OCTALCHAR [01234567] OCTAL ({OCTALCHAR})(({OCTALCHAR})?)(({OCTALCHAR})?) HEXACHAR [0123456789ABCDEFabcdef] HEXA ({HEXACHAR})(({HEXACHAR})?) STRING ({STRINGDELIMITER})((("\\\\")|(("\\")[\"\'\?ntabfrv])|(("\\")({OCTAL}))|(("\\x")({HEXA}))|([^\"\\]))*)({STRINGDELIMITER}) VERBOSITY "verbosity" SHOWMESSAGENUMBERS "showmessagenumbers" WORSTCASE "worstcase" LEFTANGLE "<" RIGHTANGLEUNDERSCORE ">_" RIGHTANGLEDOT ">." RIGHTANGLE ">" STARLEFTANGLE "*<" RIGHTANGLESTAR ">*" COMPAREEQUAL "==" EXCLAMATIONEQUAL "!=" AND "&&" OR "||" SUBSTITUTE "substitute" COMPOSEPOLYNOMIALS "composepolynomials" DOTS "..." IMPLEMENTPOLY "implementpoly" IMPLEMENTCONST "implementconstant" CHECKINFNORM "checkinfnorm" TAYLORRECURSIONS "taylorrecursions" PRINTHEXA ("printhexa"|"printdouble") PRINTFLOAT ("printfloat"|"printsingle") PRINTBINARY "printbinary" ROUNDCOEFFICIENTS "roundcoefficients" RESTART "restart" ZERODENOMINATORS "zerodenominators" ISEVALUABLE "isevaluable" HONORCOEFFPREC "honorcoeffprec" ACCURATEINFNORM "accurateinfnorm" FILE "file" POSTSCRIPT "postscript" POSTSCRIPTFILE "postscriptfile" PRINTEXPANSION "printexpansion" BASHEXECUTE "bashexecute" BASHEVALUATE "bashevaluate" GETSUPPRESSEDMESSAGES "getsuppressedmessages" GETBACKTRACE "getbacktrace" EXTERNALPLOT "externalplot" PERTURB "perturb" COEFF "coeff" SUBPOLY "subpoly" QUESTIONMARK "?" SEARCHGAL "searchgal" RATIONALAPPROX "rationalapprox" READ "read" COMMENTSTART "/*" COMMENTEND "*/" ONELINECOMMENT ("//")([^\n])*"\n" WRITE "write" ASCIIPLOT "asciiplot" ROUNDTOFORMAT "round" MINUSWORD "RD" PLUSWORD "RU" ZEROWORD "RZ" NEAREST "RN" GUESSDEGREE "guessdegree" PARSE "parse" AUTOSIMPLIFY "autosimplify" TIMING "timing" TIME "time" FULLPARENTHESES "fullparentheses" MIDPOINTMODE "midpointmode" DIEONERRORMODE "dieonerrormode" SUPPRESSWARNINGS "roundingwarnings" RATIONALMODE "rationalmode" LIBRARY "library" LIBRARYCONSTANT "libraryconstant" HOPITALRECURSIONS "hopitalrecursions" HELP "help" DIRTYFINDZEROS "dirtyfindzeros" CEIL "ceil" FLOOR "floor" NEARESTINT "nearestint" HEAD "head" TAIL "tail" VERTBAR "|" AT "@" IF "if" THEN "then" ELSE "else" FOR "for" IN "in" FROM "from" TO "to" BY "by" DO "do" BEGIN "begin" END "end" LBRACE "{" RBRACE "}" WHILEDEF "while" TRUE "true" FALSE "false" DEFAULT "default" MATCH "match" WITH "with" RENAME "rename" OBJECTNAME "objectname" BIND "bind" LENGTH "length" ABSOLUTE "absolute" RELATIVE "relative" DECIMAL "decimal" FIXED "fixed" FLOATING "floating" ERROR "error" PRINTXML "printxml" INF "inf" MID "mid" SUP "sup" MIN "min" MAX "max" READXML "readxml" MANTISSA "mantissa" EXPONENT "exponent" PRECISION "precision" REVERT "revert" SORT "sort" READFILE "readfile" ROUNDCORRECTLY "roundcorrectly" EXECUTE "execute" ISBOUND "isbound" EXTERNALPROC "externalproc" VOID "void" CONSTANTTYPE "constant" FUNCTION "function" OBJECT "object" RANGE "range" INTEGER "integer" STRINGTYPE "string" BOOLEAN "boolean" LIST "list" OF "of" VAR "var" PROC "proc" PROCEDURE "procedure" RETURN "return" NOP "nop" %% %{ %} {COMMENTSTART} { BEGIN(commentstate); } {COMMENTEND} { BEGIN(INITIAL); } . { /* Eat up comments */ } [\n] { /* Eat up newlines in comments */ } {ONELINECOMMENT} { /* Eat up comments */ } <> { yyterminate(); } {MIDPOINTCONSTANT} { constBuffer2 = (char *) safeCalloc(yyleng+1,sizeof(char)); if (removeSpaces(constBuffer2,yytext)) { printMessage(2,SOLLYA_MSG_SPACES_REMOVED_FROM_CONSTANT_IN_SCIENTIF_NOTAT,"Information: removed spaces in scientific notation constant \"%s\", it will be considered as \"%s\"\n",yytext,constBuffer2); } yylval->value = constBuffer2; return MIDPOINTCONSTANTTOKEN; } {CONSTANT} { constBuffer2 = (char *) safeCalloc(yyleng+1,sizeof(char)); if (removeSpaces(constBuffer2,yytext)) { printMessage(2,SOLLYA_MSG_SPACES_REMOVED_FROM_CONSTANT_IN_SCIENTIF_NOTAT,"Information: removed spaces in scientific notation constant \"%s\", it will be considered as \"%s\"\n",yytext,constBuffer2); } yylval->value = constBuffer2; return CONSTANTTOKEN; } {DYADICCONSTANT} { constBuffer = (char *) safeCalloc(yyleng+1,sizeof(char)); strncpy(constBuffer,yytext,yyleng); yylval->value = constBuffer; return DYADICCONSTANTTOKEN; } {HEXADECIMALCONSTANT} { constBuffer = (char *) safeCalloc(yyleng+1,sizeof(char)); strncpy(constBuffer,yytext,yyleng); yylval->value = constBuffer; return HEXADECIMALCONSTANTTOKEN; } {HEXCONSTANT} { constBuffer = (char *) safeCalloc(yyleng+1,sizeof(char)); strncpy(constBuffer,yytext,yyleng); yylval->value = constBuffer; return HEXCONSTANTTOKEN; } {BINARYCONSTANT} { constBuffer = (char *) safeCalloc(yyleng-1,sizeof(char)); strncpy(constBuffer,yytext,yyleng-2); yylval->value = constBuffer; return BINARYCONSTANTTOKEN; } {PI} { return PITOKEN; } {STRING} { constBuffer = (char *) safeCalloc(yyleng-1,sizeof(char)); constBuffer2 = (char *) safeCalloc(yyleng-1,sizeof(char)); strncpy(constBuffer2,yytext+1,yyleng-2); demaskString(constBuffer,constBuffer2); safeFree(constBuffer2); yylval->value = constBuffer; return STRINGTOKEN; } {LPAR} { return LPARTOKEN; } {RPAR} { return RPARTOKEN; } {LBRACKET} { return LBRACKETTOKEN; } {RBRACKET} { return RBRACKETTOKEN; } {EXCLAMATIONEQUAL} { return EXCLAMATIONEQUALTOKEN; } {COMPAREEQUAL} { return COMPAREEQUALTOKEN; } {EQUAL} { return EQUALTOKEN; } {ASSIGNEQUAL} { return ASSIGNEQUALTOKEN; } {COMMA} { return COMMATOKEN; } {EXCLAMATION} { return EXCLAMATIONTOKEN; } {SEMICOLON} { return SEMICOLONTOKEN; } {LEFTANGLE} { return LEFTANGLETOKEN; } {STARLEFTANGLE} { return STARLEFTANGLETOKEN; } {RIGHTANGLEUNDERSCORE} { return RIGHTANGLEUNDERSCORETOKEN; } {RIGHTANGLEDOT} { return RIGHTANGLEDOTTOKEN; } {RIGHTANGLESTAR} { return RIGHTANGLESTARTOKEN; } {RIGHTANGLE} { return RIGHTANGLETOKEN; } {DOTS} { return DOTSTOKEN; } {DOT} { return DOTTOKEN; } {QUESTIONMARK} { return QUESTIONMARKTOKEN; } {AND} { return ANDTOKEN; } {OR} { return ORTOKEN; } {VERTBAR} { return VERTBARTOKEN; } {VAR} { return VARTOKEN; } {PROC} { return PROCTOKEN; } {PROCEDURE} { return PROCEDURETOKEN; } {RETURN} { return RETURNTOKEN; } {NOP} { return NOPTOKEN; } {AT} { return ATTOKEN; } {DOUBLECOLON} { return DOUBLECOLONTOKEN; } {COLON} { return COLONTOKEN; } {DOTCOLON} { return DOTCOLONTOKEN; } {COLONDOT} { return COLONDOTTOKEN; } {PLUS} { return PLUSTOKEN; } {MINUS} { return MINUSTOKEN; } {MUL} { return MULTOKEN; } {DIV} { return DIVTOKEN; } {POW} { return POWTOKEN; } {SQRT} { return SQRTTOKEN; } {EXP} { return EXPTOKEN; } {FREEVAR} { return FREEVARTOKEN; } {LOG} { return LOGTOKEN; } {LOG2} { return LOG2TOKEN; } {LOG10} { return LOG10TOKEN; } {SIN} { return SINTOKEN; } {COS} { return COSTOKEN; } {TAN} { return TANTOKEN; } {ASIN} { return ASINTOKEN; } {ACOS} { return ACOSTOKEN; } {ATAN} { return ATANTOKEN; } {SINH} { return SINHTOKEN; } {COSH} { return COSHTOKEN; } {TANH} { return TANHTOKEN; } {ASINH} { return ASINHTOKEN; } {ACOSH} { return ACOSHTOKEN; } {ATANH} { return ATANHTOKEN; } {ABS} { return ABSTOKEN; } {ERF} { return ERFTOKEN; } {ERFC} { return ERFCTOKEN; } {LOG1P} { return LOG1PTOKEN; } {EXPM1} { return EXPM1TOKEN; } {DOUBLE} { return DOUBLETOKEN; } {SINGLE} { return SINGLETOKEN; } {QUAD} { return QUADTOKEN; } {HALFPRECISION} { return HALFPRECISIONTOKEN; } {DOUBLEDOUBLE} { return DOUBLEDOUBLETOKEN; } {TRIPLEDOUBLE} { return TRIPLEDOUBLETOKEN; } {DOUBLEEXTENDED} { return DOUBLEEXTENDEDTOKEN; } {CEIL} { return CEILTOKEN; } {FLOOR} { return FLOORTOKEN; } {NEARESTINT} { return NEARESTINTTOKEN; } {PREC} { return PRECTOKEN; } {POINTS} { return POINTSTOKEN; } {DIAM} { return DIAMTOKEN; } {DISPLAY} { return DISPLAYTOKEN; } {VERBOSITY} { return VERBOSITYTOKEN; } {SHOWMESSAGENUMBERS} { return SHOWMESSAGENUMBERSTOKEN; } {CANONICAL} { return CANONICALTOKEN; } {AUTOSIMPLIFY} { return AUTOSIMPLIFYTOKEN; } {TAYLORRECURSIONS} { return TAYLORRECURSIONSTOKEN; } {TIMING} { return TIMINGTOKEN; } {TIME} { return TIMETOKEN; } {FULLPARENTHESES} { return FULLPARENTHESESTOKEN; } {MIDPOINTMODE} { return MIDPOINTMODETOKEN; } {DIEONERRORMODE} { return DIEONERRORMODETOKEN; } {SUPPRESSWARNINGS} { return SUPPRESSWARNINGSTOKEN; } {RATIONALMODE} { return RATIONALMODETOKEN; } {HOPITALRECURSIONS} { return HOPITALRECURSIONSTOKEN; } {ON} { return ONTOKEN; } {OFF} { return OFFTOKEN; } {DYADIC} { return DYADICTOKEN; } {POWERS} { return POWERSTOKEN; } {BINARY} { return BINARYTOKEN; } {HEXADECIMAL} { return HEXADECIMALTOKEN; } {FILE} { return FILETOKEN; } {POSTSCRIPT} { return POSTSCRIPTTOKEN; } {POSTSCRIPTFILE} { return POSTSCRIPTFILETOKEN; } {PERTURB} { return PERTURBTOKEN; } {MINUSWORD} { return MINUSWORDTOKEN; } {PLUSWORD} { return PLUSWORDTOKEN; } {ZEROWORD} { return ZEROWORDTOKEN; } {NEAREST} { return NEARESTTOKEN; } {HONORCOEFFPREC} { return HONORCOEFFPRECTOKEN; } {TRUE} { return TRUETOKEN; } {FALSE} { return FALSETOKEN; } {DEFAULT} { return DEFAULTTOKEN; } {MATCH} { return MATCHTOKEN; } {WITH} { return WITHTOKEN; } {HEAD} { return HEADTOKEN; } {ROUNDCORRECTLY} { return ROUNDCORRECTLYTOKEN; } {REVERT} { return REVERTTOKEN; } {SORT} { return SORTTOKEN; } {MANTISSA} { return MANTISSATOKEN; } {EXPONENT} { return EXPONENTTOKEN; } {PRECISION} { return PRECISIONTOKEN; } {TAIL} { return TAILTOKEN; } {INF} { return INFTOKEN; } {MID} { return MIDTOKEN; } {SUP} { return SUPTOKEN; } {MIN} { return MINTOKEN; } {MAX} { return MAXTOKEN; } {READXML} { return READXMLTOKEN; } {LENGTH} { return LENGTHTOKEN; } {ABSOLUTE} { return ABSOLUTETOKEN; } {RELATIVE} { return RELATIVETOKEN; } {DECIMAL} { return DECIMALTOKEN; } {FIXED} { return FIXEDTOKEN; } {FLOATING} { return FLOATINGTOKEN; } {ERROR} { return ERRORTOKEN; } {READFILE} { return READFILETOKEN; } {ISBOUND} { return ISBOUNDTOKEN; } {QUIT} { return FALSEQUITTOKEN; } {RESTART} { return FALSERESTARTTOKEN; } {LIBRARY} { return LIBRARYTOKEN; } {LIBRARYCONSTANT} { return LIBRARYCONSTANTTOKEN; } {DIFF} { return DIFFTOKEN; } {DIRTYSIMPLIFY} { return DIRTYSIMPLIFYTOKEN; } {REMEZ} { return REMEZTOKEN; } {ANNOTATEFUNCTION} { return ANNOTATEFUNCTIONTOKEN; } {FPMINIMAX} { return FPMINIMAXTOKEN; } {HORNER} { return HORNERTOKEN; } {EXPAND} { return EXPANDTOKEN; } {SIMPLIFYSAFE} { return SIMPLIFYSAFETOKEN; } {TAYLOR} { return TAYLORTOKEN; } {TAYLORFORM} { return TAYLORFORMTOKEN; } {CHEBYSHEVFORM} { return CHEBYSHEVFORMTOKEN; } {AUTODIFF} { return AUTODIFFTOKEN; } {DEGREE} { return DEGREETOKEN; } {NUMERATOR} { return NUMERATORTOKEN; } {DENOMINATOR} { return DENOMINATORTOKEN; } {SUBSTITUTE} { return SUBSTITUTETOKEN; } {COMPOSEPOLYNOMIALS} { return COMPOSEPOLYNOMIALSTOKEN; } {COEFF} { return COEFFTOKEN; } {SUBPOLY} { return SUBPOLYTOKEN; } {ROUNDCOEFFICIENTS} { return ROUNDCOEFFICIENTSTOKEN; } {RATIONALAPPROX} { return RATIONALAPPROXTOKEN; } {APPROX} { return APPROXTOKEN; } {ACCURATEINFNORM} { return ACCURATEINFNORMTOKEN; } {ROUNDTOFORMAT} { return ROUNDTOFORMATTOKEN; } {EVALUATE} { return EVALUATETOKEN; } {PARSE} { return PARSETOKEN; } {PRINT} { return PRINTTOKEN; } {SUPPRESSMESSAGE} { return SUPPRESSMESSAGETOKEN; } {UNSUPPRESSMESSAGE} { return UNSUPPRESSMESSAGETOKEN; } {PRINTXML} { return PRINTXMLTOKEN; } {EXECUTE} { return EXECUTETOKEN; } {PLOT} { return PLOTTOKEN; } {PRINTHEXA} { return PRINTHEXATOKEN; } {PRINTFLOAT} { return PRINTFLOATTOKEN; } {PRINTBINARY} { return PRINTBINARYTOKEN; } {PRINTEXPANSION} { return PRINTEXPANSIONTOKEN; } {BASHEXECUTE} { return BASHEXECUTETOKEN; } {BASHEVALUATE} { return BASHEVALUATETOKEN; } {GETSUPPRESSEDMESSAGES} { return GETSUPPRESSEDMESSAGESTOKEN; } {GETBACKTRACE} { return GETBACKTRACETOKEN; } {EXTERNALPLOT} { return EXTERNALPLOTTOKEN; } {WRITE} { return WRITETOKEN; } {ASCIIPLOT} { return ASCIIPLOTTOKEN; } {RENAME} { return RENAMETOKEN; } {OBJECTNAME} { return OBJECTNAMETOKEN; } {BIND} { return BINDTOKEN; } {INFNORM} { return INFNORMTOKEN; } {SUPNORM} { return SUPNORMTOKEN; } {FINDZEROS} { return FINDZEROSTOKEN; } {FPFINDZEROS} { return FPFINDZEROSTOKEN; } {DIRTYINFNORM} { return DIRTYINFNORMTOKEN; } {NUMBERROOTS} { return NUMBERROOTSTOKEN; } {INTEGRAL} { return INTEGRALTOKEN; } {DIRTYINTEGRAL} { return DIRTYINTEGRALTOKEN; } {WORSTCASE} { return WORSTCASETOKEN; } {IMPLEMENTPOLY} { return IMPLEMENTPOLYTOKEN; } {IMPLEMENTCONST} { return IMPLEMENTCONSTTOKEN; } {CHECKINFNORM} { return CHECKINFNORMTOKEN; } {ZERODENOMINATORS} { return ZERODENOMINATORSTOKEN; } {ISEVALUABLE} { return ISEVALUABLETOKEN; } {SEARCHGAL} { return SEARCHGALTOKEN; } {GUESSDEGREE} { return GUESSDEGREETOKEN; } {DIRTYFINDZEROS} { return DIRTYFINDZEROSTOKEN; } {IF} { return IFTOKEN; } {THEN} { return THENTOKEN; } {ELSE} { return ELSETOKEN; } {FOR} { return FORTOKEN; } {IN} { return INTOKEN; } {FROM} { return FROMTOKEN; } {TO} { return TOTOKEN; } {BY} { return BYTOKEN; } {DO} { return DOTOKEN; } {BEGIN} { return BEGINTOKEN; } {END} { return ENDTOKEN; } {LBRACE} { return LEFTCURLYBRACETOKEN; } {RBRACE} { return RIGHTCURLYBRACETOKEN; } {WHILEDEF} { return WHILETOKEN; } {EXTERNALPROC} { return EXTERNALPROCTOKEN; } {VOID} { return VOIDTOKEN; } {CONSTANTTYPE} { return CONSTANTTYPETOKEN; } {FUNCTION} { return FUNCTIONTOKEN; } {OBJECT} { return OBJECTTOKEN; } {RANGE} { return RANGETOKEN; } {INTEGER} { return INTEGERTOKEN; } {STRINGTYPE} { return STRINGTYPETOKEN; } {BOOLEAN} { return BOOLEANTOKEN; } {LIST} { return LISTTOKEN; } {OF} { return OFTOKEN; } [ \t] { /* Eat up spaces and tabulators */ } [\r] { /* Eat up carriage return for compatibility with DOS-like systems */ } [\n] { } {IDENTIFIER} { constBuffer = (char *) safeCalloc(yyleng+1,sizeof(char)); strncpy(constBuffer,yytext,yyleng); yylval->value = constBuffer; return IDENTIFIERTOKEN; } . { /* otherwise */ printMessage(1,SOLLYA_MSG_A_CHARACTER_COULD_NOT_BE_RECOGNIZED,"The character \"%s\" cannot be recognized. Will ignore it.\n", yytext); } %% void *yyalloc (yy_size_t size , yyscan_t yyscanner) { UNUSED_PARAM(yyscanner); return (void *) malloc( size ); } void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) { /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter * because both ANSI C and C++ allow castless assignment from * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ UNUSED_PARAM(yyscanner); return (void *) realloc( (char *) ptr, size ); } void yyfree (void * ptr , yyscan_t yyscanner) { UNUSED_PARAM(yyscanner); free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } sollya-6.0+ds/internparser.y000066400000000000000000002110521300174114700161710ustar00rootroot00000000000000/* Copyright 2007-2014 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2) and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ %{ #include #include #include #include #include "expression.h" #include "assignment.h" #include "chain.h" #include "general.h" #include "execute.h" #include "internparser.h" /* Mess with the mallocs used by the parser */ extern void *parserCalloc(size_t, size_t); extern void *parserMalloc(size_t); extern void *parserRealloc(void *, size_t); extern void parserFree(void *); #undef malloc #undef realloc #undef calloc #undef free #define malloc parserMalloc #define realloc parserRealloc #define calloc parserCalloc #define free parserFree /* End of the malloc mess */ #define YYERROR_VERBOSE 1 #define YYFPRINTF sollyaFprintf extern int internyylex(YYSTYPE *lvalp, void *scanner); extern FILE *internyyget_in(void *scanner); void internyyerror(void *myScanner, const char *message) { if (!feof(internyyget_in(myScanner))) { printMessage(1,SOLLYA_MSG_SYNTAX_ERROR_ENCOUNTERED_WHILE_PARSING,"Warning: %s.\nWill skip input until next semicolon after the unexpected token. May leak memory.\n",message); considerDyingOnError(); } } %} %parse-param {void *myScanner} %lex-param {void *myScanner} %defines %name-prefix "internyy" %expect 2 %pure-parser %union { doubleNode *dblnode; struct entryStruct *association; char *value; node *tree; chain *list; int *integerval; int count; void *other; }; %token CONSTANTTOKEN "decimal constant" %token MIDPOINTCONSTANTTOKEN "interval" %token DYADICCONSTANTTOKEN "dyadic constant" %token HEXCONSTANTTOKEN "constant in memory notation" %token HEXADECIMALCONSTANTTOKEN "hexadecimal constant" %token BINARYCONSTANTTOKEN "binary constant" %token PITOKEN "pi" %token IDENTIFIERTOKEN "identifier" %token STRINGTOKEN "character string" %token LPARTOKEN "(" %token RPARTOKEN ")" %token LBRACKETTOKEN "[" %token RBRACKETTOKEN "]" %token EQUALTOKEN "=" %token ASSIGNEQUALTOKEN ":=" %token COMPAREEQUALTOKEN "==" %token COMMATOKEN "," %token EXCLAMATIONTOKEN "!" %token SEMICOLONTOKEN ";" %token STARLEFTANGLETOKEN "*<" %token LEFTANGLETOKEN "<" %token RIGHTANGLEUNDERSCORETOKEN ">_" %token RIGHTANGLEDOTTOKEN ">." %token RIGHTANGLESTARTOKEN ">*" %token RIGHTANGLETOKEN ">" %token DOTSTOKEN "..." %token DOTTOKEN "." %token QUESTIONMARKTOKEN "?" %token VERTBARTOKEN "|" %token ATTOKEN "@" %token DOUBLECOLONTOKEN "::" %token COLONTOKEN ":" %token DOTCOLONTOKEN ".:" %token COLONDOTTOKEN ":." %token EXCLAMATIONEQUALTOKEN "!=" %token APPROXTOKEN "~" %token ANDTOKEN "&&" %token ORTOKEN "||" %token PLUSTOKEN "+" %token MINUSTOKEN "-" %token MULTOKEN "*" %token DIVTOKEN "/" %token POWTOKEN "^" %token SQRTTOKEN "sqrt" %token EXPTOKEN "exp" %token FREEVARTOKEN "_x_" %token LOGTOKEN "log" %token LOG2TOKEN "log2" %token LOG10TOKEN "log10" %token SINTOKEN "sin" %token COSTOKEN "cos" %token TANTOKEN "tan" %token ASINTOKEN "asin" %token ACOSTOKEN "acos" %token ATANTOKEN "atan" %token SINHTOKEN "sinh" %token COSHTOKEN "cosh" %token TANHTOKEN "tanh" %token ASINHTOKEN "asinh" %token ACOSHTOKEN "acosh" %token ATANHTOKEN "atanh" %token ABSTOKEN "abs" %token ERFTOKEN "erf" %token ERFCTOKEN "erfc" %token LOG1PTOKEN "log1p" %token EXPM1TOKEN "expm1" %token DOUBLETOKEN "D" %token SINGLETOKEN "SG" %token HALFPRECISIONTOKEN "HP" %token QUADTOKEN "QD" %token DOUBLEDOUBLETOKEN "DD" %token TRIPLEDOUBLETOKEN "TD" %token DOUBLEEXTENDEDTOKEN "DE" %token CEILTOKEN "ceil" %token FLOORTOKEN "floor" %token NEARESTINTTOKEN "nearestint" %token HEADTOKEN "head" %token REVERTTOKEN "revert" %token SORTTOKEN "sort" %token TAILTOKEN "tail" %token MANTISSATOKEN "mantissa" %token EXPONENTTOKEN "exponent" %token PRECISIONTOKEN "precision" %token ROUNDCORRECTLYTOKEN "roundcorrectly" %token PRECTOKEN "prec" %token POINTSTOKEN "points" %token DIAMTOKEN "diam" %token DISPLAYTOKEN "display" %token VERBOSITYTOKEN "verbosity" %token SHOWMESSAGENUMBERSTOKEN "showmessagenumbers" %token CANONICALTOKEN "canonical" %token AUTOSIMPLIFYTOKEN "autosimplify" %token TAYLORRECURSIONSTOKEN "taylorrecursions" %token TIMINGTOKEN "timing" %token TIMETOKEN "time" %token FULLPARENTHESESTOKEN "fullparentheses" %token MIDPOINTMODETOKEN "midpointmode" %token DIEONERRORMODETOKEN "dieonerrormode" %token SUPPRESSWARNINGSTOKEN "roundingwarnings" %token RATIONALMODETOKEN "rationalmode" %token HOPITALRECURSIONSTOKEN "hopitalrecursions" %token ONTOKEN "on" %token OFFTOKEN "off" %token DYADICTOKEN "dyadic" %token POWERSTOKEN "powers" %token BINARYTOKEN "binary" %token HEXADECIMALTOKEN "hexadecimal" %token FILETOKEN "file" %token POSTSCRIPTTOKEN "postscript" %token POSTSCRIPTFILETOKEN "postscriptfile" %token PERTURBTOKEN "perturb" %token MINUSWORDTOKEN "RD" %token PLUSWORDTOKEN "RU" %token ZEROWORDTOKEN "RZ" %token NEARESTTOKEN "RN" %token HONORCOEFFPRECTOKEN "honorcoeffprec" %token TRUETOKEN "true" %token FALSETOKEN "false" %token DEFAULTTOKEN "default" %token MATCHTOKEN "match" %token WITHTOKEN "with" %token ABSOLUTETOKEN "absolute" %token DECIMALTOKEN "decimal" %token RELATIVETOKEN "relative" %token FIXEDTOKEN "fixed" %token FLOATINGTOKEN "floating" %token ERRORTOKEN "error" %token QUITTOKEN "quit" %token FALSEQUITTOKEN "quit in an included file" %token FALSERESTARTTOKEN "restart" %token LIBRARYTOKEN "library" %token LIBRARYCONSTANTTOKEN "libraryconstant" %token DIFFTOKEN "diff" %token DIRTYSIMPLIFYTOKEN "dirtysimplify" %token REMEZTOKEN "remez" %token ANNOTATEFUNCTIONTOKEN "annotatefunction" %token BASHEVALUATETOKEN "bashevaluate" %token GETSUPPRESSEDMESSAGESTOKEN "getsuppressedmessages" %token GETBACKTRACETOKEN "getbacktrace" %token FPMINIMAXTOKEN "fpminimax" %token HORNERTOKEN "horner" %token EXPANDTOKEN "expand" %token SIMPLIFYSAFETOKEN "simplify" %token TAYLORTOKEN "taylor" %token TAYLORFORMTOKEN "taylorform" %token CHEBYSHEVFORMTOKEN "chebyshevform" %token AUTODIFFTOKEN "autodiff" %token DEGREETOKEN "degree" %token NUMERATORTOKEN "numerator" %token DENOMINATORTOKEN "denominator" %token SUBSTITUTETOKEN "substitute" %token COMPOSEPOLYNOMIALSTOKEN "composepolynomials" %token COEFFTOKEN "coeff" %token SUBPOLYTOKEN "subpoly" %token ROUNDCOEFFICIENTSTOKEN "roundcoefficients" %token RATIONALAPPROXTOKEN "rationalapprox" %token ACCURATEINFNORMTOKEN "accurateinfnorm" %token ROUNDTOFORMATTOKEN "round" %token EVALUATETOKEN "evaluate" %token LENGTHTOKEN "length" %token OBJECTNAMETOKEN "objectname" %token INFTOKEN "inf" %token MIDTOKEN "mid" %token SUPTOKEN "sup" %token MINTOKEN "min" %token MAXTOKEN "max" %token READXMLTOKEN "read" %token PARSETOKEN "parse" %token PRINTTOKEN "print" %token PRINTXMLTOKEN "printxml" %token PLOTTOKEN "plot" %token PRINTHEXATOKEN "printhexa" %token PRINTFLOATTOKEN "printfloat" %token PRINTBINARYTOKEN "printbinary" %token SUPPRESSMESSAGETOKEN "suppressmessage" %token UNSUPPRESSMESSAGETOKEN "unsuppressmessage" %token PRINTEXPANSIONTOKEN "printexpansion" %token BASHEXECUTETOKEN "bashexecute" %token EXTERNALPLOTTOKEN "externalplot" %token WRITETOKEN "write" %token ASCIIPLOTTOKEN "asciiplot" %token RENAMETOKEN "rename" %token BINDTOKEN "bind" %token INFNORMTOKEN "infnorm" %token SUPNORMTOKEN "supnorm" %token FINDZEROSTOKEN "findzeros" %token FPFINDZEROSTOKEN "fpfindzeros" %token DIRTYINFNORMTOKEN "dirtyinfnorm" %token NUMBERROOTSTOKEN "numberroots" %token INTEGRALTOKEN "integral" %token DIRTYINTEGRALTOKEN "dirtyintegral" %token WORSTCASETOKEN "worstcase" %token IMPLEMENTPOLYTOKEN "implementpoly" %token IMPLEMENTCONSTTOKEN "implementconst" %token CHECKINFNORMTOKEN "checkinfnorm" %token ZERODENOMINATORSTOKEN "zerodenominators" %token ISEVALUABLETOKEN "isevaluable" %token SEARCHGALTOKEN "searchgal" %token GUESSDEGREETOKEN "guessdegree" %token DIRTYFINDZEROSTOKEN "dirtyfindzeros" %token IFTOKEN "if" %token THENTOKEN "then" %token ELSETOKEN "else" %token FORTOKEN "for" %token INTOKEN "in" %token FROMTOKEN "from" %token TOTOKEN "to" %token BYTOKEN "by" %token DOTOKEN "do" %token BEGINTOKEN "begin" %token ENDTOKEN "end" %token LEFTCURLYBRACETOKEN "{" %token RIGHTCURLYBRACETOKEN "}" %token WHILETOKEN "while" %token READFILETOKEN "readfile" %token ISBOUNDTOKEN "isbound" %token EXECUTETOKEN "execute" %token EXTERNALPROCTOKEN "externalproc" %token VOIDTOKEN "void" %token CONSTANTTYPETOKEN "constant" %token FUNCTIONTOKEN "function" %token OBJECTTOKEN "object" %token RANGETOKEN "range" %token INTEGERTOKEN "integer" %token STRINGTYPETOKEN "string" %token BOOLEANTOKEN "boolean" %token LISTTOKEN "list" %token OFTOKEN "of" %token VARTOKEN "var" %token PROCTOKEN "proc" %token PROCEDURETOKEN "procedure" %token RETURNTOKEN "return" %token NOPTOKEN "nop" %type startsymbol; %type egalquestionmark; %type unaryplusminus; %type startsymbolwitherr; %type command; %type procbody; %type variabledeclaration; %type simplecommand; %type commandlist; %type variabledeclarationlist; %type identifierlist; %type thing; %type supermegaterm; %type thinglist; %type matchlist; %type matchelement; %type structelementlist; %type structelement; %type structelementseparator; %type structuring; %type ifcommand; %type forcommand; %type assignment; %type simpleassignment; %type stateassignment; %type stillstateassignment; %type basicthing; %type list; %type constant; %type simplelist; %type range; %type debound; %type headfunction; %type term; %type hyperterm; %type subterm; %type megaterm; %type statedereference; %type indexing; %type externalproctype; %type extendedexternalproctype; %type externalproctypesimplelist; %type externalproctypelist; %type beginsymbol; %type endsymbol; %% startsymbol: startsymbolwitherr { parsedThingIntern = $1; $$ = NULL; YYACCEPT; } ; startsymbolwitherr: command SEMICOLONTOKEN { $$ = $1; } | error SEMICOLONTOKEN { $$ = NULL; } ; beginsymbol: BEGINTOKEN { $$ = NULL; } | LEFTCURLYBRACETOKEN { $$ = NULL; } ; endsymbol: ENDTOKEN { $$ = NULL; } | RIGHTCURLYBRACETOKEN { $$ = NULL; } ; command: simplecommand { $$ = $1; } | beginsymbol commandlist endsymbol { $$ = makeCommandList($2); } | beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeCommandList(concatChains($2, $3)); } | beginsymbol variabledeclarationlist endsymbol { $$ = makeCommandList($2); } | beginsymbol endsymbol { $$ = makeNop(); } | IFTOKEN ifcommand { $$ = $2; } | WHILETOKEN thing DOTOKEN command { $$ = makeWhile($2, $4); } | FORTOKEN forcommand { $$ = $2; } ; ifcommand: thing THENTOKEN command { $$ = makeIf($1, $3); } | thing THENTOKEN command ELSETOKEN command { $$ = makeIfElse($1,$3,$5); } ; forcommand: IDENTIFIERTOKEN FROMTOKEN thing TOTOKEN thing DOTOKEN command { $$ = makeFor($1, $3, $5, makeConstantDouble(1.0), $7); safeFree($1); } | IDENTIFIERTOKEN FROMTOKEN thing TOTOKEN thing BYTOKEN thing DOTOKEN command { $$ = makeFor($1, $3, $5, $7, $9); safeFree($1); } | IDENTIFIERTOKEN INTOKEN thing DOTOKEN command { $$ = makeForIn($1, $3, $5); safeFree($1); } ; commandlist: command SEMICOLONTOKEN { $$ = addElement(NULL, $1); } | command SEMICOLONTOKEN commandlist { $$ = addElement($3, $1); } ; variabledeclarationlist: variabledeclaration SEMICOLONTOKEN { $$ = addElement(NULL, $1); } | variabledeclaration SEMICOLONTOKEN variabledeclarationlist { $$ = addElement($3, $1); } ; variabledeclaration: VARTOKEN identifierlist { $$ = makeVariableDeclaration($2); } ; identifierlist: IDENTIFIERTOKEN { $$ = addElement(NULL, $1); } | IDENTIFIERTOKEN COMMATOKEN identifierlist { $$ = addElement($3, $1); } ; procbody: LPARTOKEN RPARTOKEN beginsymbol commandlist endsymbol { $$ = makeProc(NULL, makeCommandList($4), makeUnit()); } | LPARTOKEN RPARTOKEN beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeProc(NULL, makeCommandList(concatChains($4, $5)), makeUnit()); } | LPARTOKEN RPARTOKEN beginsymbol variabledeclarationlist endsymbol { $$ = makeProc(NULL, makeCommandList($4), makeUnit()); } | LPARTOKEN RPARTOKEN beginsymbol endsymbol { $$ = makeProc(NULL, makeCommandList(addElement(NULL,makeNop())), makeUnit()); } | LPARTOKEN RPARTOKEN beginsymbol commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc(NULL, makeCommandList($4), $6); } | LPARTOKEN RPARTOKEN beginsymbol variabledeclarationlist commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc(NULL, makeCommandList(concatChains($4, $5)), $7); } | LPARTOKEN RPARTOKEN beginsymbol variabledeclarationlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc(NULL, makeCommandList($4), $6); } | LPARTOKEN RPARTOKEN beginsymbol RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc(NULL, makeCommandList(addElement(NULL,makeNop())), $5); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol commandlist endsymbol { $$ = makeProc($2, makeCommandList($5), makeUnit()); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeProc($2, makeCommandList(concatChains($5, $6)), makeUnit()); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol variabledeclarationlist endsymbol { $$ = makeProc($2, makeCommandList($5), makeUnit()); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol endsymbol { $$ = makeProc($2, makeCommandList(addElement(NULL,makeNop())), makeUnit()); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc($2, makeCommandList($5), $7); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol variabledeclarationlist commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc($2, makeCommandList(concatChains($5, $6)), $8); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol variabledeclarationlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc($2, makeCommandList($5), $7); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc($2, makeCommandList(addElement(NULL, makeNop())), $6); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol commandlist endsymbol { $$ = makeProcIllim($2, makeCommandList($7), makeUnit()); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeProcIllim($2, makeCommandList(concatChains($7, $8)), makeUnit()); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol variabledeclarationlist endsymbol { $$ = makeProcIllim($2, makeCommandList($7), makeUnit()); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol endsymbol { $$ = makeProcIllim($2, makeCommandList(addElement(NULL,makeNop())), makeUnit()); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProcIllim($2, makeCommandList($7), $9); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol variabledeclarationlist commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProcIllim($2, makeCommandList(concatChains($7, $8)), $10); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol variabledeclarationlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProcIllim($2, makeCommandList($7), $9); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProcIllim($2, makeCommandList(addElement(NULL, makeNop())), $8); } ; simplecommand: FALSEQUITTOKEN { $$ = makeQuit(); } | FALSERESTARTTOKEN { $$ = makeFalseRestart(); } | NOPTOKEN { $$ = makeNop(); } | NOPTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeNopArg($3); } | NOPTOKEN LPARTOKEN RPARTOKEN { $$ = makeNopArg(makeDefault()); } | PRINTTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makePrint($3); } | PRINTTOKEN LPARTOKEN thinglist RPARTOKEN RIGHTANGLETOKEN thing { $$ = makeNewFilePrint($6, $3); } | PRINTTOKEN LPARTOKEN thinglist RPARTOKEN RIGHTANGLETOKEN RIGHTANGLETOKEN thing { $$ = makeAppendFilePrint($7, $3); } | PLOTTOKEN LPARTOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makePlot(addElement($5, $3)); } | PRINTHEXATOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintHexa($3); } | PRINTFLOATTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintFloat($3); } | PRINTBINARYTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintBinary($3); } | SUPPRESSMESSAGETOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeSuppressMessage($3); } | UNSUPPRESSMESSAGETOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeUnsuppressMessage($3); } | PRINTEXPANSIONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintExpansion($3); } | BASHEXECUTETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeBashExecute($3); } | EXTERNALPLOTTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeExternalPlot(addElement(addElement(addElement(addElement($11,$9),$7),$5),$3)); } | WRITETOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeWrite($3); } | WRITETOKEN LPARTOKEN thinglist RPARTOKEN RIGHTANGLETOKEN thing { $$ = makeNewFileWrite($6, $3); } | WRITETOKEN LPARTOKEN thinglist RPARTOKEN RIGHTANGLETOKEN RIGHTANGLETOKEN thing { $$ = makeAppendFileWrite($7, $3); } | ASCIIPLOTTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeAsciiPlot($3, $5); } | PRINTXMLTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintXml($3); } | EXECUTETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExecute($3); } | PRINTXMLTOKEN LPARTOKEN thing RPARTOKEN RIGHTANGLETOKEN thing { $$ = makePrintXmlNewFile($3,$6); } | PRINTXMLTOKEN LPARTOKEN thing RPARTOKEN RIGHTANGLETOKEN RIGHTANGLETOKEN thing { $$ = makePrintXmlAppendFile($3,$7); } | WORSTCASETOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeWorstCase(addElement(addElement(addElement(addElement($11, $9), $7), $5), $3)); } | RENAMETOKEN LPARTOKEN IDENTIFIERTOKEN COMMATOKEN IDENTIFIERTOKEN RPARTOKEN { $$ = makeRename($3, $5); safeFree($3); safeFree($5); } | RENAMETOKEN LPARTOKEN FREEVARTOKEN COMMATOKEN IDENTIFIERTOKEN RPARTOKEN { $$ = makeRename("_x_", $5); safeFree($5); } | EXTERNALPROCTOKEN LPARTOKEN IDENTIFIERTOKEN COMMATOKEN thing COMMATOKEN externalproctypelist MINUSTOKEN RIGHTANGLETOKEN extendedexternalproctype RPARTOKEN { $$ = makeExternalProc($3, $5, addElement($7, $10)); safeFree($3); } | assignment { $$ = $1; } | thinglist { $$ = makeAutoprint($1); } | PROCEDURETOKEN IDENTIFIERTOKEN procbody { $$ = makeAssignment($2, $3); safeFree($2); } ; assignment: stateassignment { $$ = $1; } | stillstateassignment EXCLAMATIONTOKEN { $$ = $1; } | simpleassignment { $$ = $1; } | simpleassignment EXCLAMATIONTOKEN { $$ = $1; } ; simpleassignment: IDENTIFIERTOKEN EQUALTOKEN thing { $$ = makeAssignment($1, $3); safeFree($1); } | IDENTIFIERTOKEN ASSIGNEQUALTOKEN thing { $$ = makeFloatAssignment($1, $3); safeFree($1); } | IDENTIFIERTOKEN EQUALTOKEN LIBRARYTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLibraryBinding($1, $5); safeFree($1); } | IDENTIFIERTOKEN EQUALTOKEN LIBRARYCONSTANTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLibraryConstantBinding($1, $5); safeFree($1); } | indexing EQUALTOKEN thing { $$ = makeAssignmentInIndexing($1->a,$1->b,$3); safeFree($1); } | indexing ASSIGNEQUALTOKEN thing { $$ = makeFloatAssignmentInIndexing($1->a,$1->b,$3); safeFree($1); } | structuring EQUALTOKEN thing { $$ = makeProtoAssignmentInStructure($1,$3); } | structuring ASSIGNEQUALTOKEN thing { $$ = makeProtoFloatAssignmentInStructure($1,$3); } ; structuring: basicthing DOTTOKEN IDENTIFIERTOKEN { $$ = makeStructAccess($1,$3); safeFree($3); } ; stateassignment: PRECTOKEN EQUALTOKEN thing { $$ = makePrecAssign($3); } | POINTSTOKEN EQUALTOKEN thing { $$ = makePointsAssign($3); } | DIAMTOKEN EQUALTOKEN thing { $$ = makeDiamAssign($3); } | DISPLAYTOKEN EQUALTOKEN thing { $$ = makeDisplayAssign($3); } | VERBOSITYTOKEN EQUALTOKEN thing { $$ = makeVerbosityAssign($3); } | SHOWMESSAGENUMBERSTOKEN EQUALTOKEN thing { $$ = makeShowMessageNumbersAssign($3); } | CANONICALTOKEN EQUALTOKEN thing { $$ = makeCanonicalAssign($3); } | AUTOSIMPLIFYTOKEN EQUALTOKEN thing { $$ = makeAutoSimplifyAssign($3); } | TAYLORRECURSIONSTOKEN EQUALTOKEN thing { $$ = makeTaylorRecursAssign($3); } | TIMINGTOKEN EQUALTOKEN thing { $$ = makeTimingAssign($3); } | FULLPARENTHESESTOKEN EQUALTOKEN thing { $$ = makeFullParenAssign($3); } | MIDPOINTMODETOKEN EQUALTOKEN thing { $$ = makeMidpointAssign($3); } | DIEONERRORMODETOKEN EQUALTOKEN thing { $$ = makeDieOnErrorAssign($3); } | RATIONALMODETOKEN EQUALTOKEN thing { $$ = makeRationalModeAssign($3); } | SUPPRESSWARNINGSTOKEN EQUALTOKEN thing { $$ = makeSuppressWarningsAssign($3); } | HOPITALRECURSIONSTOKEN EQUALTOKEN thing { $$ = makeHopitalRecursAssign($3); } ; stillstateassignment: PRECTOKEN EQUALTOKEN thing { $$ = makePrecStillAssign($3); } | POINTSTOKEN EQUALTOKEN thing { $$ = makePointsStillAssign($3); } | DIAMTOKEN EQUALTOKEN thing { $$ = makeDiamStillAssign($3); } | DISPLAYTOKEN EQUALTOKEN thing { $$ = makeDisplayStillAssign($3); } | VERBOSITYTOKEN EQUALTOKEN thing { $$ = makeVerbosityStillAssign($3); } | SHOWMESSAGENUMBERSTOKEN EQUALTOKEN thing { $$ = makeShowMessageNumbersStillAssign($3); } | CANONICALTOKEN EQUALTOKEN thing { $$ = makeCanonicalStillAssign($3); } | AUTOSIMPLIFYTOKEN EQUALTOKEN thing { $$ = makeAutoSimplifyStillAssign($3); } | TAYLORRECURSIONSTOKEN EQUALTOKEN thing { $$ = makeTaylorRecursStillAssign($3); } | TIMINGTOKEN EQUALTOKEN thing { $$ = makeTimingStillAssign($3); } | FULLPARENTHESESTOKEN EQUALTOKEN thing { $$ = makeFullParenStillAssign($3); } | MIDPOINTMODETOKEN EQUALTOKEN thing { $$ = makeMidpointStillAssign($3); } | DIEONERRORMODETOKEN EQUALTOKEN thing { $$ = makeDieOnErrorStillAssign($3); } | RATIONALMODETOKEN EQUALTOKEN thing { $$ = makeRationalModeStillAssign($3); } | SUPPRESSWARNINGSTOKEN EQUALTOKEN thing { $$ = makeSuppressWarningsStillAssign($3); } | HOPITALRECURSIONSTOKEN EQUALTOKEN thing { $$ = makeHopitalRecursStillAssign($3); } ; thinglist: thing { $$ = addElement(NULL, $1); } | thing COMMATOKEN thinglist { $$ = addElement($3, $1); } ; structelementlist: structelement { $$ = addElement(NULL, $1); } | structelement structelementseparator structelementlist { $$ = addElement($3, $1); } ; structelementseparator: COMMATOKEN { $$ = NULL; } | SEMICOLONTOKEN { $$ = NULL; } ; structelement: DOTTOKEN IDENTIFIERTOKEN EQUALTOKEN thing { $$ = (entry *) safeMalloc(sizeof(entry)); $$->name = (char *) safeCalloc(strlen($2) + 1, sizeof(char)); strcpy($$->name,$2); safeFree($2); $$->value = (void *) ($4); } ; thing: supermegaterm { $$ = $1; } | MATCHTOKEN supermegaterm WITHTOKEN matchlist { $$ = makeMatch($2,$4); } ; supermegaterm: megaterm { $$ = $1; } | thing ANDTOKEN megaterm { $$ = makeAnd($1, $3); } | thing ORTOKEN megaterm { $$ = makeOr($1, $3); } | EXCLAMATIONTOKEN megaterm { $$ = makeNegation($2); } ; indexing: basicthing LBRACKETTOKEN thing RBRACKETTOKEN { $$ = (doubleNode *) safeMalloc(sizeof(doubleNode)); $$->a = $1; $$->b = $3; } ; megaterm: hyperterm { $$ = $1; } | megaterm COMPAREEQUALTOKEN hyperterm { $$ = makeCompareEqual($1, $3); } | megaterm INTOKEN hyperterm { $$ = makeCompareIn($1, $3); } | megaterm LEFTANGLETOKEN hyperterm { $$ = makeCompareLess($1, $3); } | megaterm RIGHTANGLETOKEN hyperterm { $$ = makeCompareGreater($1, $3); } | megaterm LEFTANGLETOKEN EQUALTOKEN hyperterm { $$ = makeCompareLessEqual($1, $4); } | megaterm RIGHTANGLETOKEN EQUALTOKEN hyperterm { $$ = makeCompareGreaterEqual($1, $4); } | megaterm EXCLAMATIONEQUALTOKEN hyperterm { $$ = makeCompareNotEqual($1, $3); } ; hyperterm: term { $$ = $1; } | hyperterm PLUSTOKEN term { $$ = makeAdd($1, $3); } | hyperterm MINUSTOKEN term { $$ = makeSub($1, $3); } | hyperterm ATTOKEN term { $$ = makeConcat($1, $3); } | hyperterm DOUBLECOLONTOKEN term { $$ = makeAddToList($1, $3); } | hyperterm COLONDOTTOKEN term { $$ = makeAppend($1, $3); } ; unaryplusminus: PLUSTOKEN { $$ = 0; } | MINUSTOKEN { $$ = 1; } | PLUSTOKEN unaryplusminus { $$ = $2; } | MINUSTOKEN unaryplusminus { $$ = $2+1; } ; term: subterm { $$ = $1; } | unaryplusminus subterm { tempNode = $2; for (tempInteger=0;tempInteger<$1;tempInteger++) tempNode = makeNeg(tempNode); $$ = tempNode; } | APPROXTOKEN subterm { $$ = makeEvalConst($2); } | term MULTOKEN subterm { $$ = makeMul($1, $3); } | term DIVTOKEN subterm { $$ = makeDiv($1, $3); } | term MULTOKEN unaryplusminus subterm { tempNode = $4; for (tempInteger=0;tempInteger<$3;tempInteger++) tempNode = makeNeg(tempNode); $$ = makeMul($1, tempNode); } | term DIVTOKEN unaryplusminus subterm { tempNode = $4; for (tempInteger=0;tempInteger<$3;tempInteger++) tempNode = makeNeg(tempNode); $$ = makeDiv($1, tempNode); } | term MULTOKEN APPROXTOKEN subterm { $$ = makeMul($1, makeEvalConst($4)); } | term DIVTOKEN APPROXTOKEN subterm { $$ = makeDiv($1, makeEvalConst($4)); } ; subterm: basicthing { $$ = $1; } | basicthing POWTOKEN subterm { $$ = makePow($1, $3); } | basicthing POWTOKEN unaryplusminus subterm { tempNode = $4; for (tempInteger=0;tempInteger<$3;tempInteger++) tempNode = makeNeg(tempNode); $$ = makePow($1, tempNode); } | basicthing POWTOKEN APPROXTOKEN subterm { $$ = makePow($1, makeEvalConst($4)); } | basicthing DOTCOLONTOKEN subterm { $$ = makePrepend($1, $3); } | basicthing DOTCOLONTOKEN APPROXTOKEN subterm { $$ = makePrepend($1, makeEvalConst($4)); } ; basicthing: ONTOKEN { $$ = makeOn(); } | OFFTOKEN { $$ = makeOff(); } | DYADICTOKEN { $$ = makeDyadic(); } | POWERSTOKEN { $$ = makePowers(); } | BINARYTOKEN { $$ = makeBinaryThing(); } | HEXADECIMALTOKEN { $$ = makeHexadecimalThing(); } | FILETOKEN { $$ = makeFile(); } | POSTSCRIPTTOKEN { $$ = makePostscript(); } | POSTSCRIPTFILETOKEN { $$ = makePostscriptFile(); } | PERTURBTOKEN { $$ = makePerturb(); } | MINUSWORDTOKEN { $$ = makeRoundDown(); } | PLUSWORDTOKEN { $$ = makeRoundUp(); } | ZEROWORDTOKEN { $$ = makeRoundToZero(); } | NEARESTTOKEN { $$ = makeRoundToNearest(); } | HONORCOEFFPRECTOKEN { $$ = makeHonorCoeff(); } | TRUETOKEN { $$ = makeTrue(); } | VOIDTOKEN { $$ = makeUnit(); } | FALSETOKEN { $$ = makeFalse(); } | DEFAULTTOKEN { $$ = makeDefault(); } | DECIMALTOKEN { $$ = makeDecimal(); } | ABSOLUTETOKEN { $$ = makeAbsolute(); } | RELATIVETOKEN { $$ = makeRelative(); } | FIXEDTOKEN { $$ = makeFixed(); } | FLOATINGTOKEN { $$ = makeFloating(); } | ERRORTOKEN { $$ = makeError(); } | DOUBLETOKEN { $$ = makeDoubleSymbol(); } | SINGLETOKEN { $$ = makeSingleSymbol(); } | QUADTOKEN { $$ = makeQuadSymbol(); } | HALFPRECISIONTOKEN { $$ = makeHalfPrecisionSymbol(); } | DOUBLEEXTENDEDTOKEN { $$ = makeDoubleextendedSymbol(); } | FREEVARTOKEN { $$ = makeVariable(); } | DOUBLEDOUBLETOKEN { $$ = makeDoubleDoubleSymbol(); } | TRIPLEDOUBLETOKEN { $$ = makeTripleDoubleSymbol(); } | STRINGTOKEN { tempString = safeCalloc(strlen($1) + 1, sizeof(char)); strcpy(tempString, $1); safeFree($1); tempString2 = safeCalloc(strlen(tempString) + 1, sizeof(char)); strcpy(tempString2, tempString); safeFree(tempString); $$ = makeString(tempString2); safeFree(tempString2); } | constant { $$ = $1; } | IDENTIFIERTOKEN { $$ = makeTableAccess($1); safeFree($1); } | ISBOUNDTOKEN LPARTOKEN IDENTIFIERTOKEN RPARTOKEN { $$ = makeIsBound($3); safeFree($3); } | IDENTIFIERTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeTableAccessWithSubstitute($1, $3); safeFree($1); } | IDENTIFIERTOKEN LPARTOKEN RPARTOKEN { $$ = makeTableAccessWithSubstitute($1, NULL); safeFree($1); } | list { $$ = $1; } | range { $$ = $1; } | debound { $$ = $1; } | headfunction { $$ = $1; } | LPARTOKEN thing RPARTOKEN { $$ = $2; } | LEFTCURLYBRACETOKEN structelementlist RIGHTCURLYBRACETOKEN { $$ = makeStructure($2); } | statedereference { $$ = $1; } | indexing { $$ = makeIndex($1->a, $1->b); safeFree($1); } | basicthing DOTTOKEN IDENTIFIERTOKEN { $$ = makeStructAccess($1,$3); safeFree($3); } | basicthing DOTTOKEN IDENTIFIERTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeApply(makeStructAccess($1,$3),$5); safeFree($3); } | LPARTOKEN thing RPARTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeApply($2,$5); } | LPARTOKEN thing RPARTOKEN LPARTOKEN RPARTOKEN { $$ = makeApply($2,addElement(NULL,makeUnit())); } | PROCTOKEN procbody { $$ = $2; } | TIMETOKEN LPARTOKEN command RPARTOKEN { $$ = makeTime($3); } ; matchlist: matchelement { $$ = addElement(NULL,$1); } | matchelement matchlist { $$ = addElement($2,$1); } ; matchelement: thing COLONTOKEN beginsymbol variabledeclarationlist commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeMatchElement($1,makeCommandList(concatChains($4, $5)),$7); } | thing COLONTOKEN beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeMatchElement($1,makeCommandList(concatChains($4, $5)),makeUnit()); } | thing COLONTOKEN beginsymbol variabledeclarationlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeMatchElement($1,makeCommandList($4),$6); } | thing COLONTOKEN beginsymbol variabledeclarationlist endsymbol { $$ = makeMatchElement($1,makeCommandList($4),makeUnit()); } | thing COLONTOKEN beginsymbol commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeMatchElement($1,makeCommandList($4),$6); } | thing COLONTOKEN beginsymbol commandlist endsymbol { $$ = makeMatchElement($1,makeCommandList($4),makeUnit()); } | thing COLONTOKEN beginsymbol RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeMatchElement($1, makeCommandList(addElement(NULL,makeNop())), $5); } | thing COLONTOKEN beginsymbol endsymbol { $$ = makeMatchElement($1, makeCommandList(addElement(NULL,makeNop())), makeUnit()); } | thing COLONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeMatchElement($1, makeCommandList(addElement(NULL,makeNop())), $4); } ; constant: CONSTANTTOKEN { $$ = makeDecimalConstant($1); safeFree($1); } | MIDPOINTCONSTANTTOKEN { $$ = makeMidpointConstant($1); safeFree($1); } | DYADICCONSTANTTOKEN { $$ = makeDyadicConstant($1); safeFree($1); } | HEXCONSTANTTOKEN { $$ = makeHexConstant($1); safeFree($1); } | HEXADECIMALCONSTANTTOKEN { $$ = makeHexadecimalConstant($1); safeFree($1); } | BINARYCONSTANTTOKEN { $$ = makeBinaryConstant($1); safeFree($1); } | PITOKEN { $$ = makePi(); } ; list: LBRACKETTOKEN VERTBARTOKEN VERTBARTOKEN RBRACKETTOKEN { $$ = makeEmptyList(); } | LBRACKETTOKEN ORTOKEN RBRACKETTOKEN { $$ = makeEmptyList(); } | LBRACKETTOKEN VERTBARTOKEN simplelist VERTBARTOKEN RBRACKETTOKEN { $$ = makeRevertedList($3); } | LBRACKETTOKEN VERTBARTOKEN simplelist DOTSTOKEN VERTBARTOKEN RBRACKETTOKEN { $$ = makeRevertedFinalEllipticList($3); } ; simplelist: thing { $$ = addElement(NULL, $1); } | simplelist COMMATOKEN thing { $$ = addElement($1, $3); } | simplelist COMMATOKEN DOTSTOKEN COMMATOKEN thing { $$ = addElement(addElement($1, makeElliptic()), $5); } ; range: LBRACKETTOKEN thing COMMATOKEN thing RBRACKETTOKEN { $$ = makeRange($2, $4); } | LBRACKETTOKEN thing SEMICOLONTOKEN thing RBRACKETTOKEN { $$ = makeRange($2, $4); } | LBRACKETTOKEN thing RBRACKETTOKEN { $$ = makeRange($2, copyThing($2)); } ; debound: STARLEFTANGLETOKEN thing RIGHTANGLESTARTOKEN { $$ = makeDeboundMax($2); } | STARLEFTANGLETOKEN thing RIGHTANGLEDOTTOKEN { $$ = makeDeboundMid($2); } | STARLEFTANGLETOKEN thing RIGHTANGLEUNDERSCORETOKEN { $$ = makeDeboundMin($2); } | SUPTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDeboundMax($3); } | MIDTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDeboundMid($3); } | INFTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDeboundMin($3); } ; headfunction: DIFFTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDiff($3); } | BASHEVALUATETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeBashevaluate(addElement(NULL,$3)); } | GETSUPPRESSEDMESSAGESTOKEN LPARTOKEN RPARTOKEN { $$ = makeGetSuppressedMessages(); } | GETBACKTRACETOKEN LPARTOKEN RPARTOKEN { $$ = makeGetBacktrace(); } | BASHEVALUATETOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeBashevaluate(addElement(addElement(NULL,$5),$3)); } | DIRTYSIMPLIFYTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDirtysimplify($3); } | REMEZTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeRemez(addElement(addElement($7, $5), $3)); } | ANNOTATEFUNCTIONTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeAnnotateFunction(addElement(addElement(addElement($9, $7), $5), $3)); } | BINDTOKEN LPARTOKEN thing COMMATOKEN IDENTIFIERTOKEN COMMATOKEN thing RPARTOKEN { $$ = makeBind($3, $5, $7); safeFree($5); } | MINTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeMin($3); } | MAXTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeMax($3); } | FPMINIMAXTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeFPminimax(addElement(addElement(addElement($9, $7), $5), $3)); } | HORNERTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeHorner($3); } | CANONICALTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeCanonicalThing($3); } | EXPANDTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExpand($3); } | SIMPLIFYSAFETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSimplifySafe($3); } | TAYLORTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeTaylor($3, $5, $7); } | TAYLORFORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeTaylorform(addElement(addElement($7, $5), $3)); } | AUTODIFFTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeAutodiff(addElement(addElement(addElement(NULL, $7), $5), $3)); } | DEGREETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDegree($3); } | NUMERATORTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeNumerator($3); } | DENOMINATORTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDenominator($3); } | SUBSTITUTETOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSubstitute($3, $5); } | COMPOSEPOLYNOMIALSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSubstitute($3, $5); } | COEFFTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeCoeff($3, $5); } | SUBPOLYTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSubpoly($3, $5); } | ROUNDCOEFFICIENTSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeRoundcoefficients($3, $5); } | RATIONALAPPROXTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeRationalapprox($3, $5); } | ACCURATEINFNORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeAccurateInfnorm(addElement(addElement($7, $5), $3)); } | ROUNDTOFORMATTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeRoundToFormat($3, $5, $7); } | EVALUATETOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeEvaluate($3, $5); } | PARSETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeParse($3); } | READXMLTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeReadXml($3); } | INFNORMTOKEN LPARTOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeInfnorm(addElement($5, $3)); } | SUPNORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSupnorm(addElement(addElement(addElement(addElement(addElement(NULL,$11),$9),$7),$5),$3)); } | FINDZEROSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeFindZeros($3, $5); } | FPFINDZEROSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeFPFindZeros($3, $5); } | DIRTYINFNORMTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeDirtyInfnorm($3, $5); } | NUMBERROOTSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeNumberRoots($3, $5); } | INTEGRALTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeIntegral($3, $5); } | DIRTYINTEGRALTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeDirtyIntegral($3, $5); } | IMPLEMENTPOLYTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeImplementPoly(addElement(addElement(addElement(addElement(addElement($13, $11), $9), $7), $5), $3)); } | IMPLEMENTCONSTTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeImplementConst($3); } | CHECKINFNORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeCheckInfnorm($3, $5, $7); } | ZERODENOMINATORSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeZeroDenominators($3, $5); } | ISEVALUABLETOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeIsEvaluable($3, $5); } | SEARCHGALTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeSearchGal($3); } | GUESSDEGREETOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeGuessDegree(addElement(addElement($7, $5), $3)); } | DIRTYFINDZEROSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeDirtyFindZeros($3, $5); } | HEADTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeHead($3); } | ROUNDCORRECTLYTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeRoundCorrectly($3); } | READFILETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeReadFile($3); } | REVERTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeRevert($3); } | SORTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSort($3); } | MANTISSATOKEN LPARTOKEN thing RPARTOKEN { $$ = makeMantissa($3); } | EXPONENTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExponent($3); } | PRECISIONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrecision($3); } | TAILTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeTail($3); } | SQRTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSqrt($3); } | EXPTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExp($3); } | FREEVARTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeApply(makeVariable(),addElement(NULL,$3)); } | FUNCTIONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeProcedureFunction($3); } | FUNCTIONTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSubstitute(makeProcedureFunction($3),$5); } | LOGTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLog($3); } | LOG2TOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLog2($3); } | LOG10TOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLog10($3); } | SINTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSin($3); } | COSTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeCos($3); } | TANTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeTan($3); } | ASINTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAsin($3); } | ACOSTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAcos($3); } | ATANTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAtan($3); } | SINHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSinh($3); } | COSHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeCosh($3); } | TANHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeTanh($3); } | ASINHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAsinh($3); } | ACOSHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAcosh($3); } | ATANHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAtanh($3); } | ABSTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAbs($3); } | ERFTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeErf($3); } | ERFCTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeErfc($3); } | LOG1PTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLog1p($3); } | EXPM1TOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExpm1($3); } | DOUBLETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDouble($3); } | SINGLETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSingle($3); } | QUADTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeQuad($3); } | HALFPRECISIONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeHalfPrecision($3); } | DOUBLEDOUBLETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDoubledouble($3); } | TRIPLEDOUBLETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeTripledouble($3); } | DOUBLEEXTENDEDTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDoubleextended($3); } | CEILTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeCeil($3); } | FLOORTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeFloor($3); } | NEARESTINTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeNearestInt($3); } | LENGTHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLength($3); } | OBJECTNAMETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeObjectName($3); } ; egalquestionmark: EQUALTOKEN QUESTIONMARKTOKEN { $$ = NULL; } | { $$ = NULL; } ; statedereference: PRECTOKEN egalquestionmark { $$ = makePrecDeref(); } | POINTSTOKEN egalquestionmark { $$ = makePointsDeref(); } | DIAMTOKEN egalquestionmark { $$ = makeDiamDeref(); } | DISPLAYTOKEN egalquestionmark { $$ = makeDisplayDeref(); } | VERBOSITYTOKEN egalquestionmark { $$ = makeVerbosityDeref(); } | SHOWMESSAGENUMBERSTOKEN egalquestionmark { $$ = makeShowMessageNumbersDeref(); } | CANONICALTOKEN egalquestionmark { $$ = makeCanonicalDeref(); } | AUTOSIMPLIFYTOKEN egalquestionmark { $$ = makeAutoSimplifyDeref(); } | TAYLORRECURSIONSTOKEN egalquestionmark { $$ = makeTaylorRecursDeref(); } | TIMINGTOKEN egalquestionmark { $$ = makeTimingDeref(); } | FULLPARENTHESESTOKEN egalquestionmark { $$ = makeFullParenDeref(); } | MIDPOINTMODETOKEN egalquestionmark { $$ = makeMidpointDeref(); } | DIEONERRORMODETOKEN egalquestionmark { $$ = makeDieOnErrorDeref(); } | RATIONALMODETOKEN egalquestionmark { $$ = makeRationalModeDeref(); } | SUPPRESSWARNINGSTOKEN egalquestionmark { $$ = makeSuppressWarningsDeref(); } | HOPITALRECURSIONSTOKEN egalquestionmark { $$ = makeHopitalRecursDeref(); } ; externalproctype: CONSTANTTYPETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = CONSTANT_TYPE; $$ = tempIntPtr; } | FUNCTIONTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = FUNCTION_TYPE; $$ = tempIntPtr; } | OBJECTTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = OBJECT_TYPE; $$ = tempIntPtr; } | RANGETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = RANGE_TYPE; $$ = tempIntPtr; } | INTEGERTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = INTEGER_TYPE; $$ = tempIntPtr; } | STRINGTYPETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = STRING_TYPE; $$ = tempIntPtr; } | BOOLEANTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = BOOLEAN_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN CONSTANTTYPETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = CONSTANT_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN FUNCTIONTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = FUNCTION_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN OBJECTTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = OBJECT_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN RANGETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = RANGE_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN INTEGERTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = INTEGER_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN STRINGTYPETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = STRING_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN BOOLEANTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = BOOLEAN_LIST_TYPE; $$ = tempIntPtr; } ; extendedexternalproctype: VOIDTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = VOID_TYPE; $$ = tempIntPtr; } | externalproctype { $$ = $1; } ; externalproctypesimplelist: externalproctype { $$ = addElement(NULL, $1); } | externalproctype COMMATOKEN externalproctypesimplelist { $$ = addElement($3, $1); } ; externalproctypelist: extendedexternalproctype { $$ = addElement(NULL, $1); } | LPARTOKEN externalproctypesimplelist RPARTOKEN { $$ = $2; } ; sollya-6.0+ds/lexer.l000066400000000000000000001045161300174114700145650ustar00rootroot00000000000000/* Copyright 2006-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2) and by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ %{ #include #include #include #include "expression.h" #include "parser.h" #include "general.h" #include "chain.h" #define YY_NO_UNPUT 1 #define YY_NO_INPUT 1 /* Mess with the mallocs used by the lexer */ extern void *parserCalloc(size_t, size_t); extern void *parserMalloc(size_t); extern void *parserRealloc(void *, size_t); extern void parserFree(void *); #undef malloc #undef realloc #undef calloc #undef free #define malloc parserMalloc #define realloc parserRealloc #define calloc parserCalloc #define free UNUSED_PARAM(yyscanner); parserFree /* End of the malloc mess */ /* Mess with fprintf to use sollyaFprintf instead. */ #undef fprintf #define fprintf UNUSED_PARAM(yyscanner); sollyaFprintf /* End of fprintf mess */ /* Mess with getc... and fread to use sollya_getc, sollya_feof, sollya_ferror, sollya_fwrite and sollya_fread instead. */ #undef getc #undef fread #undef feof #undef ferror #undef fwrite #define getc sollya_getc #define fread sollya_fread #define feof sollya_feof #define ferror sollya_ferror #define fwrite sollya_fwrite /* End of getc, feof, ferror, fwrite and fread mess */ /* const mess */ #if defined(const) #undef const #endif /* End of the const mess */ %} %option noyyalloc noyyrealloc noyyfree %option noyywrap %option always-interactive %option reentrant %option bison-bridge %option nounput %x readstate %x readstate2 %x commentstate CHAR [a-zA-Z] NUMBER [0-9] HEXNUMBER (([0-9])|([ABCDEFabcdef])) SPECIAL [_$§] ACONSTANT ((({NUMBER}+|({NUMBER}*"."{NUMBER}+))(((((" ")*)(([eE]))([+-])?{NUMBER}+)?)))|("infty"|"nan"|"NAN"|"NaN"|"@Inf@"|"@NaN@")) CONSTANT ({ACONSTANT})|((("%")({NUMBER})({NUMBER}+)("%"))({ACONSTANT})) DYADICCONSTANT ({NUMBER}+)([bB])([+-]?)({NUMBER}+) HEXCONSTANT ("0x")({HEXNUMBER}{16}|{HEXNUMBER}{8}) HEXADECIMALCONSTANT ("0x"|"0X")(({HEXNUMBER}*"."{HEXNUMBER}+)|({HEXNUMBER}+((".")?)))(("p"|"P")(([+-])?)({NUMBER}*)) BINARYCONSTANT (([0-1])+|(([0-1])*"."([0-1])+))"_2" AMIDPOINTCONSTANT (({NUMBER}+|({NUMBER}*"."{NUMBER}+))(("~"({NUMBER})+("/")({NUMBER})+("~")))(((((" ")*)(([eE]))([+-])?{NUMBER}+)?))) MIDPOINTCONSTANT (({AMIDPOINTCONSTANT})|(("-")((" ")*)({AMIDPOINTCONSTANT}))) IDENTIFIER ({CHAR}|{SPECIAL})({CHAR}|{NUMBER}|{SPECIAL})* DOT "." LPAR "(" RPAR ")" LBRACKET "[" RBRACKET "]" PI ("pi")|("Pi") PLUS "+" MINUS "-" APPROX "~" MUL "*" DIV "/" POW "^" SQRT "sqrt" EXP "exp" FREEVAR "_x_" LOG "log" LOG2 "log2" LOG10 "log10" SIN "sin" COS "cos" TAN "tan" ASIN "asin" ACOS "acos" ATAN "atan" SINH "sinh" COSH "cosh" TANH "tanh" ASINH "asinh" ACOSH "acosh" ATANH "atanh" ABS "abs" ERF "erf" ERFC "erfc" LOG1P "log1p" EXPM1 "expm1" EQUAL "=" COMMA "," PREC "prec" POINTS "points" EXCLAMATION "!" DOUBLECOLON "::" COLON ":" DOTCOLON ".:" COLONDOT ":." ASSIGNEQUAL ":=" SEMICOLON ";" QUIT "quit" PRINT "print" SUPPRESSMESSAGE "suppressmessage" UNSUPPRESSMESSAGE "unsuppressmessage" DIFF "diff" DIRTYSIMPLIFY "dirtysimplify" CANONICAL "canonical" PLOT "plot" REMEZ "remez" ANNOTATEFUNCTION "annotatefunction" FPMINIMAX "fpminimax" INFNORM "infnorm" SUPNORM "supnorm" DIAM "diam" DOUBLELONG "double" SINGLELONG "single" QUADLONG "quad" HALFPRECISIONLONG "halfprecision" DOUBLEDOUBLELONG "doubledouble" TRIPLEDOUBLELONG "tripledouble" DOUBLEEXTENDEDLONG "doubleextended" DOUBLESHORT "D" SINGLESHORT "SG" QUADSHORT "QD" HALFPRECISIONSHORT "HP" DOUBLEDOUBLESHORT "DD" TRIPLEDOUBLESHORT "TD" DOUBLEEXTENDEDSHORT "DE" DOUBLE ({DOUBLELONG}|{DOUBLESHORT}) SINGLE ({SINGLELONG}|{SINGLESHORT}) QUAD ({QUADLONG}|{QUADSHORT}) HALFPRECISION ({HALFPRECISIONLONG}|{HALFPRECISIONSHORT}) DOUBLEDOUBLE ({DOUBLEDOUBLELONG}|{DOUBLEDOUBLESHORT}) TRIPLEDOUBLE ({TRIPLEDOUBLELONG}|{TRIPLEDOUBLESHORT}) DOUBLEEXTENDED ({DOUBLEEXTENDEDLONG}|{DOUBLEEXTENDEDSHORT}) HORNER "horner" DEGREE "degree" EXPAND "expand" SIMPLIFYSAFE1 "simplify" SIMPLIFYSAFE2 "simplifysafe" SIMPLIFYSAFE ({SIMPLIFYSAFE1}|{SIMPLIFYSAFE2}) TAYLOR "taylor" TAYLORFORM "taylorform" CHEBYSHEVFORM "chebyshevform" AUTODIFF "autodiff" FINDZEROS "findzeros" FPFINDZEROS "fpfindzeros" DIRTYINFNORM "dirtyinfnorm" NUMBERROOTS "numberroots" EVALUATE "evaluate" NUMERATOR "numerator" DENOMINATOR "denominator" DYADIC "dyadic" DISPLAY "display" ON "on" OFF "off" POWERS "powers" BINARY "binary" HEXADECIMAL "hexadecimal" INTEGRAL "integral" DIRTYINTEGRAL "dirtyintegral" STRINGDELIMITER [\"] OCTALCHAR [01234567] OCTAL ({OCTALCHAR})(({OCTALCHAR})?)(({OCTALCHAR})?) HEXACHAR [0123456789ABCDEFabcdef] HEXA ({HEXACHAR})(({HEXACHAR})?) STRING ({STRINGDELIMITER})((("\\\\")|(("\\")[\"\'\?ntabfrv])|(("\\")({OCTAL}))|(("\\x")({HEXA}))|([^\"\\]))*)({STRINGDELIMITER}) VERBOSITY "verbosity" SHOWMESSAGENUMBERS "showmessagenumbers" WORSTCASE "worstcase" LEFTANGLE "<" RIGHTANGLEUNDERSCORE ">_" RIGHTANGLEDOT ">." RIGHTANGLE ">" STARLEFTANGLE "*<" RIGHTANGLESTAR ">*" COMPAREEQUAL "==" EXCLAMATIONEQUAL "!=" AND "&&" OR "||" SUBSTITUTE "substitute" COMPOSEPOLYNOMIALS "composepolynomials" DOTS "..." IMPLEMENTPOLY "implementpoly" IMPLEMENTCONST "implementconstant" CHECKINFNORM "checkinfnorm" TAYLORRECURSIONS "taylorrecursions" PRINTHEXA ("printhexa"|"printdouble") PRINTFLOAT ("printfloat"|"printsingle") PRINTBINARY "printbinary" ROUNDCOEFFICIENTS "roundcoefficients" RESTART "restart" ZERODENOMINATORS "zerodenominators" ISEVALUABLE "isevaluable" HONORCOEFFPREC "honorcoeffprec" ACCURATEINFNORM "accurateinfnorm" FILE "file" POSTSCRIPT "postscript" POSTSCRIPTFILE "postscriptfile" PRINTEXPANSION "printexpansion" BASHEXECUTE "bashexecute" BASHEVALUATE "bashevaluate" GETSUPPRESSEDMESSAGES "getsuppressedmessages" GETBACKTRACE "getbacktrace" EXTERNALPLOT "externalplot" PERTURB "perturb" COEFF "coeff" SUBPOLY "subpoly" QUESTIONMARK "?" SEARCHGAL "searchgal" RATIONALAPPROX "rationalapprox" READ ("read"|"#include") COMMENTSTART "/*" COMMENTEND "*/" ONELINECOMMENT ("//"|"#!")([^\n])*"\n" WRITE "write" ASCIIPLOT "asciiplot" ROUNDTOFORMAT "round" MINUSWORD "RD" PLUSWORD "RU" ZEROWORD "RZ" NEAREST "RN" GUESSDEGREE "guessdegree" PARSE "parse" AUTOSIMPLIFY "autosimplify" TIMING "timing" TIME "time" FULLPARENTHESES "fullparentheses" MIDPOINTMODE "midpointmode" SUPPRESSWARNINGS "roundingwarnings" RATIONALMODE "rationalmode" DIEONERRORMODE "dieonerrormode" LIBRARY "library" LIBRARYCONSTANT "libraryconstant" HOPITALRECURSIONS "hopitalrecursions" HELP "help" DIRTYFINDZEROS "dirtyfindzeros" CEIL "ceil" FLOOR "floor" NEARESTINT "nearestint" HEAD "head" TAIL "tail" VERTBAR "|" AT "@" IF "if" THEN "then" ELSE "else" FOR "for" IN "in" FROM "from" TO "to" BY "by" DO "do" BEGIN "begin" END "end" LBRACE "{" RBRACE "}" WHILEDEF "while" TRUE "true" FALSE "false" DEFAULT "default" MATCH "match" WITH "with" RENAME "rename" BIND "bind" OBJECTNAME "objectname" LENGTH "length" ABSOLUTE "absolute" RELATIVE "relative" DECIMAL "decimal" FIXED "fixed" FLOATING "floating" ERROR "error" PRINTXML "printxml" INF "inf" MID "mid" SUP "sup" MIN "min" MAX "max" READXML "readxml" MANTISSA "mantissa" EXPONENT "exponent" PRECISION "precision" REVERT "revert" SORT "sort" READFILE "readfile" ROUNDCORRECTLY "roundcorrectly" EXECUTE "execute" VERSION "version" ISBOUND "isbound" EXTERNALPROC "externalproc" VOID "void" CONSTANTTYPE "constant" FUNCTION "function" OBJECT "object" RANGE "range" INTEGER "integer" STRINGTYPE "string" BOOLEAN "boolean" LIST "list" OF "of" VAR "var" PROC "proc" PROCEDURE "procedure" RETURN "return" NOP "nop" %% %{ YY_BUFFER_STATE *currStatePtr; %} {COMMENTSTART} { BEGIN(commentstate); } {COMMENTEND} { BEGIN(INITIAL); } . { /* Eat up comments */ } [\n] { /* Eat up newlines in comments */ } {ONELINECOMMENT} { /* Eat up comments */ carriageReturnLexed(); } {READ} { BEGIN(readstate); } {STRING} { if (newReadFilename != NULL) safeFree(newReadFilename); newReadFilename = NULL; newReadFilename = (char*) safeCalloc(yyleng - 1,sizeof(char)); strncpy(newReadFilename,yytext+1,yyleng-2); readManipulate(); BEGIN(readstate2); } [ \t] { /* Eat up spaces and tabulators */ } [\r] { /* Eat up carriage return for compatibility with DOS-like systems */ } . { /* otherwise */ printMessage(1,SOLLYA_MSG_A_CHARACTER_COULD_NOT_BE_RECOGNIZED,"The character \"%s\" cannot be recognized. Will ignore it.\n", yytext); } {SEMICOLON} { newReadFilenameTemp = (char *) safeCalloc(strlen(newReadFilename)+1,sizeof(char)); demaskString(newReadFilenameTemp,newReadFilename); temp_fd = fopen(newReadFilenameTemp,"r"); if (temp_fd == NULL) { printMessage(1,SOLLYA_MSG_A_FILE_COULD_NOT_BE_OPENED_FOR_READING,"Warning: the file \"%s\" could not be opened for reading: \"%s\".\nThe last command will have no effect. No memory will be lost.\n", newReadFilenameTemp,strerror(errno)); if (verbosity >= 1) { considerDyingOnError(); } promptToBePrinted = 1; } else { fflush(yyin); newReadFileStarted(); currStatePtr = (YY_BUFFER_STATE *) safeMalloc(sizeof(YY_BUFFER_STATE)); *currStatePtr = YY_CURRENT_BUFFER; readStack = addElement(readStack, (void *) currStatePtr); tempFDPtr = (FILE **) safeMalloc(sizeof(FILE *)); *tempFDPtr = yyin; readStack2 = addElement(readStack2, (void *) tempFDPtr); yyin = temp_fd; yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE, scanner), scanner); } safeFree(newReadFilenameTemp); readManipulate(); BEGIN(INITIAL); } [ \t] { /* Eat up spaces and tabulators */ } [\r] { /* Eat up carriage return for compatibility with DOS-like systems */ } . { /* otherwise */ printMessage(1,SOLLYA_MSG_A_CHARACTER_COULD_NOT_BE_RECOGNIZED,"The character \"%s\" cannot be recognized. Will ignore it.\n", yytext); } <> { if (readStack == NULL) { if (!eliminatePromptBackup) sollyaPrintf("\n"); yyterminate(); } else { fclose(yyin); yyin = *((FILE **) (readStack2->value)); fflush(yyin); safeFree(readStack2->value); readStackTemp = readStack2->next; safeFree(readStack2); readStack2 = readStackTemp; yy_delete_buffer(YY_CURRENT_BUFFER, scanner); yy_switch_to_buffer(*((YY_BUFFER_STATE *) (readStack->value)),scanner); safeFree(readStack->value); readStackTemp = readStack->next; safeFree(readStack); readStack = readStackTemp; readManipulate(); } } {MIDPOINTCONSTANT} { constBuffer2 = (char *) safeCalloc(yyleng+1,sizeof(char)); if (removeSpaces(constBuffer2,yytext)) { printMessage(2,SOLLYA_MSG_SPACES_REMOVED_FROM_CONSTANT_IN_SCIENTIF_NOTAT,"Information: removed spaces in scientific notation constant \"%s\", it will be considered as \"%s\"\n",yytext,constBuffer2); } yylval->value = constBuffer2; newTokenLexed(); return MIDPOINTCONSTANTTOKEN; } {CONSTANT} { constBuffer2 = (char *) safeCalloc(yyleng+1,sizeof(char)); if (removeSpaces(constBuffer2,yytext)) { printMessage(2,SOLLYA_MSG_SPACES_REMOVED_FROM_CONSTANT_IN_SCIENTIF_NOTAT,"Information: removed spaces in scientific notation constant \"%s\", it will be considered as \"%s\"\n",yytext,constBuffer2); } yylval->value = constBuffer2; newTokenLexed(); return CONSTANTTOKEN; } {DYADICCONSTANT} { constBuffer = (char *) safeCalloc(yyleng+1,sizeof(char)); strncpy(constBuffer,yytext,yyleng); yylval->value = constBuffer; newTokenLexed(); return DYADICCONSTANTTOKEN; } {HEXADECIMALCONSTANT} { constBuffer = (char *) safeCalloc(yyleng+1,sizeof(char)); strncpy(constBuffer,yytext,yyleng); yylval->value = constBuffer; newTokenLexed(); return HEXADECIMALCONSTANTTOKEN; } {HEXCONSTANT} { constBuffer = (char *) safeCalloc(yyleng+1,sizeof(char)); strncpy(constBuffer,yytext,yyleng); yylval->value = constBuffer; newTokenLexed(); return HEXCONSTANTTOKEN; } {BINARYCONSTANT} { constBuffer = (char *) safeCalloc(yyleng-1,sizeof(char)); strncpy(constBuffer,yytext,yyleng-2); yylval->value = constBuffer; newTokenLexed(); return BINARYCONSTANTTOKEN; } {PI} { newTokenLexed(); return PITOKEN; } {STRING} { constBuffer = (char *) safeCalloc(yyleng-1,sizeof(char)); constBuffer2 = (char *) safeCalloc(yyleng-1,sizeof(char)); strncpy(constBuffer2,yytext+1,yyleng-2); demaskString(constBuffer,constBuffer2); safeFree(constBuffer2); yylval->value = constBuffer; newTokenLexed(); return STRINGTOKEN; } {LPAR} { newTokenLexed(); return LPARTOKEN; } {RPAR} { newTokenLexed(); return RPARTOKEN; } {LBRACKET} { newTokenLexed(); return LBRACKETTOKEN; } {RBRACKET} { newTokenLexed(); return RBRACKETTOKEN; } {EXCLAMATIONEQUAL} { newTokenLexed(); return EXCLAMATIONEQUALTOKEN; } {COMPAREEQUAL} { newTokenLexed(); return COMPAREEQUALTOKEN; } {EQUAL} { newTokenLexed(); return EQUALTOKEN; } {ASSIGNEQUAL} { newTokenLexed(); return ASSIGNEQUALTOKEN; } {COMMA} { newTokenLexed(); return COMMATOKEN; } {EXCLAMATION} { newTokenLexed(); return EXCLAMATIONTOKEN; } {SEMICOLON} { newTokenLexed(); return SEMICOLONTOKEN; } {LEFTANGLE} { newTokenLexed(); return LEFTANGLETOKEN; } {STARLEFTANGLE} { newTokenLexed(); return STARLEFTANGLETOKEN; } {RIGHTANGLEUNDERSCORE} { newTokenLexed(); return RIGHTANGLEUNDERSCORETOKEN; } {RIGHTANGLEDOT} { newTokenLexed(); return RIGHTANGLEDOTTOKEN; } {RIGHTANGLESTAR} { newTokenLexed(); return RIGHTANGLESTARTOKEN; } {RIGHTANGLE} { newTokenLexed(); return RIGHTANGLETOKEN; } {DOTS} { newTokenLexed(); return DOTSTOKEN; } {DOT} { newTokenLexed(); return DOTTOKEN; } {QUESTIONMARK} { newTokenLexed(); return QUESTIONMARKTOKEN; } {AND} { newTokenLexed(); return ANDTOKEN; } {OR} { newTokenLexed(); return ORTOKEN; } {VERTBAR} { newTokenLexed(); return VERTBARTOKEN; } {VAR} { newTokenLexed(); return VARTOKEN; } {PROC} { newTokenLexed(); return PROCTOKEN; } {PROCEDURE} { newTokenLexed(); return PROCEDURETOKEN; } {RETURN} { newTokenLexed(); return RETURNTOKEN; } {NOP} { newTokenLexed(); return NOPTOKEN; } {AT} { newTokenLexed(); return ATTOKEN; } {DOUBLECOLON} { newTokenLexed(); return DOUBLECOLONTOKEN; } {COLON} { newTokenLexed(); return COLONTOKEN; } {DOTCOLON} { newTokenLexed(); return DOTCOLONTOKEN; } {COLONDOT} { newTokenLexed(); return COLONDOTTOKEN; } {PLUS} { newTokenLexed(); return PLUSTOKEN; } {MINUS} { newTokenLexed(); return MINUSTOKEN; } {APPROX} { newTokenLexed(); return APPROXTOKEN; } {MUL} { newTokenLexed(); return MULTOKEN; } {DIV} { newTokenLexed(); return DIVTOKEN; } {POW} { newTokenLexed(); return POWTOKEN; } {SQRT} { newTokenLexed(); return SQRTTOKEN; } {EXP} { newTokenLexed(); return EXPTOKEN; } {FREEVAR} { newTokenLexed(); return FREEVARTOKEN; } {LOG} { newTokenLexed(); return LOGTOKEN; } {LOG2} { newTokenLexed(); return LOG2TOKEN; } {LOG10} { newTokenLexed(); return LOG10TOKEN; } {SIN} { newTokenLexed(); return SINTOKEN; } {COS} { newTokenLexed(); return COSTOKEN; } {TAN} { newTokenLexed(); return TANTOKEN; } {ASIN} { newTokenLexed(); return ASINTOKEN; } {ACOS} { newTokenLexed(); return ACOSTOKEN; } {ATAN} { newTokenLexed(); return ATANTOKEN; } {SINH} { newTokenLexed(); return SINHTOKEN; } {COSH} { newTokenLexed(); return COSHTOKEN; } {TANH} { newTokenLexed(); return TANHTOKEN; } {ASINH} { newTokenLexed(); return ASINHTOKEN; } {ACOSH} { newTokenLexed(); return ACOSHTOKEN; } {ATANH} { newTokenLexed(); return ATANHTOKEN; } {ABS} { newTokenLexed(); return ABSTOKEN; } {ERF} { newTokenLexed(); return ERFTOKEN; } {ERFC} { newTokenLexed(); return ERFCTOKEN; } {LOG1P} { newTokenLexed(); return LOG1PTOKEN; } {EXPM1} { newTokenLexed(); return EXPM1TOKEN; } {DOUBLE} { newTokenLexed(); return DOUBLETOKEN; } {SINGLE} { newTokenLexed(); return SINGLETOKEN; } {QUAD} { newTokenLexed(); return QUADTOKEN; } {HALFPRECISION} { newTokenLexed(); return HALFPRECISIONTOKEN; } {DOUBLEDOUBLE} { newTokenLexed(); return DOUBLEDOUBLETOKEN; } {TRIPLEDOUBLE} { newTokenLexed(); return TRIPLEDOUBLETOKEN; } {DOUBLEEXTENDED} { newTokenLexed(); return DOUBLEEXTENDEDTOKEN; } {CEIL} { newTokenLexed(); return CEILTOKEN; } {FLOOR} { newTokenLexed(); return FLOORTOKEN; } {NEARESTINT} { newTokenLexed(); return NEARESTINTTOKEN; } {PREC} { newTokenLexed(); return PRECTOKEN; } {POINTS} { newTokenLexed(); return POINTSTOKEN; } {DIAM} { newTokenLexed(); return DIAMTOKEN; } {DISPLAY} { newTokenLexed(); return DISPLAYTOKEN; } {VERBOSITY} { newTokenLexed(); return VERBOSITYTOKEN; } {SHOWMESSAGENUMBERS} { newTokenLexed(); return SHOWMESSAGENUMBERSTOKEN; } {CANONICAL} { newTokenLexed(); return CANONICALTOKEN; } {AUTOSIMPLIFY} { newTokenLexed(); return AUTOSIMPLIFYTOKEN; } {TAYLORRECURSIONS} { newTokenLexed(); return TAYLORRECURSIONSTOKEN; } {TIMING} { newTokenLexed(); return TIMINGTOKEN; } {TIME} { newTokenLexed(); return TIMETOKEN; } {FULLPARENTHESES} { newTokenLexed(); return FULLPARENTHESESTOKEN; } {MIDPOINTMODE} { newTokenLexed(); return MIDPOINTMODETOKEN; } {DIEONERRORMODE} { newTokenLexed(); return DIEONERRORMODETOKEN; } {SUPPRESSWARNINGS} { newTokenLexed(); return SUPPRESSWARNINGSTOKEN; } {RATIONALMODE} { newTokenLexed(); return RATIONALMODETOKEN; } {HOPITALRECURSIONS} { newTokenLexed(); return HOPITALRECURSIONSTOKEN; } {ON} { newTokenLexed(); return ONTOKEN; } {OFF} { newTokenLexed(); return OFFTOKEN; } {DYADIC} { newTokenLexed(); return DYADICTOKEN; } {POWERS} { newTokenLexed(); return POWERSTOKEN; } {BINARY} { newTokenLexed(); return BINARYTOKEN; } {HEXADECIMAL} { newTokenLexed(); return HEXADECIMALTOKEN; } {FILE} { newTokenLexed(); return FILETOKEN; } {POSTSCRIPT} { newTokenLexed(); return POSTSCRIPTTOKEN; } {POSTSCRIPTFILE} { newTokenLexed(); return POSTSCRIPTFILETOKEN; } {PERTURB} { newTokenLexed(); return PERTURBTOKEN; } {MINUSWORD} { newTokenLexed(); return MINUSWORDTOKEN; } {PLUSWORD} { newTokenLexed(); return PLUSWORDTOKEN; } {ZEROWORD} { newTokenLexed(); return ZEROWORDTOKEN; } {NEAREST} { newTokenLexed(); return NEARESTTOKEN; } {HONORCOEFFPREC} { newTokenLexed(); return HONORCOEFFPRECTOKEN; } {TRUE} { newTokenLexed(); return TRUETOKEN; } {FALSE} { newTokenLexed(); return FALSETOKEN; } {DEFAULT} { newTokenLexed(); return DEFAULTTOKEN; } {MATCH} { newTokenLexed(); return MATCHTOKEN; } {WITH} { newTokenLexed(); return WITHTOKEN; } {HEAD} { newTokenLexed(); return HEADTOKEN; } {ROUNDCORRECTLY} { newTokenLexed(); return ROUNDCORRECTLYTOKEN; } {REVERT} { newTokenLexed(); return REVERTTOKEN; } {SORT} { newTokenLexed(); return SORTTOKEN; } {MANTISSA} { newTokenLexed(); return MANTISSATOKEN; } {EXPONENT} { newTokenLexed(); return EXPONENTTOKEN; } {PRECISION} { newTokenLexed(); return PRECISIONTOKEN; } {TAIL} { newTokenLexed(); return TAILTOKEN; } {INF} { newTokenLexed(); return INFTOKEN; } {MID} { newTokenLexed(); return MIDTOKEN; } {SUP} { newTokenLexed(); return SUPTOKEN; } {MIN} { newTokenLexed(); return MINTOKEN; } {MAX} { newTokenLexed(); return MAXTOKEN; } {READXML} { newTokenLexed(); return READXMLTOKEN; } {LENGTH} { newTokenLexed(); return LENGTHTOKEN; } {ABSOLUTE} { newTokenLexed(); return ABSOLUTETOKEN; } {RELATIVE} { newTokenLexed(); return RELATIVETOKEN; } {DECIMAL} { newTokenLexed(); return DECIMALTOKEN; } {FIXED} { newTokenLexed(); return FIXEDTOKEN; } {FLOATING} { newTokenLexed(); return FLOATINGTOKEN; } {ERROR} { newTokenLexed(); return ERRORTOKEN; } {READFILE} { newTokenLexed(); return READFILETOKEN; } {ISBOUND} { newTokenLexed(); return ISBOUNDTOKEN; } {QUIT} { newTokenLexed(); if (readStack != NULL) { return FALSEQUITTOKEN; } return QUITTOKEN; } {RESTART} { newTokenLexed(); return RESTARTTOKEN; } {VERSION} { newTokenLexed(); return VERSIONTOKEN; } {LIBRARY} { newTokenLexed(); return LIBRARYTOKEN; } {LIBRARYCONSTANT} { newTokenLexed(); return LIBRARYCONSTANTTOKEN; } {DIFF} { newTokenLexed(); return DIFFTOKEN; } {DIRTYSIMPLIFY} { newTokenLexed(); return DIRTYSIMPLIFYTOKEN; } {REMEZ} { newTokenLexed(); return REMEZTOKEN; } {ANNOTATEFUNCTION} { newTokenLexed(); return ANNOTATEFUNCTIONTOKEN; } {FPMINIMAX} { newTokenLexed(); return FPMINIMAXTOKEN; } {HORNER} { newTokenLexed(); return HORNERTOKEN; } {EXPAND} { newTokenLexed(); return EXPANDTOKEN; } {SIMPLIFYSAFE} { newTokenLexed(); return SIMPLIFYSAFETOKEN; } {TAYLOR} { newTokenLexed(); return TAYLORTOKEN; } {TAYLORFORM} { newTokenLexed(); return TAYLORFORMTOKEN; } {CHEBYSHEVFORM} { newTokenLexed(); return CHEBYSHEVFORMTOKEN; } {AUTODIFF} { newTokenLexed(); return AUTODIFFTOKEN; } {DEGREE} { newTokenLexed(); return DEGREETOKEN; } {NUMERATOR} { newTokenLexed(); return NUMERATORTOKEN; } {DENOMINATOR} { newTokenLexed(); return DENOMINATORTOKEN; } {SUBSTITUTE} { newTokenLexed(); return SUBSTITUTETOKEN; } {COMPOSEPOLYNOMIALS} { newTokenLexed(); return COMPOSEPOLYNOMIALSTOKEN; } {COEFF} { newTokenLexed(); return COEFFTOKEN; } {SUBPOLY} { newTokenLexed(); return SUBPOLYTOKEN; } {ROUNDCOEFFICIENTS} { newTokenLexed(); return ROUNDCOEFFICIENTSTOKEN; } {RATIONALAPPROX} { newTokenLexed(); return RATIONALAPPROXTOKEN; } {ACCURATEINFNORM} { newTokenLexed(); return ACCURATEINFNORMTOKEN; } {ROUNDTOFORMAT} { newTokenLexed(); return ROUNDTOFORMATTOKEN; } {EVALUATE} { newTokenLexed(); return EVALUATETOKEN; } {PARSE} { newTokenLexed(); return PARSETOKEN; } {PRINT} { newTokenLexed(); return PRINTTOKEN; } {SUPPRESSMESSAGE} { newTokenLexed(); return SUPPRESSMESSAGETOKEN; } {UNSUPPRESSMESSAGE} { newTokenLexed(); return UNSUPPRESSMESSAGETOKEN; } {PRINTXML} { newTokenLexed(); return PRINTXMLTOKEN; } {EXECUTE} { newTokenLexed(); return EXECUTETOKEN; } {PLOT} { newTokenLexed(); return PLOTTOKEN; } {PRINTHEXA} { newTokenLexed(); return PRINTHEXATOKEN; } {PRINTFLOAT} { newTokenLexed(); return PRINTFLOATTOKEN; } {PRINTBINARY} { newTokenLexed(); return PRINTBINARYTOKEN; } {PRINTEXPANSION} { newTokenLexed(); return PRINTEXPANSIONTOKEN; } {BASHEXECUTE} { newTokenLexed(); return BASHEXECUTETOKEN; } {BASHEVALUATE} { newTokenLexed(); return BASHEVALUATETOKEN; } {GETSUPPRESSEDMESSAGES} { newTokenLexed(); return GETSUPPRESSEDMESSAGESTOKEN; } {GETBACKTRACE} { newTokenLexed(); return GETBACKTRACETOKEN; } {EXTERNALPLOT} { newTokenLexed(); return EXTERNALPLOTTOKEN; } {WRITE} { newTokenLexed(); return WRITETOKEN; } {ASCIIPLOT} { newTokenLexed(); return ASCIIPLOTTOKEN; } {RENAME} { newTokenLexed(); return RENAMETOKEN; } {OBJECTNAME} { newTokenLexed(); return OBJECTNAMETOKEN; } {BIND} { newTokenLexed(); return BINDTOKEN; } {INFNORM} { newTokenLexed(); return INFNORMTOKEN; } {SUPNORM} { newTokenLexed(); return SUPNORMTOKEN; } {FINDZEROS} { newTokenLexed(); return FINDZEROSTOKEN; } {FPFINDZEROS} { newTokenLexed(); return FPFINDZEROSTOKEN; } {DIRTYINFNORM} { newTokenLexed(); return DIRTYINFNORMTOKEN; } {NUMBERROOTS} { newTokenLexed(); return NUMBERROOTSTOKEN; } {INTEGRAL} { newTokenLexed(); return INTEGRALTOKEN; } {DIRTYINTEGRAL} { newTokenLexed(); return DIRTYINTEGRALTOKEN; } {WORSTCASE} { newTokenLexed(); return WORSTCASETOKEN; } {IMPLEMENTPOLY} { newTokenLexed(); return IMPLEMENTPOLYTOKEN; } {IMPLEMENTCONST} { newTokenLexed(); return IMPLEMENTCONSTTOKEN; } {CHECKINFNORM} { newTokenLexed(); return CHECKINFNORMTOKEN; } {ZERODENOMINATORS} { newTokenLexed(); return ZERODENOMINATORSTOKEN; } {ISEVALUABLE} { newTokenLexed(); return ISEVALUABLETOKEN; } {SEARCHGAL} { newTokenLexed(); return SEARCHGALTOKEN; } {GUESSDEGREE} { newTokenLexed(); return GUESSDEGREETOKEN; } {DIRTYFINDZEROS} { newTokenLexed(); return DIRTYFINDZEROSTOKEN; } {IF} { newTokenLexed(); return IFTOKEN; } {THEN} { newTokenLexed(); return THENTOKEN; } {ELSE} { newTokenLexed(); return ELSETOKEN; } {FOR} { newTokenLexed(); return FORTOKEN; } {IN} { newTokenLexed(); return INTOKEN; } {FROM} { newTokenLexed(); return FROMTOKEN; } {TO} { newTokenLexed(); return TOTOKEN; } {BY} { newTokenLexed(); return BYTOKEN; } {DO} { newTokenLexed(); return DOTOKEN; } {BEGIN} { newTokenLexed(); return BEGINTOKEN; } {END} { newTokenLexed(); return ENDTOKEN; } {LBRACE} { newTokenLexed(); return LEFTCURLYBRACETOKEN; } {RBRACE} { newTokenLexed(); return RIGHTCURLYBRACETOKEN; } {WHILEDEF} { newTokenLexed(); return WHILETOKEN; } {EXTERNALPROC} { newTokenLexed(); return EXTERNALPROCTOKEN; } {VOID} { newTokenLexed(); return VOIDTOKEN; } {CONSTANTTYPE} { newTokenLexed(); return CONSTANTTYPETOKEN; } {FUNCTION} { newTokenLexed(); return FUNCTIONTOKEN; } {OBJECT} { newTokenLexed(); return OBJECTTOKEN; } {RANGE} { newTokenLexed(); return RANGETOKEN; } {INTEGER} { newTokenLexed(); return INTEGERTOKEN; } {STRINGTYPE} { newTokenLexed(); return STRINGTYPETOKEN; } {BOOLEAN} { newTokenLexed(); return BOOLEANTOKEN; } {LIST} { newTokenLexed(); return LISTTOKEN; } {OF} { newTokenLexed(); return OFTOKEN; } {HELP} { newTokenLexed(); return HELPTOKEN; } [ \t] { /* Eat up spaces and tabulators */ } [\r] { /* Eat up carriage return for compatibility with DOS-like systems */ } [\n] { carriageReturnLexed(); } {IDENTIFIER} { constBuffer = (char *) safeCalloc(yyleng+1,sizeof(char)); strncpy(constBuffer,yytext,yyleng); yylval->value = constBuffer; newTokenLexed(); return IDENTIFIERTOKEN; } . { /* otherwise */ printMessage(1,SOLLYA_MSG_A_CHARACTER_COULD_NOT_BE_RECOGNIZED,"The character \"%s\" cannot be recognized. Will ignore it.\n", yytext); } %% FILE *getCurrentLexerStream() { return yyget_in(scanner); } char *getCurrentLexSymbol() { char *str; str = (char *) safeCalloc(yyget_leng(scanner)+1,sizeof(char)); strcpy(str,yyget_text(scanner)); return str; } void *yyalloc (yy_size_t size , yyscan_t yyscanner) { UNUSED_PARAM(yyscanner); return (void *) malloc( size ); } void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) { /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter * because both ANSI C and C++ allow castless assignment from * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ UNUSED_PARAM(yyscanner); return (void *) realloc( (char *) ptr, size ); } void yyfree (void * ptr , yyscan_t yyscanner) { UNUSED_PARAM(yyscanner); free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } sollya-6.0+ds/library.c000066400000000000000000001117401300174114700150760ustar00rootroot00000000000000/* Copyright 2007-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2) and by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #if (defined(HAVE_DLADDR) && (HAVE_DLADDR) && defined(HAVE_DL_INFO_TYPE) && (HAVE_DL_INFO_TYPE)) #define _GNU_SOURCE 1 #define _DARWIN_C_SOURCE 1 #endif #include #include #include #include #include #include #include "mpfi-compat.h" #include "expression.h" #include "general.h" #include "library.h" #include "chain.h" #include "execute.h" #ifndef RTLD_LOCAL #define RTLD_LOCAL 0 #endif #define LIBRARYFUNCTION_CASE 0 #define LIBRARYCONSTANT_CASE 1 #define LIBRARYPROC_CASE 2 /* List of Sollya keywords we must not bind dynamic objects to. The last entry must be NULL. */ static const char* sollyaKeywords[] = { "D", "DD", "DE", "Pi", "RD", "RN", "RU", "RZ", "SG", "TD", "abs", "absolute", "accurateinfnorm", "acos", "acosh", "annotatefunction", "asciiplot", "asin", "asinh", "atan", "atanh", "autodiff", "autosimplify", "bashexecute", "begin", "binary", "bind", "boolean", "by", "canonical", "ceil", "chebyshevform", "checkinfnorm", "coeff", "composepolynomials", "constant", "cos", "cosh", "decimal", "default", "degree", "denominator", "diam", "dieonerrormode", "diff", "dirtyfindzeros", "dirtyinfnorm", "dirtyintegral", "dirtysimplify", "display", "do", "double", "doubledouble", "doubleextended", "dyadic", "else", "end", "erf", "erfc", "error", "evaluate", "execute", "exp", "expand", "expm1", "exponent", "externalplot", "externalproc", "false", "file", "findzeros", "fixed", "floating", "floor", "for", "fpfindzeros", "fpminimax", "from", "fullparentheses", "function", "getsuppressedmessages", "getbacktrace", "guessdegree", "head", "hexadecimal", "honorcoeffprec", "hopitalrecursions", "horner", "if", "implementpoly", "implementconstant", "in", "inf", "infnorm", "integer", "integral", "isbound", "isevaluable", "length", "library", "libraryconstant", "list", "log", "log10", "log1p", "log2", "mantissa", "max", "mid", "midpointmode", "min", "nearestint", "numberroots", "nop", "numerator", "object", "objectname", "of", "off", "on", "parse", "perturb", "pi", "plot", "points", "postscript", "postscriptfile", "powers", "prec", "precision", "print", "printbinary", "printdouble", "printexpansion", "printfloat", "printhexa", "printsingle", "printxml", "proc", "procedure", "quit", "range", "rationalapprox", "rationalmode", "readfile", "readxml", "relative", "remez", "rename", "restart", "return", "revert", "round", "roundcoefficients", "roundcorrectly", "roundingwarnings", "searchgal", "showmessagenumbers", "simplify", "simplifysafe", "sin", "single", "sinh", "sort", "sqrt", "string", "subpoly", "substitute", "sup", "supnorm", "suppressmessage", "tail", "tan", "tanh", "taylor", "taylorform", "taylorrecursions", "then", "time", "timing", "to", "tripledouble", "true", "unsuppressmessage", "var", "verbosity", "version", "void", "while", "worstcase", "write", "zerodenominators", "_x_", "quad", "halfprecision", "QD", "HP", "bashevaluate", "help", "match", "with", NULL }; /* The last entry must be NULL */ chain *openedFunctionLibraries = NULL; chain *openedConstantLibraries = NULL; chain *openedProcLibraries = NULL; chain *globalLibraryFunctions = NULL; chain *globalLibraryConstants = NULL; chain *globalLibraryProcedures = NULL; void copyIdentifierSymbols(char *ptr, const char *src) { char *currPtr; const char *currSrc; currPtr = ptr; currSrc = src; while ((*currPtr = *currSrc) != '\0') { if (currPtr == ptr) { if (((*currSrc >= 'a') && (*currSrc <= 'z')) || ((*currSrc >= 'A') && (*currSrc <= 'Z')) || (*currSrc == '_') || (*currSrc == '$')) { currPtr++; } } else { if (((*currSrc >= 'a') && (*currSrc <= 'z')) || ((*currSrc >= 'A') && (*currSrc <= 'Z')) || ((*currSrc >= '0') && (*currSrc <= '9')) || (*currSrc == '_') || (*currSrc == '$')) { currPtr++; } } currSrc++; } } char *getBaseFunctionName(void *func, const char *base, int hasData, void *data) { char *myFuncName, *funcName; #if (defined(HAVE_DLADDR) && (HAVE_DLADDR) && defined(HAVE_DL_INFO_TYPE) && (HAVE_DL_INFO_TYPE)) int errorOccurred; Dl_info myInfo; char *temp; errorOccurred = 0; if (dladdr(func, &myInfo) != 0) { if ((myInfo.dli_sname != NULL) && (myInfo.dli_saddr != NULL)) { if (myInfo.dli_saddr == func) { if (strlen(myInfo.dli_sname) > 0) { temp = (char *) safeCalloc(strlen(myInfo.dli_sname) + 8 * sizeof(void *) + 1 + 1, sizeof(char)); if (hasData) { sprintf(temp, "%s_%p", myInfo.dli_sname, data); } else { sprintf(temp, "%s", myInfo.dli_sname); } myFuncName = (char *) safeCalloc(strlen(myInfo.dli_sname) + 8 * sizeof(void *) + 1 + 1, sizeof(char)); copyIdentifierSymbols(myFuncName, temp); safeFree(temp); } else { errorOccurred = 1; } } else { errorOccurred = 1; } } else { errorOccurred = 1; } } else { errorOccurred = 1; } if (errorOccurred) { myFuncName = (char *) safeCalloc(strlen(base) + 3 + 8 * sizeof(void *) + 1 + 8 * sizeof(void *) + 1 + 8 * sizeof(void *) + 1,sizeof(char)); if (hasData) { sprintf(myFuncName, "%s_%p_%p", base, func, data); } else { sprintf(myFuncName, "%s_%p", base, func); } } #else myFuncName = (char *) safeCalloc(strlen(base) + 3 + 8 * sizeof(void *) + 1 + 8 * sizeof(void *) + 1 + 8 * sizeof(void *) + 1,sizeof(char)); if (hasData) { sprintf(myFuncName, "%s_%p_%p", base, func, data); } else { sprintf(myFuncName, "%s_%p", base, func); } #endif funcName = (char *) safeCalloc(strlen(myFuncName)+1,sizeof(char)); strcpy(funcName, myFuncName); safeFree(myFuncName); return funcName; } char *filterSymbolName(char *basename) { char *res; res = (char *) safeCalloc(strlen(basename)+1,sizeof(char)); copyIdentifierSymbols(res, basename); return res; } int symbolNameIsKeyword(char *name) { int i; for (i=0; sollyaKeywords[i] != NULL; i++) { if (!strcmp(name, sollyaKeywords[i])) return 1; } return 0; } int isValidIdentifier(char *name) { char *tmp; int equal; if (symbolNameIsKeyword(name)) return 0; tmp = (char *) safeCalloc(strlen(name) + 1, sizeof(char)); copyIdentifierSymbols(tmp, name); equal = (strcmp(tmp, name) == 0); safeFree(tmp); return equal; } char *unifySymbolName(char *basename) { char *res, *str; uint64_t number; int found; size_t lenbasename; if (!(symbolNameAlreadyUsed(basename) || symbolNameIsKeyword(basename))) { res = (char *) safeCalloc(strlen(basename)+1,sizeof(char)); strcpy(res, basename); return res; } lenbasename = strlen(basename); number = 0; found = 0; str = NULL; do { if (str != NULL) { safeFree(str); str = NULL; } str = (char *) safeCalloc(lenbasename + 1 + 8 * sizeof(uint64_t) + 1, sizeof(char)); sprintf(str,"%s_%" PRIu64, basename, number); if (!(symbolNameAlreadyUsed(str) || symbolNameIsKeyword(str))) { found = 1; } else { number++; } } while (!found); res = safeCalloc(strlen(str)+1,sizeof(char)); strcpy(res, str); safeFree(str); return res; } libraryHandle *getLibraryHandle(char *libraryName, int type) { chain *curr; chain *openedLibraries; libraryHandle *currHandle; void *dlfcnHandle, *otherDlfcnHandle; int shallowCopy, foundElsewhere, i; chain *otherLibraries[2]; openedLibraries = NULL; switch(type) { case LIBRARYFUNCTION_CASE: openedLibraries = openedFunctionLibraries; break; case LIBRARYCONSTANT_CASE: openedLibraries = openedConstantLibraries; break; case LIBRARYPROC_CASE: openedLibraries = openedProcLibraries; break; } curr = openedLibraries; while (curr != NULL) { currHandle = (libraryHandle *) curr->value; if (strcmp(currHandle->libraryName,libraryName) == 0) return currHandle; curr = curr->next; } switch (type) { case LIBRARYFUNCTION_CASE: otherLibraries[0] = openedConstantLibraries; otherLibraries[1] = openedProcLibraries; break; case LIBRARYCONSTANT_CASE: otherLibraries[0] = openedFunctionLibraries; otherLibraries[1] = openedProcLibraries; break; case LIBRARYPROC_CASE: otherLibraries[0] = openedConstantLibraries; otherLibraries[1] = openedFunctionLibraries; break; default: sollyaFprintf(stderr,"Error: getLibraryHandle: unknown type (%d)\n", type); exit(1); } otherDlfcnHandle = NULL; for (i=0,foundElsewhere=0;(i<2)&&(!foundElsewhere);i++) { curr = otherLibraries[i]; while (curr != NULL) { currHandle = (libraryHandle *) curr->value; if (strcmp(currHandle->libraryName,libraryName) == 0) { otherDlfcnHandle = currHandle->libraryDescriptor; foundElsewhere = 1; break; } curr = curr->next; } } if (!foundElsewhere) { dlerror(); dlfcnHandle = dlopen(libraryName, RTLD_LOCAL | RTLD_NOW); if (dlfcnHandle == NULL) return NULL; shallowCopy = 0; } else { dlfcnHandle = otherDlfcnHandle; shallowCopy = 1; } currHandle = (libraryHandle *) safeMalloc(sizeof(libraryHandle)); currHandle->libraryName = (char *) safeCalloc(strlen(libraryName)+1,sizeof(char)); strcpy(currHandle->libraryName,libraryName); currHandle->libraryDescriptor = dlfcnHandle; currHandle->functionList = NULL; currHandle->shallowCopy = shallowCopy; openedLibraries = addElement(openedLibraries,currHandle); switch(type) { case LIBRARYFUNCTION_CASE: openedFunctionLibraries = openedLibraries; break; case LIBRARYCONSTANT_CASE: openedConstantLibraries = openedLibraries; break; case LIBRARYPROC_CASE: openedProcLibraries = openedLibraries; break; } return currHandle; } libraryHandle *getLibraryFunctionHandle(char *libraryName) { return getLibraryHandle(libraryName, LIBRARYFUNCTION_CASE); } libraryHandle *getConstantLibraryHandle(char *libraryName) { return getLibraryHandle(libraryName, LIBRARYCONSTANT_CASE); } libraryHandle *getProcLibraryHandle(char *libraryName) { return getLibraryHandle(libraryName, LIBRARYPROC_CASE); } /* Functions related to library functions */ libraryFunction *bindFunction(char* libraryName, char *functionName) { libraryHandle *libHandle; libraryFunction *currFunct; int (*myFunction)(sollya_mpfi_t, sollya_mpfi_t, int); char *error; sollya_mpfi_t op, rop; currFunct = getFunction(functionName); if (currFunct != NULL) { printMessage(1,SOLLYA_MSG_EXTERNAL_FUNC_OR_PROC_ALREADY_BOUND,"Warning: a function named \"%s\" has already been bound.\n",functionName); return currFunct; } libHandle = getLibraryFunctionHandle(libraryName); if (libHandle == NULL) { printMessage(1,SOLLYA_MSG_COULD_NOT_OPEN_LIBRARY_WITH_EXTERN_FUNC_OR_PROC,"Error: could not open library \"%s\" for binding \"%s\": %s\n",libraryName,functionName,dlerror()); return NULL; } dlerror(); myFunction = (int (*)(sollya_mpfi_t, sollya_mpfi_t, int)) dlsym(libHandle->libraryDescriptor, functionName); if ((error = dlerror()) != NULL) { printMessage(1, SOLLYA_MSG_EXTERNAL_FUNC_OR_PROC_NOT_FOUND_IN_LIBRARY, "Error: could not find function \"%s\" in library \"%s\" for binding: %s\n",functionName,libraryName,error); return NULL; } sollya_mpfi_init2(rop,12); sollya_mpfi_init2(op,12); sollya_mpfi_set_d(op,1.0); myFunction(rop,op,0); sollya_mpfi_clear(rop); sollya_mpfi_clear(op); currFunct = (libraryFunction *) safeMalloc(sizeof(libraryFunction)); currFunct->functionName = (char *) safeCalloc(strlen(functionName)+1,sizeof(char)); strcpy(currFunct->functionName,functionName); currFunct->code = (void *) myFunction; currFunct->hasData = 0; currFunct->data = NULL; currFunct->dealloc = NULL; libHandle->functionList = addElement(libHandle->functionList,currFunct); return currFunct; } libraryFunction *getFunction(char *functionName) { chain *currLibList, *currFunList; libraryFunction *currFunct; libraryHandle *currLibHandle; for (currFunList=globalLibraryFunctions;currFunList!=NULL;currFunList=currFunList->next) { currFunct = (libraryFunction *) currFunList->value; if (strcmp(currFunct->functionName,functionName) == 0) return currFunct; } currLibList = openedFunctionLibraries; while (currLibList != NULL) { currLibHandle = (libraryHandle *) currLibList->value; currFunList = currLibHandle->functionList; while (currFunList != NULL) { currFunct = (libraryFunction *) currFunList->value; if (strcmp(currFunct->functionName,functionName) == 0) return currFunct; currFunList = currFunList->next; } currLibList = currLibList->next; } return NULL; } libraryFunction *getFunctionByPtr(void *func, int hasData, void *data) { chain *currLibList, *currFunList; libraryFunction *currFunct; libraryHandle *currLibHandle; for (currFunList=globalLibraryFunctions;currFunList!=NULL;currFunList=currFunList->next) { currFunct = (libraryFunction *) currFunList->value; if ((currFunct->code == func) && ((!(currFunct->hasData && hasData)) || (currFunct->data == data))) return currFunct; } currLibList = openedFunctionLibraries; while (currLibList != NULL) { currLibHandle = (libraryHandle *) currLibList->value; currFunList = currLibHandle->functionList; while (currFunList != NULL) { currFunct = (libraryFunction *) currFunList->value; if ((currFunct->code == func) && ((!(currFunct->hasData && hasData)) || (currFunct->data == data))) return currFunct; currFunList = currFunList->next; } currLibList = currLibList->next; } return NULL; } static libraryFunction *__bindFunctionByPtrImpl(char *suggestedName, void *func, int hasData, void *data, void *dealloc) { libraryFunction *res; char *unifiedName, *basename, *filteredSuggestedName, *filteredBaseName; res = getFunctionByPtr(func, hasData, data); if (res != NULL) { if (hasData) { if (res->hasData) { if (res->dealloc != dealloc) { res->dealloc = dealloc; } } } return res; } if (suggestedName != NULL) { filteredSuggestedName = filterSymbolName(suggestedName); if (filteredSuggestedName[0] == '\0') { basename = getBaseFunctionName(func, "func", hasData, data); filteredBaseName = filterSymbolName(basename); safeFree(basename); if (filteredBaseName[0] == '\0') { unifiedName = unifySymbolName("func"); } else { unifiedName = unifySymbolName(filteredBaseName); } safeFree(filteredBaseName); } else { unifiedName = unifySymbolName(filteredSuggestedName); } safeFree(filteredSuggestedName); } else { basename = getBaseFunctionName(func, "func", hasData, data); filteredBaseName = filterSymbolName(basename); safeFree(basename); if (filteredBaseName[0] == '\0') { unifiedName = unifySymbolName("func"); } else { unifiedName = unifySymbolName(filteredBaseName); } safeFree(filteredBaseName); } res = (libraryFunction *) safeMalloc(sizeof(libraryFunction)); res->functionName = unifiedName; res->code = func; res->hasData = hasData; res->data = data; res->dealloc = dealloc; globalLibraryFunctions = addElement(globalLibraryFunctions, res); return res; } libraryFunction *bindFunctionByPtr(char *suggestedName, int (*func)(mpfi_t, mpfi_t, int)) { return __bindFunctionByPtrImpl(suggestedName, ((void *) func), 0, NULL, NULL); } libraryFunction *bindFunctionByPtrWithData(char *suggestedName, int (*func)(mpfi_t, mpfi_t, int, void *), void *data, void (*dealloc)(void *)) { return __bindFunctionByPtrImpl(suggestedName, ((void *) func), 1, data, ((void *) dealloc)); } void freeFunctionLibraries() { chain *currLibList, *currFunList, *prevFunList, *prevLibList; libraryFunction *currFunct; libraryHandle *currLibHandle; int (*myFunction)(void); int res; currFunList = globalLibraryFunctions; while (currFunList != NULL) { currFunct = (libraryFunction *) currFunList->value; if (currFunct->dealloc != NULL) { if (currFunct->hasData) { ((void (*)(void *)) currFunct->dealloc)(currFunct->data); } else { ((void (*)()) currFunct->dealloc)(); } } safeFree(currFunct->functionName); safeFree(currFunList->value); prevFunList = currFunList; currFunList = currFunList->next; safeFree(prevFunList); } currLibList = openedFunctionLibraries; while (currLibList != NULL) { currLibHandle = (libraryHandle *) currLibList->value; if (!(currLibHandle->shallowCopy)) { dlerror(); myFunction = (int (*)(void)) dlsym(currLibHandle->libraryDescriptor, "sollya_external_lib_close"); if (dlerror() == NULL) { res = myFunction(); if (res) { printMessage(1,SOLLYA_MSG_LIBRARY_CLOSER_ERROR,"Warning: while closing library \"%s\", the function \"sollya_external_lib_close\" was found and called but it signaled the error %d\n",currLibHandle->libraryName,res); } } } currFunList = currLibHandle->functionList; while (currFunList != NULL) { currFunct = (libraryFunction *) currFunList->value; if (currFunct->dealloc != NULL) { if (currFunct->hasData) { ((void (*)(void *)) currFunct->dealloc)(currFunct->data); } else { ((void (*)()) currFunct->dealloc)(); } } safeFree(currFunct->functionName); safeFree(currFunList->value); prevFunList = currFunList; currFunList = currFunList->next; safeFree(prevFunList); } if (!(currLibHandle->shallowCopy)) { dlerror(); if (dlclose(currLibHandle->libraryDescriptor) != 0) printMessage(1,SOLLYA_MSG_COULD_NOT_CLOSE_LIBRARY,"Warning: could not close library \"%s\": %s\n",currLibHandle->libraryName,dlerror()); } safeFree(currLibHandle->libraryName); safeFree(currLibHandle); prevLibList = currLibList; currLibList = currLibList->next; safeFree(prevLibList); } openedFunctionLibraries = NULL; } /* Functions related to library constants */ libraryFunction *bindConstantFunction(char* libraryName, char *functionName) { libraryHandle *libHandle; libraryFunction *currFunct; void (*myFunction)(mpfr_t, mp_prec_t); char *error; mpfr_t op; currFunct = getConstantFunction(functionName); if (currFunct != NULL) { printMessage(1,SOLLYA_MSG_EXTERNAL_FUNC_OR_PROC_ALREADY_BOUND,"Warning: a function named \"%s\" has already been bound.\n",functionName); return currFunct; } libHandle = getConstantLibraryHandle(libraryName); if (libHandle == NULL) { printMessage(1,SOLLYA_MSG_COULD_NOT_OPEN_LIBRARY_WITH_EXTERN_FUNC_OR_PROC,"Error: could not open library \"%s\" for binding \"%s\": %s\n",libraryName,functionName,dlerror()); return NULL; } dlerror(); myFunction = (void (*)(mpfr_t, mp_prec_t)) dlsym(libHandle->libraryDescriptor, functionName); if ((error = dlerror()) != NULL) { printMessage(1, SOLLYA_MSG_EXTERNAL_FUNC_OR_PROC_NOT_FOUND_IN_LIBRARY, "Error: could not find function \"%s\" in library \"%s\" for binding: %s\n",functionName,libraryName,error); return NULL; } mpfr_init2(op,20); myFunction(op,5); mpfr_clear(op); currFunct = (libraryFunction *) safeMalloc(sizeof(libraryFunction)); currFunct->functionName = (char *) safeCalloc(strlen(functionName)+1,sizeof(char)); strcpy(currFunct->functionName,functionName); currFunct->code = (void *) myFunction; currFunct->hasData = 0; currFunct->data = NULL; currFunct->dealloc = NULL; libHandle->functionList = addElement(libHandle->functionList,currFunct); return currFunct; } libraryFunction *getConstantFunction(char *functionName) { chain *currLibList, *currFunList; libraryFunction *currFunct; libraryHandle *currLibHandle; for (currFunList=globalLibraryConstants;currFunList!=NULL;currFunList=currFunList->next) { currFunct = (libraryFunction *) currFunList->value; if (strcmp(currFunct->functionName,functionName) == 0) return currFunct; } currLibList = openedConstantLibraries; while (currLibList != NULL) { currLibHandle = (libraryHandle *) currLibList->value; currFunList = currLibHandle->functionList; while (currFunList != NULL) { currFunct = (libraryFunction *) currFunList->value; if (strcmp(currFunct->functionName,functionName) == 0) return currFunct; currFunList = currFunList->next; } currLibList = currLibList->next; } return NULL; } libraryFunction *getConstantFunctionByPtr(void *func, int hasData, void *data) { chain *currLibList, *currFunList; libraryFunction *currFunct; libraryHandle *currLibHandle; for (currFunList=globalLibraryConstants;currFunList!=NULL;currFunList=currFunList->next) { currFunct = (libraryFunction *) currFunList->value; if ((currFunct->code == func) && ((!(currFunct->hasData && hasData)) || (currFunct->data == data))) return currFunct; } currLibList = openedConstantLibraries; while (currLibList != NULL) { currLibHandle = (libraryHandle *) currLibList->value; currFunList = currLibHandle->functionList; while (currFunList != NULL) { currFunct = (libraryFunction *) currFunList->value; if ((currFunct->code == func) && ((!(currFunct->hasData && hasData)) || (currFunct->data == data))) return currFunct; currFunList = currFunList->next; } currLibList = currLibList->next; } return NULL; } static libraryFunction *__bindConstantFunctionByPtrImpl(char *suggestedName, void *func, int hasData, void *data, void *dealloc) { libraryFunction *res; char *unifiedName, *basename, *filteredBaseName, *filteredSuggestedName; res = getConstantFunctionByPtr(func, hasData, data); if (res != NULL) { if (hasData) { if (res->hasData) { if (res->dealloc != dealloc) { res->dealloc = dealloc; } } } return res; } if (suggestedName != NULL) { filteredSuggestedName = filterSymbolName(suggestedName); if (filteredSuggestedName[0] == '\0') { basename = getBaseFunctionName(func, "const", hasData, data); filteredBaseName = filterSymbolName(basename); safeFree(basename); if (filteredBaseName[0] == '\0') { unifiedName = unifySymbolName("const"); } else { unifiedName = unifySymbolName(filteredBaseName); } safeFree(filteredBaseName); } else { unifiedName = unifySymbolName(filteredSuggestedName); } safeFree(filteredSuggestedName); } else { basename = getBaseFunctionName(func, "const", hasData, data); filteredBaseName = filterSymbolName(basename); safeFree(basename); if (filteredBaseName[0] == '\0') { unifiedName = unifySymbolName("const"); } else { unifiedName = unifySymbolName(filteredBaseName); } safeFree(filteredBaseName); } res = (libraryFunction *) safeMalloc(sizeof(libraryFunction)); res->functionName = unifiedName; res->code = func; res->hasData = hasData; res->data = data; res->dealloc = dealloc; globalLibraryConstants = addElement(globalLibraryConstants, res); return res; } libraryFunction *bindConstantFunctionByPtr(char *suggestedName, void (*func)(mpfr_t, mp_prec_t)) { return __bindConstantFunctionByPtrImpl(suggestedName, ((void *) func), 0, NULL, NULL); } libraryFunction *bindConstantFunctionByPtrWithData(char *suggestedName, void (*func)(mpfr_t, mp_prec_t, void *), void *data, void (*dealloc)(void *)) { return __bindConstantFunctionByPtrImpl(suggestedName, ((void *) func), 1, data, ((void *) dealloc)); } void freeConstantLibraries() { chain *currLibList, *currFunList, *prevFunList, *prevLibList; libraryFunction *currFunct; libraryHandle *currLibHandle; int res; int (*myFunction)(void); currFunList = globalLibraryConstants; while (currFunList != NULL) { currFunct = (libraryFunction *) currFunList->value; if (currFunct->dealloc != NULL) { if (currFunct->hasData) { ((void (*)(void *)) currFunct->dealloc)(currFunct->data); } else { ((void (*)()) currFunct->dealloc)(); } } safeFree(currFunct->functionName); safeFree(currFunList->value); prevFunList = currFunList; currFunList = currFunList->next; safeFree(prevFunList); } currLibList = openedConstantLibraries; while (currLibList != NULL) { currLibHandle = (libraryHandle *) currLibList->value; if (!(currLibHandle->shallowCopy)) { dlerror(); myFunction = (int (*)(void)) dlsym(currLibHandle->libraryDescriptor, "sollya_external_lib_close"); if (dlerror() == NULL) { res = myFunction(); if (res) { printMessage(1,SOLLYA_MSG_LIBRARY_CLOSER_ERROR,"Warning: while closing library \"%s\", the function \"sollya_external_lib_close\" was found and called but it signaled the error %d\n",currLibHandle->libraryName,res); } } } currFunList = currLibHandle->functionList; while (currFunList != NULL) { currFunct = (libraryFunction *) currFunList->value; if (currFunct->dealloc != NULL) { if (currFunct->hasData) { ((void (*)(void *)) currFunct->dealloc)(currFunct->data); } else { ((void (*)()) currFunct->dealloc)(); } } safeFree(currFunct->functionName); safeFree(currFunList->value); prevFunList = currFunList; currFunList = currFunList->next; safeFree(prevFunList); } if (!(currLibHandle->shallowCopy)) { dlerror(); if (dlclose(currLibHandle->libraryDescriptor) != 0) printMessage(1,SOLLYA_MSG_COULD_NOT_CLOSE_LIBRARY,"Warning: could not close library \"%s\": %s\n",currLibHandle->libraryName,dlerror()); } safeFree(currLibHandle->libraryName); safeFree(currLibHandle); prevLibList = currLibList; currLibList = currLibList->next; safeFree(prevLibList); } openedConstantLibraries = NULL; } /* Functions related to external procedures */ libraryProcedure *bindProcedure(char* libraryName, char *procedureName, chain *signature) { libraryHandle *libHandle; libraryProcedure *currProc; char *error; void *myFunction; currProc = getProcedure(procedureName); if (currProc != NULL) { printMessage(1,SOLLYA_MSG_EXTERNAL_FUNC_OR_PROC_ALREADY_BOUND,"Warning: a function named \"%s\" has already been bound.\n",procedureName); return currProc; } libHandle = getProcLibraryHandle(libraryName); if (libHandle == NULL) { printMessage(1,SOLLYA_MSG_COULD_NOT_OPEN_LIBRARY_WITH_EXTERN_FUNC_OR_PROC,"Error: could not open library \"%s\" for binding \"%s\": %s\n",libraryName,procedureName,dlerror()); return NULL; } dlerror(); myFunction = dlsym(libHandle->libraryDescriptor, procedureName); if ((error = dlerror()) != NULL) { printMessage(1, SOLLYA_MSG_EXTERNAL_FUNC_OR_PROC_NOT_FOUND_IN_LIBRARY, "Error: could not find function \"%s\" in library \"%s\" for binding: %s\n",procedureName,libraryName,error); return NULL; } currProc = (libraryProcedure *) safeMalloc(sizeof(libraryProcedure)); currProc->procedureName = (char *) safeCalloc(strlen(procedureName)+1,sizeof(char)); strcpy(currProc->procedureName,procedureName); currProc->code = myFunction; currProc->signature = copyChainWithoutReversal(signature, copyIntPtrOnVoid); currProc->hasData = 0; currProc->data = NULL; currProc->dealloc = NULL; libHandle->functionList = addElement(libHandle->functionList,currProc); return currProc; } libraryProcedure *getProcedure(char *procedureName) { chain *currLibList, *currProcList; libraryProcedure *currProc; libraryHandle *currLibHandle; for (currProcList=globalLibraryProcedures;currProcList!=NULL;currProcList=currProcList->next) { currProc = (libraryProcedure *) currProcList->value; if (strcmp(currProc->procedureName,procedureName) == 0) return currProc; } currLibList = openedProcLibraries; while (currLibList != NULL) { currLibHandle = (libraryHandle *) currLibList->value; currProcList = currLibHandle->functionList; while (currProcList != NULL) { currProc = (libraryProcedure *) currProcList->value; if (strcmp(currProc->procedureName,procedureName) == 0) return currProc; currProcList = currProcList->next; } currLibList = currLibList->next; } return NULL; } libraryProcedure *getProcedureByPtr(void *ptr, int hasData, void *data) { chain *currLibList, *currProcList; libraryProcedure *currProc; libraryHandle *currLibHandle; for (currProcList=globalLibraryProcedures;currProcList!=NULL;currProcList=currProcList->next) { currProc = (libraryProcedure *) currProcList->value; if ((currProc->code == ptr) && ((!(currProc->hasData && hasData)) || (currProc->data == data))) return currProc; } currLibList = openedProcLibraries; while (currLibList != NULL) { currLibHandle = (libraryHandle *) currLibList->value; currProcList = currLibHandle->functionList; while (currProcList != NULL) { currProc = (libraryProcedure *) currProcList->value; if ((currProc->code == ptr) && ((!(currProc->hasData && hasData)) || (currProc->data == data))) return currProc; currProcList = currProcList->next; } currLibList = currLibList->next; } return NULL; } static libraryProcedure *__bindProcedureByPtrImpl(int resType, int *argTypes, int arity, char *suggestedName, void *func, int hasData, void *data, void *dealloc) { libraryProcedure *res; char *unifiedName, *basename, *filteredBaseName, *filteredSuggestedName; chain *signature, *temp; int i; int *t; if (arity < 0) return NULL; if (arity > 1) { for (i=1;ihasData) { if (res->dealloc != dealloc) { res->dealloc = dealloc; } } } return res; } signature = NULL; t = (int *) safeMalloc(sizeof(int)); *t = resType; signature = addElement(signature, t); if (arity == 0) { t = (int *) safeMalloc(sizeof(int)); *t = VOID_TYPE; signature = addElement(signature, t); } else { for (i=0;iprocedureName = unifiedName; res->code = func; res->signature = signature; res->hasData = hasData; res->data = data; res->dealloc = dealloc; globalLibraryProcedures = addElement(globalLibraryProcedures, res); return res; } libraryProcedure *bindProcedureByPtr(int resType, int *argTypes, int arity, char *suggestedName, void *func) { return __bindProcedureByPtrImpl(resType, argTypes, arity, suggestedName, func, 0, NULL, NULL); } libraryProcedure *bindProcedureByPtrWithData(int resType, int *argTypes, int arity, char *suggestedName, void *func, void *data, void (*dealloc)(void *)) { return __bindProcedureByPtrImpl(resType, argTypes, arity, suggestedName, func, 1, data, ((void *) dealloc)); } void freeProcLibraries() { chain *currLibList, *currProcList, *prevProcList, *prevLibList; libraryProcedure *currProc; libraryHandle *currLibHandle; int res; int (*myFunction)(void); currProcList = globalLibraryProcedures; while (currProcList != NULL) { currProc = (libraryProcedure *) currProcList->value; if (currProc->dealloc != NULL) { if (currProc->hasData) { ((void (*)(void *)) currProc->dealloc)(currProc->data); } else { ((void (*)()) currProc->dealloc)(); } } safeFree(currProc->procedureName); freeChain(currProc->signature,freeIntPtr); safeFree(currProcList->value); prevProcList = currProcList; currProcList = currProcList->next; safeFree(prevProcList); } currLibList = openedProcLibraries; while (currLibList != NULL) { currLibHandle = (libraryHandle *) currLibList->value; if (!(currLibHandle->shallowCopy)) { dlerror(); myFunction = (int (*)(void)) dlsym(currLibHandle->libraryDescriptor, "sollya_external_lib_close"); if (dlerror() == NULL) { res = myFunction(); if (res) { printMessage(1,SOLLYA_MSG_LIBRARY_CLOSER_ERROR,"Warning: while closing library \"%s\", the function \"sollya_external_lib_close\" was found and called but it signaled the error %d\n",currLibHandle->libraryName,res); } } } currProcList = currLibHandle->functionList; while (currProcList != NULL) { currProc = (libraryProcedure *) currProcList->value; if (currProc->dealloc != NULL) { if (currProc->hasData) { ((void (*)(void *)) currProc->dealloc)(currProc->data); } else { ((void (*)()) currProc->dealloc)(); } } safeFree(currProc->procedureName); freeChain(currProc->signature,freeIntPtr); safeFree(currProcList->value); prevProcList = currProcList; currProcList = currProcList->next; safeFree(prevProcList); } if (!(currLibHandle->shallowCopy)) { dlerror(); if (dlclose(currLibHandle->libraryDescriptor) != 0) printMessage(1,SOLLYA_MSG_COULD_NOT_CLOSE_LIBRARY,"Warning: could not close library \"%s\": %s\n",currLibHandle->libraryName,dlerror()); } safeFree(currLibHandle->libraryName); safeFree(currLibHandle); prevLibList = currLibList; currLibList = currLibList->next; safeFree(prevLibList); } openedProcLibraries = NULL; } sollya-6.0+ds/library.h000066400000000000000000000111341300174114700150770ustar00rootroot00000000000000/* Copyright 2007-2015 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2) and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributor Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef LIBRARY_H #define LIBRARY_H #include #include "mpfi-compat.h" #include #include "expression.h" #include "chain.h" typedef struct libraryHandleStruct libraryHandle; struct libraryHandleStruct { char *libraryName; void *libraryDescriptor; chain *functionList; int shallowCopy; }; typedef struct libraryFunctionStruct libraryFunction; struct libraryFunctionStruct { char *functionName; void *code; int hasData; void *data; void *dealloc; }; typedef struct libraryProcedureStruct libraryProcedure; struct libraryProcedureStruct { char *procedureName; void *code; chain *signature; int hasData; void *data; void *dealloc; }; #define VOID_TYPE 0 #define CONSTANT_TYPE 1 #define FUNCTION_TYPE 2 #define RANGE_TYPE 3 #define INTEGER_TYPE 4 #define STRING_TYPE 5 #define BOOLEAN_TYPE 6 #define CONSTANT_LIST_TYPE 7 #define FUNCTION_LIST_TYPE 8 #define RANGE_LIST_TYPE 9 #define INTEGER_LIST_TYPE 10 #define STRING_LIST_TYPE 11 #define BOOLEAN_LIST_TYPE 12 #define OBJECT_TYPE 13 #define OBJECT_LIST_TYPE 14 libraryFunction *bindFunction(char* libraryName, char *functionName); libraryFunction *bindConstantFunction(char* libraryName, char *functionName); libraryProcedure *bindProcedure(char* libraryName, char *procedureName, chain *signature); libraryFunction *getFunction(char *functionName); libraryFunction *getConstantFunction(char *functionName); libraryProcedure *getProcedure(char *procedureName); void freeFunctionLibraries(); void freeConstantLibraries(); void freeProcLibraries(); libraryFunction *bindFunctionByPtr(char *suggestedName, int (*func)(mpfi_t, mpfi_t, int)); libraryFunction *bindConstantFunctionByPtr(char *suggestedName, void (*func)(mpfr_t, mp_prec_t)); libraryProcedure *bindProcedureByPtr(int resType, int *argTypes, int arity, char *suggestedName, void *func); libraryFunction *bindFunctionByPtrWithData(char *suggestedName, int (*func)(mpfi_t, mpfi_t, int, void *), void *data, void (*dealloc)(void *)); libraryFunction *bindConstantFunctionByPtrWithData(char *suggestedName, void (*func)(mpfr_t, mp_prec_t, void *), void *data, void (*dealloc)(void *)); libraryProcedure *bindProcedureByPtrWithData(int resType, int *argTypes, int arity, char *suggestedName, void *func, void *data, void (*dealloc)(void *)); int isValidIdentifier(char *name); #endif /* ifdef LIBRARY_H*/ sollya-6.0+ds/main.c000066400000000000000000000047401300174114700143570ustar00rootroot00000000000000/* Copyright 2006-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ int sollya_tool_main(int, char *[]); int main(int argc, char *argv[]) { return sollya_tool_main(argc, argv); } sollya-6.0+ds/match.c000066400000000000000000001527571300174114700145430ustar00rootroot00000000000000/* Copyright 2011-2014 by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also herefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "expression.h" #include "execute.h" #include "chain.h" #include "assignment.h" #include #include /* A small wrapper around evaluateThing to be sure that the returned object has no memory references */ node *evaluateThingDeepCopy(node *thing) { node *tempNode, *res; tempNode = evaluateThing(thing); res = deepCopyThing(tempNode); freeThing(tempNode); return res; } /* Declare tryMatch immediately as it is recursively used almost everywhere */ int tryMatch(chain **, node *, node *); /* Add association identifier -> thing to list If identifier exists already: - And is associated to a thing that is equal to thing, return success (1) - And is associated to a different thing, return failure (0) Otherwise: create the association identifier -> thing and add it to the list, return success (1) */ int associateThing(chain **associations, char *identifier, node *thing) { chain *curr; entry *newEntry; for (curr = *associations; curr != NULL; curr = curr->next) { if (!strcmp(identifier, ((char *) (((entry *) (curr->value))->name)))) { /* Identifier exists already in list */ if (isEqualThing(thing, ((node *) (((entry *) (curr->value))->value)))) { /* But it is associated to the same thing */ return 1; } else { /* But it is associated to another thing */ return 0; } } } newEntry = (entry *) safeMalloc(sizeof(entry)); newEntry->name = (char *) safeCalloc(strlen(identifier) + 1,sizeof(char)); strcpy(newEntry->name, identifier); newEntry->value = copyThing(thing); *associations = addElement(*associations, newEntry); return 1; } int tryCombineAssociations(chain **associations, chain *assoc1, chain *assoc2) { int okay; chain *myAssociations = NULL; chain *curr; if ((assoc1 == NULL) && (assoc2 == NULL)) { *associations = NULL; return 1; } if (assoc1 == NULL) { *associations = copyChain(assoc2,copyEntryOnVoid); return 1; } if (assoc2 == NULL) { *associations = copyChain(assoc1,copyEntryOnVoid); return 1; } okay = 1; myAssociations = copyChain(assoc1,copyEntryOnVoid); for (curr=assoc2; curr != NULL; curr = curr->next) { if (!associateThing(&myAssociations, ((char *) ((entry *) (curr->value))->name), ((node *) ((entry *) (curr->value))->value))) { okay = 0; break; } } if (okay) { *associations = myAssociations; } else { if (myAssociations != NULL) { freeChain(myAssociations, freeEntryOnVoid); } } return okay; } node *headFunction(node *tree) { node *copy; switch (tree->nodeType) { case MEMREF: return headFunction(getMemRefChild(tree)); break; case VARIABLE: case CONSTANT: case ADD: case SUB: case MUL: case DIV: case POW: case PI_CONST: case LIBRARYCONSTANT: copy = NULL; break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case DOUBLE: case SINGLE: case QUAD: case HALFPRECISION: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case CEIL: case FLOOR: case NEARESTINT: copy = (node *) safeMalloc(sizeof(node)); copy->nodeType = tree->nodeType; copy->child1 = makeVariable(); break; case LIBRARYFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = LIBRARYFUNCTION; copy->libFun = tree->libFun; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = makeVariable(); break; case PROCEDUREFUNCTION: copy = (node*) safeMalloc(sizeof(node)); copy->nodeType = PROCEDUREFUNCTION; copy->libFunDeriv = tree->libFunDeriv; copy->child1 = makeVariable(); copy->child2 = copyThing(tree->child2); break; default: sollyaFprintf(stderr,"Error: headFunction: unknown identifier in the tree\n"); exit(1); } return copy; } int tryMatchExtendedPureTree(chain **associations, node *thingToMatch, node *possibleMatcher) { chain *leftAssoc, *rightAssoc, *recursionAssoc; int okay, recursion, matchRecursion; node *currentThingToMatch, *currentPossibleMatcher, *headSymbol, *newHeadSymbol, *tempNode; char *currentIdentifier; /* Special case: possibleMatcher is default. Everthing that is correctly typed (and we know it is) matches without creating any binding. */ if (accessThruMemRef(possibleMatcher)->nodeType == DEFAULT) { return 1; } /* The free variable matches the free variable */ if ((accessThruMemRef(possibleMatcher)->nodeType == VARIABLE) && (accessThruMemRef(thingToMatch)->nodeType == VARIABLE)) { return 1; } /* Special case: possibleMatcher is an apply of the free variable on a function */ if (accessThruMemRef(possibleMatcher)->nodeType == APPLY) { /* Check if the child of the apply is the free variable */ if (accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->nodeType != VARIABLE) { if (variablename == NULL) return 0; if (accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->nodeType != TABLEACCESS) return 0; if (strcmp(variablename,accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->string)) return 0; } /* Check if recursion is possible on the thing to match */ switch (accessThruMemRef(thingToMatch)->nodeType) { case VARIABLE: case CONSTANT: case PI_CONST: case LIBRARYCONSTANT: case ADD: case SUB: case MUL: case DIV: case POW: return 0; break; default: break; } /* If we are here, we are sure that recursion is possible on the one, first and only child of the thing to match. */ okay = tryMatchExtendedPureTree(associations, thingToMatch, ((node *) (accessThruMemRef(possibleMatcher)->arguments->value))); if (okay) { if (variablename != NULL) { printMessage(1,SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION,"Warning: the identifier \"%s\" is bound to the current free variable. In a functional context it will be considered as the identity function.\n", variablename); } else { printMessage(1,SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION,"Warning: \"_x_\" is the free variable. In a functional context it will be considered as the identity function.\n"); } } return okay; } /* Special case: possibleMatcher is a free variable to bind Check if it is possible equal to the mathematical free variable. If not, create an association */ if (accessThruMemRef(possibleMatcher)->nodeType == TABLEACCESS) { if ((variablename != NULL) && (!strcmp(variablename, accessThruMemRef(possibleMatcher)->string))) { /* Here, the free variable to bind is actually equal to the free mathematical variable. We have a match if the thing to match is also equal to the free mathematical variable. Otherwise, we have no match. In none of the cases, we have to establish an association nor call ourselves for recursion. */ return (accessThruMemRef(thingToMatch)->nodeType == VARIABLE); } /* Here, the free variable is not the mathematical one. We have to establish an association and return success (unless the association fails). */ return associateThing(associations, accessThruMemRef(possibleMatcher)->string, thingToMatch); } /* Second special case: possibleMatcher is a free variable in an application context (e.g. f(thing)) First check, if recursion is actually possible on the thing to match. Recursion is not possible: - On a variable - On a constant - On pi - On a library constant - On a binary function (as we have only one variable on the possible matcher). Second check if it is equal to the free mathematical variable. If it is, consider the free mathematic variable as the identity function (emitting a warning) and return the match result of child tree. Otherwise, perform matching logic for the case when f(thing) makes sense. */ if (accessThruMemRef(possibleMatcher)->nodeType == TABLEACCESSWITHSUBSTITUTE) { /* Check if recursion is possible on the thing to match */ switch (accessThruMemRef(thingToMatch)->nodeType) { case VARIABLE: case CONSTANT: case PI_CONST: case LIBRARYCONSTANT: case ADD: case SUB: case MUL: case DIV: case POW: return 0; break; default: break; } /* If we are here, we are sure that recursion is possible on the one, first and only child of the thing to match. Now check if the identifier is equal to the free mathematical variable. */ if ((variablename != NULL) && (!strcmp(variablename, accessThruMemRef(possibleMatcher)->string))) { /* Here, the free variable to bind is actually equal to the free mathematical variable. */ okay = tryMatchExtendedPureTree(associations, thingToMatch, ((node *) (accessThruMemRef(possibleMatcher)->arguments->value))); if (okay) { if (variablename != NULL) { printMessage(1,SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION,"Warning: the identifier \"%s\" is bound to the current free variable. In a functional context it will be considered as the identity function.\n", variablename); } else { printMessage(1,SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION,"Warning: \"_x_\" is the free variable. In a functional context it will be considered as the identity function.\n"); } } return okay; } /* Here, the free variable is not the mathematical one. We know that recursion is possible on the one, first and only child of the thing to match. */ okay = 0; recursion = 1; currentThingToMatch = accessThruMemRef(thingToMatch)->child1; /* No copy, just the ptr */ currentPossibleMatcher = (node *) (accessThruMemRef(possibleMatcher)->arguments->value); /* No copy, just the ptr */ currentIdentifier = accessThruMemRef(possibleMatcher)->string; /* No copy, just the ptr */ headSymbol = headFunction(thingToMatch); /* This one performs mallocs */ if (headSymbol == NULL) { /* This case should never happen */ return 0; } do { recursionAssoc = NULL; matchRecursion = tryMatchExtendedPureTree(&recursionAssoc, currentThingToMatch, currentPossibleMatcher); if (matchRecursion) { /* We have a match on recursion. This means we just have to check if we can associate the current identifier with the headSymbol */ recursion = 0; okay = associateThing(&recursionAssoc, currentIdentifier, headSymbol); if (okay) { *associations = copyChainWithoutReversal(recursionAssoc, copyEntryOnVoid); } } else { /* Here, we do not match on recursion. We have to check now if we can extend the head symbol to one level below and check again. There is no recursion possible: - if the current thing to match is one of -- variable -- constant -- pi -- libraryconstant -- binary function - if the current possible matcher is a free variable in an application context */ switch (accessThruMemRef(currentThingToMatch)->nodeType) { case VARIABLE: case CONSTANT: case PI_CONST: case LIBRARYCONSTANT: case ADD: case SUB: case MUL: case DIV: case POW: recursion = 0; break; default: break; } if (recursion) { if (accessThruMemRef(currentPossibleMatcher)->nodeType == TABLEACCESSWITHSUBSTITUTE) recursion = 0; if (recursion) { /* Here, recursion is possible Compute a new head symbol. Move currentThingToMatch to the one, first and only child of the current thing to match. */ tempNode = headFunction(currentThingToMatch); if (tempNode == NULL) { /* This case should never happen */ recursion = 0; } else { newHeadSymbol = substitute(headSymbol, tempNode); free_memory(tempNode); free_memory(headSymbol); headSymbol = newHeadSymbol; currentThingToMatch = accessThruMemRef(currentThingToMatch)->child1; } } } } if (recursionAssoc != NULL) freeChain(recursionAssoc, freeEntryOnVoid); } while (recursion); free_memory(headSymbol); return okay; } /* Here, possibleMatcher is itself a pure tree, i.e. a function without free variables to bind. To start with, we cannot have a match if the head symbols are not the same. */ if (accessThruMemRef(possibleMatcher)->nodeType != accessThruMemRef(thingToMatch)->nodeType) return 0; /* Here, the head symbols are always the same */ switch (accessThruMemRef(possibleMatcher)->nodeType) { case VARIABLE: /* The free mathematical variable matches the free mathematical variable */ return 1; break; case CONSTANT: /* Constants match if they are the same. We have to be careful with NaNs */ if (mpfr_nan_p(*(accessThruMemRef(possibleMatcher)->value)) && mpfr_nan_p(*(accessThruMemRef(thingToMatch)->value))) return 1; if (mpfr_equal_p(*(accessThruMemRef(possibleMatcher)->value),*(accessThruMemRef(thingToMatch)->value))) return 1; return 0; break; case ADD: case SUB: case MUL: case DIV: case POW: /* Binary functions match if both sub-expressions match and if we can combine ("unify") both association lists. */ leftAssoc = NULL; rightAssoc = NULL; if (!tryMatchExtendedPureTree(&leftAssoc, accessThruMemRef(thingToMatch)->child1, accessThruMemRef(possibleMatcher)->child1)) return 0; if (!tryMatchExtendedPureTree(&rightAssoc, accessThruMemRef(thingToMatch)->child2, accessThruMemRef(possibleMatcher)->child2)) return 0; okay = tryCombineAssociations(associations, leftAssoc, rightAssoc); if (leftAssoc != NULL) freeChain(leftAssoc, freeEntryOnVoid); if (rightAssoc != NULL) freeChain(rightAssoc, freeEntryOnVoid); return okay; break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case NEG: case ABS: case DOUBLE: case SINGLE: case QUAD: case HALFPRECISION: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case CEIL: case FLOOR: case NEARESTINT: /* Unary functions: we have a match if we have a match on recursion Possible associations are established on recursion. */ return tryMatchExtendedPureTree(associations, accessThruMemRef(thingToMatch)->child1, accessThruMemRef(possibleMatcher)->child1); break; case PI_CONST: /* Pi matches pi */ return 1; break; case LIBRARYFUNCTION: /* Library functions to not match if they are not bound to the same code or if they are at different differentiation levels */ if ((accessThruMemRef(possibleMatcher)->libFun != accessThruMemRef(thingToMatch)->libFun) || (accessThruMemRef(possibleMatcher)->libFunDeriv != accessThruMemRef(thingToMatch)->libFunDeriv)) return 0; /* Otherwise they match when recursion matches */ return tryMatchExtendedPureTree(associations, accessThruMemRef(thingToMatch)->child1, accessThruMemRef(possibleMatcher)->child1); break; case LIBRARYCONSTANT: /* Library constants match iff they are bound to the same code */ return (accessThruMemRef(possibleMatcher)->libFun == accessThruMemRef(thingToMatch)->libFun); break; case PROCEDUREFUNCTION: /* Procedure functions do not match if they are not based on the same procedure or if they are at different differentiation levels */ if ((!isEqualThing(accessThruMemRef(possibleMatcher)->child2, accessThruMemRef(thingToMatch)->child2)) || (accessThruMemRef(possibleMatcher)->libFunDeriv != accessThruMemRef(thingToMatch)->libFunDeriv)) return 0; /* Otherwise they match when recursion matches */ return tryMatchExtendedPureTree(associations, accessThruMemRef(thingToMatch)->child1, accessThruMemRef(possibleMatcher)->child1); break; default: sollyaFprintf(stderr,"Error: tryMatchExtendedPureTree: unknown identifier (%d) in the tree\n",accessThruMemRef(possibleMatcher)->nodeType); exit(1); } /* We should never get here */ return 0; } int tryMatchRange(chain **associations, mpfr_t a, mpfr_t b, node *possibleMatcher) { chain *myAssociations; node *tempNode; int okay; if (accessThruMemRef(possibleMatcher)->nodeType != RANGE) return 0; if (!((accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->nodeType == CONSTANT) || (accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->nodeType == TABLEACCESS) || (accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->nodeType == DEFAULT))) return 0; if (!((accessThruMemRef(accessThruMemRef(possibleMatcher)->child2)->nodeType == CONSTANT) || (accessThruMemRef(accessThruMemRef(possibleMatcher)->child2)->nodeType == TABLEACCESS) || (accessThruMemRef(accessThruMemRef(possibleMatcher)->child2)->nodeType == DEFAULT))) return 0; if (variablename != NULL) { if (accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->nodeType == TABLEACCESS) { if (!strcmp(accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->string,variablename)) return 0; } if (accessThruMemRef(accessThruMemRef(possibleMatcher)->child2)->nodeType == TABLEACCESS) { if (!strcmp(accessThruMemRef(accessThruMemRef(possibleMatcher)->child2)->string,variablename)) return 0; } } if (accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->nodeType == CONSTANT) { if ((!mpfr_equal_p(*(accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->value),a)) && (!(mpfr_nan_p(*(accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->value)) && mpfr_nan_p(a)))) return 0; } if (accessThruMemRef(accessThruMemRef(possibleMatcher)->child2)->nodeType == CONSTANT) { if ((!mpfr_equal_p(*(accessThruMemRef(accessThruMemRef(possibleMatcher)->child2)->value),b)) && (!(mpfr_nan_p(*(accessThruMemRef(accessThruMemRef(possibleMatcher)->child2)->value)) && mpfr_nan_p(b)))) return 0; } /* Here, we know that the possible Matcher is a range, that its childs are either constants equal to the bounds of the thing to match or that they are free variables different from the free mathematical variable or default */ myAssociations = NULL; okay = 1; if (accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->nodeType == TABLEACCESS) { tempNode = makeConstant(a); okay = associateThing(&myAssociations, accessThruMemRef(accessThruMemRef(possibleMatcher)->child1)->string, tempNode); free_memory(tempNode); } if (okay && (accessThruMemRef(accessThruMemRef(possibleMatcher)->child2)->nodeType == TABLEACCESS)) { tempNode = makeConstant(b); okay = associateThing(&myAssociations, accessThruMemRef(accessThruMemRef(possibleMatcher)->child2)->string, tempNode); free_memory(tempNode); } if (okay) { *associations = myAssociations; } else { if (myAssociations != NULL) freeChain(myAssociations, freeEntryOnVoid); } return okay; } int isIntegerElement(int *res, node *thing) { mpfr_t a, b; int i, okay; if (!isPureTree(thing)) return 0; if (!isConstant(thing)) return 0; okay = 0; i = 0; mpfr_init2(a, tools_precision); if (evaluateThingToConstant(a, thing, NULL, 0, 0)) { if (mpfr_integer_p(a)) { i = mpfr_get_si(a, GMP_RNDN); mpfr_init2(b, 8 * sizeof(i) + 5); mpfr_set_si(b, i, GMP_RNDN); if (mpfr_cmp(a, b) == 0) { okay = 1; } mpfr_clear(b); } } mpfr_clear(a); if (okay) { *res = i; } return okay; } int formConsecutiveIntegers(node *thing1, node *thing2) { mpfr_t a, b, c, d; int i, j, okay; if (!isPureTree(thing1)) return 0; if (!isPureTree(thing2)) return 0; if (!isConstant(thing1)) return 0; if (!isConstant(thing2)) return 0; okay = 0; mpfr_init2(a, tools_precision); if (evaluateThingToConstant(a, thing1, NULL, 0, 0)) { if (mpfr_integer_p(a)) { i = mpfr_get_si(a, GMP_RNDN); mpfr_init2(b, 8 * sizeof(i) + 5); mpfr_set_si(b, i, GMP_RNDN); if (mpfr_cmp(a, b) == 0) { mpfr_init2(c, tools_precision); if (evaluateThingToConstant(c, thing2, NULL, 0, 0)) { if (mpfr_integer_p(c)) { j = mpfr_get_si(c, GMP_RNDN); mpfr_init2(d, 8 * sizeof(i) + 5); mpfr_set_si(d, j, GMP_RNDN); if (mpfr_cmp(c, d) == 0) { okay = (i + 1 == j); } mpfr_clear(d); } } mpfr_clear(c); } mpfr_clear(b); } } mpfr_clear(a); return okay; } chain *normalizeFinalEllipticList(chain *list) { node **thingArray; int i, len, shortenedLen, mayShorten; chain *curr; chain *copy; if (list == NULL) return NULL; len = lengthChain(list); shortenedLen = len; thingArray = (node **) safeCalloc(len,sizeof(node *)); for (i=0, curr=list; curr != NULL; curr = curr->next, i++) thingArray[i] = copyThing((node *) (curr->value)); while (shortenedLen >= 2) { mayShorten = 0; if ((accessThruMemRef(thingArray[shortenedLen - 2])->nodeType != TABLEACCESS) && (accessThruMemRef(thingArray[shortenedLen - 1])->nodeType != TABLEACCESS)) { if (formConsecutiveIntegers(thingArray[shortenedLen - 2], thingArray[shortenedLen - 1])) { mayShorten = 1; } else { if (isEqualThing(thingArray[shortenedLen - 2], thingArray[shortenedLen - 1]) || ((accessThruMemRef(thingArray[shortenedLen - 2])->nodeType == CONSTANT) && (accessThruMemRef(thingArray[shortenedLen - 1])->nodeType == CONSTANT) && mpfr_nan_p(*(accessThruMemRef(thingArray[shortenedLen - 2])->value)) && mpfr_nan_p(*(accessThruMemRef(thingArray[shortenedLen - 2])->value)))) { mayShorten = 1; } } } if (mayShorten) { shortenedLen--; } else { break; } } copy = NULL; for (i=shortenedLen-1;i>=0;i--) { copy = addElement(copy,copyThing(thingArray[i])); } for (i=0;inodeType != accessThruMemRef(possibleMatcher)->nodeType) return 0; /* Here, both lists are of the same type Now check if normalization is needed for final elliptic lists. */ okay = 1; myAssociations = NULL; freeLists = 0; if (isPureFinalEllipticList(thingToMatch) && (lengthChain(accessThruMemRef(thingToMatch)->arguments) != lengthChain(accessThruMemRef(possibleMatcher)->arguments))) { thingToMatchList = normalizeFinalEllipticList(accessThruMemRef(thingToMatch)->arguments); possibleMatcherList = normalizeFinalEllipticList(accessThruMemRef(possibleMatcher)->arguments); freeLists = 1; } else { thingToMatchList = accessThruMemRef(thingToMatch)->arguments; possibleMatcherList = accessThruMemRef(possibleMatcher)->arguments; freeLists = 0; } /* After normalization, there can be no match if the lists are not of the same length (for lists) or if the possibleMatcherList is shorter than the thingToMatchList */ lenThingToMatchList = lengthChain(thingToMatchList); lenPossibleMatcherList = lengthChain(possibleMatcherList); okay = (lenThingToMatchList == lenPossibleMatcherList) || (isPureFinalEllipticList(thingToMatch) && (lenThingToMatchList <= lenPossibleMatcherList)); if (okay) { /* Matching is possible because the lists are of appropriate lengths. Now check if each element pair of the lists matches. Keep attention to the associations. */ myAssociations = NULL; for (currThingToMatch = thingToMatchList, currPossibleMatcher = possibleMatcherList; (currThingToMatch != NULL) && (currPossibleMatcher != NULL); currThingToMatch = currThingToMatch->next, currPossibleMatcher = currPossibleMatcher->next) { lastThingToMatch = currThingToMatch; elementAssociations = NULL; okay = tryMatch(&elementAssociations, (node *) (currThingToMatch->value), (node *) (currPossibleMatcher->value)); if (okay) { myNewAssociations = NULL; okay = tryCombineAssociations(&myNewAssociations, myAssociations, elementAssociations); if (myAssociations != NULL) freeChain(myAssociations, freeEntryOnVoid); myAssociations = myNewAssociations; } if (elementAssociations != NULL) freeChain(elementAssociations, freeEntryOnVoid); if (!okay) break; } } if (okay && isPureFinalEllipticList(thingToMatch) && (currPossibleMatcher != NULL)) { /* Here, the explicit possible matcher list is longer and both list are final elliptic. We have to continue on the possible matcher list until it is empty (explicitly speaking). For each of its elements, we have to "invent", i.e. generate, an implicit element of the thing-to-match list. This generation is based on the type of the last explicit element in the thing-to-match list, stored on variable lastThingToMatch->value. We start by performing a test that allows us to decide if we have a sequence of integers or another type continued to infinity. */ integerSequence = 0; integerBase = 0; mpfr_init2(c, tools_precision); if (evaluateThingToConstant(c, (node *) (lastThingToMatch->value), NULL, 0, 0)) { if (mpfr_integer_p(c)) { integerBase = mpfr_get_si(c, GMP_RNDN); mpfr_init2(d, 8 * sizeof(i) + 5); mpfr_set_si(d, integerBase, GMP_RNDN); if (mpfr_cmp(c, d) == 0) { integerSequence = 1; } mpfr_clear(d); } } mpfr_clear(c); /* Now check all remaining elements of the possible matcher */ for (i = 1; (currPossibleMatcher != NULL); currPossibleMatcher = currPossibleMatcher->next, i++) { /* Start by generating the implicit element of the sequence */ if (integerSequence) { mpfr_init2(c, 8 * sizeof(int) + 1 + 5); mpfr_set_si(c,integerBase,GMP_RNDN); /* exact */ mpfr_add_si(c,c,i,GMP_RNDN); /* exact */ implicitElement = makeConstant(c); mpfr_clear(c); } else { /* We just have to repeat the last element of the sequence We avoid mallocs here. We'll have to account for that later. */ implicitElement = (node *) (lastThingToMatch->value); } /* Now perform the match check */ elementAssociations = NULL; okay = tryMatch(&elementAssociations, implicitElement, (node *) (currPossibleMatcher->value)); if (okay) { myNewAssociations = NULL; okay = tryCombineAssociations(&myNewAssociations, myAssociations, elementAssociations); if (myAssociations != NULL) freeChain(myAssociations, freeEntryOnVoid); myAssociations = myNewAssociations; } if (elementAssociations != NULL) freeChain(elementAssociations, freeEntryOnVoid); /* If we have an integer sequence, we malloc'ed for the implicit element. So we have to free it. */ if (integerSequence) { freeThing(implicitElement); } if (!okay) break; } } /* Free the list if it was us who allocated them */ if (freeLists) { freeChain(thingToMatchList,freeThingOnVoid); freeChain(possibleMatcherList,freeThingOnVoid); } if (okay) { *associations = myAssociations; } else { if (myAssociations != NULL) freeChain(myAssociations, freeEntryOnVoid); } return okay; } int tryMatchPrepend(chain **associations, node *thingToMatch, node *possibleMatcher) { int okay; chain *myAssociations, *headAssoc, *tailAssoc; node *tailList, *tempNode; if ((accessThruMemRef(thingToMatch)->nodeType != LIST) && (accessThruMemRef(thingToMatch)->nodeType != FINALELLIPTICLIST)) return 0; myAssociations = NULL; headAssoc = NULL; okay = tryMatch(&headAssoc, (node *) (accessThruMemRef(thingToMatch)->arguments->value), accessThruMemRef(possibleMatcher)->child1); if (okay) { tempNode = makeTail(copyThing(thingToMatch)); tailList = evaluateThingDeepCopy(tempNode); freeThing(tempNode); tailAssoc = NULL; okay = tryMatch(&tailAssoc, tailList, accessThruMemRef(possibleMatcher)->child2); if (okay) { okay = tryCombineAssociations(&myAssociations, headAssoc, tailAssoc); } if (tailAssoc != NULL) freeChain(tailAssoc, freeEntryOnVoid); freeThing(tailList); } if (headAssoc != NULL) freeChain(headAssoc, freeEntryOnVoid); if (okay) { *associations = myAssociations; } else { if (myAssociations != NULL) freeChain(myAssociations, freeEntryOnVoid); } return okay; } int tryMatchAppend(chain **associations, node *thingToMatch, node *possibleMatcher) { int okay, len, i; chain *myAssociations, *headAssoc, *tailAssoc, *curr; node *headList, *tailElement, **elementArray; if (accessThruMemRef(thingToMatch)->nodeType != LIST) return 0; myAssociations = NULL; if (accessThruMemRef(thingToMatch)->arguments->next != NULL) { /* The list of things to match has more than one element. Its is easy to compute the head list and the tailElement. */ len = lengthChain(accessThruMemRef(thingToMatch)->arguments); elementArray = (node **) safeCalloc(len,sizeof(node *)); for (i=0, curr=accessThruMemRef(thingToMatch)->arguments; curr != NULL; curr = curr->next, i++) { elementArray[i] = (node *) (curr->value); } tailElement = elementArray[len-1]; curr = NULL; for (i=len-2;i>=0;i--) { curr = addElement(curr,copyThing(elementArray[i])); } headList = makeList(curr); safeFree(elementArray); } else { /* The list of things to match has only one element, so the head list is the empty list. The tail element is easy to get, too. */ tailElement = (node *) (accessThruMemRef(thingToMatch)->arguments->value); headList = makeEmptyList(); } headAssoc = NULL; okay = tryMatch(&headAssoc, headList, accessThruMemRef(possibleMatcher)->child1); if (okay) { tailAssoc = NULL; okay = tryMatch(&tailAssoc, tailElement, accessThruMemRef(possibleMatcher)->child2); if (okay) { okay = tryCombineAssociations(&myAssociations, headAssoc, tailAssoc); } if (tailAssoc != NULL) freeChain(tailAssoc, freeEntryOnVoid); } if (headAssoc != NULL) freeChain(headAssoc, freeEntryOnVoid); freeThing(headList); if (okay) { *associations = myAssociations; } else { if (myAssociations != NULL) freeChain(myAssociations, freeEntryOnVoid); } return okay; } int tryEvaluateRecursiveConcatMatcherToString(char **concatenatedString, node *tree) { char *buf, *bufLeft, *bufRight, *curr; int okayLeft, okayRight, okay; if (accessThruMemRef(tree)->nodeType == STRING) { buf = (char *) safeCalloc(strlen(accessThruMemRef(tree)->string) + 1, sizeof(char)); strcpy(buf,accessThruMemRef(tree)->string); *concatenatedString = buf; return 1; } if (accessThruMemRef(tree)->nodeType == CONCAT) { okayLeft = tryEvaluateRecursiveConcatMatcherToString(&bufLeft, accessThruMemRef(tree)->child1); okayRight = tryEvaluateRecursiveConcatMatcherToString(&bufRight, accessThruMemRef(tree)->child2); okay = 0; if (okayLeft && okayRight) { buf = (char *) safeCalloc(strlen(bufLeft) + strlen(bufRight) + 1, sizeof(char)); *concatenatedString = buf; for (curr=bufLeft; *curr != '\0'; curr++, buf++) { *buf = *curr; } for (curr=bufRight; *curr != '\0'; curr++, buf++) { *buf = *curr; } okay = 1; } if (okayLeft) safeFree(bufLeft); if (okayRight) safeFree(bufRight); return okay; } return 0; } int tryCutPrefix(char **rest, char *mainString, char *prefix) { int okay; char *ptrStr, *ptrPref, *buf; okay = 1; for (ptrStr = mainString, ptrPref = prefix; (*ptrStr != '\0') && (*ptrPref != '\0'); ptrStr++, ptrPref++) { if (*ptrStr != *ptrPref) { okay = 0; break; } } if ((*ptrStr == '\0') && (*ptrPref != '\0')) { okay = 0; } if (okay) { buf = (char *) safeCalloc(strlen(ptrStr) + 1, sizeof(char)); strcpy(buf, ptrStr); *rest = buf; } return okay; } char *revertString(char *buf) { char *revBuf; int len, i; len = strlen(buf); revBuf = (char *) safeCalloc(len + 1, sizeof(char)); for (i=0;inodeType != CONCAT) return 0; okayLeftEvaluate = tryEvaluateRecursiveConcatMatcherToString(&stringLeftEvaluate, accessThruMemRef(possibleMatcher)->child1); okayRightEvaluate = tryEvaluateRecursiveConcatMatcherToString(&stringRightEvaluate, accessThruMemRef(possibleMatcher)->child2); if (okayLeftEvaluate || okayRightEvaluate) { okay = 0; if (okayLeftEvaluate) { okayCut = tryCutPrefix(&restString,stringToMatch,stringLeftEvaluate); } else { okayCut = tryCutPostfix(&restString,stringToMatch,stringRightEvaluate); } if (okayCut) { restStringThing = makeString(restString); myAssociations = NULL; if (okayLeftEvaluate) { okay = tryMatch(&myAssociations,restStringThing,accessThruMemRef(possibleMatcher)->child2); } else { okay = tryMatch(&myAssociations,restStringThing,accessThruMemRef(possibleMatcher)->child1); } freeThing(restStringThing); safeFree(restString); } if (okayLeftEvaluate) safeFree(stringLeftEvaluate); if (okayRightEvaluate) safeFree(stringRightEvaluate); if (okay) { *associations = myAssociations; } else { if (myAssociations != NULL) freeChain(myAssociations, freeEntryOnVoid); } return okay; } return 0; } int tryEvaluateRecursiveConcatMatcherToList(node **concatenatedList, node *tree) { node *evalLeft, *evalRight; int okayLeft, okayRight, okay; chain *tempChain, *tempChain2; switch (accessThruMemRef(tree)->nodeType) { case EMPTYLIST: case LIST: case FINALELLIPTICLIST: *concatenatedList = copyThing(tree); return 1; break; case PREPEND: evalRight = NULL; okayRight = tryEvaluateRecursiveConcatMatcherToList(&evalRight, accessThruMemRef(tree)->child2); if (okayRight) { okay = 0; switch (accessThruMemRef(evalRight)->nodeType) { case EMPTYLIST: *concatenatedList = makeList(addElement(NULL, copyThing(accessThruMemRef(tree)->child1))); okay = 1; break; case LIST: tempChain = copyChainWithoutReversal(accessThruMemRef(evalRight)->arguments, copyThingOnVoid); tempChain = addElement(tempChain, copyThing(accessThruMemRef(tree)->child1)); *concatenatedList = makeList(tempChain); okay = 1; break; case FINALELLIPTICLIST: tempChain = copyChainWithoutReversal(accessThruMemRef(evalRight)->arguments, copyThingOnVoid); tempChain = addElement(tempChain, copyThing(accessThruMemRef(tree)->child1)); *concatenatedList = makeFinalEllipticList(tempChain); okay = 1; break; default: okay = 0; } freeThing(evalRight); return okay; } return 0; break; case APPEND: evalLeft = NULL; okayLeft = tryEvaluateRecursiveConcatMatcherToList(&evalLeft, accessThruMemRef(tree)->child1); if (okayLeft) { okay = 0; switch (accessThruMemRef(evalLeft)->nodeType) { case EMPTYLIST: *concatenatedList = makeList(addElement(NULL, copyThing(accessThruMemRef(tree)->child2))); okay = 1; break; case LIST: tempChain = copyChain(accessThruMemRef(evalLeft)->arguments, copyThingOnVoid); tempChain = addElement(tempChain, copyThing(accessThruMemRef(tree)->child2)); tempChain2 = copyChain(tempChain, copyThingOnVoid); freeChain(tempChain, freeThingOnVoid); *concatenatedList = makeList(tempChain2); okay = 1; break; default: okay = 0; } freeThing(evalLeft); return okay; } return 0; break; case CONCAT: evalLeft = NULL; okayLeft = tryEvaluateRecursiveConcatMatcherToList(&evalLeft, accessThruMemRef(tree)->child1); if (okayLeft) { okay = 0; evalRight = NULL; okayRight = tryEvaluateRecursiveConcatMatcherToList(&evalRight, accessThruMemRef(tree)->child2); if (okayRight) { switch (accessThruMemRef(evalLeft)->nodeType) { case EMPTYLIST: switch (accessThruMemRef(evalRight)->nodeType) { case EMPTYLIST: case LIST: case FINALELLIPTICLIST: *concatenatedList = copyThing(evalRight); okay = 1; break; default: okay = 0; break; } break; case LIST: switch (accessThruMemRef(evalRight)->nodeType) { case EMPTYLIST: *concatenatedList = copyThing(evalLeft); okay = 1; break; case LIST: tempChain = concatChains(copyChainWithoutReversal(accessThruMemRef(evalLeft)->arguments, copyThingOnVoid), copyChainWithoutReversal(accessThruMemRef(evalRight)->arguments, copyThingOnVoid)); *concatenatedList = makeList(tempChain); okay = 1; break; case FINALELLIPTICLIST: tempChain = concatChains(copyChainWithoutReversal(accessThruMemRef(evalLeft)->arguments, copyThingOnVoid), copyChainWithoutReversal(accessThruMemRef(evalRight)->arguments, copyThingOnVoid)); *concatenatedList = makeFinalEllipticList(tempChain); okay = 1; break; default: okay = 0; break; } break; default: okay = 0; break; } freeThing(evalRight); } freeThing(evalLeft); return okay; } return 0; break; default: return 0; } return 0; } int tryCutPostfixList(chain **associations, node **restList, node *mainList, node *postfix) { int lenMainList, lenPostfix, i, k, okay, offset; node **mainListArray; chain *curr, *possibleMatchList, *possibleRestList; node *possibleThingToMatch, *possibleRest, *tempNode, *myMainList; chain *myAssociations; node *postfixFirstElem, *mainListLastElem; chain *mainListCurr; int mainListInt, postfixInt; if ((accessThruMemRef(mainList)->nodeType == FINALELLIPTICLIST) && (accessThruMemRef(postfix)->nodeType != FINALELLIPTICLIST)) return 0; if ((accessThruMemRef(postfix)->nodeType == FINALELLIPTICLIST) && (accessThruMemRef(mainList)->nodeType != FINALELLIPTICLIST)) return 0; switch (accessThruMemRef(postfix)->nodeType) { case EMPTYLIST: *restList = copyThing(mainList); *associations = NULL; return 1; break; case LIST: if (accessThruMemRef(mainList)->nodeType == LIST) { lenMainList = lengthChain(accessThruMemRef(mainList)->arguments); lenPostfix = lengthChain(accessThruMemRef(postfix)->arguments); if (lenMainList >= lenPostfix) { mainListArray = (node **) safeCalloc(lenMainList, sizeof(node *)); for (i=0, curr = accessThruMemRef(mainList)->arguments; curr != NULL; curr = curr->next, i++) { mainListArray[i] = (node *) (curr->value); } possibleMatchList = NULL; for (i=lenMainList-1, k=0; (i >= 0) && (k < lenPostfix); i--, k++) { possibleMatchList = addElement(possibleMatchList, copyThing(mainListArray[i])); } possibleThingToMatch = makeList(possibleMatchList); if (lenMainList == lenPostfix) { possibleRest = makeEmptyList(); } else { possibleRestList = NULL; for (i=lenMainList-lenPostfix-1;i>=0;i--) { possibleRestList = addElement(possibleRestList, copyThing(mainListArray[i])); } possibleRest = makeList(possibleRestList); } safeFree(mainListArray); okay = tryMatch(associations, possibleThingToMatch, postfix); freeThing(possibleThingToMatch); if (okay) { *restList = possibleRest; } else { freeThing(possibleRest); } return okay; } else { return 0; } } else { return 0; } break; case FINALELLIPTICLIST: if (accessThruMemRef(mainList)->nodeType == FINALELLIPTICLIST) { lenMainList = lengthChain(accessThruMemRef(mainList)->arguments); possibleRest = makeEmptyList(); myMainList = copyThing(mainList); offset = 1; postfixFirstElem = (node *) (((chain *) (accessThruMemRef(postfix)->arguments))->value); for (mainListCurr = accessThruMemRef(mainList)->arguments; mainListCurr->next != NULL; mainListCurr = mainListCurr->next); mainListLastElem = (node *) (mainListCurr->value); if (isIntegerElement(&mainListInt, mainListLastElem) && isIntegerElement(&postfixInt, postfixFirstElem) && (postfixInt > mainListInt)) { offset = postfixInt - mainListInt + 2; } okay = 0; for (i=1; i<=lenMainList+offset; i++) { myAssociations = NULL; okay = tryMatch(&myAssociations, myMainList, postfix); if (okay) { *associations = myAssociations; *restList = copyThing(possibleRest); break; } else { if (myAssociations != NULL) freeChain(myAssociations, freeEntryOnVoid); tempNode = makeAppend(possibleRest, makeHead(copyThing(myMainList))); possibleRest = evaluateThingDeepCopy(tempNode); freeThing(tempNode); tempNode = makeTail(myMainList); myMainList = evaluateThingDeepCopy(tempNode); freeThing(tempNode); } } freeThing(possibleRest); freeThing(myMainList); return okay; } else { return 0; } break; default: return 0; break; } return 0; } int tryCutPrefixList(chain **associations, node **restList, node *mainList, node *prefix) { node *myRestList, *possibleMatchingPrefix, *tempNode; int lenPrefix, i, okay; switch (accessThruMemRef(prefix)->nodeType) { case EMPTYLIST: *restList = copyThing(mainList); *associations = NULL; return 1; break; case LIST: switch (accessThruMemRef(mainList)->nodeType) { case LIST: case FINALELLIPTICLIST: lenPrefix = lengthChain(accessThruMemRef(prefix)->arguments); possibleMatchingPrefix = makeEmptyList(); myRestList = copyThing(mainList); for (i=0; inodeType != CONCAT) return 0; leftEval = NULL; rightEval = NULL; okayLeft = tryEvaluateRecursiveConcatMatcherToList(&leftEval, accessThruMemRef(possibleMatcher)->child1); okayRight = tryEvaluateRecursiveConcatMatcherToList(&rightEval, accessThruMemRef(possibleMatcher)->child2); if (okayLeft || okayRight) { myAssociations = NULL; okay = 1; if (okayLeft && (accessThruMemRef(leftEval)->nodeType == FINALELLIPTICLIST)) okay = 0; if (okay) { if (okayRight) { cutAssociations = NULL; restList = NULL; okay = tryCutPostfixList(&cutAssociations, &restList, thingToMatch, rightEval); if (okay) { restAssociations = NULL; okay = tryMatch(&restAssociations,restList,accessThruMemRef(possibleMatcher)->child1); if (okay) { myAssociations = NULL; okay = tryCombineAssociations(&myAssociations, restAssociations, cutAssociations); if (restAssociations != NULL) freeChain(restAssociations, freeEntryOnVoid); } if (cutAssociations != NULL) freeChain(cutAssociations, freeEntryOnVoid); freeThing(restList); } } else { cutAssociations = NULL; restList = NULL; okay = tryCutPrefixList(&cutAssociations, &restList, thingToMatch, leftEval); if (okay) { restAssociations = NULL; okay = tryMatch(&restAssociations,restList,accessThruMemRef(possibleMatcher)->child2); if (okay) { myAssociations = NULL; okay = tryCombineAssociations(&myAssociations, restAssociations, cutAssociations); if (restAssociations != NULL) freeChain(restAssociations, freeEntryOnVoid); } if (cutAssociations != NULL) freeChain(cutAssociations, freeEntryOnVoid); freeThing(restList); } } } if (okayLeft) freeThing(leftEval); if (okayRight) freeThing(rightEval); if (okay) { *associations = myAssociations; } else { if (myAssociations != NULL) freeChain(myAssociations, freeEntryOnVoid); } return okay; } return 0; } int tryMatchStructure(chain **associations, node *thingToMatch, node *possibleMatcher) { int okay, found, okayRecurse, okayCombine; chain *myAssociations, *currPossibleMatcher, *currThingToMatch, *recurseAssoc, *myCombinedAssoc; char *currPossibleMatcherName, *currThingToMatchName; node *currPossibleMatcherMatcher, *currThingToMatchThing; if (accessThruMemRef(thingToMatch)->nodeType != STRUCTURE) return 0; if (accessThruMemRef(possibleMatcher)->nodeType != STRUCTURE) return 0; okay = 1; myAssociations = NULL; for (currPossibleMatcher=accessThruMemRef(possibleMatcher)->arguments; currPossibleMatcher != NULL; currPossibleMatcher=currPossibleMatcher->next) { currPossibleMatcherName = (char *) (((entry *) (currPossibleMatcher->value))->name); currPossibleMatcherMatcher = (node *) (((entry *) (currPossibleMatcher->value))->value); for (found = 0, currThingToMatch=accessThruMemRef(thingToMatch)->arguments; (!found) && (currThingToMatch != NULL); currThingToMatch=currThingToMatch->next) { currThingToMatchName = (char *) (((entry *) (currThingToMatch->value))->name); currThingToMatchThing = (node *) (((entry *) (currThingToMatch->value))->value); if (!strcmp(currThingToMatchName,currPossibleMatcherName)) found = 1; } if (found) { recurseAssoc = NULL; okayRecurse = tryMatch(&recurseAssoc, currThingToMatchThing, currPossibleMatcherMatcher); if (okayRecurse) { myCombinedAssoc = NULL; okayCombine = tryCombineAssociations(&myCombinedAssoc, recurseAssoc, myAssociations); if (okayCombine) { if (myAssociations != NULL) freeChain(myAssociations, freeEntryOnVoid); myAssociations = myCombinedAssoc; } else { okay = 0; } if (recurseAssoc != NULL) freeChain(recurseAssoc, freeEntryOnVoid); } else { okay = 0; } } else { okay = 0; } if (!okay) break; } if (okay) { *associations = myAssociations; } else { if (myAssociations != NULL) freeChain(myAssociations, freeEntryOnVoid); } return okay; } int tryMatchInner(chain **associations, node *thingToMatch, node *possibleMatcher) { /* Default case: a match for everything, no association to perform */ if (accessThruMemRef(possibleMatcher)->nodeType == DEFAULT) return 1; /* Base symbols: a match is obtained if the thing to match is equal to the matcher */ if (isCorrectlyTypedBaseSymbol(possibleMatcher)) { if (isEqualThing(thingToMatch, possibleMatcher)) { return 1; } return 0; } /* Extended pure trees (functions with possible variables to bind to): run specialized code if the thing to match is a pure tree (a function without variables) */ if (isExtendedPureTree(possibleMatcher)) { if (!isPureTree(thingToMatch) && !(accessThruMemRef(possibleMatcher)->nodeType == TABLEACCESS)) return 0; return tryMatchExtendedPureTree(associations, thingToMatch, possibleMatcher); } /* Match ranges */ if (accessThruMemRef(possibleMatcher)->nodeType == RANGE) { if (!isRange(thingToMatch)) return 0; return tryMatchRange(associations, *(accessThruMemRef(accessThruMemRef(thingToMatch)->child1)->value), *(accessThruMemRef(accessThruMemRef(thingToMatch)->child2)->value), possibleMatcher); } /* Match lists */ if (isMatchableList(possibleMatcher)) { if (!(isEmptyList(thingToMatch) || isPureList(thingToMatch) || isPureFinalEllipticList(thingToMatch))) return 0; return tryMatchList(associations, thingToMatch, possibleMatcher); } /* Match the prepend operator .: */ if (isMatchablePrepend(possibleMatcher)) { if (!(isPureList(thingToMatch) || isPureFinalEllipticList(thingToMatch))) return 0; return tryMatchPrepend(associations, thingToMatch, possibleMatcher); } /* Match the append operator :. */ if (isMatchableAppend(possibleMatcher)) { if (!isPureList(thingToMatch)) return 0; return tryMatchAppend(associations, thingToMatch, possibleMatcher); } /* Match the concat operator @ for strings and lists */ if (isMatchableConcat(possibleMatcher)) { if (!(isPureList(thingToMatch) || isPureFinalEllipticList(thingToMatch) || isEmptyList(thingToMatch) || isString(thingToMatch))) return 0; if (isString(thingToMatch)) { return tryMatchConcatOnString(associations, accessThruMemRef(thingToMatch)->string, possibleMatcher); } else { return tryMatchConcatOnList(associations, thingToMatch, possibleMatcher); } } /* Match literate structures */ if (isMatchableStructure(possibleMatcher)) { if (!isStructure(thingToMatch)) return 0; if (associationContainsDoubleEntries(accessThruMemRef(thingToMatch)->arguments)) return 0; return tryMatchStructure(associations, thingToMatch, possibleMatcher); } return 0; } int tryMatch(chain **associations, node *thingToMatch, node *possibleMatcher) { int okay; chain *myAssociations = NULL; okay = tryMatchInner(&myAssociations, thingToMatch, possibleMatcher); if (okay) { *associations = myAssociations; } else { if (myAssociations != NULL) { freeChain(myAssociations, freeEntryOnVoid); } } return okay; } sollya-6.0+ds/match.h000066400000000000000000000045521300174114700145350ustar00rootroot00000000000000/* Copyright 2011 by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributor Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef MATCH_H #define MATCH_H #include "expression.h" #include "execute.h" #include "chain.h" #include "assignment.h" int tryMatch(chain **associations, node *thingToMatch, node *possibleMatcher); #endif /* ifdef MATCH_H*/ sollya-6.0+ds/minilexer.l000066400000000000000000001101021300174114700154260ustar00rootroot00000000000000/* Copyright 2007-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ %{ #include #include #include #include "expression.h" #include "miniparser.h" #include "general.h" #include "chain.h" #define YY_NO_UNPUT 1 #define YY_NO_INPUT 1 /* Mess with the mallocs used by the lexer */ extern void *parserCalloc(size_t, size_t); extern void *parserMalloc(size_t); extern void *parserRealloc(void *, size_t); extern void parserFree(void *); #undef malloc #undef realloc #undef calloc #undef free #define malloc parserMalloc #define realloc parserRealloc #define calloc parserCalloc #define free UNUSED_PARAM(yyscanner); parserFree /* End of the malloc mess */ /* Mess with fprintf to use sollyaFprintf instead. */ #undef fprintf #define fprintf UNUSED_PARAM(yyscanner); sollyaFprintf /* End of fprintf mess */ /* Mess with getc... and fread to use sollya_getc, sollya_feof, sollya_ferror, sollya_fwrite and sollya_fread instead. */ #undef getc #undef fread #undef feof #undef ferror #undef fwrite #define getc sollya_getc #define fread sollya_fread #define feof sollya_feof #define ferror sollya_ferror #define fwrite sollya_fwrite /* End of getc, feof, ferror, fwrite and fread mess */ /* const mess */ #if defined(const) #undef const #endif /* End of the const mess */ %} %option noyyalloc noyyrealloc noyyfree %option noyywrap %option always-interactive %option prefix="miniyy" %option reentrant %option bison-bridge %option nounput %x commentstate CHAR [a-zA-Z] NUMBER [0-9] HEXNUMBER (([0-9])|([ABCDEFabcdef])) SPECIAL [_$§] ACONSTANT ((({NUMBER}+|({NUMBER}*"."{NUMBER}+))(((((" ")*)(([eE]))([+-])?{NUMBER}+)?)))|("infty"|"nan"|"NAN"|"NaN"|"@Inf@"|"@NaN@")) CONSTANT ({ACONSTANT})|((("%")({NUMBER})({NUMBER}+)("%"))({ACONSTANT})) DYADICCONSTANT ({NUMBER}+)([bB])([+-]?)({NUMBER}+) HEXCONSTANT ("0x")({HEXNUMBER}{16}|{HEXNUMBER}{8}) HEXADECIMALCONSTANT ("0x"|"0X")(({HEXNUMBER}*"."{HEXNUMBER}+)|({HEXNUMBER}+((".")?)))(("p"|"P")(([+-])?)({NUMBER}*)) BINARYCONSTANT (([0-1])+|(([0-1])*"."([0-1])+))"_2" AMIDPOINTCONSTANT (({NUMBER}+|({NUMBER}*"."{NUMBER}+))(("~"({NUMBER})+("/")({NUMBER})+("~")))(((((" ")*)(([eE]))([+-])?{NUMBER}+)?))) MIDPOINTCONSTANT (({AMIDPOINTCONSTANT})|(("-")((" ")*)({AMIDPOINTCONSTANT}))) IDENTIFIER ({CHAR}|{SPECIAL})({CHAR}|{NUMBER}|{SPECIAL})* DOT "." LPAR "(" RPAR ")" LBRACKET "[" RBRACKET "]" PI ("pi")|("Pi") PLUS "+" MINUS "-" APPROX "~" MUL "*" DIV "/" POW "^" SQRT "sqrt" EXP "exp" FREEVAR "_x_" LOG "log" LOG2 "log2" LOG10 "log10" SIN "sin" COS "cos" TAN "tan" ASIN "asin" ACOS "acos" ATAN "atan" SINH "sinh" COSH "cosh" TANH "tanh" ASINH "asinh" ACOSH "acosh" ATANH "atanh" ABS "abs" ERF "erf" ERFC "erfc" LOG1P "log1p" EXPM1 "expm1" EQUAL "=" COMMA "," PREC "prec" POINTS "points" EXCLAMATION "!" DOUBLECOLON "::" COLON ":" DOTCOLON ".:" COLONDOT ":." ASSIGNEQUAL ":=" SEMICOLON ";" QUIT "quit" PRINT "print" SUPPRESSMESSAGE "suppressmessage" UNSUPPRESSMESSAGE "unsuppressmessage" DIFF "diff" DIRTYSIMPLIFY "dirtysimplify" CANONICAL "canonical" PLOT "plot" REMEZ "remez" ANNOTATEFUNCTION "annotatefunction" FPMINIMAX "fpminimax" INFNORM "infnorm" SUPNORM "supnorm" DIAM "diam" DOUBLELONG "double" SINGLELONG "single" QUADLONG "quad" HALFPRECISIONLONG "halfprecision" DOUBLEDOUBLELONG "doubledouble" TRIPLEDOUBLELONG "tripledouble" DOUBLEEXTENDEDLONG "doubleextended" DOUBLESHORT "D" SINGLESHORT "SG" QUADSHORT "QD" HALFPRECISIONSHORT "HP" DOUBLEDOUBLESHORT "DD" TRIPLEDOUBLESHORT "TD" DOUBLEEXTENDEDSHORT "DE" DOUBLE ({DOUBLELONG}|{DOUBLESHORT}) SINGLE ({SINGLELONG}|{SINGLESHORT}) QUAD ({QUADLONG}|{QUADSHORT}) HALFPRECISION ({HALFPRECISIONLONG}|{HALFPRECISIONSHORT}) DOUBLEDOUBLE ({DOUBLEDOUBLELONG}|{DOUBLEDOUBLESHORT}) TRIPLEDOUBLE ({TRIPLEDOUBLELONG}|{TRIPLEDOUBLESHORT}) DOUBLEEXTENDED ({DOUBLEEXTENDEDLONG}|{DOUBLEEXTENDEDSHORT}) HORNER "horner" DEGREE "degree" EXPAND "expand" SIMPLIFYSAFE1 "simplify" SIMPLIFYSAFE2 "simplifysafe" SIMPLIFYSAFE ({SIMPLIFYSAFE1}|{SIMPLIFYSAFE2}) TAYLOR "taylor" TAYLORFORM "taylorform" CHEBYSHEVFORM "chebyshevform" AUTODIFF "autodiff" FINDZEROS "findzeros" FPFINDZEROS "fpfindzeros" DIRTYINFNORM "dirtyinfnorm" NUMBERROOTS "numberroots" EVALUATE "evaluate" NUMERATOR "numerator" DENOMINATOR "denominator" DYADIC "dyadic" DISPLAY "display" ON "on" OFF "off" POWERS "powers" BINARY "binary" HEXADECIMAL "hexadecimal" INTEGRAL "integral" DIRTYINTEGRAL "dirtyintegral" STRINGDELIMITER [\"] OCTALCHAR [01234567] OCTAL ({OCTALCHAR})(({OCTALCHAR})?)(({OCTALCHAR})?) HEXACHAR [0123456789ABCDEFabcdef] HEXA ({HEXACHAR})(({HEXACHAR})?) STRING ({STRINGDELIMITER})((("\\\\")|(("\\")[\"\'\?ntabfrv])|(("\\")({OCTAL}))|(("\\x")({HEXA}))|([^\"\\]))*)({STRINGDELIMITER}) VERBOSITY "verbosity" SHOWMESSAGENUMBERS "showmessagenumbers" WORSTCASE "worstcase" LEFTANGLE "<" RIGHTANGLEUNDERSCORE ">_" RIGHTANGLEDOT ">." RIGHTANGLE ">" STARLEFTANGLE "*<" RIGHTANGLESTAR ">*" COMPAREEQUAL "==" EXCLAMATIONEQUAL "!=" AND "&&" OR "||" SUBSTITUTE "substitute" COMPOSEPOLYNOMIALS "composepolynomials" DOTS "..." IMPLEMENTPOLY "implementpoly" IMPLEMENTCONST "implementconstant" CHECKINFNORM "checkinfnorm" TAYLORRECURSIONS "taylorrecursions" PRINTHEXA ("printhexa"|"printdouble") PRINTFLOAT ("printfloat"|"printsingle") PRINTBINARY "printbinary" ROUNDCOEFFICIENTS "roundcoefficients" RESTART "restart" ZERODENOMINATORS "zerodenominators" ISEVALUABLE "isevaluable" HONORCOEFFPREC "honorcoeffprec" ACCURATEINFNORM "accurateinfnorm" FILE "file" POSTSCRIPT "postscript" POSTSCRIPTFILE "postscriptfile" PRINTEXPANSION "printexpansion" BASHEXECUTE "bashexecute" BASHEVALUATE "bashevaluate" GETSUPPRESSEDMESSAGES "getsuppressedmessages" GETBACKTRACE "getbacktrace" EXTERNALPLOT "externalplot" PERTURB "perturb" COEFF "coeff" SUBPOLY "subpoly" QUESTIONMARK "?" SEARCHGAL "searchgal" RATIONALAPPROX "rationalapprox" READ "read" COMMENTSTART "/*" COMMENTEND "*/" ONELINECOMMENT ("//")([^\n])*"\n" WRITE "write" ASCIIPLOT "asciiplot" ROUNDTOFORMAT "round" MINUSWORD "RD" PLUSWORD "RU" ZEROWORD "RZ" NEAREST "RN" GUESSDEGREE "guessdegree" PARSE "parse" AUTOSIMPLIFY "autosimplify" TIMING "timing" TIME "time" FULLPARENTHESES "fullparentheses" MIDPOINTMODE "midpointmode" DIEONERRORMODE "dieonerrormode" SUPPRESSWARNINGS "roundingwarnings" RATIONALMODE "rationalmode" LIBRARY "library" LIBRARYCONSTANT "libraryconstant" HOPITALRECURSIONS "hopitalrecursions" HELP "help" DIRTYFINDZEROS "dirtyfindzeros" CEIL "ceil" FLOOR "floor" NEARESTINT "nearestint" HEAD "head" TAIL "tail" VERTBAR "|" AT "@" IF "if" THEN "then" ELSE "else" FOR "for" IN "in" FROM "from" TO "to" BY "by" DO "do" BEGIN "begin" END "end" LBRACE "{" RBRACE "}" WHILEDEF "while" TRUE "true" FALSE "false" DEFAULT "default" MATCH "match" WITH "with" RENAME "rename" OBJECTNAME "objectname" BIND "bind" LENGTH "length" ABSOLUTE "absolute" RELATIVE "relative" DECIMAL "decimal" FIXED "fixed" FLOATING "floating" ERROR "error" PRINTXML "printxml" INF "inf" MID "mid" SUP "sup" MIN "min" MAX "max" READXML "readxml" MANTISSA "mantissa" EXPONENT "exponent" PRECISION "precision" REVERT "revert" SORT "sort" READFILE "readfile" ROUNDCORRECTLY "roundcorrectly" EXECUTE "execute" ISBOUND "isbound" EXTERNALPROC "externalproc" VOID "void" CONSTANTTYPE "constant" FUNCTION "function" OBJECT "object" RANGE "range" INTEGER "integer" STRINGTYPE "string" BOOLEAN "boolean" LIST "list" OF "of" VAR "var" PROC "proc" PROCEDURE "procedure" RETURN "return" NOP "nop" %% %{ %} {COMMENTSTART} { miniparserCharactersRead += yyleng; BEGIN(commentstate); } {COMMENTEND} { miniparserCharactersRead += yyleng; BEGIN(INITIAL); } . { /* Eat up comments */ miniparserCharactersRead += yyleng; } [\n] { /* Eat up newlines in comments */ miniparserCharactersRead += yyleng; } {ONELINECOMMENT} { /* Eat up comments */ miniparserCharactersRead += yyleng; } <> { miniparserEofReached = 1; yyterminate(); } {MIDPOINTCONSTANT} { miniparserCharactersRead += yyleng; constBuffer2 = (char *) safeCalloc(yyleng+1,sizeof(char)); if (removeSpaces(constBuffer2,yytext)) { printMessage(2,SOLLYA_MSG_SPACES_REMOVED_FROM_CONSTANT_IN_SCIENTIF_NOTAT,"Information: removed spaces in scientific notation constant \"%s\", it will be considered as \"%s\"\n",yytext,constBuffer2); } yylval->value = constBuffer2; return MIDPOINTCONSTANTTOKEN; } {CONSTANT} { miniparserCharactersRead += yyleng; constBuffer2 = (char *) safeCalloc(yyleng+1,sizeof(char)); if (removeSpaces(constBuffer2,yytext)) { printMessage(2,SOLLYA_MSG_SPACES_REMOVED_FROM_CONSTANT_IN_SCIENTIF_NOTAT,"Information: removed spaces in scientific notation constant \"%s\", it will be considered as \"%s\"\n",yytext,constBuffer2); } yylval->value = constBuffer2; return CONSTANTTOKEN; } {DYADICCONSTANT} { miniparserCharactersRead += yyleng; constBuffer = (char *) safeCalloc(yyleng+1,sizeof(char)); strncpy(constBuffer,yytext,yyleng); yylval->value = constBuffer; return DYADICCONSTANTTOKEN; } {HEXADECIMALCONSTANT} { miniparserCharactersRead += yyleng; constBuffer = (char *) safeCalloc(yyleng+1,sizeof(char)); strncpy(constBuffer,yytext,yyleng); yylval->value = constBuffer; return HEXADECIMALCONSTANTTOKEN; } {HEXCONSTANT} { miniparserCharactersRead += yyleng; constBuffer = (char *) safeCalloc(yyleng+1,sizeof(char)); strncpy(constBuffer,yytext,yyleng); yylval->value = constBuffer; return HEXCONSTANTTOKEN; } {BINARYCONSTANT} { miniparserCharactersRead += yyleng; constBuffer = (char *) safeCalloc(yyleng-1,sizeof(char)); strncpy(constBuffer,yytext,yyleng-2); yylval->value = constBuffer; return BINARYCONSTANTTOKEN; } {PI} { miniparserCharactersRead += yyleng; return PITOKEN; } {STRING} { miniparserCharactersRead += yyleng; constBuffer = (char *) safeCalloc(yyleng-1,sizeof(char)); constBuffer2 = (char *) safeCalloc(yyleng-1,sizeof(char)); strncpy(constBuffer2,yytext+1,yyleng-2); demaskString(constBuffer,constBuffer2); safeFree(constBuffer2); yylval->value = constBuffer; return STRINGTOKEN; } {LPAR} { miniparserCharactersRead += yyleng; return LPARTOKEN; } {RPAR} { miniparserCharactersRead += yyleng; return RPARTOKEN; } {LBRACKET} { miniparserCharactersRead += yyleng; return LBRACKETTOKEN; } {RBRACKET} { miniparserCharactersRead += yyleng; return RBRACKETTOKEN; } {EXCLAMATIONEQUAL} { miniparserCharactersRead += yyleng; return EXCLAMATIONEQUALTOKEN; } {COMPAREEQUAL} { miniparserCharactersRead += yyleng; return COMPAREEQUALTOKEN; } {EQUAL} { miniparserCharactersRead += yyleng; return EQUALTOKEN; } {ASSIGNEQUAL} { miniparserCharactersRead += yyleng; return ASSIGNEQUALTOKEN; } {COMMA} { miniparserCharactersRead += yyleng; return COMMATOKEN; } {EXCLAMATION} { miniparserCharactersRead += yyleng; return EXCLAMATIONTOKEN; } {SEMICOLON} { miniparserCharactersRead += yyleng; return SEMICOLONTOKEN; } {LEFTANGLE} { miniparserCharactersRead += yyleng; return LEFTANGLETOKEN; } {STARLEFTANGLE} { miniparserCharactersRead += yyleng; return STARLEFTANGLETOKEN; } {RIGHTANGLEUNDERSCORE} { miniparserCharactersRead += yyleng; return RIGHTANGLEUNDERSCORETOKEN; } {RIGHTANGLEDOT} { miniparserCharactersRead += yyleng; return RIGHTANGLEDOTTOKEN; } {RIGHTANGLESTAR} { miniparserCharactersRead += yyleng; return RIGHTANGLESTARTOKEN; } {RIGHTANGLE} { miniparserCharactersRead += yyleng; return RIGHTANGLETOKEN; } {DOTS} { miniparserCharactersRead += yyleng; return DOTSTOKEN; } {DOT} { miniparserCharactersRead += yyleng; return DOTTOKEN; } {QUESTIONMARK} { miniparserCharactersRead += yyleng; return QUESTIONMARKTOKEN; } {AND} { miniparserCharactersRead += yyleng; return ANDTOKEN; } {OR} { miniparserCharactersRead += yyleng; return ORTOKEN; } {VERTBAR} { miniparserCharactersRead += yyleng; return VERTBARTOKEN; } {VAR} { miniparserCharactersRead += yyleng; return VARTOKEN; } {PROC} { miniparserCharactersRead += yyleng; return PROCTOKEN; } {PROCEDURE} { miniparserCharactersRead += yyleng; return PROCEDURETOKEN; } {RETURN} { miniparserCharactersRead += yyleng; return RETURNTOKEN; } {NOP} { miniparserCharactersRead += yyleng; return NOPTOKEN; } {AT} { miniparserCharactersRead += yyleng; return ATTOKEN; } {DOUBLECOLON} { miniparserCharactersRead += yyleng; return DOUBLECOLONTOKEN; } {COLON} { miniparserCharactersRead += yyleng; return COLONTOKEN; } {DOTCOLON} { miniparserCharactersRead += yyleng; return DOTCOLONTOKEN; } {COLONDOT} { miniparserCharactersRead += yyleng; return COLONDOTTOKEN; } {PLUS} { miniparserCharactersRead += yyleng; return PLUSTOKEN; } {MINUS} { miniparserCharactersRead += yyleng; return MINUSTOKEN; } {MUL} { miniparserCharactersRead += yyleng; return MULTOKEN; } {DIV} { miniparserCharactersRead += yyleng; return DIVTOKEN; } {POW} { miniparserCharactersRead += yyleng; return POWTOKEN; } {SQRT} { miniparserCharactersRead += yyleng; return SQRTTOKEN; } {EXP} { miniparserCharactersRead += yyleng; return EXPTOKEN; } {FREEVAR} { miniparserCharactersRead += yyleng; return FREEVARTOKEN; } {LOG} { miniparserCharactersRead += yyleng; return LOGTOKEN; } {LOG2} { miniparserCharactersRead += yyleng; return LOG2TOKEN; } {LOG10} { miniparserCharactersRead += yyleng; return LOG10TOKEN; } {SIN} { miniparserCharactersRead += yyleng; return SINTOKEN; } {COS} { miniparserCharactersRead += yyleng; return COSTOKEN; } {TAN} { miniparserCharactersRead += yyleng; return TANTOKEN; } {ASIN} { miniparserCharactersRead += yyleng; return ASINTOKEN; } {ACOS} { miniparserCharactersRead += yyleng; return ACOSTOKEN; } {ATAN} { miniparserCharactersRead += yyleng; return ATANTOKEN; } {SINH} { miniparserCharactersRead += yyleng; return SINHTOKEN; } {COSH} { miniparserCharactersRead += yyleng; return COSHTOKEN; } {TANH} { miniparserCharactersRead += yyleng; return TANHTOKEN; } {ASINH} { miniparserCharactersRead += yyleng; return ASINHTOKEN; } {ACOSH} { miniparserCharactersRead += yyleng; return ACOSHTOKEN; } {ATANH} { miniparserCharactersRead += yyleng; return ATANHTOKEN; } {ABS} { miniparserCharactersRead += yyleng; return ABSTOKEN; } {ERF} { miniparserCharactersRead += yyleng; return ERFTOKEN; } {ERFC} { miniparserCharactersRead += yyleng; return ERFCTOKEN; } {LOG1P} { miniparserCharactersRead += yyleng; return LOG1PTOKEN; } {EXPM1} { miniparserCharactersRead += yyleng; return EXPM1TOKEN; } {DOUBLE} { miniparserCharactersRead += yyleng; return DOUBLETOKEN; } {SINGLE} { miniparserCharactersRead += yyleng; return SINGLETOKEN; } {QUAD} { miniparserCharactersRead += yyleng; return QUADTOKEN; } {HALFPRECISION} { miniparserCharactersRead += yyleng; return HALFPRECISIONTOKEN; } {DOUBLEDOUBLE} { miniparserCharactersRead += yyleng; return DOUBLEDOUBLETOKEN; } {TRIPLEDOUBLE} { miniparserCharactersRead += yyleng; return TRIPLEDOUBLETOKEN; } {DOUBLEEXTENDED} { miniparserCharactersRead += yyleng; return DOUBLEEXTENDEDTOKEN; } {CEIL} { miniparserCharactersRead += yyleng; return CEILTOKEN; } {FLOOR} { miniparserCharactersRead += yyleng; return FLOORTOKEN; } {PREC} { miniparserCharactersRead += yyleng; return PRECTOKEN; } {POINTS} { miniparserCharactersRead += yyleng; return POINTSTOKEN; } {DIAM} { miniparserCharactersRead += yyleng; return DIAMTOKEN; } {DISPLAY} { miniparserCharactersRead += yyleng; return DISPLAYTOKEN; } {VERBOSITY} { miniparserCharactersRead += yyleng; return VERBOSITYTOKEN; } {SHOWMESSAGENUMBERS} { miniparserCharactersRead += yyleng; return SHOWMESSAGENUMBERSTOKEN; } {CANONICAL} { miniparserCharactersRead += yyleng; return CANONICALTOKEN; } {AUTOSIMPLIFY} { miniparserCharactersRead += yyleng; return AUTOSIMPLIFYTOKEN; } {TAYLORRECURSIONS} { miniparserCharactersRead += yyleng; return TAYLORRECURSIONSTOKEN; } {TIMING} { miniparserCharactersRead += yyleng; return TIMINGTOKEN; } {TIME} { miniparserCharactersRead += yyleng; return TIMETOKEN; } {FULLPARENTHESES} { miniparserCharactersRead += yyleng; return FULLPARENTHESESTOKEN; } {MIDPOINTMODE} { miniparserCharactersRead += yyleng; return MIDPOINTMODETOKEN; } {DIEONERRORMODE} { miniparserCharactersRead += yyleng; return DIEONERRORMODETOKEN; } {SUPPRESSWARNINGS} { miniparserCharactersRead += yyleng; return SUPPRESSWARNINGSTOKEN; } {RATIONALMODE} { miniparserCharactersRead += yyleng; return RATIONALMODETOKEN; } {HOPITALRECURSIONS} { miniparserCharactersRead += yyleng; return HOPITALRECURSIONSTOKEN; } {ON} { miniparserCharactersRead += yyleng; return ONTOKEN; } {OFF} { miniparserCharactersRead += yyleng; return OFFTOKEN; } {DYADIC} { miniparserCharactersRead += yyleng; return DYADICTOKEN; } {POWERS} { miniparserCharactersRead += yyleng; return POWERSTOKEN; } {BINARY} { miniparserCharactersRead += yyleng; return BINARYTOKEN; } {HEXADECIMAL} { miniparserCharactersRead += yyleng; return HEXADECIMALTOKEN; } {FILE} { miniparserCharactersRead += yyleng; return FILETOKEN; } {POSTSCRIPT} { miniparserCharactersRead += yyleng; return POSTSCRIPTTOKEN; } {POSTSCRIPTFILE} { miniparserCharactersRead += yyleng; return POSTSCRIPTFILETOKEN; } {PERTURB} { miniparserCharactersRead += yyleng; return PERTURBTOKEN; } {MINUSWORD} { miniparserCharactersRead += yyleng; return MINUSWORDTOKEN; } {PLUSWORD} { miniparserCharactersRead += yyleng; return PLUSWORDTOKEN; } {ZEROWORD} { miniparserCharactersRead += yyleng; return ZEROWORDTOKEN; } {NEAREST} { miniparserCharactersRead += yyleng; return NEARESTTOKEN; } {HONORCOEFFPREC} { miniparserCharactersRead += yyleng; return HONORCOEFFPRECTOKEN; } {TRUE} { miniparserCharactersRead += yyleng; return TRUETOKEN; } {FALSE} { miniparserCharactersRead += yyleng; return FALSETOKEN; } {DEFAULT} { miniparserCharactersRead += yyleng; return DEFAULTTOKEN; } {MATCH} { miniparserCharactersRead += yyleng; return MATCHTOKEN; } {WITH} { miniparserCharactersRead += yyleng; return WITHTOKEN; } {HEAD} { miniparserCharactersRead += yyleng; return HEADTOKEN; } {ROUNDCORRECTLY} { miniparserCharactersRead += yyleng; return ROUNDCORRECTLYTOKEN; } {REVERT} { miniparserCharactersRead += yyleng; return REVERTTOKEN; } {SORT} { miniparserCharactersRead += yyleng; return SORTTOKEN; } {MANTISSA} { miniparserCharactersRead += yyleng; return MANTISSATOKEN; } {EXPONENT} { miniparserCharactersRead += yyleng; return EXPONENTTOKEN; } {PRECISION} { miniparserCharactersRead += yyleng; return PRECISIONTOKEN; } {TAIL} { miniparserCharactersRead += yyleng; return TAILTOKEN; } {INF} { miniparserCharactersRead += yyleng; return INFTOKEN; } {MID} { miniparserCharactersRead += yyleng; return MIDTOKEN; } {SUP} { miniparserCharactersRead += yyleng; return SUPTOKEN; } {MIN} { miniparserCharactersRead += yyleng; return MINTOKEN; } {MAX} { miniparserCharactersRead += yyleng; return MAXTOKEN; } {READXML} { miniparserCharactersRead += yyleng; return READXMLTOKEN; } {LENGTH} { miniparserCharactersRead += yyleng; return LENGTHTOKEN; } {ABSOLUTE} { miniparserCharactersRead += yyleng; return ABSOLUTETOKEN; } {RELATIVE} { miniparserCharactersRead += yyleng; return RELATIVETOKEN; } {DECIMAL} { miniparserCharactersRead += yyleng; return DECIMALTOKEN; } {FIXED} { miniparserCharactersRead += yyleng; return FIXEDTOKEN; } {FLOATING} { miniparserCharactersRead += yyleng; return FLOATINGTOKEN; } {ERROR} { miniparserCharactersRead += yyleng; return ERRORTOKEN; } {READFILE} { miniparserCharactersRead += yyleng; return READFILETOKEN; } {ISBOUND} { miniparserCharactersRead += yyleng; return ISBOUNDTOKEN; } {QUIT} { miniparserCharactersRead += yyleng; return FALSEQUITTOKEN; } {RESTART} { miniparserCharactersRead += yyleng; return FALSERESTARTTOKEN; } {LIBRARY} { miniparserCharactersRead += yyleng; return LIBRARYTOKEN; } {LIBRARYCONSTANT} { miniparserCharactersRead += yyleng; return LIBRARYCONSTANTTOKEN; } {DIFF} { miniparserCharactersRead += yyleng; return DIFFTOKEN; } {DIRTYSIMPLIFY} { miniparserCharactersRead += yyleng; return DIRTYSIMPLIFYTOKEN; } {REMEZ} { miniparserCharactersRead += yyleng; return REMEZTOKEN; } {ANNOTATEFUNCTION} { miniparserCharactersRead += yyleng; return ANNOTATEFUNCTIONTOKEN; } {FPMINIMAX} { miniparserCharactersRead += yyleng; return FPMINIMAXTOKEN; } {HORNER} { miniparserCharactersRead += yyleng; return HORNERTOKEN; } {EXPAND} { miniparserCharactersRead += yyleng; return EXPANDTOKEN; } {SIMPLIFYSAFE} { miniparserCharactersRead += yyleng; return SIMPLIFYSAFETOKEN; } {TAYLOR} { miniparserCharactersRead += yyleng; return TAYLORTOKEN; } {TAYLORFORM} { miniparserCharactersRead += yyleng; return TAYLORFORMTOKEN; } {CHEBYSHEVFORM} { miniparserCharactersRead += yyleng; return CHEBYSHEVFORMTOKEN; } {AUTODIFF} { miniparserCharactersRead += yyleng; return AUTODIFFTOKEN; } {DEGREE} { miniparserCharactersRead += yyleng; return DEGREETOKEN; } {NUMERATOR} { miniparserCharactersRead += yyleng; return NUMERATORTOKEN; } {DENOMINATOR} { miniparserCharactersRead += yyleng; return DENOMINATORTOKEN; } {SUBSTITUTE} { miniparserCharactersRead += yyleng; return SUBSTITUTETOKEN; } {COMPOSEPOLYNOMIALS} { miniparserCharactersRead += yyleng; return COMPOSEPOLYNOMIALSTOKEN; } {COEFF} { miniparserCharactersRead += yyleng; return COEFFTOKEN; } {SUBPOLY} { miniparserCharactersRead += yyleng; return SUBPOLYTOKEN; } {ROUNDCOEFFICIENTS} { miniparserCharactersRead += yyleng; return ROUNDCOEFFICIENTSTOKEN; } {RATIONALAPPROX} { miniparserCharactersRead += yyleng; return RATIONALAPPROXTOKEN; } {APPROX} { miniparserCharactersRead += yyleng; return APPROXTOKEN; } {ACCURATEINFNORM} { miniparserCharactersRead += yyleng; return ACCURATEINFNORMTOKEN; } {ROUNDTOFORMAT} { miniparserCharactersRead += yyleng; return ROUNDTOFORMATTOKEN; } {EVALUATE} { miniparserCharactersRead += yyleng; return EVALUATETOKEN; } {PARSE} { miniparserCharactersRead += yyleng; return PARSETOKEN; } {PRINT} { miniparserCharactersRead += yyleng; return PRINTTOKEN; } {SUPPRESSMESSAGE} { miniparserCharactersRead += yyleng; return SUPPRESSMESSAGETOKEN; } {UNSUPPRESSMESSAGE} { miniparserCharactersRead += yyleng; return UNSUPPRESSMESSAGETOKEN; } {PRINTXML} { miniparserCharactersRead += yyleng; return PRINTXMLTOKEN; } {EXECUTE} { miniparserCharactersRead += yyleng; return EXECUTETOKEN; } {PLOT} { miniparserCharactersRead += yyleng; return PLOTTOKEN; } {PRINTHEXA} { miniparserCharactersRead += yyleng; return PRINTHEXATOKEN; } {PRINTFLOAT} { miniparserCharactersRead += yyleng; return PRINTFLOATTOKEN; } {PRINTBINARY} { miniparserCharactersRead += yyleng; return PRINTBINARYTOKEN; } {PRINTEXPANSION} { miniparserCharactersRead += yyleng; return PRINTEXPANSIONTOKEN; } {BASHEXECUTE} { miniparserCharactersRead += yyleng; return BASHEXECUTETOKEN; } {BASHEVALUATE} { miniparserCharactersRead += yyleng; return BASHEVALUATETOKEN; } {GETSUPPRESSEDMESSAGES} { miniparserCharactersRead += yyleng; return GETSUPPRESSEDMESSAGESTOKEN; } {GETBACKTRACE} { miniparserCharactersRead += yyleng; return GETBACKTRACETOKEN; } {EXTERNALPLOT} { miniparserCharactersRead += yyleng; return EXTERNALPLOTTOKEN; } {WRITE} { miniparserCharactersRead += yyleng; return WRITETOKEN; } {ASCIIPLOT} { miniparserCharactersRead += yyleng; return ASCIIPLOTTOKEN; } {RENAME} { miniparserCharactersRead += yyleng; return RENAMETOKEN; } {OBJECTNAME} { miniparserCharactersRead += yyleng; return OBJECTNAMETOKEN; } {BIND} { miniparserCharactersRead += yyleng; return BINDTOKEN; } {INFNORM} { miniparserCharactersRead += yyleng; return INFNORMTOKEN; } {SUPNORM} { miniparserCharactersRead += yyleng; return SUPNORMTOKEN; } {FINDZEROS} { miniparserCharactersRead += yyleng; return FINDZEROSTOKEN; } {FPFINDZEROS} { miniparserCharactersRead += yyleng; return FPFINDZEROSTOKEN; } {DIRTYINFNORM} { miniparserCharactersRead += yyleng; return DIRTYINFNORMTOKEN; } {NUMBERROOTS} { miniparserCharactersRead += yyleng; return NUMBERROOTSTOKEN; } {INTEGRAL} { miniparserCharactersRead += yyleng; return INTEGRALTOKEN; } {DIRTYINTEGRAL} { miniparserCharactersRead += yyleng; return DIRTYINTEGRALTOKEN; } {WORSTCASE} { miniparserCharactersRead += yyleng; return WORSTCASETOKEN; } {IMPLEMENTPOLY} { miniparserCharactersRead += yyleng; return IMPLEMENTPOLYTOKEN; } {IMPLEMENTCONST} { miniparserCharactersRead += yyleng; return IMPLEMENTCONSTTOKEN; } {CHECKINFNORM} { miniparserCharactersRead += yyleng; return CHECKINFNORMTOKEN; } {ZERODENOMINATORS} { miniparserCharactersRead += yyleng; return ZERODENOMINATORSTOKEN; } {ISEVALUABLE} { miniparserCharactersRead += yyleng; return ISEVALUABLETOKEN; } {SEARCHGAL} { miniparserCharactersRead += yyleng; return SEARCHGALTOKEN; } {GUESSDEGREE} { miniparserCharactersRead += yyleng; return GUESSDEGREETOKEN; } {DIRTYFINDZEROS} { miniparserCharactersRead += yyleng; return DIRTYFINDZEROSTOKEN; } {IF} { miniparserCharactersRead += yyleng; return IFTOKEN; } {THEN} { miniparserCharactersRead += yyleng; return THENTOKEN; } {ELSE} { miniparserCharactersRead += yyleng; return ELSETOKEN; } {FOR} { miniparserCharactersRead += yyleng; return FORTOKEN; } {IN} { miniparserCharactersRead += yyleng; return INTOKEN; } {FROM} { miniparserCharactersRead += yyleng; return FROMTOKEN; } {TO} { miniparserCharactersRead += yyleng; return TOTOKEN; } {BY} { miniparserCharactersRead += yyleng; return BYTOKEN; } {DO} { miniparserCharactersRead += yyleng; return DOTOKEN; } {BEGIN} { miniparserCharactersRead += yyleng; return BEGINTOKEN; } {END} { miniparserCharactersRead += yyleng; return ENDTOKEN; } {LBRACE} { miniparserCharactersRead += yyleng; return LEFTCURLYBRACETOKEN; } {RBRACE} { miniparserCharactersRead += yyleng; return RIGHTCURLYBRACETOKEN; } {WHILEDEF} { miniparserCharactersRead += yyleng; return WHILETOKEN; } {EXTERNALPROC} { miniparserCharactersRead += yyleng; return EXTERNALPROCTOKEN; } {VOID} { miniparserCharactersRead += yyleng; return VOIDTOKEN; } {CONSTANTTYPE} { miniparserCharactersRead += yyleng; return CONSTANTTYPETOKEN; } {FUNCTION} { miniparserCharactersRead += yyleng; return FUNCTIONTOKEN; } {OBJECT} { miniparserCharactersRead += yyleng; return OBJECTTOKEN; } {RANGE} { miniparserCharactersRead += yyleng; return RANGETOKEN; } {INTEGER} { miniparserCharactersRead += yyleng; return INTEGERTOKEN; } {STRINGTYPE} { miniparserCharactersRead += yyleng; return STRINGTYPETOKEN; } {BOOLEAN} { miniparserCharactersRead += yyleng; return BOOLEANTOKEN; } {LIST} { miniparserCharactersRead += yyleng; return LISTTOKEN; } {OF} { miniparserCharactersRead += yyleng; return OFTOKEN; } [ \t] { /* Eat up spaces and tabulators */ miniparserCharactersRead += yyleng; } [\r] { /* Eat up carriage return for compatibility with DOS-like systems */ miniparserCharactersRead += yyleng; } [\n] { miniparserCharactersRead += yyleng; } {IDENTIFIER} { miniparserCharactersRead += yyleng; constBuffer = (char *) safeCalloc(yyleng+1,sizeof(char)); strncpy(constBuffer,yytext,yyleng); yylval->value = constBuffer; return IDENTIFIERTOKEN; } . { /* otherwise */ miniparserCharactersRead += yyleng; printMessage(1,SOLLYA_MSG_A_CHARACTER_COULD_NOT_BE_RECOGNIZED,"The character \"%s\" cannot be recognized. Will ignore it.\n", yytext); } %% void *startMiniparser(void *scanner, char *str) { YY_BUFFER_STATE buf; miniparserSemicolonAtEnd = 0; miniparserEofReached = 0; miniparserCharactersRead = 0; buf = miniyy_scan_string(str, scanner); miniyy_switch_to_buffer(buf, scanner); return NULL; } void endMiniparser(void *buf, void *scanner) { miniyy_delete_buffer(buf, scanner); } void *yyalloc (yy_size_t size , yyscan_t yyscanner) { UNUSED_PARAM(yyscanner); return (void *) malloc( size ); } void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) { /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter * because both ANSI C and C++ allow castless assignment from * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ UNUSED_PARAM(yyscanner); return (void *) realloc( (char *) ptr, size ); } void yyfree (void * ptr , yyscan_t yyscanner) { UNUSED_PARAM(yyscanner); free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } sollya-6.0+ds/miniparser.y000066400000000000000000002113471300174114700156350ustar00rootroot00000000000000/* Copyright 2007-2014 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ %{ #include #include #include #include #include "expression.h" #include "assignment.h" #include "chain.h" #include "general.h" #include "execute.h" #include "miniparser.h" /* Mess with the mallocs used by the parser */ extern void *parserCalloc(size_t, size_t); extern void *parserMalloc(size_t); extern void *parserRealloc(void *, size_t); extern void parserFree(void *); #undef malloc #undef realloc #undef calloc #undef free #define malloc parserMalloc #define realloc parserRealloc #define calloc parserCalloc #define free safeFree /* End of the malloc mess */ #define YYERROR_VERBOSE 1 #define YYFPRINTF sollyaFprintf extern int miniyylex(YYSTYPE *lvalp, void *scanner); void miniyyerror(void *myScanner, const char *message) { UNUSED_PARAM(myScanner); printMessage(1,SOLLYA_MSG_SYNTAX_ERROR_ENCOUNTERED_WHILE_PARSING,"Warning: %s. Will try to continue parsing (expecting \";\"). May leak memory.\n",message); } %} %parse-param {void *myScanner} %lex-param {void *myScanner} %defines %name-prefix "miniyy" %expect 2 %pure-parser %union { doubleNode *dblnode; struct entryStruct *association; char *value; node *tree; chain *list; int *integerval; int count; void *other; }; %token CONSTANTTOKEN "decimal constant" %token MIDPOINTCONSTANTTOKEN "interval" %token DYADICCONSTANTTOKEN "dyadic constant" %token HEXCONSTANTTOKEN "constant in memory notation" %token HEXADECIMALCONSTANTTOKEN "hexadecimal constant" %token BINARYCONSTANTTOKEN "binary constant" %token PITOKEN "pi" %token IDENTIFIERTOKEN "identifier" %token STRINGTOKEN "character string" %token LPARTOKEN "(" %token RPARTOKEN ")" %token LBRACKETTOKEN "[" %token RBRACKETTOKEN "]" %token EQUALTOKEN "=" %token ASSIGNEQUALTOKEN ":=" %token COMPAREEQUALTOKEN "==" %token COMMATOKEN "," %token EXCLAMATIONTOKEN "!" %token SEMICOLONTOKEN ";" %token STARLEFTANGLETOKEN "*<" %token LEFTANGLETOKEN "<" %token RIGHTANGLEUNDERSCORETOKEN ">_" %token RIGHTANGLEDOTTOKEN ">." %token RIGHTANGLESTARTOKEN ">*" %token RIGHTANGLETOKEN ">" %token DOTSTOKEN "..." %token DOTTOKEN "." %token QUESTIONMARKTOKEN "?" %token VERTBARTOKEN "|" %token ATTOKEN "@" %token DOUBLECOLONTOKEN "::" %token COLONTOKEN ":" %token DOTCOLONTOKEN ".:" %token COLONDOTTOKEN ":." %token EXCLAMATIONEQUALTOKEN "!=" %token APPROXTOKEN "~" %token ANDTOKEN "&&" %token ORTOKEN "||" %token PLUSTOKEN "+" %token MINUSTOKEN "-" %token MULTOKEN "*" %token DIVTOKEN "/" %token POWTOKEN "^" %token SQRTTOKEN "sqrt" %token EXPTOKEN "exp" %token FREEVARTOKEN "_x_" %token LOGTOKEN "log" %token LOG2TOKEN "log2" %token LOG10TOKEN "log10" %token SINTOKEN "sin" %token COSTOKEN "cos" %token TANTOKEN "tan" %token ASINTOKEN "asin" %token ACOSTOKEN "acos" %token ATANTOKEN "atan" %token SINHTOKEN "sinh" %token COSHTOKEN "cosh" %token TANHTOKEN "tanh" %token ASINHTOKEN "asinh" %token ACOSHTOKEN "acosh" %token ATANHTOKEN "atanh" %token ABSTOKEN "abs" %token ERFTOKEN "erf" %token ERFCTOKEN "erfc" %token LOG1PTOKEN "log1p" %token EXPM1TOKEN "expm1" %token DOUBLETOKEN "D" %token SINGLETOKEN "SG" %token HALFPRECISIONTOKEN "HP" %token QUADTOKEN "QD" %token DOUBLEDOUBLETOKEN "DD" %token TRIPLEDOUBLETOKEN "TD" %token DOUBLEEXTENDEDTOKEN "DE" %token CEILTOKEN "ceil" %token FLOORTOKEN "floor" %token NEARESTINTTOKEN "nearestint" %token HEADTOKEN "head" %token REVERTTOKEN "revert" %token SORTTOKEN "sort" %token TAILTOKEN "tail" %token MANTISSATOKEN "mantissa" %token EXPONENTTOKEN "exponent" %token PRECISIONTOKEN "precision" %token ROUNDCORRECTLYTOKEN "roundcorrectly" %token PRECTOKEN "prec" %token POINTSTOKEN "points" %token DIAMTOKEN "diam" %token DISPLAYTOKEN "display" %token VERBOSITYTOKEN "verbosity" %token SHOWMESSAGENUMBERSTOKEN "showmessagenumbers" %token CANONICALTOKEN "canonical" %token AUTOSIMPLIFYTOKEN "autosimplify" %token TAYLORRECURSIONSTOKEN "taylorrecursions" %token TIMINGTOKEN "timing" %token TIMETOKEN "time" %token FULLPARENTHESESTOKEN "fullparentheses" %token MIDPOINTMODETOKEN "midpointmode" %token DIEONERRORMODETOKEN "dieonerrormode" %token SUPPRESSWARNINGSTOKEN "roundingwarnings" %token RATIONALMODETOKEN "rationalmode" %token HOPITALRECURSIONSTOKEN "hopitalrecursions" %token ONTOKEN "on" %token OFFTOKEN "off" %token DYADICTOKEN "dyadic" %token POWERSTOKEN "powers" %token BINARYTOKEN "binary" %token HEXADECIMALTOKEN "hexadecimal" %token FILETOKEN "file" %token POSTSCRIPTTOKEN "postscript" %token POSTSCRIPTFILETOKEN "postscriptfile" %token PERTURBTOKEN "perturb" %token MINUSWORDTOKEN "RD" %token PLUSWORDTOKEN "RU" %token ZEROWORDTOKEN "RZ" %token NEARESTTOKEN "RN" %token HONORCOEFFPRECTOKEN "honorcoeffprec" %token TRUETOKEN "true" %token FALSETOKEN "false" %token DEFAULTTOKEN "default" %token MATCHTOKEN "match" %token WITHTOKEN "with" %token ABSOLUTETOKEN "absolute" %token DECIMALTOKEN "decimal" %token RELATIVETOKEN "relative" %token FIXEDTOKEN "fixed" %token FLOATINGTOKEN "floating" %token ERRORTOKEN "error" %token QUITTOKEN "quit" %token FALSEQUITTOKEN "quit in an included file" %token FALSERESTARTTOKEN "restart" %token LIBRARYTOKEN "library" %token LIBRARYCONSTANTTOKEN "libraryconstant" %token DIFFTOKEN "diff" %token DIRTYSIMPLIFYTOKEN "dirtysimplify" %token REMEZTOKEN "remez" %token ANNOTATEFUNCTIONTOKEN "annotatefunction" %token BASHEVALUATETOKEN "bashevaluate" %token GETSUPPRESSEDMESSAGESTOKEN "getsuppressedmessages" %token GETBACKTRACETOKEN "getbacktrace" %token FPMINIMAXTOKEN "fpminimax" %token HORNERTOKEN "horner" %token EXPANDTOKEN "expand" %token SIMPLIFYSAFETOKEN "simplify" %token TAYLORTOKEN "taylor" %token TAYLORFORMTOKEN "taylorform" %token CHEBYSHEVFORMTOKEN "chebyshevform" %token AUTODIFFTOKEN "autodiff" %token DEGREETOKEN "degree" %token NUMERATORTOKEN "numerator" %token DENOMINATORTOKEN "denominator" %token SUBSTITUTETOKEN "substitute" %token COMPOSEPOLYNOMIALSTOKEN "composepolynomials" %token COEFFTOKEN "coeff" %token SUBPOLYTOKEN "subpoly" %token ROUNDCOEFFICIENTSTOKEN "roundcoefficients" %token RATIONALAPPROXTOKEN "rationalapprox" %token ACCURATEINFNORMTOKEN "accurateinfnorm" %token ROUNDTOFORMATTOKEN "round" %token EVALUATETOKEN "evaluate" %token LENGTHTOKEN "length" %token OBJECTNAMETOKEN "objectname" %token INFTOKEN "inf" %token MIDTOKEN "mid" %token SUPTOKEN "sup" %token MINTOKEN "min" %token MAXTOKEN "max" %token READXMLTOKEN "read" %token PARSETOKEN "parse" %token PRINTTOKEN "print" %token PRINTXMLTOKEN "printxml" %token PLOTTOKEN "plot" %token PRINTHEXATOKEN "printhexa" %token PRINTFLOATTOKEN "printfloat" %token PRINTBINARYTOKEN "printbinary" %token SUPPRESSMESSAGETOKEN "suppressmessage" %token UNSUPPRESSMESSAGETOKEN "unsuppressmessage" %token PRINTEXPANSIONTOKEN "printexpansion" %token BASHEXECUTETOKEN "bashexecute" %token EXTERNALPLOTTOKEN "externalplot" %token WRITETOKEN "write" %token ASCIIPLOTTOKEN "asciiplot" %token RENAMETOKEN "rename" %token BINDTOKEN "bind" %token INFNORMTOKEN "infnorm" %token SUPNORMTOKEN "supnorm" %token FINDZEROSTOKEN "findzeros" %token FPFINDZEROSTOKEN "fpfindzeros" %token DIRTYINFNORMTOKEN "dirtyinfnorm" %token NUMBERROOTSTOKEN "numberroots" %token INTEGRALTOKEN "integral" %token DIRTYINTEGRALTOKEN "dirtyintegral" %token WORSTCASETOKEN "worstcase" %token IMPLEMENTPOLYTOKEN "implementpoly" %token IMPLEMENTCONSTTOKEN "implementconst" %token CHECKINFNORMTOKEN "checkinfnorm" %token ZERODENOMINATORSTOKEN "zerodenominators" %token ISEVALUABLETOKEN "isevaluable" %token SEARCHGALTOKEN "searchgal" %token GUESSDEGREETOKEN "guessdegree" %token DIRTYFINDZEROSTOKEN "dirtyfindzeros" %token IFTOKEN "if" %token THENTOKEN "then" %token ELSETOKEN "else" %token FORTOKEN "for" %token INTOKEN "in" %token FROMTOKEN "from" %token TOTOKEN "to" %token BYTOKEN "by" %token DOTOKEN "do" %token BEGINTOKEN "begin" %token ENDTOKEN "end" %token LEFTCURLYBRACETOKEN "{" %token RIGHTCURLYBRACETOKEN "}" %token WHILETOKEN "while" %token READFILETOKEN "readfile" %token ISBOUNDTOKEN "isbound" %token EXECUTETOKEN "execute" %token EXTERNALPROCTOKEN "externalproc" %token VOIDTOKEN "void" %token CONSTANTTYPETOKEN "constant" %token FUNCTIONTOKEN "function" %token OBJECTTOKEN "object" %token RANGETOKEN "range" %token INTEGERTOKEN "integer" %token STRINGTYPETOKEN "string" %token BOOLEANTOKEN "boolean" %token LISTTOKEN "list" %token OFTOKEN "of" %token VARTOKEN "var" %token PROCTOKEN "proc" %token PROCEDURETOKEN "procedure" %token RETURNTOKEN "return" %token NOPTOKEN "nop" %type startsymbol; %type egalquestionmark; %type unaryplusminus; %type startsymbolwitherr; %type command; %type procbody; %type variabledeclaration; %type simplecommand; %type commandlist; %type variabledeclarationlist; %type identifierlist; %type thing; %type supermegaterm; %type thinglist; %type matchlist; %type matchelement; %type structelementlist; %type structelement; %type structelementseparator; %type structuring; %type ifcommand; %type forcommand; %type assignment; %type simpleassignment; %type stateassignment; %type stillstateassignment; %type basicthing; %type list; %type constant; %type simplelist; %type range; %type debound; %type headfunction; %type term; %type hyperterm; %type subterm; %type megaterm; %type statedereference; %type indexing; %type externalproctype; %type extendedexternalproctype; %type externalproctypesimplelist; %type externalproctypelist; %type beginsymbol; %type endsymbol; %% startsymbol: startsymbolwitherr { minitree = $1; $$ = NULL; YYACCEPT; } ; startsymbolwitherr: thing { $$ = $1; } | thing SEMICOLONTOKEN { miniparserSemicolonAtEnd = 1; $$ = $1; } | error { $$ = NULL; } ; beginsymbol: BEGINTOKEN { $$ = NULL; } | LEFTCURLYBRACETOKEN { $$ = NULL; } ; endsymbol: ENDTOKEN { $$ = NULL; } | RIGHTCURLYBRACETOKEN { $$ = NULL; } ; command: simplecommand { $$ = $1; } | beginsymbol commandlist endsymbol { $$ = makeCommandList($2); } | beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeCommandList(concatChains($2, $3)); } | beginsymbol variabledeclarationlist endsymbol { $$ = makeCommandList($2); } | beginsymbol endsymbol { $$ = makeNop(); } | IFTOKEN ifcommand { $$ = $2; } | WHILETOKEN thing DOTOKEN command { $$ = makeWhile($2, $4); } | FORTOKEN forcommand { $$ = $2; } ; ifcommand: thing THENTOKEN command { $$ = makeIf($1, $3); } | thing THENTOKEN command ELSETOKEN command { $$ = makeIfElse($1,$3,$5); } ; forcommand: IDENTIFIERTOKEN FROMTOKEN thing TOTOKEN thing DOTOKEN command { $$ = makeFor($1, $3, $5, makeConstantDouble(1.0), $7); safeFree($1); } | IDENTIFIERTOKEN FROMTOKEN thing TOTOKEN thing BYTOKEN thing DOTOKEN command { $$ = makeFor($1, $3, $5, $7, $9); safeFree($1); } | IDENTIFIERTOKEN INTOKEN thing DOTOKEN command { $$ = makeForIn($1, $3, $5); safeFree($1); } ; commandlist: command SEMICOLONTOKEN { $$ = addElement(NULL, $1); } | command SEMICOLONTOKEN commandlist { $$ = addElement($3, $1); } ; variabledeclarationlist: variabledeclaration SEMICOLONTOKEN { $$ = addElement(NULL, $1); } | variabledeclaration SEMICOLONTOKEN variabledeclarationlist { $$ = addElement($3, $1); } ; variabledeclaration: VARTOKEN identifierlist { $$ = makeVariableDeclaration($2); } ; identifierlist: IDENTIFIERTOKEN { $$ = addElement(NULL, $1); } | IDENTIFIERTOKEN COMMATOKEN identifierlist { $$ = addElement($3, $1); } ; procbody: LPARTOKEN RPARTOKEN beginsymbol commandlist endsymbol { $$ = makeProc(NULL, makeCommandList($4), makeUnit()); } | LPARTOKEN RPARTOKEN beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeProc(NULL, makeCommandList(concatChains($4, $5)), makeUnit()); } | LPARTOKEN RPARTOKEN beginsymbol variabledeclarationlist endsymbol { $$ = makeProc(NULL, makeCommandList($4), makeUnit()); } | LPARTOKEN RPARTOKEN beginsymbol endsymbol { $$ = makeProc(NULL, makeCommandList(addElement(NULL,makeNop())), makeUnit()); } | LPARTOKEN RPARTOKEN beginsymbol commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc(NULL, makeCommandList($4), $6); } | LPARTOKEN RPARTOKEN beginsymbol variabledeclarationlist commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc(NULL, makeCommandList(concatChains($4, $5)), $7); } | LPARTOKEN RPARTOKEN beginsymbol variabledeclarationlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc(NULL, makeCommandList($4), $6); } | LPARTOKEN RPARTOKEN beginsymbol RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc(NULL, makeCommandList(addElement(NULL,makeNop())), $5); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol commandlist endsymbol { $$ = makeProc($2, makeCommandList($5), makeUnit()); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeProc($2, makeCommandList(concatChains($5, $6)), makeUnit()); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol variabledeclarationlist endsymbol { $$ = makeProc($2, makeCommandList($5), makeUnit()); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol endsymbol { $$ = makeProc($2, makeCommandList(addElement(NULL,makeNop())), makeUnit()); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc($2, makeCommandList($5), $7); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol variabledeclarationlist commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc($2, makeCommandList(concatChains($5, $6)), $8); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol variabledeclarationlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc($2, makeCommandList($5), $7); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc($2, makeCommandList(addElement(NULL, makeNop())), $6); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol commandlist endsymbol { $$ = makeProcIllim($2, makeCommandList($7), makeUnit()); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeProcIllim($2, makeCommandList(concatChains($7, $8)), makeUnit()); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol variabledeclarationlist endsymbol { $$ = makeProcIllim($2, makeCommandList($7), makeUnit()); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol endsymbol { $$ = makeProcIllim($2, makeCommandList(addElement(NULL,makeNop())), makeUnit()); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProcIllim($2, makeCommandList($7), $9); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol variabledeclarationlist commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProcIllim($2, makeCommandList(concatChains($7, $8)), $10); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol variabledeclarationlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProcIllim($2, makeCommandList($7), $9); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProcIllim($2, makeCommandList(addElement(NULL, makeNop())), $8); } ; simplecommand: FALSEQUITTOKEN { $$ = makeQuit(); } | FALSERESTARTTOKEN { $$ = makeFalseRestart(); } | NOPTOKEN { $$ = makeNop(); } | NOPTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeNopArg($3); } | NOPTOKEN LPARTOKEN RPARTOKEN { $$ = makeNopArg(makeDefault()); } | PRINTTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makePrint($3); } | PRINTTOKEN LPARTOKEN thinglist RPARTOKEN RIGHTANGLETOKEN thing { $$ = makeNewFilePrint($6, $3); } | PRINTTOKEN LPARTOKEN thinglist RPARTOKEN RIGHTANGLETOKEN RIGHTANGLETOKEN thing { $$ = makeAppendFilePrint($7, $3); } | PLOTTOKEN LPARTOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makePlot(addElement($5, $3)); } | PRINTHEXATOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintHexa($3); } | PRINTFLOATTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintFloat($3); } | PRINTBINARYTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintBinary($3); } | SUPPRESSMESSAGETOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeSuppressMessage($3); } | UNSUPPRESSMESSAGETOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeUnsuppressMessage($3); } | PRINTEXPANSIONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintExpansion($3); } | BASHEXECUTETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeBashExecute($3); } | EXTERNALPLOTTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeExternalPlot(addElement(addElement(addElement(addElement($11,$9),$7),$5),$3)); } | WRITETOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeWrite($3); } | WRITETOKEN LPARTOKEN thinglist RPARTOKEN RIGHTANGLETOKEN thing { $$ = makeNewFileWrite($6, $3); } | WRITETOKEN LPARTOKEN thinglist RPARTOKEN RIGHTANGLETOKEN RIGHTANGLETOKEN thing { $$ = makeAppendFileWrite($7, $3); } | ASCIIPLOTTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeAsciiPlot($3, $5); } | PRINTXMLTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintXml($3); } | EXECUTETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExecute($3); } | PRINTXMLTOKEN LPARTOKEN thing RPARTOKEN RIGHTANGLETOKEN thing { $$ = makePrintXmlNewFile($3,$6); } | PRINTXMLTOKEN LPARTOKEN thing RPARTOKEN RIGHTANGLETOKEN RIGHTANGLETOKEN thing { $$ = makePrintXmlAppendFile($3,$7); } | WORSTCASETOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeWorstCase(addElement(addElement(addElement(addElement($11, $9), $7), $5), $3)); } | RENAMETOKEN LPARTOKEN IDENTIFIERTOKEN COMMATOKEN IDENTIFIERTOKEN RPARTOKEN { $$ = makeRename($3, $5); safeFree($3); safeFree($5); } | RENAMETOKEN LPARTOKEN FREEVARTOKEN COMMATOKEN IDENTIFIERTOKEN RPARTOKEN { $$ = makeRename("_x_", $5); safeFree($5); } | EXTERNALPROCTOKEN LPARTOKEN IDENTIFIERTOKEN COMMATOKEN thing COMMATOKEN externalproctypelist MINUSTOKEN RIGHTANGLETOKEN extendedexternalproctype RPARTOKEN { $$ = makeExternalProc($3, $5, addElement($7, $10)); safeFree($3); } | assignment { $$ = $1; } | thinglist { $$ = makeAutoprint($1); } | PROCEDURETOKEN IDENTIFIERTOKEN procbody { $$ = makeAssignment($2, $3); safeFree($2); } ; assignment: stateassignment { $$ = $1; } | stillstateassignment EXCLAMATIONTOKEN { $$ = $1; } | simpleassignment { $$ = $1; } | simpleassignment EXCLAMATIONTOKEN { $$ = $1; } ; simpleassignment: IDENTIFIERTOKEN EQUALTOKEN thing { $$ = makeAssignment($1, $3); safeFree($1); } | IDENTIFIERTOKEN ASSIGNEQUALTOKEN thing { $$ = makeFloatAssignment($1, $3); safeFree($1); } | IDENTIFIERTOKEN EQUALTOKEN LIBRARYTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLibraryBinding($1, $5); safeFree($1); } | IDENTIFIERTOKEN EQUALTOKEN LIBRARYCONSTANTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLibraryConstantBinding($1, $5); safeFree($1); } | indexing EQUALTOKEN thing { $$ = makeAssignmentInIndexing($1->a,$1->b,$3); safeFree($1); } | indexing ASSIGNEQUALTOKEN thing { $$ = makeFloatAssignmentInIndexing($1->a,$1->b,$3); safeFree($1); } | structuring EQUALTOKEN thing { $$ = makeProtoAssignmentInStructure($1,$3); } | structuring ASSIGNEQUALTOKEN thing { $$ = makeProtoFloatAssignmentInStructure($1,$3); } ; structuring: basicthing DOTTOKEN IDENTIFIERTOKEN { $$ = makeStructAccess($1,$3); safeFree($3); } ; stateassignment: PRECTOKEN EQUALTOKEN thing { $$ = makePrecAssign($3); } | POINTSTOKEN EQUALTOKEN thing { $$ = makePointsAssign($3); } | DIAMTOKEN EQUALTOKEN thing { $$ = makeDiamAssign($3); } | DISPLAYTOKEN EQUALTOKEN thing { $$ = makeDisplayAssign($3); } | VERBOSITYTOKEN EQUALTOKEN thing { $$ = makeVerbosityAssign($3); } | SHOWMESSAGENUMBERSTOKEN EQUALTOKEN thing { $$ = makeShowMessageNumbersAssign($3); } | CANONICALTOKEN EQUALTOKEN thing { $$ = makeCanonicalAssign($3); } | AUTOSIMPLIFYTOKEN EQUALTOKEN thing { $$ = makeAutoSimplifyAssign($3); } | TAYLORRECURSIONSTOKEN EQUALTOKEN thing { $$ = makeTaylorRecursAssign($3); } | TIMINGTOKEN EQUALTOKEN thing { $$ = makeTimingAssign($3); } | FULLPARENTHESESTOKEN EQUALTOKEN thing { $$ = makeFullParenAssign($3); } | MIDPOINTMODETOKEN EQUALTOKEN thing { $$ = makeMidpointAssign($3); } | DIEONERRORMODETOKEN EQUALTOKEN thing { $$ = makeDieOnErrorAssign($3); } | RATIONALMODETOKEN EQUALTOKEN thing { $$ = makeRationalModeAssign($3); } | SUPPRESSWARNINGSTOKEN EQUALTOKEN thing { $$ = makeSuppressWarningsAssign($3); } | HOPITALRECURSIONSTOKEN EQUALTOKEN thing { $$ = makeHopitalRecursAssign($3); } ; stillstateassignment: PRECTOKEN EQUALTOKEN thing { $$ = makePrecStillAssign($3); } | POINTSTOKEN EQUALTOKEN thing { $$ = makePointsStillAssign($3); } | DIAMTOKEN EQUALTOKEN thing { $$ = makeDiamStillAssign($3); } | DISPLAYTOKEN EQUALTOKEN thing { $$ = makeDisplayStillAssign($3); } | VERBOSITYTOKEN EQUALTOKEN thing { $$ = makeVerbosityStillAssign($3); } | SHOWMESSAGENUMBERSTOKEN EQUALTOKEN thing { $$ = makeShowMessageNumbersStillAssign($3); } | CANONICALTOKEN EQUALTOKEN thing { $$ = makeCanonicalStillAssign($3); } | AUTOSIMPLIFYTOKEN EQUALTOKEN thing { $$ = makeAutoSimplifyStillAssign($3); } | TAYLORRECURSIONSTOKEN EQUALTOKEN thing { $$ = makeTaylorRecursStillAssign($3); } | TIMINGTOKEN EQUALTOKEN thing { $$ = makeTimingStillAssign($3); } | FULLPARENTHESESTOKEN EQUALTOKEN thing { $$ = makeFullParenStillAssign($3); } | MIDPOINTMODETOKEN EQUALTOKEN thing { $$ = makeMidpointStillAssign($3); } | DIEONERRORMODETOKEN EQUALTOKEN thing { $$ = makeDieOnErrorStillAssign($3); } | RATIONALMODETOKEN EQUALTOKEN thing { $$ = makeRationalModeStillAssign($3); } | SUPPRESSWARNINGSTOKEN EQUALTOKEN thing { $$ = makeSuppressWarningsStillAssign($3); } | HOPITALRECURSIONSTOKEN EQUALTOKEN thing { $$ = makeHopitalRecursStillAssign($3); } ; thinglist: thing { $$ = addElement(NULL, $1); } | thing COMMATOKEN thinglist { $$ = addElement($3, $1); } ; structelementlist: structelement { $$ = addElement(NULL, $1); } | structelement structelementseparator structelementlist { $$ = addElement($3, $1); } ; structelementseparator: COMMATOKEN { $$ = NULL; } | SEMICOLONTOKEN { $$ = NULL; } ; structelement: DOTTOKEN IDENTIFIERTOKEN EQUALTOKEN thing { $$ = (entry *) safeMalloc(sizeof(entry)); $$->name = (char *) safeCalloc(strlen($2) + 1, sizeof(char)); strcpy($$->name,$2); safeFree($2); $$->value = (void *) ($4); } ; thing: supermegaterm { $$ = $1; } | MATCHTOKEN supermegaterm WITHTOKEN matchlist { $$ = makeMatch($2,$4); } ; supermegaterm: megaterm { $$ = $1; } | thing ANDTOKEN megaterm { $$ = makeAnd($1, $3); } | thing ORTOKEN megaterm { $$ = makeOr($1, $3); } | EXCLAMATIONTOKEN megaterm { $$ = makeNegation($2); } ; indexing: basicthing LBRACKETTOKEN thing RBRACKETTOKEN { $$ = (doubleNode *) safeMalloc(sizeof(doubleNode)); $$->a = $1; $$->b = $3; } ; megaterm: hyperterm { $$ = $1; } | megaterm COMPAREEQUALTOKEN hyperterm { $$ = makeCompareEqual($1, $3); } | megaterm INTOKEN hyperterm { $$ = makeCompareIn($1, $3); } | megaterm LEFTANGLETOKEN hyperterm { $$ = makeCompareLess($1, $3); } | megaterm RIGHTANGLETOKEN hyperterm { $$ = makeCompareGreater($1, $3); } | megaterm LEFTANGLETOKEN EQUALTOKEN hyperterm { $$ = makeCompareLessEqual($1, $4); } | megaterm RIGHTANGLETOKEN EQUALTOKEN hyperterm { $$ = makeCompareGreaterEqual($1, $4); } | megaterm EXCLAMATIONEQUALTOKEN hyperterm { $$ = makeCompareNotEqual($1, $3); } ; hyperterm: term { $$ = $1; } | hyperterm PLUSTOKEN term { $$ = makeAdd($1, $3); } | hyperterm MINUSTOKEN term { $$ = makeSub($1, $3); } | hyperterm ATTOKEN term { $$ = makeConcat($1, $3); } | hyperterm DOUBLECOLONTOKEN term { $$ = makeAddToList($1, $3); } | hyperterm COLONDOTTOKEN term { $$ = makeAppend($1, $3); } ; unaryplusminus: PLUSTOKEN { $$ = 0; } | MINUSTOKEN { $$ = 1; } | PLUSTOKEN unaryplusminus { $$ = $2; } | MINUSTOKEN unaryplusminus { $$ = $2+1; } ; term: subterm { $$ = $1; } | unaryplusminus subterm { tempNode = $2; for (tempInteger=0;tempInteger<$1;tempInteger++) tempNode = makeNeg(tempNode); $$ = tempNode; } | APPROXTOKEN subterm { $$ = makeEvalConst($2); } | term MULTOKEN subterm { $$ = makeMul($1, $3); } | term DIVTOKEN subterm { $$ = makeDiv($1, $3); } | term MULTOKEN unaryplusminus subterm { tempNode = $4; for (tempInteger=0;tempInteger<$3;tempInteger++) tempNode = makeNeg(tempNode); $$ = makeMul($1, tempNode); } | term DIVTOKEN unaryplusminus subterm { tempNode = $4; for (tempInteger=0;tempInteger<$3;tempInteger++) tempNode = makeNeg(tempNode); $$ = makeDiv($1, tempNode); } | term MULTOKEN APPROXTOKEN subterm { $$ = makeMul($1, makeEvalConst($4)); } | term DIVTOKEN APPROXTOKEN subterm { $$ = makeDiv($1, makeEvalConst($4)); } ; subterm: basicthing { $$ = $1; } | basicthing POWTOKEN subterm { $$ = makePow($1, $3); } | basicthing POWTOKEN unaryplusminus subterm { tempNode = $4; for (tempInteger=0;tempInteger<$3;tempInteger++) tempNode = makeNeg(tempNode); $$ = makePow($1, tempNode); } | basicthing POWTOKEN APPROXTOKEN subterm { $$ = makePow($1, makeEvalConst($4)); } | basicthing DOTCOLONTOKEN subterm { $$ = makePrepend($1, $3); } | basicthing DOTCOLONTOKEN APPROXTOKEN subterm { $$ = makePrepend($1, makeEvalConst($4)); } ; basicthing: ONTOKEN { $$ = makeOn(); } | OFFTOKEN { $$ = makeOff(); } | DYADICTOKEN { $$ = makeDyadic(); } | POWERSTOKEN { $$ = makePowers(); } | BINARYTOKEN { $$ = makeBinaryThing(); } | HEXADECIMALTOKEN { $$ = makeHexadecimalThing(); } | FILETOKEN { $$ = makeFile(); } | POSTSCRIPTTOKEN { $$ = makePostscript(); } | POSTSCRIPTFILETOKEN { $$ = makePostscriptFile(); } | PERTURBTOKEN { $$ = makePerturb(); } | MINUSWORDTOKEN { $$ = makeRoundDown(); } | PLUSWORDTOKEN { $$ = makeRoundUp(); } | ZEROWORDTOKEN { $$ = makeRoundToZero(); } | NEARESTTOKEN { $$ = makeRoundToNearest(); } | HONORCOEFFPRECTOKEN { $$ = makeHonorCoeff(); } | TRUETOKEN { $$ = makeTrue(); } | VOIDTOKEN { $$ = makeUnit(); } | FALSETOKEN { $$ = makeFalse(); } | DEFAULTTOKEN { $$ = makeDefault(); } | DECIMALTOKEN { $$ = makeDecimal(); } | ABSOLUTETOKEN { $$ = makeAbsolute(); } | RELATIVETOKEN { $$ = makeRelative(); } | FIXEDTOKEN { $$ = makeFixed(); } | FLOATINGTOKEN { $$ = makeFloating(); } | ERRORTOKEN { $$ = makeError(); } | DOUBLETOKEN { $$ = makeDoubleSymbol(); } | SINGLETOKEN { $$ = makeSingleSymbol(); } | QUADTOKEN { $$ = makeQuadSymbol(); } | HALFPRECISIONTOKEN { $$ = makeHalfPrecisionSymbol(); } | DOUBLEEXTENDEDTOKEN { $$ = makeDoubleextendedSymbol(); } | FREEVARTOKEN { $$ = makeVariable(); } | DOUBLEDOUBLETOKEN { $$ = makeDoubleDoubleSymbol(); } | TRIPLEDOUBLETOKEN { $$ = makeTripleDoubleSymbol(); } | STRINGTOKEN { tempString = safeCalloc(strlen($1) + 1, sizeof(char)); strcpy(tempString, $1); safeFree($1); tempString2 = safeCalloc(strlen(tempString) + 1, sizeof(char)); strcpy(tempString2, tempString); safeFree(tempString); $$ = makeString(tempString2); safeFree(tempString2); } | constant { $$ = $1; } | IDENTIFIERTOKEN { $$ = makeTableAccess($1); safeFree($1); } | ISBOUNDTOKEN LPARTOKEN IDENTIFIERTOKEN RPARTOKEN { $$ = makeIsBound($3); safeFree($3); } | IDENTIFIERTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeTableAccessWithSubstitute($1, $3); safeFree($1); } | IDENTIFIERTOKEN LPARTOKEN RPARTOKEN { $$ = makeTableAccessWithSubstitute($1, NULL); safeFree($1); } | list { $$ = $1; } | range { $$ = $1; } | debound { $$ = $1; } | headfunction { $$ = $1; } | LPARTOKEN thing RPARTOKEN { $$ = $2; } | LEFTCURLYBRACETOKEN structelementlist RIGHTCURLYBRACETOKEN { $$ = makeStructure($2); } | statedereference { $$ = $1; } | indexing { $$ = makeIndex($1->a, $1->b); safeFree($1); } | basicthing DOTTOKEN IDENTIFIERTOKEN { $$ = makeStructAccess($1,$3); safeFree($3); } | basicthing DOTTOKEN IDENTIFIERTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeApply(makeStructAccess($1,$3),$5); safeFree($3); } | LPARTOKEN thing RPARTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeApply($2,$5); } | LPARTOKEN thing RPARTOKEN LPARTOKEN RPARTOKEN { $$ = makeApply($2,addElement(NULL,makeUnit())); } | PROCTOKEN procbody { $$ = $2; } | TIMETOKEN LPARTOKEN command RPARTOKEN { $$ = makeTime($3); } ; matchlist: matchelement { $$ = addElement(NULL,$1); } | matchelement matchlist { $$ = addElement($2,$1); } ; matchelement: thing COLONTOKEN beginsymbol variabledeclarationlist commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeMatchElement($1,makeCommandList(concatChains($4, $5)),$7); } | thing COLONTOKEN beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeMatchElement($1,makeCommandList(concatChains($4, $5)),makeUnit()); } | thing COLONTOKEN beginsymbol variabledeclarationlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeMatchElement($1,makeCommandList($4),$6); } | thing COLONTOKEN beginsymbol variabledeclarationlist endsymbol { $$ = makeMatchElement($1,makeCommandList($4),makeUnit()); } | thing COLONTOKEN beginsymbol commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeMatchElement($1,makeCommandList($4),$6); } | thing COLONTOKEN beginsymbol commandlist endsymbol { $$ = makeMatchElement($1,makeCommandList($4),makeUnit()); } | thing COLONTOKEN beginsymbol RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeMatchElement($1, makeCommandList(addElement(NULL,makeNop())), $5); } | thing COLONTOKEN beginsymbol endsymbol { $$ = makeMatchElement($1, makeCommandList(addElement(NULL,makeNop())), makeUnit()); } | thing COLONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeMatchElement($1, makeCommandList(addElement(NULL,makeNop())), $4); } ; constant: CONSTANTTOKEN { $$ = makeDecimalConstant($1); safeFree($1); } | MIDPOINTCONSTANTTOKEN { $$ = makeMidpointConstant($1); safeFree($1); } | DYADICCONSTANTTOKEN { $$ = makeDyadicConstant($1); safeFree($1); } | HEXCONSTANTTOKEN { $$ = makeHexConstant($1); safeFree($1); } | HEXADECIMALCONSTANTTOKEN { $$ = makeHexadecimalConstant($1); safeFree($1); } | BINARYCONSTANTTOKEN { $$ = makeBinaryConstant($1); safeFree($1); } | PITOKEN { $$ = makePi(); } ; list: LBRACKETTOKEN VERTBARTOKEN VERTBARTOKEN RBRACKETTOKEN { $$ = makeEmptyList(); } | LBRACKETTOKEN ORTOKEN RBRACKETTOKEN { $$ = makeEmptyList(); } | LBRACKETTOKEN VERTBARTOKEN simplelist VERTBARTOKEN RBRACKETTOKEN { $$ = makeRevertedList($3); } | LBRACKETTOKEN VERTBARTOKEN simplelist DOTSTOKEN VERTBARTOKEN RBRACKETTOKEN { $$ = makeRevertedFinalEllipticList($3); } ; simplelist: thing { $$ = addElement(NULL, $1); } | simplelist COMMATOKEN thing { $$ = addElement($1, $3); } | simplelist COMMATOKEN DOTSTOKEN COMMATOKEN thing { $$ = addElement(addElement($1, makeElliptic()), $5); } ; range: LBRACKETTOKEN thing COMMATOKEN thing RBRACKETTOKEN { $$ = makeRange($2, $4); } | LBRACKETTOKEN thing SEMICOLONTOKEN thing RBRACKETTOKEN { $$ = makeRange($2, $4); } | LBRACKETTOKEN thing RBRACKETTOKEN { $$ = makeRange($2, copyThing($2)); } ; debound: STARLEFTANGLETOKEN thing RIGHTANGLESTARTOKEN { $$ = makeDeboundMax($2); } | STARLEFTANGLETOKEN thing RIGHTANGLEDOTTOKEN { $$ = makeDeboundMid($2); } | STARLEFTANGLETOKEN thing RIGHTANGLEUNDERSCORETOKEN { $$ = makeDeboundMin($2); } | SUPTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDeboundMax($3); } | MIDTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDeboundMid($3); } | INFTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDeboundMin($3); } ; headfunction: DIFFTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDiff($3); } | BASHEVALUATETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeBashevaluate(addElement(NULL,$3)); } | GETSUPPRESSEDMESSAGESTOKEN LPARTOKEN RPARTOKEN { $$ = makeGetSuppressedMessages(); } | GETBACKTRACETOKEN LPARTOKEN RPARTOKEN { $$ = makeGetBacktrace(); } | BASHEVALUATETOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeBashevaluate(addElement(addElement(NULL,$5),$3)); } | DIRTYSIMPLIFYTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDirtysimplify($3); } | REMEZTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeRemez(addElement(addElement($7, $5), $3)); } | ANNOTATEFUNCTIONTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeAnnotateFunction(addElement(addElement(addElement($9, $7), $5), $3)); } | BINDTOKEN LPARTOKEN thing COMMATOKEN IDENTIFIERTOKEN COMMATOKEN thing RPARTOKEN { $$ = makeBind($3, $5, $7); safeFree($5); } | MINTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeMin($3); } | MAXTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeMax($3); } | FPMINIMAXTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeFPminimax(addElement(addElement(addElement($9, $7), $5), $3)); } | HORNERTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeHorner($3); } | CANONICALTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeCanonicalThing($3); } | EXPANDTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExpand($3); } | SIMPLIFYSAFETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSimplifySafe($3); } | TAYLORTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeTaylor($3, $5, $7); } | TAYLORFORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeTaylorform(addElement(addElement($7, $5), $3)); } | CHEBYSHEVFORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeChebyshevform(addElement(addElement(addElement(NULL, $7), $5), $3)); } | AUTODIFFTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeAutodiff(addElement(addElement(addElement(NULL, $7), $5), $3)); } | DEGREETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDegree($3); } | NUMERATORTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeNumerator($3); } | DENOMINATORTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDenominator($3); } | SUBSTITUTETOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSubstitute($3, $5); } | COMPOSEPOLYNOMIALSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeComposePolynomials($3, $5); } | COEFFTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeCoeff($3, $5); } | SUBPOLYTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSubpoly($3, $5); } | ROUNDCOEFFICIENTSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeRoundcoefficients($3, $5); } | RATIONALAPPROXTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeRationalapprox($3, $5); } | ACCURATEINFNORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeAccurateInfnorm(addElement(addElement($7, $5), $3)); } | ROUNDTOFORMATTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeRoundToFormat($3, $5, $7); } | EVALUATETOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeEvaluate($3, $5); } | PARSETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeParse($3); } | READXMLTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeReadXml($3); } | INFNORMTOKEN LPARTOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeInfnorm(addElement($5, $3)); } | SUPNORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSupnorm(addElement(addElement(addElement(addElement(addElement(NULL,$11),$9),$7),$5),$3)); } | FINDZEROSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeFindZeros($3, $5); } | FPFINDZEROSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeFPFindZeros($3, $5); } | DIRTYINFNORMTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeDirtyInfnorm($3, $5); } | NUMBERROOTSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeNumberRoots($3, $5); } | INTEGRALTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeIntegral($3, $5); } | DIRTYINTEGRALTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeDirtyIntegral($3, $5); } | IMPLEMENTPOLYTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeImplementPoly(addElement(addElement(addElement(addElement(addElement($13, $11), $9), $7), $5), $3)); } | IMPLEMENTCONSTTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeImplementConst($3); } | CHECKINFNORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeCheckInfnorm($3, $5, $7); } | ZERODENOMINATORSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeZeroDenominators($3, $5); } | ISEVALUABLETOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeIsEvaluable($3, $5); } | SEARCHGALTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeSearchGal($3); } | GUESSDEGREETOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeGuessDegree(addElement(addElement($7, $5), $3)); } | DIRTYFINDZEROSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeDirtyFindZeros($3, $5); } | HEADTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeHead($3); } | ROUNDCORRECTLYTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeRoundCorrectly($3); } | READFILETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeReadFile($3); } | REVERTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeRevert($3); } | SORTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSort($3); } | MANTISSATOKEN LPARTOKEN thing RPARTOKEN { $$ = makeMantissa($3); } | EXPONENTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExponent($3); } | PRECISIONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrecision($3); } | TAILTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeTail($3); } | SQRTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSqrt($3); } | EXPTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExp($3); } | FREEVARTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeApply(makeVariable(),addElement(NULL,$3)); } | FUNCTIONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeProcedureFunction($3); } | FUNCTIONTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSubstitute(makeProcedureFunction($3),$5); } | LOGTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLog($3); } | LOG2TOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLog2($3); } | LOG10TOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLog10($3); } | SINTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSin($3); } | COSTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeCos($3); } | TANTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeTan($3); } | ASINTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAsin($3); } | ACOSTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAcos($3); } | ATANTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAtan($3); } | SINHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSinh($3); } | COSHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeCosh($3); } | TANHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeTanh($3); } | ASINHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAsinh($3); } | ACOSHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAcosh($3); } | ATANHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAtanh($3); } | ABSTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAbs($3); } | ERFTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeErf($3); } | ERFCTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeErfc($3); } | LOG1PTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLog1p($3); } | EXPM1TOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExpm1($3); } | DOUBLETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDouble($3); } | SINGLETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSingle($3); } | QUADTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeQuad($3); } | HALFPRECISIONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeHalfPrecision($3); } | DOUBLEDOUBLETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDoubledouble($3); } | TRIPLEDOUBLETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeTripledouble($3); } | DOUBLEEXTENDEDTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDoubleextended($3); } | CEILTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeCeil($3); } | FLOORTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeFloor($3); } | NEARESTINTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeNearestInt($3); } | LENGTHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLength($3); } | OBJECTNAMETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeObjectName($3); } ; egalquestionmark: EQUALTOKEN QUESTIONMARKTOKEN { $$ = NULL; } | { $$ = NULL; } ; statedereference: PRECTOKEN egalquestionmark { $$ = makePrecDeref(); } | POINTSTOKEN egalquestionmark { $$ = makePointsDeref(); } | DIAMTOKEN egalquestionmark { $$ = makeDiamDeref(); } | DISPLAYTOKEN egalquestionmark { $$ = makeDisplayDeref(); } | VERBOSITYTOKEN egalquestionmark { $$ = makeVerbosityDeref(); } | SHOWMESSAGENUMBERSTOKEN egalquestionmark { $$ = makeShowMessageNumbersDeref(); } | CANONICALTOKEN egalquestionmark { $$ = makeCanonicalDeref(); } | AUTOSIMPLIFYTOKEN egalquestionmark { $$ = makeAutoSimplifyDeref(); } | TAYLORRECURSIONSTOKEN egalquestionmark { $$ = makeTaylorRecursDeref(); } | TIMINGTOKEN egalquestionmark { $$ = makeTimingDeref(); } | FULLPARENTHESESTOKEN egalquestionmark { $$ = makeFullParenDeref(); } | MIDPOINTMODETOKEN egalquestionmark { $$ = makeMidpointDeref(); } | DIEONERRORMODETOKEN egalquestionmark { $$ = makeDieOnErrorDeref(); } | RATIONALMODETOKEN egalquestionmark { $$ = makeRationalModeDeref(); } | SUPPRESSWARNINGSTOKEN egalquestionmark { $$ = makeSuppressWarningsDeref(); } | HOPITALRECURSIONSTOKEN egalquestionmark { $$ = makeHopitalRecursDeref(); } ; externalproctype: CONSTANTTYPETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = CONSTANT_TYPE; $$ = tempIntPtr; } | FUNCTIONTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = FUNCTION_TYPE; $$ = tempIntPtr; } | OBJECTTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = OBJECT_TYPE; $$ = tempIntPtr; } | RANGETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = RANGE_TYPE; $$ = tempIntPtr; } | INTEGERTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = INTEGER_TYPE; $$ = tempIntPtr; } | STRINGTYPETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = STRING_TYPE; $$ = tempIntPtr; } | BOOLEANTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = BOOLEAN_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN CONSTANTTYPETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = CONSTANT_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN FUNCTIONTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = FUNCTION_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN OBJECTTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = OBJECT_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN RANGETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = RANGE_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN INTEGERTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = INTEGER_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN STRINGTYPETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = STRING_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN BOOLEANTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = BOOLEAN_LIST_TYPE; $$ = tempIntPtr; } ; extendedexternalproctype: VOIDTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = VOID_TYPE; $$ = tempIntPtr; } | externalproctype { $$ = $1; } ; externalproctypesimplelist: externalproctype { $$ = addElement(NULL, $1); } | externalproctype COMMATOKEN externalproctypesimplelist { $$ = addElement($3, $1); } ; externalproctypelist: extendedexternalproctype { $$ = addElement(NULL, $1); } | LPARTOKEN externalproctypesimplelist RPARTOKEN { $$ = $2; } ; sollya-6.0+ds/mpfi-compat.c000066400000000000000000001152471300174114700156540ustar00rootroot00000000000000/* Copyright 2007-2014 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2) and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard, M. Joldes christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org joldes@laas.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "mpfi-compat.h" #include "general.h" #include "sollya-messaging.h" #include #include /* Functions that handle non regular intervals */ int sollya_mpfi_has_nan(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ return ( mpfr_nan_p(&(op->left)) || mpfr_nan_p(&(op->right)) ); } static inline int sollya_mpfi_has_nan_opt(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ return ( mpfr_nan_p(&(op->left)) || mpfr_nan_p(&(op->right)) ); } int sollya_mpfi_nan_p(sollya_mpfi_t op) { return sollya_mpfi_has_nan_opt(op); } int sollya_mpfi_set_nan(sollya_mpfi_t rop) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_set_nan(&(rop->left)); mpfr_set_nan(&(rop->right)); return MPFI_FLAGS_BOTH_ENDPOINTS_INEXACT; } static inline int sollya_mpfi_set_nan_opt(sollya_mpfi_t rop) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_set_nan(&(rop->left)); mpfr_set_nan(&(rop->right)); return MPFI_FLAGS_BOTH_ENDPOINTS_INEXACT; } void sollya_mpfi_nan_normalize(sollya_mpfi_t rop) { if (sollya_mpfi_has_nan_opt(rop)) sollya_mpfi_set_nan_opt(rop); } static inline void sollya_mpfi_nan_normalize_opt(sollya_mpfi_t rop) { if (sollya_mpfi_has_nan_opt(rop)) sollya_mpfi_set_nan_opt(rop); } void sollya_mpfi_zero_sign_normalize(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if (mpfr_zero_p(&(op->left))) { mpfr_mul(&(op->left), &(op->left), &(op->left), GMP_RNDN); /* (+/- 0)^2 = +0 */ } if (mpfr_zero_p(&(op->right))) { mpfr_mul(&(op->right), &(op->right), &(op->right), GMP_RNDN); /* (+/- 0)^2 = +0 */ mpfr_neg(&(op->right), &(op->right), GMP_RNDN); /* - (+0) = -0 */ } } int sollya_mpfi_is_empty(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if (sollya_mpfi_has_nan_opt(op)) return 0; else return mpfr_greater_p(&(op->left), &(op->right)); } static inline int sollya_mpfi_is_empty_opt(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if (sollya_mpfi_has_nan_opt(op)) return 0; else return mpfr_greater_p(&(op->left), &(op->right)); } int sollya_mpfi_set_empty(sollya_mpfi_t rop) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_set_inf(&(rop->left),1); mpfr_set_inf(&(rop->right),-1); return MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } static inline int sollya_mpfi_set_empty_opt(sollya_mpfi_t rop) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_set_inf(&(rop->left),1); mpfr_set_inf(&(rop->right),-1); return MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } void sollya_mpfi_empty_normalize(sollya_mpfi_t rop) { if (sollya_mpfi_is_empty_opt(rop)) sollya_mpfi_set_empty_opt(rop); } static inline void sollya_mpfi_empty_normalize_opt(sollya_mpfi_t rop) { if (sollya_mpfi_is_empty_opt(rop)) sollya_mpfi_set_empty_opt(rop); } int sollya_mpfi_set_full_range(sollya_mpfi_t rop) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_set_inf(&(rop->left),-1); mpfr_set_inf(&(rop->right),1); return MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } int sollya_mpfi_set_negative_inf(sollya_mpfi_t rop) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_set_inf(&(rop->left),-1); mpfr_set_inf(&(rop->right),-1); return MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } int sollya_mpfi_set_positive_inf(sollya_mpfi_t rop) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_set_inf(&(rop->left),1); mpfr_set_inf(&(rop->right),1); return MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } /* Check for infinities and zeros */ int sollya_mpfi_has_zero(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ( sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op) ) return 0; else return ( mpfr_sgn(&(op->left)) * mpfr_sgn(&(op->right)) <= 0 ); } int sollya_mpfi_has_zero_inside(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ( sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op) ) return 0; else return ( mpfr_sgn(&(op->left)) * mpfr_sgn(&(op->right)) < 0 ); } int sollya_mpfi_is_zero(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ( sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op) ) return 0; else return ( (mpfr_sgn(&(op->left))==0) && (mpfr_sgn(&(op->right)) == 0) ); } int mpfr_is_positive_infinity(mpfr_t op) { return (mpfr_inf_p(op) && (mpfr_sgn(op) > 0)); } int mpfr_is_negative_infinity(mpfr_t op) { return (mpfr_inf_p(op) && (mpfr_sgn(op) < 0)); } int sollya_mpfi_has_positive_numbers(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ( sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op) ) return 0; else return (mpfr_sgn(&(op->right)) > 0); } int sollya_mpfi_has_negative_numbers(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ( sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op) ) return 0; else return (mpfr_sgn(&(op->left)) < 0); } int sollya_mpfi_is_nonneg(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ( sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op) ) return 0; else return (mpfr_sgn(&(op->left)) >= 0); } int sollya_mpfi_is_nonpos(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ( sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op) ) return 0; else return (mpfr_sgn(&(op->right)) <= 0); } int sollya_mpfi_has_positive_infinity(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ( sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op) ) return 0; else return mpfr_is_positive_infinity(&(op->right)); } int sollya_mpfi_is_positive_infinity(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ( sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op) ) return 0; else return mpfr_is_positive_infinity(&(op->left)); } int sollya_mpfi_has_negative_infinity(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ( sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op) ) return 0; else return mpfr_is_negative_infinity(&(op->left)); } int sollya_mpfi_is_negative_infinity(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if ( sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op) ) return 0; else return mpfr_is_negative_infinity(&(op->right)); } int sollya_mpfi_has_infinity(sollya_mpfi_t op) { return (sollya_mpfi_has_negative_infinity(op) || sollya_mpfi_has_positive_infinity(op)); } int sollya_mpfi_is_infinity(sollya_mpfi_t op) { return (sollya_mpfi_is_negative_infinity(op) || sollya_mpfi_is_positive_infinity(op)); } int sollya_mpfi_inf_p(sollya_mpfi_t op) { return sollya_mpfi_has_infinity(op); } /* Functions that create sollya_mpfi_t */ int sollya_mpfi_set(sollya_mpfi_t rop, sollya_mpfi_srcptr op) { int res; res = mpfi_set(rop,op); sollya_mpfi_nan_normalize_opt(rop); sollya_mpfi_empty_normalize_opt(rop); return res; } int sollya_mpfi_set_z_2exp(sollya_mpfi_t rop, mpz_t op1, mp_exp_t op2) { int res, ra, rb; /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ ra = mpfr_set_z_2exp(&(rop->left), op1, op2, GMP_RNDD); rb = mpfr_set_z_2exp(&(rop->right), op1, op2, GMP_RNDU); if ((ra == 0) && (rb == 0)) { res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } else { if ((ra != 0) && (rb != 0)) { res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } else { if (ra != 0) { res = MPFI_FLAGS_LEFT_ENDPOINT_INEXACT; } else { res = MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT; } } } sollya_mpfi_nan_normalize_opt(rop); sollya_mpfi_empty_normalize_opt(rop); return res; } int mpfi_to_sollya_mpfi(sollya_mpfi_t rop, mpfi_t op) { int res; res = mpfi_set(rop,op); sollya_mpfi_nan_normalize_opt(rop); sollya_mpfi_empty_normalize_opt(rop); return res; } int sollya_init_and_convert_interval(sollya_mpfi_t rop, mpfi_t op) { int res; /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ sollya_mpfi_init2(rop, mpfi_get_prec(op)); if ((!sollya_mpfi_has_nan_opt(op)) && (mpfr_cmp(&(op->left), &(op->right)) > 0)) { printMessage(1,SOLLYA_MSG_RANGE_BOUNDS_IN_INVERSE_ORDER,"Warning: the bounds of a given interval are given in inverse order. Will revert them.\n"); res = sollya_mpfi_interv_fr(rop, &(op->right), &(op->left)); } else { if (sollya_mpfi_has_nan_opt(op)) { if ((!!(mpfr_nan_p(&(op->left)))) ^ (!!(mpfr_nan_p(&(op->right))))) { printMessage(1,SOLLYA_MSG_ONLY_ONE_ENDPOINT_OF_RANGE_IS_NAN,"Warning: one bound of a given interval is NaN while the other is not. Will normalize the interval to have two NaN endpoints.\n"); } res = sollya_mpfi_set_nan_opt(rop); } else { res = mpfi_to_sollya_mpfi(rop, op); } } return res; } int sollya_mpfi_to_mpfi(mpfi_t rop, sollya_mpfi_t op) { return mpfi_set(rop,op); } int sollya_mpfi_set_d(sollya_mpfi_t rop, double op) { return mpfi_set_d(rop,op); } int sollya_mpfi_set_fr(sollya_mpfi_t rop, mpfr_t op) { return mpfi_set_fr(rop,op); } int sollya_mpfi_set_q(sollya_mpfi_t rop, mpq_t op) { int res; res = mpfi_set_q(rop,op); sollya_mpfi_nan_normalize_opt(rop); sollya_mpfi_empty_normalize_opt(rop); return res; } int sollya_mpfi_set_si(sollya_mpfi_t rop, long op) { return mpfi_set_si(rop,op); } int sollya_mpfi_set_ui(sollya_mpfi_t rop, unsigned long op) { return mpfi_set_ui(rop,op); } int sollya_mpfi_interv_d(sollya_mpfi_t rop, double op1, double op2) { int res; res = mpfi_interv_d(rop,op1,op2); sollya_mpfi_nan_normalize_opt(rop); sollya_mpfi_empty_normalize_opt(rop); return res; } int sollya_mpfi_interv_fr(sollya_mpfi_t rop, mpfr_t op1, mpfr_t op2) { int res; res = mpfi_interv_fr(rop,op1,op2); sollya_mpfi_nan_normalize_opt(rop); sollya_mpfi_empty_normalize_opt(rop); return res; } int sollya_mpfi_interv_si(sollya_mpfi_t rop, long op1, long op2) { int res; res = mpfi_interv_si(rop,op1,op2); sollya_mpfi_nan_normalize_opt(rop); sollya_mpfi_empty_normalize_opt(rop); return res; } int sollya_mpfi_interv_d_safe(sollya_mpfi_t rop, double op1, double op2) { int res = sollya_mpfi_interv_d(rop, op1, op2); if (sollya_mpfi_is_empty_opt(rop)) { sollyaFprintf(stderr,"Error: trying to define an interval with reversed bounds.\nThis should never happen. Please report the bug to the developers.\n"); exit(1); } return res; } int sollya_mpfi_interv_fr_safe(sollya_mpfi_t rop, mpfr_t op1, mpfr_t op2) { int res = sollya_mpfi_interv_fr(rop, op1, op2); if (sollya_mpfi_is_empty_opt(rop)) { sollyaFprintf(stderr,"Error: trying to define an interval with reversed bounds.\nThis should never happen. Please report the bug to the developers.\n"); exit(1); } return res; } int sollya_mpfi_interv_si_safe(sollya_mpfi_t rop, long op1, long op2) { int res = sollya_mpfi_interv_si(rop, op1, op2); if (sollya_mpfi_is_empty_opt(rop)) { sollyaFprintf(stderr,"Error: trying to define an interval with reversed bounds.\nThis should never happen. Please report the bug to the developers.\n"); exit(1); } return res; } int sollya_mpfi_interv_si_2exp(sollya_mpfi_t rop, long op1, mp_exp_t op2, long op3, mp_exp_t op4) { int res, ra, rb; /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ ra = mpfr_set_si_2exp(&(rop->left), op1, op2, GMP_RNDD); rb = mpfr_set_si_2exp(&(rop->right), op3, op4, GMP_RNDU); if ((ra == 0) && (rb == 0)) { res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } else { if ((ra != 0) && (rb != 0)) { res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } else { if (ra != 0) { res = MPFI_FLAGS_LEFT_ENDPOINT_INEXACT; } else { res = MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT; } } } sollya_mpfi_nan_normalize_opt(rop); sollya_mpfi_empty_normalize_opt(rop); return res; } /* Elementary univariate functions */ #define define_simple_func(f) \ int sollya_mpfi_##f (sollya_mpfi_t rop, sollya_mpfi_t op) { \ int res; \ \ if (sollya_mpfi_is_empty_opt(op)) return sollya_mpfi_set_empty_opt(rop); \ \ res = mpfi_##f (rop,op); sollya_mpfi_nan_normalize_opt(rop); \ return res; \ } define_simple_func(abs) define_simple_func(acos) define_simple_func(acosh) define_simple_func(asin) define_simple_func(asinh) define_simple_func(atan) define_simple_func(atanh) define_simple_func(cosh) define_simple_func(sinh) define_simple_func(tanh) define_simple_func(exp) define_simple_func(expm1) define_simple_func(sqr) define_simple_func(sqrt) #define define_trig_func(f, compute_range) \ int sollya_mpfi_##f (sollya_mpfi_t rop, sollya_mpfi_t op) { \ int res; \ \ if (sollya_mpfi_is_empty_opt(op)) return sollya_mpfi_set_empty_opt(rop); \ if (sollya_mpfi_has_infinity(op)) { \ compute_range; \ res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; \ } \ else res = mpfi_##f (rop,op); \ \ sollya_mpfi_nan_normalize_opt(rop); \ return res; \ } \ define_trig_func(cos, sollya_mpfi_interv_si(rop,-1,1)) define_trig_func(sin, sollya_mpfi_interv_si(rop,-1,1)) define_trig_func(tan, sollya_mpfi_set_full_range(rop)) /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ #define define_log_func(f, left_bound_of_the_domain) \ int sollya_mpfi_##f (sollya_mpfi_t rop, sollya_mpfi_t op) { \ int res; \ \ if (sollya_mpfi_is_empty_opt(op)) return sollya_mpfi_set_empty_opt(rop); \ if (sollya_mpfi_has_nan_opt(op)) return sollya_mpfi_set_nan_opt(rop); \ if (mpfr_cmp_si(&(op->left), left_bound_of_the_domain) < 0) \ return sollya_mpfi_set_nan_opt(rop); \ if (mpfr_cmp_si(&(op->left), left_bound_of_the_domain) == 0) { \ if (mpfr_cmp_si(&(op->right), left_bound_of_the_domain) == 0) { \ sollya_mpfi_set_negative_inf(rop); \ return MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; \ } \ else { \ mpfr_set_inf(&(rop->left),-1); \ if (mpfr_##f (&(rop->right),&(op->right),GMP_RNDU) == 0) \ res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; \ else \ res = MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT; \ sollya_mpfi_zero_sign_normalize(rop); \ } \ } \ else res = mpfi_##f (rop,op); \ \ sollya_mpfi_nan_normalize_opt(rop); \ \ return res; \ } define_log_func(log, 0) define_log_func(log2, 0) define_log_func(log10, 0) define_log_func(log1p, -1) /* Tricky binary functions */ /* Cases for the division: # op1 = NaN or op2 = NaN -> NaN # op1 empty or op2 empty -> empty # If op1 = [0] : # If op2 = [0] -> NaN # Else -> [0] the argument here is: even if op2 contains 0, the function op1/y is 0 everywhere so we define it at y=0 by continuity. # If op1 = [+Inf] or op1 = [-Inf] : # If op2 = [+Inf] or op2 = [-Inf] -> NaN # If 0 is inside op2 or op2=[0] -> [-Inf, Inf] The argument when op2=[0] is: Inf/[0] is an Inf but we do not know its sign. So we return [-Inf, Inf] and we are sure. # If 0 is not inside op2 (this includes the case when 0 does not belong to op2) -> sgn(op2)*op1 the argument is: even if op2 contains an Inf, the function op1/y is constant to Inf everywhere, so we define it at Inf as this constant. Now, we know that op1 is neither [0], nor [-Inf] or [+Inf] # If op2 = [0] -> [-Inf, Inf] the argument here is: even if op1 contains 0, x/[0] is always -Inf or +Inf, hence we define it at 0 by continuity as -Inf or +Inf. Sadly, we do not know the sign of 0, so we have to return [-Inf, +Inf] as a result # If op2 = [-Inf] or [+Inf] -> [0] (even if op1 contains an Inf: by continuity) Now, we know that neither op1 nor op2 are singular point intervals # If op2 does not contain 0 -> mpfi_div(op1, op2) # If op2 has 0 inside -> [-Inf, +Inf] # Else op2 = [0, b] or op2 = [a, 0]: # In both cases, if op1 has 0 inside -> [-Inf, +Inf] # If op2 = [0, b] # If op1 = [u, v] with 0<=u -> [u/b, +Inf] # If op1 = [u, v] with v<=0 -> [-Inf, v/b] # Else (op2 = [a, 0]) : # If op1 = [u, v] with 0<=u -> [-Inf, u/a] # If op1 = [u, v] with v<=0 -> [v/a, +Inf] */ int sollya_mpfi_div(sollya_mpfi_t rop, sollya_mpfi_t op1, sollya_mpfi_t op2) { int res; int sign; if (sollya_mpfi_is_empty_opt(op1) || sollya_mpfi_is_empty_opt(op2)) return sollya_mpfi_set_empty_opt(rop); if (sollya_mpfi_has_nan_opt(op1) || sollya_mpfi_has_nan_opt(op2)) return sollya_mpfi_set_nan_opt(rop); if (sollya_mpfi_is_zero(op1)) { if (sollya_mpfi_is_zero(op2)) return sollya_mpfi_set_nan_opt(rop); else return sollya_mpfi_set_si(rop, 0); } if (sollya_mpfi_is_infinity(op1)) { if (sollya_mpfi_is_infinity(op2)) return sollya_mpfi_set_nan_opt(rop); if (sollya_mpfi_is_zero(op2) || sollya_mpfi_has_zero_inside(op2)) return sollya_mpfi_set_full_range(rop); /* Now the case op1=[+/-Inf], and op2 has constant sign */ sign = (sollya_mpfi_has_positive_numbers(op2) ? +1 : -1); if (sollya_mpfi_is_negative_infinity(op1)) sign = -sign; if (sign > 0) return sollya_mpfi_set_positive_inf(rop); else return sollya_mpfi_set_negative_inf(rop); } /* Here op1 != [0], op1 != [+/-Inf] */ if (sollya_mpfi_is_zero(op2)) return sollya_mpfi_set_full_range(rop); if (sollya_mpfi_is_infinity(op2)) return sollya_mpfi_set_si(rop, 0); /* Here op1 != [0], op1 != [+/-Inf], op2 != [0], op2 != [+/-Inf] */ if (!sollya_mpfi_has_zero(op2)) return mpfi_div(rop, op1, op2); if (sollya_mpfi_has_zero_inside(op2)) return sollya_mpfi_set_full_range(rop); if (sollya_mpfi_has_zero_inside(op1)) return sollya_mpfi_set_full_range(rop); /* Now one of the bounds of op2 (and only one) is zero. */ /* If op1 contains 0, it is one of its bounds (and only one) */ /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if (sollya_mpfi_has_positive_numbers(op2)) { if (mpfr_sgn(&(op1->left)) >= 0) { /* Case 0<=u and op2=[0,b] */ mpfr_set_inf(&(rop->right),1); if (mpfr_div(&(rop->left),&(op1->left),&(op2->right),GMP_RNDD) == 0) res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; else res = MPFI_FLAGS_LEFT_ENDPOINT_INEXACT; sollya_mpfi_zero_sign_normalize(rop); } else { /* Case v<=0 and op2=[0,b] */ mpfr_set_inf(&(rop->left),-1); if (mpfr_div(&(rop->right),&(op1->right),&(op2->right),GMP_RNDU) == 0) res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; else res = MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT; sollya_mpfi_zero_sign_normalize(rop); } } else { /* Case op2=[a,0]... */ if (mpfr_sgn(&(op1->left)) >= 0) { /* ...and 0<=u */ mpfr_set_inf(&(rop->left),-1); if (mpfr_div(&(rop->right),&(op1->left),&(op2->left),GMP_RNDU) == 0) res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; else res = MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT; sollya_mpfi_zero_sign_normalize(rop); } else { /* case v<=0 */ mpfr_set_inf(&(rop->right),1); if (mpfr_div(&(rop->left),&(op1->right),&(op2->left),GMP_RNDD) == 0) res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; else res = MPFI_FLAGS_LEFT_ENDPOINT_INEXACT; sollya_mpfi_zero_sign_normalize(rop); } } sollya_mpfi_nan_normalize_opt(rop); return res; } int sollya_mpfi_mul(sollya_mpfi_t rop, sollya_mpfi_t op1, sollya_mpfi_t op2) { /* # op1 = NaN or op2 = NaN -> NaN # op1 empty or op2 empty -> empty # If op1 = [+Inf] or op1 = [-Inf] : # If op2 = [0] -> NaN # If op2 has 0 inside -> [-Inf, Inf] The argument here is: Inf*y is an +/-Inf for every y. Since y can have both signs, we can have bot +Inf and -Inf. # Else -> sgn(op2)*op1 # If op2 = [-Inf] or [+Inf] : # If op1 = [0] -> NaN # If op1 has 0 inside -> [-Inf, +Inf] # Else -> sgn(op1)*op2 Now, we know that neither op1 or op2 is [-Inf] or [Inf]. # If op1 = [0] or op2 = [0] -> [0] the argument here is: even if the other contains an Inf, the function 0*y is 0 everywhere so we define it at y=Inf by continuity. Now, we know that neither op1 nor op2 are singular point intervals # Else -> mpfi_mul(op1, op2) */ if (sollya_mpfi_is_empty_opt(op1) || sollya_mpfi_is_empty_opt(op2)) return sollya_mpfi_set_empty_opt(rop); if (sollya_mpfi_has_nan_opt(op1) || sollya_mpfi_has_nan_opt(op2)) return sollya_mpfi_set_nan_opt(rop); if (sollya_mpfi_is_infinity(op1)) { if (sollya_mpfi_is_zero(op2)) return sollya_mpfi_set_nan_opt(rop); if (sollya_mpfi_has_zero_inside(op2)) return sollya_mpfi_set_full_range(rop); if (sollya_mpfi_is_nonneg(op2)) return sollya_mpfi_set(rop, op1); /* else: op2<=0 */ return sollya_mpfi_neg(rop, op1); } if (sollya_mpfi_is_infinity(op2)) { if (sollya_mpfi_is_zero(op1)) return sollya_mpfi_set_nan_opt(rop); if (sollya_mpfi_has_zero_inside(op1)) return sollya_mpfi_set_full_range(rop); if (sollya_mpfi_is_nonneg(op1)) return sollya_mpfi_set(rop, op2); /* else: op1<=0 */ return sollya_mpfi_neg(rop, op2); } if (sollya_mpfi_is_zero(op1) || sollya_mpfi_is_zero(op2)) return sollya_mpfi_set_ui(rop, 0); /* else: default case: */ return mpfi_mul(rop,op1,op2); } /* Easy binary operations */ int sollya_mpfi_add(sollya_mpfi_t rop, sollya_mpfi_t op1, sollya_mpfi_t op2) { int res; if (sollya_mpfi_is_empty_opt(op1)) return sollya_mpfi_set_empty_opt(rop); if (sollya_mpfi_is_empty_opt(op2)) return sollya_mpfi_set_empty_opt(rop); res = mpfi_add(rop,op1,op2); sollya_mpfi_nan_normalize_opt(rop); return res; } int sollya_mpfi_add_fr(sollya_mpfi_t rop, sollya_mpfi_t op1, mpfr_t op2) { int res; if (sollya_mpfi_is_empty_opt(op1)) return sollya_mpfi_set_empty_opt(rop); res = mpfi_add_fr(rop,op1,op2); sollya_mpfi_nan_normalize_opt(rop); return res; } int sollya_mpfi_add_ui(sollya_mpfi_t rop, sollya_mpfi_t op1, unsigned long op2) { int res; if (sollya_mpfi_is_empty_opt(op1)) return sollya_mpfi_set_empty_opt(rop); res = mpfi_add_ui(rop,op1,op2); sollya_mpfi_nan_normalize_opt(rop); return res; } int sollya_mpfi_sub(sollya_mpfi_t rop, sollya_mpfi_t op1, sollya_mpfi_t op2) { int res; if (sollya_mpfi_is_empty_opt(op1)) return sollya_mpfi_set_empty_opt(rop); if (sollya_mpfi_is_empty_opt(op2)) return sollya_mpfi_set_empty_opt(rop); res = mpfi_sub(rop,op1,op2); sollya_mpfi_nan_normalize_opt(rop); return res; } int sollya_mpfi_sub_fr(sollya_mpfi_t rop, sollya_mpfi_t op1, mpfr_t op2) { int res; mpfi_t tmp; if (sollya_mpfi_is_empty_opt(op1)) return sollya_mpfi_set_empty_opt(rop); mpfi_init2(tmp, mpfr_get_prec(op2)); mpfi_set_fr(tmp, op2); /* exact */ res = mpfi_sub(rop,op1,tmp); mpfi_clear(tmp); sollya_mpfi_nan_normalize_opt(rop); return res; } int sollya_mpfi_sub_ui(sollya_mpfi_t rop, sollya_mpfi_t op1, unsigned long op2) { int res; if (sollya_mpfi_is_empty_opt(op1)) return sollya_mpfi_set_empty_opt(rop); res = mpfi_sub_ui(rop,op1,op2); sollya_mpfi_nan_normalize_opt(rop); return res; } int sollya_mpfi_div_ui(sollya_mpfi_t rop, sollya_mpfi_t op1, unsigned long op2) { int res; mpfi_t temp; if (sollya_mpfi_is_empty_opt(op1)) return sollya_mpfi_set_empty_opt(rop); mpfi_init2(temp,8 * sizeof(op2)); mpfi_set_ui(temp,op2); res = sollya_mpfi_div(rop,op1,temp); sollya_mpfi_nan_normalize_opt(rop); mpfi_clear(temp); return res; } int sollya_mpfi_div_z(sollya_mpfi_t rop, sollya_mpfi_t op1, mpz_t op2) { int res, ra, rb; /* Empty input */ if (sollya_mpfi_is_empty_opt(op1)) return sollya_mpfi_set_empty_opt(rop); /* Division by 0 */ if (mpz_sgn(op2) == 0) return sollya_mpfi_div_ui(rop, op1, 0); /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ /* General case */ if (mpz_sgn(op2) > 0) { ra = mpfr_div_z(&(rop->left),&(op1->left),op2,GMP_RNDD); rb = mpfr_div_z(&(rop->right),&(op1->right),op2,GMP_RNDU); } else { ra = mpfr_div_z(&(rop->left),&(op1->right),op2,GMP_RNDD); rb = mpfr_div_z(&(rop->right),&(op1->left),op2,GMP_RNDU); } if ((ra == 0) && (rb == 0)) { res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } else { if ((ra != 0) && (rb != 0)) { res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } else { if (ra != 0) { res = MPFI_FLAGS_LEFT_ENDPOINT_INEXACT; } else { res = MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT; } } } sollya_mpfi_nan_normalize_opt(rop); sollya_mpfi_empty_normalize_opt(rop); return res; } int sollya_mpfi_mul_ui(sollya_mpfi_t rop, sollya_mpfi_t op1, unsigned long op2) { int res; mpfi_t temp; if (sollya_mpfi_is_empty_opt(op1)) return sollya_mpfi_set_empty_opt(rop); mpfi_init2(temp,8 * sizeof(op2)); mpfi_set_ui(temp,op2); res = sollya_mpfi_mul(rop,op1,temp); sollya_mpfi_nan_normalize_opt(rop); mpfi_clear(temp); return res; } int sollya_mpfi_ui_div(sollya_mpfi_t rop, unsigned long op1, sollya_mpfi_t op2) { int res; mpfi_t temp; if (sollya_mpfi_is_empty_opt(op2)) return sollya_mpfi_set_empty_opt(rop); mpfi_init2(temp,8 * sizeof(op1)); mpfi_set_ui(temp,op1); res = sollya_mpfi_div(rop,temp, op2); sollya_mpfi_nan_normalize_opt(rop); mpfi_clear(temp); return res; } /* Other functions */ int sollya_mpfi_inv(sollya_mpfi_t rop, sollya_mpfi_t op) { return sollya_mpfi_ui_div(rop, 1, op); } int sollya_mpfi_blow(sollya_mpfi_t rop, sollya_mpfi_t op1, double op2) { int res; if (sollya_mpfi_is_empty_opt(op1)) return sollya_mpfi_set_empty_opt(rop); res = mpfi_blow(rop,op1,op2); sollya_mpfi_nan_normalize_opt(rop); return res; } void sollya_mpfi_blow_1ulp(sollya_mpfi_t rop) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ mpfr_nextbelow(&(rop->left)); mpfr_nextabove(&(rop->right)); } int sollya_mpfi_bounded_p(sollya_mpfi_t op) { if (sollya_mpfi_has_nan_opt(op)) return 0; if (sollya_mpfi_is_empty_opt(op)) return 1; return mpfi_bounded_p(op); } void sollya_mpfi_clear(sollya_mpfi_t op) { mpfi_clear(op); } int sollya_mpfi_const_pi(sollya_mpfi_t rop) { return mpfi_const_pi(rop); } int sollya_mpfi_diam_abs(mpfr_t rop, sollya_mpfi_t op) { if (sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op)) { mpfr_set_nan(rop); return 0; } if (sollya_mpfi_is_infinity(op)) return mpfr_set_ui(rop, 0, GMP_RNDN); /* else... */ return mpfi_diam_abs(rop, op); } int sollya_mpfi_get_left(mpfr_t rop, sollya_mpfi_t op) { if (sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op)) { mpfr_set_nan(rop); return 0; } return mpfi_get_left(rop,op); } int sollya_mpfi_get_right(mpfr_t rop, sollya_mpfi_t op) { if (sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op)) { mpfr_set_nan(rop); return 0; } return mpfi_get_right(rop,op); } void sollya_mpfi_get_fr(mpfr_t rop, sollya_mpfi_t op) { if (sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op)) mpfr_set_nan(rop); else mpfi_get_fr(rop,op); } mp_prec_t sollya_mpfi_get_prec(sollya_mpfi_srcptr op) { return mpfi_get_prec(op); } const char *sollya_mpfi_get_version() { const char *res; res = (const char *) mpfi_get_version(); return res; } void sollya_mpfi_init2(sollya_mpfi_t rop, mp_prec_t op) { mpfi_init2(rop,op); } int sollya_mpfi_intersect(sollya_mpfi_t rop, sollya_mpfi_t op1, sollya_mpfi_t op2) { int res; if (sollya_mpfi_is_empty_opt(op1) || sollya_mpfi_is_empty_opt(op2)) return sollya_mpfi_set_empty_opt(rop); if (sollya_mpfi_has_nan_opt(op1) || sollya_mpfi_has_nan_opt(op2)) return sollya_mpfi_set_nan_opt(rop); res = mpfi_intersect(rop,op1,op2); sollya_mpfi_empty_normalize_opt(rop); sollya_mpfi_nan_normalize_opt(rop); return res; } int sollya_mpfi_is_inside(sollya_mpfi_t op1, sollya_mpfi_t op2) { if (sollya_mpfi_is_empty_opt(op1)) return 0; if (sollya_mpfi_is_empty_opt(op2)) return 1; if (sollya_mpfi_has_nan_opt(op1) || sollya_mpfi_has_nan_opt(op2)) return 0; else return mpfi_is_inside(op1,op2); } int sollya_mpfi_mid(mpfr_t rop, sollya_mpfi_t op) { if (sollya_mpfi_has_nan_opt(op) || sollya_mpfi_is_empty_opt(op)) { mpfr_set_nan(rop); return 0; } return mpfi_mid(rop,op); } int sollya_mpfi_neg(sollya_mpfi_t rop, sollya_mpfi_t op) { int res; if (sollya_mpfi_is_empty_opt(op)) return sollya_mpfi_set_empty_opt(rop); res = mpfi_neg(rop,op); sollya_mpfi_nan_normalize_opt(rop); return res; } void sollya_mpfi_set_prec(sollya_mpfi_t rop, mp_prec_t op) { mpfi_set_prec(rop,op); } int sollya_mpfi_prec_round(sollya_mpfi_t rop, mp_prec_t op) { int res, ra, rb; if (sollya_mpfi_is_empty_opt(rop)) { sollya_mpfi_set_prec(rop, op); return sollya_mpfi_set_empty_opt(rop); } /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ ra = mpfr_prec_round(&(rop->left), op, GMP_RNDD); rb = mpfr_prec_round(&(rop->right), op, GMP_RNDU); if ((ra == 0) && (rb == 0)) { res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } else { if ((ra != 0) && (rb != 0)) { res = MPFI_FLAGS_BOTH_ENDPOINTS_EXACT; } else { if (ra != 0) { res = MPFI_FLAGS_LEFT_ENDPOINT_INEXACT; } else { res = MPFI_FLAGS_RIGHT_ENDPOINT_INEXACT; } } } sollya_mpfi_nan_normalize_opt(rop); sollya_mpfi_empty_normalize_opt(rop); return res; } int sollya_mpfi_union(sollya_mpfi_t rop, sollya_mpfi_t op1, sollya_mpfi_t op2) { int res; if (sollya_mpfi_has_nan_opt(op1) || sollya_mpfi_has_nan_opt(op2)) return sollya_mpfi_set_nan_opt(rop); if (sollya_mpfi_is_empty_opt(op1)) res = sollya_mpfi_set(rop, op2); else { if (sollya_mpfi_is_empty_opt(op2)) res = sollya_mpfi_set(rop, op1); else res = mpfi_union(rop, op1, op2); } sollya_mpfi_nan_normalize_opt(rop); sollya_mpfi_empty_normalize_opt(rop); return res; } int sollya_mpfi_is_point_and_real(sollya_mpfi_t op) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ return ((!(mpfr_nan_p(&(op->left)) || mpfr_nan_p(&(op->right)))) && (!(mpfr_inf_p(&(op->left)) || mpfr_inf_p(&(op->right)))) && (mpfr_equal_p(&(op->left),&(op->right)))); } int sollya_mpfi_is_quasi_point_and_real(sollya_mpfi_t op) { mp_exp_t el, er, ea, eb, d; /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if (!mpfr_number_p(&(op->left))) return 0; if (!mpfr_number_p(&(op->right))) return 0; if (mpfr_equal_p(&(op->left), &(op->right))) return 1; if (mpfr_get_prec(&(op->left)) != mpfr_get_prec(&(op->right))) return 0; if (mpfr_cmp(&(op->left), &(op->right)) > 0) return 0; if (mpfr_zero_p(&(op->left)) || mpfr_zero_p(&(op->right))) return 0; if (mpfr_sgn(&(op->left)) != mpfr_sgn(&(op->right))) return 0; el = mpfr_get_exp(&(op->left)); er = mpfr_get_exp(&(op->right)); ea = el; eb = er; if (eb > ea) { ea = er; eb = el; } d = ea - eb; if ((d < 0) || (d > 1)) return 0; mpfr_nextabove(&(op->left)); mpfr_nextabove(&(op->left)); if (mpfr_cmp(&(op->left), &(op->right)) >= 0) { mpfr_nextbelow(&(op->left)); mpfr_nextbelow(&(op->left)); return 1; } mpfr_nextbelow(&(op->left)); mpfr_nextbelow(&(op->left)); return 0; } int sollya_mpfi_equal_p(sollya_mpfi_t op1, sollya_mpfi_t op2) { /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ return (mpfr_equal_p(&(op1->left),&(op2->left)) && mpfr_equal_p(&(op1->right),&(op2->right))); } mp_exp_t sollya_mpfi_max_exp(sollya_mpfi_t op) { mp_exp_t rl, rr; /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ if (!mpfr_number_p(&(op->left))) return mpfr_get_emin_min(); if (!mpfr_number_p(&(op->right))) return mpfr_get_emin_min(); if (mpfr_zero_p(&(op->left))) { if (mpfr_zero_p(&(op->right))) { return mpfr_get_emin_min(); } else { return mpfr_get_exp(&(op->right)); } } else { if (mpfr_zero_p(&(op->right))) { return mpfr_get_exp(&(op->left)); } else { rl = mpfr_get_exp(&(op->left)); rr = mpfr_get_exp(&(op->right)); return (rl > rr ? rl : rr); } } return mpfr_get_emin_min(); } int sollya_mpfi_fr_in_interval(mpfr_t op1, sollya_mpfi_t op2) { if (!mpfr_number_p(op1)) return 0; if (sollya_mpfi_has_nan_opt(op2)) return 0; /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ return (mpfr_lessequal_p(&(op2->left), op1) && mpfr_lessequal_p(op1, &(op2->right))); } int sollya_mpfi_enclosure_accurate_enough(sollya_mpfi_t op1, mp_prec_t op2) { mp_exp_t eA, eB; mp_prec_t p; mpfr_t diam, temp; int res; if (sollya_mpfi_has_nan_opt(op1)) return 0; if (sollya_mpfi_is_empty_opt(op1)) return 0; if (sollya_mpfi_has_infinity(op1)) return 0; if (sollya_mpfi_has_zero(op1)) return 0; if (op2 <= 2) return 0; /* HACK ALERT: For performance reasons, we will access the internals of an mpfi_t !!! */ eA = mpfr_get_exp(&(op1->left)); eB = mpfr_get_exp(&(op1->right)); /* If there is a whole binade between the endpoints a and b, there is no accuracy */ if ((eB - eA) > 1) return 0; /* Compute the difference between the endpoints and compute 2^(-op2) * a, where a is the left endpoint */ p = mpfr_get_prec(&(op1->left)); if (mpfr_get_prec(&(op1->right)) > p) p = mpfr_get_prec(&(op1->right)); mpfr_init2(diam, p + 2); mpfr_init2(temp, p); mpfr_sub(diam, &(op1->right), &(op1->left), GMP_RNDN); /* exact, Sterbenz */ mpfr_mul_2si(temp, &(op1->left), -op2, GMP_RNDN); /* exact, same precision */ /* We got enough precision iff |b - a| <= 2^(-prec) * |a|, where a is the left endpoint, b the right one and prec = op2 */ res = (mpfr_cmpabs(diam, temp) <= 0); mpfr_clear(temp); mpfr_clear(diam); return res; } sollya-6.0+ds/mpfi-compat.h000066400000000000000000000212261300174114700156520ustar00rootroot00000000000000/* Copyright 2007-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard, M. Joldes christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org joldes@laas.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef MPFI_COMPAT_H #define MPFI_COMPAT_H #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include typedef mpfi_t sollya_mpfi_t; typedef mpfi_srcptr sollya_mpfi_srcptr; int sollya_mpfi_has_nan(sollya_mpfi_t op); int sollya_mpfi_nan_p(sollya_mpfi_t op); int sollya_mpfi_set_nan(sollya_mpfi_t rop); void sollya_mpfi_nan_normalize(sollya_mpfi_t rop); int sollya_mpfi_is_empty(sollya_mpfi_t op); int sollya_mpfi_set_empty(sollya_mpfi_t rop); void sollya_mpfi_empty_normalize(sollya_mpfi_t rop); int sollya_mpfi_set_full_range(sollya_mpfi_t rop); int sollya_mpfi_set_negative_inf(sollya_mpfi_t rop); int sollya_mpfi_set_positive_inf(sollya_mpfi_t rop); int sollya_mpfi_has_zero(sollya_mpfi_t op); int sollya_mpfi_has_zero_inside(sollya_mpfi_t op); int sollya_mpfi_is_zero(sollya_mpfi_t op); int mpfr_is_positive_infinity(mpfr_t op); int mpfr_is_negative_infinity(mpfr_t op); int sollya_mpfi_has_positive_numbers(sollya_mpfi_t op); int sollya_mpfi_has_negative_numbers(sollya_mpfi_t op); int sollya_mpfi_is_nonneg(sollya_mpfi_t op); int sollya_mpfi_is_nonpos(sollya_mpfi_t op); int sollya_mpfi_has_positive_infinity(sollya_mpfi_t op); int sollya_mpfi_is_positive_infinity(sollya_mpfi_t op); int sollya_mpfi_has_negative_infinity(sollya_mpfi_t op); int sollya_mpfi_is_negative_infinity(sollya_mpfi_t op); int sollya_mpfi_has_infinity(sollya_mpfi_t op); int sollya_mpfi_is_infinity(sollya_mpfi_t op); int sollya_mpfi_inf_p(sollya_mpfi_t op); int sollya_mpfi_set(sollya_mpfi_t rop, sollya_mpfi_srcptr op); int mpfi_to_sollya_mpfi(sollya_mpfi_t rop, mpfi_t op); int sollya_mpfi_to_mpfi(mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_set_d(sollya_mpfi_t rop, double op); int sollya_mpfi_set_fr(sollya_mpfi_t rop, mpfr_t op); int sollya_mpfi_set_q(sollya_mpfi_t rop, mpq_t op); int sollya_mpfi_set_si(sollya_mpfi_t rop, long op); int sollya_mpfi_set_ui(sollya_mpfi_t rop, unsigned long op); int sollya_mpfi_set_z_2exp(sollya_mpfi_t rop, mpz_t op1, mp_exp_t op2); int sollya_mpfi_interv_d(sollya_mpfi_t rop, double op1, double op2); int sollya_mpfi_interv_fr(sollya_mpfi_t rop, mpfr_t op1, mpfr_t op2); int sollya_mpfi_interv_si(sollya_mpfi_t rop, long op1, long op2); int sollya_mpfi_interv_d_safe(sollya_mpfi_t rop, double op1, double op2); int sollya_mpfi_interv_fr_safe(sollya_mpfi_t rop, mpfr_t op1, mpfr_t op2); int sollya_mpfi_interv_si_safe(sollya_mpfi_t rop, long op1, long op2); int sollya_mpfi_interv_si_2exp(sollya_mpfi_t rop, long op1, mp_exp_t op2, long op3, mp_exp_t op4); int sollya_mpfi_abs(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_acos(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_acosh(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_asin(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_asinh(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_atan(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_atanh(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_cosh(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_sinh(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_tanh(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_exp(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_expm1(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_sqr(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_sqrt(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_cos(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_sin(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_tan (sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_log(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_log2(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_log10(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_log1p(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_div(sollya_mpfi_t rop, sollya_mpfi_t op1, sollya_mpfi_t op2); int sollya_mpfi_mul(sollya_mpfi_t rop, sollya_mpfi_t op1, sollya_mpfi_t op2); int sollya_mpfi_add(sollya_mpfi_t rop, sollya_mpfi_t op1, sollya_mpfi_t op2); int sollya_mpfi_add_fr(sollya_mpfi_t rop, sollya_mpfi_t op1, mpfr_t op2); int sollya_mpfi_add_ui(sollya_mpfi_t rop, sollya_mpfi_t op1, unsigned long op2); int sollya_mpfi_sub(sollya_mpfi_t rop, sollya_mpfi_t op1, sollya_mpfi_t op2); int sollya_mpfi_sub_fr(sollya_mpfi_t rop, sollya_mpfi_t op1, mpfr_t op2); int sollya_mpfi_sub_ui(sollya_mpfi_t rop, sollya_mpfi_t op1, unsigned long op2); int sollya_mpfi_div_ui(sollya_mpfi_t rop, sollya_mpfi_t op1, unsigned long op2); int sollya_mpfi_div_z(sollya_mpfi_t rop, sollya_mpfi_t op1, mpz_t op2); int sollya_mpfi_mul_ui(sollya_mpfi_t rop, sollya_mpfi_t op1, unsigned long op2); int sollya_mpfi_ui_div(sollya_mpfi_t rop, unsigned long op1, sollya_mpfi_t op2); int sollya_mpfi_inv(sollya_mpfi_t rop, sollya_mpfi_t op); int sollya_mpfi_blow(sollya_mpfi_t rop, sollya_mpfi_t op1, double op2); void sollya_mpfi_blow_1ulp(sollya_mpfi_t rop); int sollya_mpfi_bounded_p(sollya_mpfi_t op); void sollya_mpfi_clear(sollya_mpfi_t op); int sollya_mpfi_const_pi(sollya_mpfi_t rop); int sollya_mpfi_diam_abs(mpfr_t rop, sollya_mpfi_t op); int sollya_mpfi_get_left(mpfr_t rop, sollya_mpfi_t op); int sollya_mpfi_get_right(mpfr_t rop, sollya_mpfi_t op); void sollya_mpfi_get_fr(mpfr_t rop, sollya_mpfi_t op); mp_prec_t sollya_mpfi_get_prec(sollya_mpfi_srcptr op); const char *sollya_mpfi_get_version(); void sollya_mpfi_init2(sollya_mpfi_t rop, mp_prec_t op); int sollya_mpfi_intersect(sollya_mpfi_t rop, sollya_mpfi_t op1, sollya_mpfi_t op2); int sollya_mpfi_is_inside(sollya_mpfi_t op1, sollya_mpfi_t op2); int sollya_mpfi_mid(mpfr_t rop, sollya_mpfi_t op); int sollya_mpfi_neg(sollya_mpfi_t rop, sollya_mpfi_t op); void sollya_mpfi_set_prec(sollya_mpfi_t rop, mp_prec_t op); int sollya_mpfi_prec_round(sollya_mpfi_t rop, mp_prec_t op); int sollya_mpfi_union(sollya_mpfi_t rop, sollya_mpfi_t op1, sollya_mpfi_t op2); int sollya_init_and_convert_interval(sollya_mpfi_t rop, mpfi_t op); int sollya_mpfi_is_point_and_real(sollya_mpfi_t op); int sollya_mpfi_is_quasi_point_and_real(sollya_mpfi_t op); int sollya_mpfi_equal_p(sollya_mpfi_t op1, sollya_mpfi_t op2); mp_exp_t sollya_mpfi_max_exp(sollya_mpfi_t op); int sollya_mpfi_fr_in_interval(mpfr_t op1, sollya_mpfi_t op2); int sollya_mpfi_enclosure_accurate_enough(sollya_mpfi_t op1, mp_prec_t op2); #endif /* ifdef MPFI_COMPAT_H */ sollya-6.0+ds/parser.y000066400000000000000000004742071300174114700147660ustar00rootroot00000000000000/* Copyright 2006-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ %{ #include #include #include #include #include "expression.h" #include "assignment.h" #include "chain.h" #include "general.h" #include "execute.h" #include "parser.h" #include "library.h" #include "help.h" #include "version.h" #ifdef HAVE_CONFIG_H #include "config.h" #endif /* Mess with the mallocs used by the parser */ extern void *parserCalloc(size_t, size_t); extern void *parserMalloc(size_t); extern void *parserRealloc(void *, size_t); extern void parserFree(void *); #undef malloc #undef realloc #undef calloc #undef free #define malloc parserMalloc #define realloc parserRealloc #define calloc parserCalloc #define free parserFree /* End of the malloc mess */ #define YYERROR_VERBOSE 1 #define YYFPRINTF sollyaFprintf extern int yylex(YYSTYPE *lvalp, void *scanner); extern FILE *yyget_in(void *scanner); extern char *getCurrentLexSymbol(); void yyerror(void *scanner, const char *message) { char *str; if (!feof(yyget_in(scanner))) { str = getCurrentLexSymbol(); printMessage(1,SOLLYA_MSG_SYNTAX_ERROR_ENCOUNTERED_WHILE_PARSING,"Warning: %s.\nThe last symbol read has been \"%s\".\nWill skip input until next semicolon after the unexpected token. May leak memory.\n",message,str); safeFree(str); promptToBePrinted = 1; lastWasSyntaxError = 1; considerDyingOnError(); } } int parserCheckEof() { FILE *myFd; myFd = yyget_in(scanner); if (myFd == NULL) return 0; return feof(myFd); } /* #define WARN_IF_NO_HELP_TEXT 1 */ %} %defines %expect 2 %lex-param { void* scanner } %parse-param { void* scanner } %pure-parser %union { doubleNode *dblnode; struct entryStruct *association; char *value; node *tree; chain *list; int *integerval; int count; void *other; }; %token CONSTANTTOKEN "decimal constant" %token MIDPOINTCONSTANTTOKEN "interval" %token DYADICCONSTANTTOKEN "dyadic constant" %token HEXCONSTANTTOKEN "constant in memory notation" %token HEXADECIMALCONSTANTTOKEN "hexadecimal constant" %token BINARYCONSTANTTOKEN "binary constant" %token PITOKEN "pi" %token IDENTIFIERTOKEN "identifier" %token STRINGTOKEN "character string" %token LPARTOKEN "(" %token RPARTOKEN ")" %token LBRACKETTOKEN "[" %token RBRACKETTOKEN "]" %token EQUALTOKEN "=" %token ASSIGNEQUALTOKEN ":=" %token COMPAREEQUALTOKEN "==" %token COMMATOKEN "," %token EXCLAMATIONTOKEN "!" %token SEMICOLONTOKEN ";" %token STARLEFTANGLETOKEN "*<" %token LEFTANGLETOKEN "<" %token RIGHTANGLEUNDERSCORETOKEN ">_" %token RIGHTANGLEDOTTOKEN ">." %token RIGHTANGLESTARTOKEN ">*" %token RIGHTANGLETOKEN ">" %token DOTSTOKEN "..." %token DOTTOKEN "." %token QUESTIONMARKTOKEN "?" %token VERTBARTOKEN "|" %token ATTOKEN "@" %token DOUBLECOLONTOKEN "::" %token COLONTOKEN ":" %token DOTCOLONTOKEN ".:" %token COLONDOTTOKEN ":." %token EXCLAMATIONEQUALTOKEN "!=" %token APPROXTOKEN "~" %token ANDTOKEN "&&" %token ORTOKEN "||" %token PLUSTOKEN "+" %token MINUSTOKEN "-" %token MULTOKEN "*" %token DIVTOKEN "/" %token POWTOKEN "^" %token SQRTTOKEN "sqrt" %token EXPTOKEN "exp" %token FREEVARTOKEN "_x_" %token LOGTOKEN "log" %token LOG2TOKEN "log2" %token LOG10TOKEN "log10" %token SINTOKEN "sin" %token COSTOKEN "cos" %token TANTOKEN "tan" %token ASINTOKEN "asin" %token ACOSTOKEN "acos" %token ATANTOKEN "atan" %token SINHTOKEN "sinh" %token COSHTOKEN "cosh" %token TANHTOKEN "tanh" %token ASINHTOKEN "asinh" %token ACOSHTOKEN "acosh" %token ATANHTOKEN "atanh" %token ABSTOKEN "abs" %token ERFTOKEN "erf" %token ERFCTOKEN "erfc" %token LOG1PTOKEN "log1p" %token EXPM1TOKEN "expm1" %token DOUBLETOKEN "D" %token SINGLETOKEN "SG" %token HALFPRECISIONTOKEN "HP" %token QUADTOKEN "QD" %token DOUBLEDOUBLETOKEN "DD" %token TRIPLEDOUBLETOKEN "TD" %token DOUBLEEXTENDEDTOKEN "DE" %token CEILTOKEN "ceil" %token FLOORTOKEN "floor" %token NEARESTINTTOKEN "nearestint" %token HEADTOKEN "head" %token REVERTTOKEN "revert" %token SORTTOKEN "sort" %token TAILTOKEN "tail" %token MANTISSATOKEN "mantissa" %token EXPONENTTOKEN "exponent" %token PRECISIONTOKEN "precision" %token ROUNDCORRECTLYTOKEN "roundcorrectly" %token PRECTOKEN "prec" %token POINTSTOKEN "points" %token DIAMTOKEN "diam" %token DISPLAYTOKEN "display" %token VERBOSITYTOKEN "verbosity" %token SHOWMESSAGENUMBERSTOKEN "showmessagenumbers" %token CANONICALTOKEN "canonical" %token AUTOSIMPLIFYTOKEN "autosimplify" %token TAYLORRECURSIONSTOKEN "taylorrecursions" %token TIMINGTOKEN "timing" %token TIMETOKEN "time" %token FULLPARENTHESESTOKEN "fullparentheses" %token MIDPOINTMODETOKEN "midpointmode" %token DIEONERRORMODETOKEN "dieonerrormode" %token SUPPRESSWARNINGSTOKEN "roundingwarnings" %token RATIONALMODETOKEN "rationalmode" %token HOPITALRECURSIONSTOKEN "hopitalrecursions" %token ONTOKEN "on" %token OFFTOKEN "off" %token DYADICTOKEN "dyadic" %token POWERSTOKEN "powers" %token BINARYTOKEN "binary" %token HEXADECIMALTOKEN "hexadecimal" %token FILETOKEN "file" %token POSTSCRIPTTOKEN "postscript" %token POSTSCRIPTFILETOKEN "postscriptfile" %token PERTURBTOKEN "perturb" %token MINUSWORDTOKEN "RD" %token PLUSWORDTOKEN "RU" %token ZEROWORDTOKEN "RZ" %token NEARESTTOKEN "RN" %token HONORCOEFFPRECTOKEN "honorcoeffprec" %token TRUETOKEN "true" %token FALSETOKEN "false" %token DEFAULTTOKEN "default" %token MATCHTOKEN "match" %token WITHTOKEN "with" %token ABSOLUTETOKEN "absolute" %token DECIMALTOKEN "decimal" %token RELATIVETOKEN "relative" %token FIXEDTOKEN "fixed" %token FLOATINGTOKEN "floating" %token ERRORTOKEN "error" %token QUITTOKEN "quit" %token FALSEQUITTOKEN "quit in an included file" %token RESTARTTOKEN "restart" %token LIBRARYTOKEN "library" %token LIBRARYCONSTANTTOKEN "libraryconstant" %token DIFFTOKEN "diff" %token DIRTYSIMPLIFYTOKEN "dirtysimplify" %token REMEZTOKEN "remez" %token ANNOTATEFUNCTIONTOKEN "annotatefunction" %token BASHEVALUATETOKEN "bashevaluate" %token GETSUPPRESSEDMESSAGESTOKEN "getsuppressedmessages" %token GETBACKTRACETOKEN "getbacktrace" %token FPMINIMAXTOKEN "fpminimax" %token HORNERTOKEN "horner" %token EXPANDTOKEN "expand" %token SIMPLIFYSAFETOKEN "simplify" %token TAYLORTOKEN "taylor" %token TAYLORFORMTOKEN "taylorform" %token CHEBYSHEVFORMTOKEN "chebyshevform" %token AUTODIFFTOKEN "autodiff" %token DEGREETOKEN "degree" %token NUMERATORTOKEN "numerator" %token DENOMINATORTOKEN "denominator" %token SUBSTITUTETOKEN "substitute" %token COMPOSEPOLYNOMIALSTOKEN "composepolynomials" %token COEFFTOKEN "coeff" %token SUBPOLYTOKEN "subpoly" %token ROUNDCOEFFICIENTSTOKEN "roundcoefficients" %token RATIONALAPPROXTOKEN "rationalapprox" %token ACCURATEINFNORMTOKEN "accurateinfnorm" %token ROUNDTOFORMATTOKEN "round" %token EVALUATETOKEN "evaluate" %token LENGTHTOKEN "length" %token OBJECTNAMETOKEN "objectname" %token INFTOKEN "inf" %token MIDTOKEN "mid" %token SUPTOKEN "sup" %token MINTOKEN "min" %token MAXTOKEN "max" %token READXMLTOKEN "read" %token PARSETOKEN "parse" %token PRINTTOKEN "print" %token PRINTXMLTOKEN "printxml" %token PLOTTOKEN "plot" %token PRINTHEXATOKEN "printhexa" %token PRINTFLOATTOKEN "printfloat" %token PRINTBINARYTOKEN "printbinary" %token SUPPRESSMESSAGETOKEN "suppressmessage" %token UNSUPPRESSMESSAGETOKEN "unsuppressmessage" %token PRINTEXPANSIONTOKEN "printexpansion" %token BASHEXECUTETOKEN "bashexecute" %token EXTERNALPLOTTOKEN "externalplot" %token WRITETOKEN "write" %token ASCIIPLOTTOKEN "asciiplot" %token RENAMETOKEN "rename" %token BINDTOKEN "bind" %token INFNORMTOKEN "infnorm" %token SUPNORMTOKEN "supnorm" %token FINDZEROSTOKEN "findzeros" %token FPFINDZEROSTOKEN "fpfindzeros" %token DIRTYINFNORMTOKEN "dirtyinfnorm" %token NUMBERROOTSTOKEN "numberroots" %token INTEGRALTOKEN "integral" %token DIRTYINTEGRALTOKEN "dirtyintegral" %token WORSTCASETOKEN "worstcase" %token IMPLEMENTPOLYTOKEN "implementpoly" %token IMPLEMENTCONSTTOKEN "implementconst" %token CHECKINFNORMTOKEN "checkinfnorm" %token ZERODENOMINATORSTOKEN "zerodenominators" %token ISEVALUABLETOKEN "isevaluable" %token SEARCHGALTOKEN "searchgal" %token GUESSDEGREETOKEN "guessdegree" %token DIRTYFINDZEROSTOKEN "dirtyfindzeros" %token IFTOKEN "if" %token THENTOKEN "then" %token ELSETOKEN "else" %token FORTOKEN "for" %token INTOKEN "in" %token FROMTOKEN "from" %token TOTOKEN "to" %token BYTOKEN "by" %token DOTOKEN "do" %token BEGINTOKEN "begin" %token ENDTOKEN "end" %token LEFTCURLYBRACETOKEN "{" %token RIGHTCURLYBRACETOKEN "}" %token WHILETOKEN "while" %token READFILETOKEN "readfile" %token ISBOUNDTOKEN "isbound" %token EXECUTETOKEN "execute" %token EXTERNALPROCTOKEN "externalproc" %token VOIDTOKEN "void" %token CONSTANTTYPETOKEN "constant" %token FUNCTIONTOKEN "function" %token OBJECTTOKEN "object" %token RANGETOKEN "range" %token INTEGERTOKEN "integer" %token STRINGTYPETOKEN "string" %token BOOLEANTOKEN "boolean" %token LISTTOKEN "list" %token OFTOKEN "of" %token VARTOKEN "var" %token PROCTOKEN "proc" %token PROCEDURETOKEN "procedure" %token RETURNTOKEN "return" %token NOPTOKEN "nop" %token HELPTOKEN "help" %token VERSIONTOKEN "version" %type startsymbol; %type help; %type helpmeta; %type egalquestionmark; %type unaryplusminus; %type command; %type procbody; %type variabledeclaration; %type simplecommand; %type commandlist; %type variabledeclarationlist; %type identifierlist; %type thing; %type supermegaterm; %type thinglist; %type matchlist; %type matchelement; %type structelementlist; %type structelement; %type structelementseparator; %type structuring; %type ifcommand; %type forcommand; %type assignment; %type simpleassignment; %type stateassignment; %type stillstateassignment; %type basicthing; %type list; %type constant; %type simplelist; %type range; %type debound; %type headfunction; %type term; %type hyperterm; %type subterm; %type megaterm; %type statedereference; %type indexing; %type externalproctype; %type extendedexternalproctype; %type externalproctypesimplelist; %type externalproctypelist; %type beginsymbol; %type endsymbol; %% startsymbol: command SEMICOLONTOKEN { parsedThing = $1; $$ = NULL; YYACCEPT; } | helpmeta SEMICOLONTOKEN { outputMode(); sollyaPrintf("This is %s.\nType 'help help;' for the list of available commands. Type 'help ;' for help on the specific command .\nType 'quit;' for quitting the %s interpreter.\n\nYou can get moral support and help with bugs by writing to %s.\n\n",PACKAGE_NAME,PACKAGE_NAME,PACKAGE_BUGREPORT); parsedThing = NULL; $$ = NULL; YYACCEPT; } | QUESTIONMARKTOKEN { outputMode(); sollyaPrintf("This is %s.\nType 'help help;' for the list of available commands. Type 'help ;' for help on the specific command .\nType 'quit;' for quitting the %s interpreter.\n\nYou can get moral support and help with bugs by writing to %s.\n\n",PACKAGE_NAME,PACKAGE_NAME,PACKAGE_BUGREPORT); parsedThing = NULL; $$ = NULL; YYACCEPT; } | helpmeta help SEMICOLONTOKEN { parsedThing = NULL; $$ = NULL; YYACCEPT; } | VERSIONTOKEN SEMICOLONTOKEN { outputMode(); sollyaPrintf("This is\n\n\t%s.\n\n" VERSION_COPYRIGHT_TEXT "\nSend bug reports to <%s>\n\nThis build of %s is based on GMP %s, MPFR %s and MPFI %s.\n",PACKAGE_STRING,PACKAGE_BUGREPORT,PACKAGE_STRING,gmp_version,mpfr_get_version(),sollya_mpfi_get_version()); #if defined(HAVE_FPLLL_VERSION_STRING) sollyaPrintf("It uses FPLLL as: \"%s\"\n",HAVE_FPLLL_VERSION_STRING); #endif sollyaPrintf("\n"); parsedThing = NULL; $$ = NULL; YYACCEPT; } | error SEMICOLONTOKEN { parsedThing = NULL; $$ = NULL; YYACCEPT; } ; helpmeta: HELPTOKEN { helpNotFinished = 1; $$ = NULL; } ; beginsymbol: BEGINTOKEN { $$ = NULL; } | LEFTCURLYBRACETOKEN { $$ = NULL; } ; endsymbol: ENDTOKEN { $$ = NULL; } | RIGHTCURLYBRACETOKEN { $$ = NULL; } ; command: simplecommand { $$ = $1; } | beginsymbol commandlist endsymbol { $$ = makeCommandList($2); } | beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeCommandList(concatChains($2, $3)); } | beginsymbol variabledeclarationlist endsymbol { $$ = makeCommandList($2); } | beginsymbol endsymbol { $$ = makeNop(); } | IFTOKEN ifcommand { $$ = $2; } | WHILETOKEN thing DOTOKEN command { $$ = makeWhile($2, $4); } | FORTOKEN forcommand { $$ = $2; } ; ifcommand: thing THENTOKEN command { $$ = makeIf($1, $3); } | thing THENTOKEN command ELSETOKEN command { $$ = makeIfElse($1,$3,$5); } ; forcommand: IDENTIFIERTOKEN FROMTOKEN thing TOTOKEN thing DOTOKEN command { $$ = makeFor($1, $3, $5, makeConstantDouble(1.0), $7); safeFree($1); } | IDENTIFIERTOKEN FROMTOKEN thing TOTOKEN thing BYTOKEN thing DOTOKEN command { $$ = makeFor($1, $3, $5, $7, $9); safeFree($1); } | IDENTIFIERTOKEN INTOKEN thing DOTOKEN command { $$ = makeForIn($1, $3, $5); safeFree($1); } ; commandlist: command SEMICOLONTOKEN { $$ = addElement(NULL, $1); } | command SEMICOLONTOKEN commandlist { $$ = addElement($3, $1); } ; variabledeclarationlist: variabledeclaration SEMICOLONTOKEN { $$ = addElement(NULL, $1); } | variabledeclaration SEMICOLONTOKEN variabledeclarationlist { $$ = addElement($3, $1); } ; variabledeclaration: VARTOKEN identifierlist { $$ = makeVariableDeclaration($2); } ; identifierlist: IDENTIFIERTOKEN { $$ = addElement(NULL, $1); } | IDENTIFIERTOKEN COMMATOKEN identifierlist { $$ = addElement($3, $1); } ; procbody: LPARTOKEN RPARTOKEN beginsymbol commandlist endsymbol { $$ = makeProc(NULL, makeCommandList($4), makeUnit()); } | LPARTOKEN RPARTOKEN beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeProc(NULL, makeCommandList(concatChains($4, $5)), makeUnit()); } | LPARTOKEN RPARTOKEN beginsymbol variabledeclarationlist endsymbol { $$ = makeProc(NULL, makeCommandList($4), makeUnit()); } | LPARTOKEN RPARTOKEN beginsymbol endsymbol { $$ = makeProc(NULL, makeCommandList(addElement(NULL,makeNop())), makeUnit()); } | LPARTOKEN RPARTOKEN beginsymbol commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc(NULL, makeCommandList($4), $6); } | LPARTOKEN RPARTOKEN beginsymbol variabledeclarationlist commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc(NULL, makeCommandList(concatChains($4, $5)), $7); } | LPARTOKEN RPARTOKEN beginsymbol variabledeclarationlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc(NULL, makeCommandList($4), $6); } | LPARTOKEN RPARTOKEN beginsymbol RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc(NULL, makeCommandList(addElement(NULL,makeNop())), $5); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol commandlist endsymbol { $$ = makeProc($2, makeCommandList($5), makeUnit()); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeProc($2, makeCommandList(concatChains($5, $6)), makeUnit()); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol variabledeclarationlist endsymbol { $$ = makeProc($2, makeCommandList($5), makeUnit()); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol endsymbol { $$ = makeProc($2, makeCommandList(addElement(NULL,makeNop())), makeUnit()); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc($2, makeCommandList($5), $7); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol variabledeclarationlist commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc($2, makeCommandList(concatChains($5, $6)), $8); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol variabledeclarationlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc($2, makeCommandList($5), $7); } | LPARTOKEN identifierlist RPARTOKEN beginsymbol RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProc($2, makeCommandList(addElement(NULL, makeNop())), $6); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol commandlist endsymbol { $$ = makeProcIllim($2, makeCommandList($7), makeUnit()); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeProcIllim($2, makeCommandList(concatChains($7, $8)), makeUnit()); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol variabledeclarationlist endsymbol { $$ = makeProcIllim($2, makeCommandList($7), makeUnit()); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol endsymbol { $$ = makeProcIllim($2, makeCommandList(addElement(NULL,makeNop())), makeUnit()); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProcIllim($2, makeCommandList($7), $9); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol variabledeclarationlist commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProcIllim($2, makeCommandList(concatChains($7, $8)), $10); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol variabledeclarationlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProcIllim($2, makeCommandList($7), $9); } | LPARTOKEN IDENTIFIERTOKEN EQUALTOKEN DOTSTOKEN RPARTOKEN beginsymbol RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeProcIllim($2, makeCommandList(addElement(NULL, makeNop())), $8); } ; simplecommand: QUITTOKEN { $$ = makeQuit(); } | FALSEQUITTOKEN { $$ = makeFalseQuit(); } | NOPTOKEN { $$ = makeNop(); } | NOPTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeNopArg($3); } | NOPTOKEN LPARTOKEN RPARTOKEN { $$ = makeNopArg(makeDefault()); } | RESTARTTOKEN { $$ = makeRestart(); } | PRINTTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makePrint($3); } | PRINTTOKEN LPARTOKEN thinglist RPARTOKEN RIGHTANGLETOKEN thing { $$ = makeNewFilePrint($6, $3); } | PRINTTOKEN LPARTOKEN thinglist RPARTOKEN RIGHTANGLETOKEN RIGHTANGLETOKEN thing { $$ = makeAppendFilePrint($7, $3); } | PLOTTOKEN LPARTOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makePlot(addElement($5, $3)); } | PRINTHEXATOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintHexa($3); } | PRINTFLOATTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintFloat($3); } | PRINTBINARYTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintBinary($3); } | SUPPRESSMESSAGETOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeSuppressMessage($3); } | UNSUPPRESSMESSAGETOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeUnsuppressMessage($3); } | PRINTEXPANSIONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintExpansion($3); } | IMPLEMENTCONSTTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeImplementConst($3); } | BASHEXECUTETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeBashExecute($3); } | EXTERNALPLOTTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeExternalPlot(addElement(addElement(addElement(addElement($11,$9),$7),$5),$3)); } | WRITETOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeWrite($3); } | WRITETOKEN LPARTOKEN thinglist RPARTOKEN RIGHTANGLETOKEN thing { $$ = makeNewFileWrite($6, $3); } | WRITETOKEN LPARTOKEN thinglist RPARTOKEN RIGHTANGLETOKEN RIGHTANGLETOKEN thing { $$ = makeAppendFileWrite($7, $3); } | ASCIIPLOTTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeAsciiPlot($3, $5); } | PRINTXMLTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrintXml($3); } | EXECUTETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExecute($3); } | PRINTXMLTOKEN LPARTOKEN thing RPARTOKEN RIGHTANGLETOKEN thing { $$ = makePrintXmlNewFile($3,$6); } | PRINTXMLTOKEN LPARTOKEN thing RPARTOKEN RIGHTANGLETOKEN RIGHTANGLETOKEN thing { $$ = makePrintXmlAppendFile($3,$7); } | WORSTCASETOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeWorstCase(addElement(addElement(addElement(addElement($11, $9), $7), $5), $3)); } | RENAMETOKEN LPARTOKEN IDENTIFIERTOKEN COMMATOKEN IDENTIFIERTOKEN RPARTOKEN { $$ = makeRename($3, $5); safeFree($3); safeFree($5); } | RENAMETOKEN LPARTOKEN FREEVARTOKEN COMMATOKEN IDENTIFIERTOKEN RPARTOKEN { $$ = makeRename("_x_", $5); safeFree($5); } | EXTERNALPROCTOKEN LPARTOKEN IDENTIFIERTOKEN COMMATOKEN thing COMMATOKEN externalproctypelist MINUSTOKEN RIGHTANGLETOKEN extendedexternalproctype RPARTOKEN { $$ = makeExternalProc($3, $5, addElement($7, $10)); safeFree($3); } | assignment { $$ = $1; } | thinglist { $$ = makeAutoprint($1); } | PROCEDURETOKEN IDENTIFIERTOKEN procbody { $$ = makeAssignment($2, $3); safeFree($2); } ; assignment: stateassignment { $$ = $1; } | stillstateassignment EXCLAMATIONTOKEN { $$ = $1; } | simpleassignment { $$ = $1; } | simpleassignment EXCLAMATIONTOKEN { $$ = $1; } ; simpleassignment: IDENTIFIERTOKEN EQUALTOKEN thing { $$ = makeAssignment($1, $3); safeFree($1); } | IDENTIFIERTOKEN ASSIGNEQUALTOKEN thing { $$ = makeFloatAssignment($1, $3); safeFree($1); } | IDENTIFIERTOKEN EQUALTOKEN LIBRARYTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLibraryBinding($1, $5); safeFree($1); } | IDENTIFIERTOKEN EQUALTOKEN LIBRARYCONSTANTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLibraryConstantBinding($1, $5); safeFree($1); } | indexing EQUALTOKEN thing { $$ = makeAssignmentInIndexing($1->a,$1->b,$3); safeFree($1); } | indexing ASSIGNEQUALTOKEN thing { $$ = makeFloatAssignmentInIndexing($1->a,$1->b,$3); safeFree($1); } | structuring EQUALTOKEN thing { $$ = makeProtoAssignmentInStructure($1,$3); } | structuring ASSIGNEQUALTOKEN thing { $$ = makeProtoFloatAssignmentInStructure($1,$3); } ; structuring: basicthing DOTTOKEN IDENTIFIERTOKEN { $$ = makeStructAccess($1,$3); safeFree($3); } ; stateassignment: PRECTOKEN EQUALTOKEN thing { $$ = makePrecAssign($3); } | POINTSTOKEN EQUALTOKEN thing { $$ = makePointsAssign($3); } | DIAMTOKEN EQUALTOKEN thing { $$ = makeDiamAssign($3); } | DISPLAYTOKEN EQUALTOKEN thing { $$ = makeDisplayAssign($3); } | VERBOSITYTOKEN EQUALTOKEN thing { $$ = makeVerbosityAssign($3); } | SHOWMESSAGENUMBERSTOKEN EQUALTOKEN thing { $$ = makeShowMessageNumbersAssign($3); } | CANONICALTOKEN EQUALTOKEN thing { $$ = makeCanonicalAssign($3); } | AUTOSIMPLIFYTOKEN EQUALTOKEN thing { $$ = makeAutoSimplifyAssign($3); } | TAYLORRECURSIONSTOKEN EQUALTOKEN thing { $$ = makeTaylorRecursAssign($3); } | TIMINGTOKEN EQUALTOKEN thing { $$ = makeTimingAssign($3); } | FULLPARENTHESESTOKEN EQUALTOKEN thing { $$ = makeFullParenAssign($3); } | MIDPOINTMODETOKEN EQUALTOKEN thing { $$ = makeMidpointAssign($3); } | DIEONERRORMODETOKEN EQUALTOKEN thing { $$ = makeDieOnErrorAssign($3); } | RATIONALMODETOKEN EQUALTOKEN thing { $$ = makeRationalModeAssign($3); } | SUPPRESSWARNINGSTOKEN EQUALTOKEN thing { $$ = makeSuppressWarningsAssign($3); } | HOPITALRECURSIONSTOKEN EQUALTOKEN thing { $$ = makeHopitalRecursAssign($3); } ; stillstateassignment: PRECTOKEN EQUALTOKEN thing { $$ = makePrecStillAssign($3); } | POINTSTOKEN EQUALTOKEN thing { $$ = makePointsStillAssign($3); } | DIAMTOKEN EQUALTOKEN thing { $$ = makeDiamStillAssign($3); } | DISPLAYTOKEN EQUALTOKEN thing { $$ = makeDisplayStillAssign($3); } | VERBOSITYTOKEN EQUALTOKEN thing { $$ = makeVerbosityStillAssign($3); } | SHOWMESSAGENUMBERSTOKEN EQUALTOKEN thing { $$ = makeShowMessageNumbersStillAssign($3); } | CANONICALTOKEN EQUALTOKEN thing { $$ = makeCanonicalStillAssign($3); } | AUTOSIMPLIFYTOKEN EQUALTOKEN thing { $$ = makeAutoSimplifyStillAssign($3); } | TAYLORRECURSIONSTOKEN EQUALTOKEN thing { $$ = makeTaylorRecursStillAssign($3); } | TIMINGTOKEN EQUALTOKEN thing { $$ = makeTimingStillAssign($3); } | FULLPARENTHESESTOKEN EQUALTOKEN thing { $$ = makeFullParenStillAssign($3); } | MIDPOINTMODETOKEN EQUALTOKEN thing { $$ = makeMidpointStillAssign($3); } | DIEONERRORMODETOKEN EQUALTOKEN thing { $$ = makeDieOnErrorStillAssign($3); } | RATIONALMODETOKEN EQUALTOKEN thing { $$ = makeRationalModeStillAssign($3); } | SUPPRESSWARNINGSTOKEN EQUALTOKEN thing { $$ = makeSuppressWarningsStillAssign($3); } | HOPITALRECURSIONSTOKEN EQUALTOKEN thing { $$ = makeHopitalRecursStillAssign($3); } ; thinglist: thing { $$ = addElement(NULL, $1); } | thing COMMATOKEN thinglist { $$ = addElement($3, $1); } ; structelementlist: structelement { $$ = addElement(NULL, $1); } | structelement structelementseparator structelementlist { $$ = addElement($3, $1); } ; structelementseparator: COMMATOKEN { $$ = NULL; } | SEMICOLONTOKEN { $$ = NULL; } ; structelement: DOTTOKEN IDENTIFIERTOKEN EQUALTOKEN thing { $$ = (entry *) safeMalloc(sizeof(entry)); $$->name = (char *) safeCalloc(strlen($2) + 1, sizeof(char)); strcpy($$->name,$2); safeFree($2); $$->value = (void *) ($4); } ; thing: supermegaterm { $$ = $1; } | MATCHTOKEN supermegaterm WITHTOKEN matchlist { $$ = makeMatch($2,$4); } ; supermegaterm: megaterm { $$ = $1; } | thing ANDTOKEN megaterm { $$ = makeAnd($1, $3); } | thing ORTOKEN megaterm { $$ = makeOr($1, $3); } | EXCLAMATIONTOKEN megaterm { $$ = makeNegation($2); } ; indexing: basicthing LBRACKETTOKEN thing RBRACKETTOKEN { $$ = (doubleNode *) safeMalloc(sizeof(doubleNode)); $$->a = $1; $$->b = $3; } ; megaterm: hyperterm { $$ = $1; } | megaterm COMPAREEQUALTOKEN hyperterm { $$ = makeCompareEqual($1, $3); } | megaterm INTOKEN hyperterm { $$ = makeCompareIn($1, $3); } | megaterm LEFTANGLETOKEN hyperterm { $$ = makeCompareLess($1, $3); } | megaterm RIGHTANGLETOKEN hyperterm { $$ = makeCompareGreater($1, $3); } | megaterm LEFTANGLETOKEN EQUALTOKEN hyperterm { $$ = makeCompareLessEqual($1, $4); } | megaterm RIGHTANGLETOKEN EQUALTOKEN hyperterm { $$ = makeCompareGreaterEqual($1, $4); } | megaterm EXCLAMATIONEQUALTOKEN hyperterm { $$ = makeCompareNotEqual($1, $3); } ; hyperterm: term { $$ = $1; } | hyperterm PLUSTOKEN term { $$ = makeAdd($1, $3); } | hyperterm MINUSTOKEN term { $$ = makeSub($1, $3); } | hyperterm ATTOKEN term { $$ = makeConcat($1, $3); } | hyperterm DOUBLECOLONTOKEN term { $$ = makeAddToList($1, $3); } | hyperterm COLONDOTTOKEN term { $$ = makeAppend($1, $3); } ; unaryplusminus: PLUSTOKEN { $$ = 0; } | MINUSTOKEN { $$ = 1; } | PLUSTOKEN unaryplusminus { $$ = $2; } | MINUSTOKEN unaryplusminus { $$ = $2+1; } ; term: subterm { $$ = $1; } | unaryplusminus subterm { tempNode = $2; for (tempInteger=0;tempInteger<$1;tempInteger++) tempNode = makeNeg(tempNode); $$ = tempNode; } | APPROXTOKEN subterm { $$ = makeEvalConst($2); } | term MULTOKEN subterm { $$ = makeMul($1, $3); } | term DIVTOKEN subterm { $$ = makeDiv($1, $3); } | term MULTOKEN unaryplusminus subterm { tempNode = $4; for (tempInteger=0;tempInteger<$3;tempInteger++) tempNode = makeNeg(tempNode); $$ = makeMul($1, tempNode); } | term DIVTOKEN unaryplusminus subterm { tempNode = $4; for (tempInteger=0;tempInteger<$3;tempInteger++) tempNode = makeNeg(tempNode); $$ = makeDiv($1, tempNode); } | term MULTOKEN APPROXTOKEN subterm { $$ = makeMul($1, makeEvalConst($4)); } | term DIVTOKEN APPROXTOKEN subterm { $$ = makeDiv($1, makeEvalConst($4)); } ; subterm: basicthing { $$ = $1; } | basicthing POWTOKEN subterm { $$ = makePow($1, $3); } | basicthing POWTOKEN unaryplusminus subterm { tempNode = $4; for (tempInteger=0;tempInteger<$3;tempInteger++) tempNode = makeNeg(tempNode); $$ = makePow($1, tempNode); } | basicthing POWTOKEN APPROXTOKEN subterm { $$ = makePow($1, makeEvalConst($4)); } | basicthing DOTCOLONTOKEN subterm { $$ = makePrepend($1, $3); } | basicthing DOTCOLONTOKEN APPROXTOKEN subterm { $$ = makePrepend($1, makeEvalConst($4)); } ; basicthing: ONTOKEN { $$ = makeOn(); } | OFFTOKEN { $$ = makeOff(); } | DYADICTOKEN { $$ = makeDyadic(); } | POWERSTOKEN { $$ = makePowers(); } | BINARYTOKEN { $$ = makeBinaryThing(); } | HEXADECIMALTOKEN { $$ = makeHexadecimalThing(); } | FILETOKEN { $$ = makeFile(); } | POSTSCRIPTTOKEN { $$ = makePostscript(); } | POSTSCRIPTFILETOKEN { $$ = makePostscriptFile(); } | PERTURBTOKEN { $$ = makePerturb(); } | MINUSWORDTOKEN { $$ = makeRoundDown(); } | PLUSWORDTOKEN { $$ = makeRoundUp(); } | ZEROWORDTOKEN { $$ = makeRoundToZero(); } | NEARESTTOKEN { $$ = makeRoundToNearest(); } | HONORCOEFFPRECTOKEN { $$ = makeHonorCoeff(); } | TRUETOKEN { $$ = makeTrue(); } | VOIDTOKEN { $$ = makeUnit(); } | FALSETOKEN { $$ = makeFalse(); } | DEFAULTTOKEN { $$ = makeDefault(); } | DECIMALTOKEN { $$ = makeDecimal(); } | ABSOLUTETOKEN { $$ = makeAbsolute(); } | RELATIVETOKEN { $$ = makeRelative(); } | FIXEDTOKEN { $$ = makeFixed(); } | FLOATINGTOKEN { $$ = makeFloating(); } | ERRORTOKEN { $$ = makeError(); } | DOUBLETOKEN { $$ = makeDoubleSymbol(); } | SINGLETOKEN { $$ = makeSingleSymbol(); } | QUADTOKEN { $$ = makeQuadSymbol(); } | HALFPRECISIONTOKEN { $$ = makeHalfPrecisionSymbol(); } | DOUBLEEXTENDEDTOKEN { $$ = makeDoubleextendedSymbol(); } | FREEVARTOKEN { $$ = makeVariable(); } | DOUBLEDOUBLETOKEN { $$ = makeDoubleDoubleSymbol(); } | TRIPLEDOUBLETOKEN { $$ = makeTripleDoubleSymbol(); } | STRINGTOKEN { tempString = safeCalloc(strlen($1) + 1, sizeof(char)); strcpy(tempString, $1); safeFree($1); tempString2 = safeCalloc(strlen(tempString) + 1, sizeof(char)); strcpy(tempString2, tempString); safeFree(tempString); $$ = makeString(tempString2); safeFree(tempString2); } | constant { $$ = $1; } | IDENTIFIERTOKEN { $$ = makeTableAccess($1); safeFree($1); } | ISBOUNDTOKEN LPARTOKEN IDENTIFIERTOKEN RPARTOKEN { $$ = makeIsBound($3); safeFree($3); } | IDENTIFIERTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeTableAccessWithSubstitute($1, $3); safeFree($1); } | IDENTIFIERTOKEN LPARTOKEN RPARTOKEN { $$ = makeTableAccessWithSubstitute($1, NULL); safeFree($1); } | list { $$ = $1; } | range { $$ = $1; } | debound { $$ = $1; } | headfunction { $$ = $1; } | LPARTOKEN thing RPARTOKEN { $$ = $2; } | LEFTCURLYBRACETOKEN structelementlist RIGHTCURLYBRACETOKEN { $$ = makeStructure($2); } | statedereference { $$ = $1; } | indexing { $$ = makeIndex($1->a, $1->b); safeFree($1); } | basicthing DOTTOKEN IDENTIFIERTOKEN { $$ = makeStructAccess($1,$3); safeFree($3); } | basicthing DOTTOKEN IDENTIFIERTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeApply(makeStructAccess($1,$3),$5); safeFree($3); } | LPARTOKEN thing RPARTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeApply($2,$5); } | LPARTOKEN thing RPARTOKEN LPARTOKEN RPARTOKEN { $$ = makeApply($2,addElement(NULL,makeUnit())); } | PROCTOKEN procbody { $$ = $2; } | TIMETOKEN LPARTOKEN command RPARTOKEN { $$ = makeTime($3); } ; matchlist: matchelement { $$ = addElement(NULL,$1); } | matchelement matchlist { $$ = addElement($2,$1); } ; matchelement: thing COLONTOKEN beginsymbol variabledeclarationlist commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeMatchElement($1,makeCommandList(concatChains($4, $5)),$7); } | thing COLONTOKEN beginsymbol variabledeclarationlist commandlist endsymbol { $$ = makeMatchElement($1,makeCommandList(concatChains($4, $5)),makeUnit()); } | thing COLONTOKEN beginsymbol variabledeclarationlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeMatchElement($1,makeCommandList($4),$6); } | thing COLONTOKEN beginsymbol variabledeclarationlist endsymbol { $$ = makeMatchElement($1,makeCommandList($4),makeUnit()); } | thing COLONTOKEN beginsymbol commandlist RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeMatchElement($1,makeCommandList($4),$6); } | thing COLONTOKEN beginsymbol commandlist endsymbol { $$ = makeMatchElement($1,makeCommandList($4),makeUnit()); } | thing COLONTOKEN beginsymbol RETURNTOKEN thing SEMICOLONTOKEN endsymbol { $$ = makeMatchElement($1, makeCommandList(addElement(NULL,makeNop())), $5); } | thing COLONTOKEN beginsymbol endsymbol { $$ = makeMatchElement($1, makeCommandList(addElement(NULL,makeNop())), makeUnit()); } | thing COLONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeMatchElement($1, makeCommandList(addElement(NULL,makeNop())), $4); } ; constant: CONSTANTTOKEN { $$ = makeDecimalConstant($1); safeFree($1); } | MIDPOINTCONSTANTTOKEN { $$ = makeMidpointConstant($1); safeFree($1); } | DYADICCONSTANTTOKEN { $$ = makeDyadicConstant($1); safeFree($1); } | HEXCONSTANTTOKEN { $$ = makeHexConstant($1); safeFree($1); } | HEXADECIMALCONSTANTTOKEN { $$ = makeHexadecimalConstant($1); safeFree($1); } | BINARYCONSTANTTOKEN { $$ = makeBinaryConstant($1); safeFree($1); } | PITOKEN { $$ = makePi(); } ; list: LBRACKETTOKEN VERTBARTOKEN VERTBARTOKEN RBRACKETTOKEN { $$ = makeEmptyList(); } | LBRACKETTOKEN ORTOKEN RBRACKETTOKEN { $$ = makeEmptyList(); } | LBRACKETTOKEN VERTBARTOKEN simplelist VERTBARTOKEN RBRACKETTOKEN { $$ = makeRevertedList($3); } | LBRACKETTOKEN VERTBARTOKEN simplelist DOTSTOKEN VERTBARTOKEN RBRACKETTOKEN { $$ = makeRevertedFinalEllipticList($3); } ; simplelist: thing { $$ = addElement(NULL, $1); } | simplelist COMMATOKEN thing { $$ = addElement($1, $3); } | simplelist COMMATOKEN DOTSTOKEN COMMATOKEN thing { $$ = addElement(addElement($1, makeElliptic()), $5); } ; range: LBRACKETTOKEN thing COMMATOKEN thing RBRACKETTOKEN { $$ = makeRange($2, $4); } | LBRACKETTOKEN thing SEMICOLONTOKEN thing RBRACKETTOKEN { $$ = makeRange($2, $4); } | LBRACKETTOKEN thing RBRACKETTOKEN { $$ = makeRange($2, copyThing($2)); } ; debound: STARLEFTANGLETOKEN thing RIGHTANGLESTARTOKEN { $$ = makeDeboundMax($2); } | STARLEFTANGLETOKEN thing RIGHTANGLEDOTTOKEN { $$ = makeDeboundMid($2); } | STARLEFTANGLETOKEN thing RIGHTANGLEUNDERSCORETOKEN { $$ = makeDeboundMin($2); } | SUPTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDeboundMax($3); } | MIDTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDeboundMid($3); } | INFTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDeboundMin($3); } ; headfunction: DIFFTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDiff($3); } | DIRTYSIMPLIFYTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDirtysimplify($3); } | BASHEVALUATETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeBashevaluate(addElement(NULL,$3)); } | GETSUPPRESSEDMESSAGESTOKEN LPARTOKEN RPARTOKEN { $$ = makeGetSuppressedMessages(); } | GETBACKTRACETOKEN LPARTOKEN RPARTOKEN { $$ = makeGetBacktrace(); } | BASHEVALUATETOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeBashevaluate(addElement(addElement(NULL,$5),$3)); } | REMEZTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeRemez(addElement(addElement($7, $5), $3)); } | ANNOTATEFUNCTIONTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeAnnotateFunction(addElement(addElement(addElement($9, $7), $5), $3)); } | BINDTOKEN LPARTOKEN thing COMMATOKEN IDENTIFIERTOKEN COMMATOKEN thing RPARTOKEN { $$ = makeBind($3, $5, $7); safeFree($5); } | MINTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeMin($3); } | MAXTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeMax($3); } | FPMINIMAXTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeFPminimax(addElement(addElement(addElement($9, $7), $5), $3)); } | HORNERTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeHorner($3); } | CANONICALTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeCanonicalThing($3); } | EXPANDTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExpand($3); } | SIMPLIFYSAFETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSimplifySafe($3); } | TAYLORTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeTaylor($3, $5, $7); } | TAYLORFORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeTaylorform(addElement(addElement($7, $5), $3)); } | CHEBYSHEVFORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeChebyshevform(addElement(addElement(addElement(NULL, $7), $5), $3)); } | AUTODIFFTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeAutodiff(addElement(addElement(addElement(NULL, $7), $5), $3)); } | DEGREETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDegree($3); } | NUMERATORTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeNumerator($3); } | DENOMINATORTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDenominator($3); } | SUBSTITUTETOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSubstitute($3, $5); } | COMPOSEPOLYNOMIALSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeComposePolynomials($3, $5); } | COEFFTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeCoeff($3, $5); } | SUBPOLYTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSubpoly($3, $5); } | ROUNDCOEFFICIENTSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeRoundcoefficients($3, $5); } | RATIONALAPPROXTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeRationalapprox($3, $5); } | ACCURATEINFNORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeAccurateInfnorm(addElement(addElement($7, $5), $3)); } | ROUNDTOFORMATTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeRoundToFormat($3, $5, $7); } | EVALUATETOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeEvaluate($3, $5); } | PARSETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeParse($3); } | READXMLTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeReadXml($3); } | INFNORMTOKEN LPARTOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeInfnorm(addElement($5, $3)); } | SUPNORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSupnorm(addElement(addElement(addElement(addElement(addElement(NULL,$11),$9),$7),$5),$3)); } | FINDZEROSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeFindZeros($3, $5); } | FPFINDZEROSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeFPFindZeros($3, $5); } | DIRTYINFNORMTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeDirtyInfnorm($3, $5); } | NUMBERROOTSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeNumberRoots($3, $5); } | INTEGRALTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeIntegral($3, $5); } | DIRTYINTEGRALTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeDirtyIntegral($3, $5); } | IMPLEMENTPOLYTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeImplementPoly(addElement(addElement(addElement(addElement(addElement($13, $11), $9), $7), $5), $3)); } | CHECKINFNORMTOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeCheckInfnorm($3, $5, $7); } | ZERODENOMINATORSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeZeroDenominators($3, $5); } | ISEVALUABLETOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeIsEvaluable($3, $5); } | SEARCHGALTOKEN LPARTOKEN thinglist RPARTOKEN { $$ = makeSearchGal($3); } | GUESSDEGREETOKEN LPARTOKEN thing COMMATOKEN thing COMMATOKEN thinglist RPARTOKEN { $$ = makeGuessDegree(addElement(addElement($7, $5), $3)); } | DIRTYFINDZEROSTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeDirtyFindZeros($3, $5); } | HEADTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeHead($3); } | ROUNDCORRECTLYTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeRoundCorrectly($3); } | READFILETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeReadFile($3); } | REVERTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeRevert($3); } | SORTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSort($3); } | MANTISSATOKEN LPARTOKEN thing RPARTOKEN { $$ = makeMantissa($3); } | EXPONENTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExponent($3); } | PRECISIONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makePrecision($3); } | TAILTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeTail($3); } | SQRTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSqrt($3); } | EXPTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExp($3); } | FREEVARTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeApply(makeVariable(),addElement(NULL,$3)); } | FUNCTIONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeProcedureFunction($3); } | FUNCTIONTOKEN LPARTOKEN thing COMMATOKEN thing RPARTOKEN { $$ = makeSubstitute(makeProcedureFunction($3),$5); } | LOGTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLog($3); } | LOG2TOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLog2($3); } | LOG10TOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLog10($3); } | SINTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSin($3); } | COSTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeCos($3); } | TANTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeTan($3); } | ASINTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAsin($3); } | ACOSTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAcos($3); } | ATANTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAtan($3); } | SINHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSinh($3); } | COSHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeCosh($3); } | TANHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeTanh($3); } | ASINHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAsinh($3); } | ACOSHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAcosh($3); } | ATANHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAtanh($3); } | ABSTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeAbs($3); } | ERFTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeErf($3); } | ERFCTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeErfc($3); } | LOG1PTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLog1p($3); } | EXPM1TOKEN LPARTOKEN thing RPARTOKEN { $$ = makeExpm1($3); } | DOUBLETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDouble($3); } | SINGLETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeSingle($3); } | QUADTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeQuad($3); } | HALFPRECISIONTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeHalfPrecision($3); } | DOUBLEDOUBLETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDoubledouble($3); } | TRIPLEDOUBLETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeTripledouble($3); } | DOUBLEEXTENDEDTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeDoubleextended($3); } | CEILTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeCeil($3); } | FLOORTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeFloor($3); } | NEARESTINTTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeNearestInt($3); } | LENGTHTOKEN LPARTOKEN thing RPARTOKEN { $$ = makeLength($3); } | OBJECTNAMETOKEN LPARTOKEN thing RPARTOKEN { $$ = makeObjectName($3); } ; egalquestionmark: EQUALTOKEN QUESTIONMARKTOKEN { $$ = NULL; } | { $$ = NULL; } ; statedereference: PRECTOKEN egalquestionmark { $$ = makePrecDeref(); } | POINTSTOKEN egalquestionmark { $$ = makePointsDeref(); } | DIAMTOKEN egalquestionmark { $$ = makeDiamDeref(); } | DISPLAYTOKEN egalquestionmark { $$ = makeDisplayDeref(); } | VERBOSITYTOKEN egalquestionmark { $$ = makeVerbosityDeref(); } | SHOWMESSAGENUMBERSTOKEN egalquestionmark { $$ = makeShowMessageNumbersDeref(); } | CANONICALTOKEN egalquestionmark { $$ = makeCanonicalDeref(); } | AUTOSIMPLIFYTOKEN egalquestionmark { $$ = makeAutoSimplifyDeref(); } | TAYLORRECURSIONSTOKEN egalquestionmark { $$ = makeTaylorRecursDeref(); } | TIMINGTOKEN egalquestionmark { $$ = makeTimingDeref(); } | FULLPARENTHESESTOKEN egalquestionmark { $$ = makeFullParenDeref(); } | MIDPOINTMODETOKEN egalquestionmark { $$ = makeMidpointDeref(); } | DIEONERRORMODETOKEN egalquestionmark { $$ = makeDieOnErrorDeref(); } | RATIONALMODETOKEN egalquestionmark { $$ = makeRationalModeDeref(); } | SUPPRESSWARNINGSTOKEN egalquestionmark { $$ = makeSuppressWarningsDeref(); } | HOPITALRECURSIONSTOKEN egalquestionmark { $$ = makeHopitalRecursDeref(); } ; externalproctype: CONSTANTTYPETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = CONSTANT_TYPE; $$ = tempIntPtr; } | FUNCTIONTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = FUNCTION_TYPE; $$ = tempIntPtr; } | OBJECTTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = OBJECT_TYPE; $$ = tempIntPtr; } | RANGETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = RANGE_TYPE; $$ = tempIntPtr; } | INTEGERTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = INTEGER_TYPE; $$ = tempIntPtr; } | STRINGTYPETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = STRING_TYPE; $$ = tempIntPtr; } | BOOLEANTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = BOOLEAN_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN CONSTANTTYPETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = CONSTANT_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN FUNCTIONTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = FUNCTION_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN OBJECTTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = OBJECT_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN RANGETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = RANGE_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN INTEGERTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = INTEGER_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN STRINGTYPETOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = STRING_LIST_TYPE; $$ = tempIntPtr; } | LISTTOKEN OFTOKEN BOOLEANTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = BOOLEAN_LIST_TYPE; $$ = tempIntPtr; } ; extendedexternalproctype: VOIDTOKEN { tempIntPtr = (int *) safeMalloc(sizeof(int)); *tempIntPtr = VOID_TYPE; $$ = tempIntPtr; } | externalproctype { $$ = $1; } ; externalproctypesimplelist: externalproctype { $$ = addElement(NULL, $1); } | externalproctype COMMATOKEN externalproctypesimplelist { $$ = addElement($3, $1); } ; externalproctypelist: extendedexternalproctype { $$ = addElement(NULL, $1); } | LPARTOKEN externalproctypesimplelist RPARTOKEN { $$ = $2; } ; help: CONSTANTTOKEN { outputMode(); sollyaPrintf("\"%s\" is recognized as a base 10 constant.\n",$1); safeFree($1); } | DYADICCONSTANTTOKEN { outputMode(); sollyaPrintf("\"%s\" is recognized as a dyadic number constant.\n",$1); safeFree($1); } | HEXCONSTANTTOKEN { outputMode(); sollyaPrintf("\"%s\" is recognized as a double or single precision constant.\n",$1); safeFree($1); } | HEXADECIMALCONSTANTTOKEN { outputMode(); sollyaPrintf("\"%s\" is recognized as a hexadecimal constant.\n",$1); safeFree($1); } | BINARYCONSTANTTOKEN { outputMode(); sollyaPrintf("\"%s_2\" is recognized as a base 2 constant.\n",$1); safeFree($1); } | PITOKEN { #ifdef HELP_PI_TEXT outputMode(); sollyaPrintf(HELP_PI_TEXT); #else outputMode(); sollyaPrintf("Ratio circonference and diameter of a circle.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PI" #endif #endif } | IDENTIFIERTOKEN { outputMode(); sollyaPrintf("\"%s\" is an identifier.\n",$1); safeFree($1); } | STRINGTOKEN { outputMode(); sollyaPrintf("\"%s\" is a string constant.\n",$1); safeFree($1); } | LPARTOKEN { outputMode(); sollyaPrintf("Left parenthesis.\n"); } | RPARTOKEN { outputMode(); sollyaPrintf("Right parenthesis.\n"); } | LBRACKETTOKEN { outputMode(); sollyaPrintf("Left bracket - indicates a range.\n"); } | RBRACKETTOKEN { outputMode(); sollyaPrintf("Right bracket - indicates a range.\n"); } | LBRACKETTOKEN VERTBARTOKEN { outputMode(); sollyaPrintf("Left bracket-bar - indicates a list.\n"); } | VERTBARTOKEN RBRACKETTOKEN { outputMode(); sollyaPrintf("Bar-right bracket - indicates a list.\n"); } | EQUALTOKEN { #ifdef HELP_ASSIGNMENT_TEXT outputMode(); sollyaPrintf(HELP_ASSIGNMENT_TEXT); #else outputMode(); sollyaPrintf("Assignment operator.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ASSIGNMENT" #endif #endif } | ASSIGNEQUALTOKEN { #ifdef HELP_FLOATASSIGNMENT_TEXT outputMode(); sollyaPrintf(HELP_FLOATASSIGNMENT_TEXT); #else outputMode(); sollyaPrintf("Evaluating assignment operator.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for FLOATASSIGNMENT" #endif #endif } | COMPAREEQUALTOKEN { #ifdef HELP_EQUAL_TEXT outputMode(); sollyaPrintf(HELP_EQUAL_TEXT); #else outputMode(); sollyaPrintf("Equality test.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for EQUAL" #endif #endif } | COMMATOKEN { outputMode(); sollyaPrintf("Separator in lists, ranges or structures.\n"); } | EXCLAMATIONTOKEN { #ifdef HELP_NOT_TEXT outputMode(); sollyaPrintf(HELP_NOT_TEXT); #else outputMode(); sollyaPrintf("Suppresses output on assignments or boolean negation.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for NOT" #endif #endif } | STARLEFTANGLETOKEN { outputMode(); sollyaPrintf("Dereferences range bounds.\n"); } | LEFTANGLETOKEN { #ifdef HELP_LT_TEXT outputMode(); sollyaPrintf(HELP_LT_TEXT); #else outputMode(); sollyaPrintf("Comparison less than.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for LT" #endif #endif } | LEFTANGLETOKEN EQUALTOKEN { #ifdef HELP_LE_TEXT outputMode(); sollyaPrintf(HELP_LE_TEXT); #else outputMode(); sollyaPrintf("Comparison less than or equal to.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for LE" #endif #endif } | RIGHTANGLEUNDERSCORETOKEN { outputMode(); sollyaPrintf("Dereferences the lower range bound.\n"); } | RIGHTANGLEDOTTOKEN { outputMode(); sollyaPrintf("Dereferences the mid-point of a range.\n"); } | RIGHTANGLETOKEN EQUALTOKEN { #ifdef HELP_GE_TEXT outputMode(); sollyaPrintf(HELP_GE_TEXT); #else outputMode(); sollyaPrintf("Comparison greater than or equal to.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for GE" #endif #endif } | DOTTOKEN { outputMode(); sollyaPrintf("Accessing an element in a structured type.\n"); } | RIGHTANGLESTARTOKEN { outputMode(); sollyaPrintf("Dereferences the upper range bound.\n"); } | RIGHTANGLETOKEN { #ifdef HELP_GT_TEXT outputMode(); sollyaPrintf(HELP_GT_TEXT); #else outputMode(); sollyaPrintf("Comparison greater than.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for GT" #endif #endif } | DOTSTOKEN { outputMode(); sollyaPrintf("Ellipsis.\n"); } | QUESTIONMARKTOKEN { outputMode(); sollyaPrintf("Dereferences global environment variables.\n"); } | VERTBARTOKEN { outputMode(); sollyaPrintf("Starts or ends a list.\n"); } | ATTOKEN { #ifdef HELP_CONCAT_TEXT outputMode(); sollyaPrintf(HELP_CONCAT_TEXT); #else outputMode(); sollyaPrintf("Concatenation of lists or strings.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for CONCAT" #endif #endif } | DOUBLECOLONTOKEN { outputMode(); sollyaPrintf("a::b prepends a to list b or appends b to list a, preprending list a to list b if both are lists.\n"); } | DOTCOLONTOKEN { #ifdef HELP_PREPEND_TEXT outputMode(); sollyaPrintf(HELP_PREPEND_TEXT); #else outputMode(); sollyaPrintf("a.:b prepends a to list b.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PREPEND" #endif #endif } | COLONDOTTOKEN { #ifdef HELP_APPEND_TEXT outputMode(); sollyaPrintf(HELP_APPEND_TEXT); #else outputMode(); sollyaPrintf("a:.b appends b to list a.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for APPEND" #endif #endif } | EXCLAMATIONEQUALTOKEN { #ifdef HELP_NEQ_TEXT outputMode(); sollyaPrintf(HELP_NEQ_TEXT); #else outputMode(); sollyaPrintf("Comparison not equal.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for NEQ" #endif #endif } | ANDTOKEN { #ifdef HELP_AND_TEXT outputMode(); sollyaPrintf(HELP_AND_TEXT); #else outputMode(); sollyaPrintf("Boolean and.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for AND" #endif #endif } | ORTOKEN { #ifdef HELP_OR_TEXT outputMode(); sollyaPrintf(HELP_OR_TEXT); #else outputMode(); sollyaPrintf("Boolean or.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for OR" #endif #endif } | PLUSTOKEN { #ifdef HELP_PLUS_TEXT outputMode(); sollyaPrintf(HELP_PLUS_TEXT); #else outputMode(); sollyaPrintf("Addition.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PLUS" #endif #endif } | MINUSTOKEN { #ifdef HELP_MINUS_TEXT outputMode(); sollyaPrintf(HELP_MINUS_TEXT); #else outputMode(); sollyaPrintf("Substraction.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for MINUS" #endif #endif } | APPROXTOKEN { #ifdef HELP_APPROX_TEXT outputMode(); sollyaPrintf(HELP_APPROX_TEXT); #else outputMode(); sollyaPrintf("Floating-point approximation of a constant expression.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for APPROX" #endif #endif } | MULTOKEN { #ifdef HELP_MULT_TEXT outputMode(); sollyaPrintf(HELP_MULT_TEXT); #else outputMode(); sollyaPrintf("Multiplication.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for MULT" #endif #endif } | DIVTOKEN { #ifdef HELP_DIVIDE_TEXT outputMode(); sollyaPrintf(HELP_DIVIDE_TEXT); #else outputMode(); sollyaPrintf("Division.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DIVIDE" #endif #endif } | POWTOKEN { #ifdef HELP_POWER_TEXT outputMode(); sollyaPrintf(HELP_POWER_TEXT); #else outputMode(); sollyaPrintf("Exponentiation.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for POWER" #endif #endif } | SQRTTOKEN { #ifdef HELP_SQRT_TEXT outputMode(); sollyaPrintf(HELP_SQRT_TEXT); #else outputMode(); sollyaPrintf("Square root.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SQRT" #endif #endif } | EXPTOKEN { #ifdef HELP_EXP_TEXT outputMode(); sollyaPrintf(HELP_EXP_TEXT); #else outputMode(); sollyaPrintf("Exponential.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for EXP" #endif #endif } | FREEVARTOKEN { #ifdef HELP_XFREEVARIABLE_TEXT outputMode(); sollyaPrintf(HELP_XFREEVARIABLE_TEXT); #else outputMode(); sollyaPrintf("Reserved default free variable _x_.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for XFREEVARIABLE" #endif #endif } | LOGTOKEN { #ifdef HELP_LOG_TEXT outputMode(); sollyaPrintf(HELP_LOG_TEXT); #else outputMode(); sollyaPrintf("Natural logarithm.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for LOG" #endif #endif } | LOG2TOKEN { #ifdef HELP_LOG2_TEXT outputMode(); sollyaPrintf(HELP_LOG2_TEXT); #else outputMode(); sollyaPrintf("Logarithm in base 2.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for LOG2" #endif #endif } | LOG10TOKEN { #ifdef HELP_LOG10_TEXT outputMode(); sollyaPrintf(HELP_LOG10_TEXT); #else outputMode(); sollyaPrintf("Logarithm in base 10.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for LOG10" #endif #endif } | SINTOKEN { #ifdef HELP_SIN_TEXT outputMode(); sollyaPrintf(HELP_SIN_TEXT); #else outputMode(); sollyaPrintf("Sine.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SIN" #endif #endif } | COSTOKEN { #ifdef HELP_COS_TEXT outputMode(); sollyaPrintf(HELP_COS_TEXT); #else outputMode(); sollyaPrintf("Cosine.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for COS" #endif #endif } | TANTOKEN { #ifdef HELP_TAN_TEXT outputMode(); sollyaPrintf(HELP_TAN_TEXT); #else outputMode(); sollyaPrintf("Tangent.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for TAN" #endif #endif } | ASINTOKEN { #ifdef HELP_ASIN_TEXT outputMode(); sollyaPrintf(HELP_ASIN_TEXT); #else outputMode(); sollyaPrintf("Arcsine.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ASIN" #endif #endif } | ACOSTOKEN { #ifdef HELP_ACOS_TEXT outputMode(); sollyaPrintf(HELP_ACOS_TEXT); #else outputMode(); sollyaPrintf("Arcosine.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ACOS" #endif #endif } | ATANTOKEN { #ifdef HELP_ATAN_TEXT outputMode(); sollyaPrintf(HELP_ATAN_TEXT); #else outputMode(); sollyaPrintf("Arctangent.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ATAN" #endif #endif } | SINHTOKEN { #ifdef HELP_SINH_TEXT outputMode(); sollyaPrintf(HELP_SINH_TEXT); #else outputMode(); sollyaPrintf("Hyperbolic sine.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SINH" #endif #endif } | COSHTOKEN { #ifdef HELP_COSH_TEXT outputMode(); sollyaPrintf(HELP_COSH_TEXT); #else outputMode(); sollyaPrintf("Hyperbolic cosine.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for COSH" #endif #endif } | TANHTOKEN { #ifdef HELP_TANH_TEXT outputMode(); sollyaPrintf(HELP_TANH_TEXT); #else outputMode(); sollyaPrintf("Hyperbolic tangent.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for TANH" #endif #endif } | ASINHTOKEN { #ifdef HELP_ASINH_TEXT outputMode(); sollyaPrintf(HELP_ASINH_TEXT); #else outputMode(); sollyaPrintf("Area sine.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ASINH" #endif #endif } | ACOSHTOKEN { #ifdef HELP_ACOSH_TEXT outputMode(); sollyaPrintf(HELP_ACOSH_TEXT); #else outputMode(); sollyaPrintf("Area cosine.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ACOSH" #endif #endif } | ATANHTOKEN { #ifdef HELP_ATANH_TEXT outputMode(); sollyaPrintf(HELP_ATANH_TEXT); #else outputMode(); sollyaPrintf("Area tangent.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ATANH" #endif #endif } | ABSTOKEN { #ifdef HELP_ABS_TEXT outputMode(); sollyaPrintf(HELP_ABS_TEXT); #else outputMode(); sollyaPrintf("Absolute value.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ABS" #endif #endif } | ERFTOKEN { #ifdef HELP_ERF_TEXT outputMode(); sollyaPrintf(HELP_ERF_TEXT); #else outputMode(); sollyaPrintf("Error function.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ERF" #endif #endif } | ERFCTOKEN { #ifdef HELP_ERFC_TEXT outputMode(); sollyaPrintf(HELP_ERFC_TEXT); #else outputMode(); sollyaPrintf("Complementary error function.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ERFC" #endif #endif } | LOG1PTOKEN { #ifdef HELP_LOG1P_TEXT outputMode(); sollyaPrintf(HELP_LOG1P_TEXT); #else outputMode(); sollyaPrintf("Natural logarithm of 1 plus argument.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for LOG1P" #endif #endif } | EXPM1TOKEN { #ifdef HELP_EXPM1_TEXT outputMode(); sollyaPrintf(HELP_EXPM1_TEXT); #else outputMode(); sollyaPrintf("Exponential of argument minus 1.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for EXPM1" #endif #endif } | DOUBLETOKEN { #ifdef HELP_DOUBLE_TEXT outputMode(); sollyaPrintf(HELP_DOUBLE_TEXT); #else outputMode(); sollyaPrintf("Double precision rounding operator.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DOUBLE" #endif #endif } | SINGLETOKEN { #ifdef HELP_SINGLE_TEXT outputMode(); sollyaPrintf(HELP_SINGLE_TEXT); #else outputMode(); sollyaPrintf("Single precision rounding operator.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SINGLE" #endif #endif } | QUADTOKEN { #ifdef HELP_QUAD_TEXT outputMode(); sollyaPrintf(HELP_QUAD_TEXT); #else outputMode(); sollyaPrintf("Quad precision rounding operator.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for QUAD" #endif #endif } | HALFPRECISIONTOKEN { #ifdef HELP_HALFPRECISION_TEXT outputMode(); sollyaPrintf(HELP_HALFPRECISION_TEXT); #else outputMode(); sollyaPrintf("Half-precision rounding operator.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for HALFPRECISION" #endif #endif } | DOUBLEDOUBLETOKEN { #ifdef HELP_DOUBLEDOUBLE_TEXT outputMode(); sollyaPrintf(HELP_DOUBLEDOUBLE_TEXT); #else outputMode(); sollyaPrintf("Double-double precision rounding operator.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DOUBLEDOUBLE" #endif #endif } | TRIPLEDOUBLETOKEN { #ifdef HELP_TRIPLEDOUBLE_TEXT outputMode(); sollyaPrintf(HELP_TRIPLEDOUBLE_TEXT); #else outputMode(); sollyaPrintf("Triple-double precision rounding operator.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for TRIPLEDOUBLE" #endif #endif } | DOUBLEEXTENDEDTOKEN { #ifdef HELP_DOUBLEEXTENDED_TEXT outputMode(); sollyaPrintf(HELP_DOUBLEEXTENDED_TEXT); #else outputMode(); sollyaPrintf("Double-extended precision rounding operator.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DOUBLEEXTENDED" #endif #endif } | CEILTOKEN { #ifdef HELP_CEIL_TEXT outputMode(); sollyaPrintf(HELP_CEIL_TEXT); #else outputMode(); sollyaPrintf("Ceiling.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for CEIL" #endif #endif } | FLOORTOKEN { #ifdef HELP_FLOOR_TEXT outputMode(); sollyaPrintf(HELP_FLOOR_TEXT); #else outputMode(); sollyaPrintf("Floor.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for FLOOR" #endif #endif } | NEARESTINTTOKEN { #ifdef HELP_NEARESTINT_TEXT outputMode(); sollyaPrintf(HELP_NEARESTINT_TEXT); #else outputMode(); sollyaPrintf("Nearest integer with even tie cases rule.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for NEARESTINT" #endif #endif } | HEADTOKEN { #ifdef HELP_HEAD_TEXT outputMode(); sollyaPrintf(HELP_HEAD_TEXT); #else outputMode(); sollyaPrintf("Head of a list.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for HEAD" #endif #endif } | ROUNDCORRECTLYTOKEN { #ifdef HELP_ROUNDCORRECTLY_TEXT outputMode(); sollyaPrintf(HELP_ROUNDCORRECTLY_TEXT); #else outputMode(); sollyaPrintf("Round a bounding to the nearest floating-point value such that correct rounding is possible.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ROUNDCORRECTLY" #endif #endif } | READFILETOKEN { #ifdef HELP_READFILE_TEXT outputMode(); sollyaPrintf(HELP_READFILE_TEXT); #else outputMode(); sollyaPrintf("Reads a file into a string.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for READFILE" #endif #endif } | REVERTTOKEN { #ifdef HELP_REVERT_TEXT outputMode(); sollyaPrintf(HELP_REVERT_TEXT); #else outputMode(); sollyaPrintf("Reverts a list that is not finally elliptic.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for REVERT" #endif #endif } | SORTTOKEN { #ifdef HELP_SORT_TEXT outputMode(); sollyaPrintf(HELP_SORT_TEXT); #else outputMode(); sollyaPrintf("Sorts a list of constants in ascending order.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SORT" #endif #endif } | TAILTOKEN { #ifdef HELP_TAIL_TEXT outputMode(); sollyaPrintf(HELP_TAIL_TEXT); #else outputMode(); sollyaPrintf("Tail of a list.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for TAIL" #endif #endif } | PRECTOKEN { #ifdef HELP_PREC_TEXT outputMode(); sollyaPrintf(HELP_PREC_TEXT); #else outputMode(); sollyaPrintf("Global environment variable precision.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PREC" #endif #endif } | POINTSTOKEN { #ifdef HELP_POINTS_TEXT outputMode(); sollyaPrintf(HELP_POINTS_TEXT); #else outputMode(); sollyaPrintf("Global environment variable number of points.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for POINTS" #endif #endif } | DIAMTOKEN { #ifdef HELP_DIAM_TEXT outputMode(); sollyaPrintf(HELP_DIAM_TEXT); #else outputMode(); sollyaPrintf("Global environment variable diameter.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DIAM" #endif #endif } | DISPLAYTOKEN { #ifdef HELP_DISPLAY_TEXT outputMode(); sollyaPrintf(HELP_DISPLAY_TEXT); #else outputMode(); sollyaPrintf("Global environment variable display mode.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DISPLAY" #endif #endif } | VERBOSITYTOKEN { #ifdef HELP_VERBOSITY_TEXT outputMode(); sollyaPrintf(HELP_VERBOSITY_TEXT); #else outputMode(); sollyaPrintf("Global environment variable verbosity.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for VERBOSITY" #endif #endif } | SHOWMESSAGENUMBERSTOKEN { #ifdef HELP_SHOWMESSAGENUMBERS_TEXT outputMode(); sollyaPrintf(HELP_SHOWMESSAGENUMBERS_TEXT); #else outputMode(); sollyaPrintf("Global environment variable activating the displaying of message numbers.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SHOWMESSAGENUMBERS" #endif #endif } | CANONICALTOKEN { #ifdef HELP_CANONICAL_TEXT outputMode(); sollyaPrintf(HELP_CANONICAL_TEXT); #else outputMode(); sollyaPrintf("Global environment variable canonical output.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for CANONICAL" #endif #endif } | AUTOSIMPLIFYTOKEN { #ifdef HELP_AUTOSIMPLIFY_TEXT outputMode(); sollyaPrintf(HELP_AUTOSIMPLIFY_TEXT); #else outputMode(); sollyaPrintf("Global environment variable automatic simplification.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for AUTOSIMPLIFY" #endif #endif } | TAYLORRECURSIONSTOKEN { #ifdef HELP_TAYLORRECURSIONS_TEXT outputMode(); sollyaPrintf(HELP_TAYLORRECURSIONS_TEXT); #else outputMode(); sollyaPrintf("Global environment variable recursions of Taylor evaluation.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for TAYLORRECURSIONS" #endif #endif } | TIMINGTOKEN { #ifdef HELP_TIMING_TEXT outputMode(); sollyaPrintf(HELP_TIMING_TEXT); #else outputMode(); sollyaPrintf("Global environment variable timing of computations.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for TIMING" #endif #endif } | TIMETOKEN { #ifdef HELP_TIME_TEXT outputMode(); sollyaPrintf(HELP_TIME_TEXT); #else outputMode(); sollyaPrintf("High-level time procedure.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for TIME" #endif #endif } | FULLPARENTHESESTOKEN { #ifdef HELP_FULLPARENTHESES_TEXT outputMode(); sollyaPrintf(HELP_FULLPARENTHESES_TEXT); #else outputMode(); sollyaPrintf("Global environment variable fully parenthized mode.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for FULLPARENTHESES" #endif #endif } | MIDPOINTMODETOKEN { #ifdef HELP_MIDPOINTMODE_TEXT outputMode(); sollyaPrintf(HELP_MIDPOINTMODE_TEXT); #else outputMode(); sollyaPrintf("Global environment variable midpoint mode.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for MIDPOINTMODE" #endif #endif } | DIEONERRORMODETOKEN { #ifdef HELP_DIEONERRORMODE_TEXT outputMode(); sollyaPrintf(HELP_DIEONERRORMODE_TEXT); #else outputMode(); sollyaPrintf("Global environment variable for die-on-error mode.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DIEONERRORMODE" #endif #endif } | RATIONALMODETOKEN { #ifdef HELP_RATIONALMODE_TEXT outputMode(); sollyaPrintf(HELP_RATIONALMODE_TEXT); #else outputMode(); sollyaPrintf("Global environment variable rational mode.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for RATIONALMODE" #endif #endif } | SUPPRESSWARNINGSTOKEN { #ifdef HELP_ROUNDINGWARNINGS_TEXT outputMode(); sollyaPrintf(HELP_ROUNDINGWARNINGS_TEXT); #else outputMode(); sollyaPrintf("Global environment variable activating warnings about rounding.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ROUNDINGWARNINGS" #endif #endif } | HOPITALRECURSIONSTOKEN { #ifdef HELP_HOPITALRECURSIONS_TEXT outputMode(); sollyaPrintf(HELP_HOPITALRECURSIONS_TEXT); #else outputMode(); sollyaPrintf("Global environment variable recursions of Hopital evaluation.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for HOPITALRECURSIONS" #endif #endif } | ONTOKEN { #ifdef HELP_ON_TEXT outputMode(); sollyaPrintf(HELP_ON_TEXT); #else outputMode(); sollyaPrintf("Something is switched on.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ON" #endif #endif } | OFFTOKEN { #ifdef HELP_OFF_TEXT outputMode(); sollyaPrintf(HELP_OFF_TEXT); #else outputMode(); sollyaPrintf("Something is switched off.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for OFF" #endif #endif } | DYADICTOKEN { #ifdef HELP_DYADIC_TEXT outputMode(); sollyaPrintf(HELP_DYADIC_TEXT); #else outputMode(); sollyaPrintf("Display mode is dyadic output.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DYADIC" #endif #endif } | POWERSTOKEN { #ifdef HELP_POWERS_TEXT outputMode(); sollyaPrintf(HELP_POWERS_TEXT); #else outputMode(); sollyaPrintf("Display mode is dyadic output with powers.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for POWERS" #endif #endif } | BINARYTOKEN { #ifdef HELP_BINARY_TEXT outputMode(); sollyaPrintf(HELP_BINARY_TEXT); #else outputMode(); sollyaPrintf("Display mode is binary.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for BINARY" #endif #endif } | HEXADECIMALTOKEN { #ifdef HELP_HEXADECIMAL_TEXT outputMode(); sollyaPrintf(HELP_HEXADECIMAL_TEXT); #else outputMode(); sollyaPrintf("Display mode is hexadecimal.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for HEXADECIMAL" #endif #endif } | FILETOKEN { #ifdef HELP_FILE_TEXT outputMode(); sollyaPrintf(HELP_FILE_TEXT); #else outputMode(); sollyaPrintf("A file will be specified.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for FILE" #endif #endif } | POSTSCRIPTTOKEN { #ifdef HELP_POSTSCRIPT_TEXT outputMode(); sollyaPrintf(HELP_POSTSCRIPT_TEXT); #else outputMode(); sollyaPrintf("A postscript file will be specified.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for POSTSCRIPT" #endif #endif } | POSTSCRIPTFILETOKEN { #ifdef HELP_POSTSCRIPTFILE_TEXT outputMode(); sollyaPrintf(HELP_POSTSCRIPTFILE_TEXT); #else outputMode(); sollyaPrintf("A postscript file and a file will be specified.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for POSTSCRIPTFILE" #endif #endif } | PERTURBTOKEN { #ifdef HELP_PERTURB_TEXT outputMode(); sollyaPrintf(HELP_PERTURB_TEXT); #else outputMode(); sollyaPrintf("Perturbation is demanded.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PERTURB" #endif #endif } | MINUSWORDTOKEN { #ifdef HELP_RD_TEXT outputMode(); sollyaPrintf(HELP_RD_TEXT); #else outputMode(); sollyaPrintf("Round towards minus infinity.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for RD" #endif #endif } | PLUSWORDTOKEN { #ifdef HELP_RU_TEXT outputMode(); sollyaPrintf(HELP_RU_TEXT); #else outputMode(); sollyaPrintf("Round towards plus infinity.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for RU" #endif #endif } | ZEROWORDTOKEN { #ifdef HELP_RZ_TEXT outputMode(); sollyaPrintf(HELP_RZ_TEXT); #else outputMode(); sollyaPrintf("Round towards zero.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for RZ" #endif #endif } | NEARESTTOKEN { #ifdef HELP_RN_TEXT outputMode(); sollyaPrintf(HELP_RN_TEXT); #else outputMode(); sollyaPrintf("Round to nearest.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for RN" #endif #endif } | HONORCOEFFPRECTOKEN { #ifdef HELP_HONORCOEFFPREC_TEXT outputMode(); sollyaPrintf(HELP_HONORCOEFFPREC_TEXT); #else outputMode(); sollyaPrintf("Honorate the precision of the coefficients.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for HONORCOEFFPREC" #endif #endif } | TRUETOKEN { #ifdef HELP_TRUE_TEXT outputMode(); sollyaPrintf(HELP_TRUE_TEXT); #else outputMode(); sollyaPrintf("Boolean constant true.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for TRUE" #endif #endif } | FALSETOKEN { #ifdef HELP_FALSE_TEXT outputMode(); sollyaPrintf(HELP_FALSE_TEXT); #else outputMode(); sollyaPrintf("Boolean constant false.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for FALSE" #endif #endif } | DEFAULTTOKEN { #ifdef HELP_DEFAULT_TEXT outputMode(); sollyaPrintf(HELP_DEFAULT_TEXT); #else outputMode(); sollyaPrintf("Default value.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DEFAULT" #endif #endif } | MATCHTOKEN { #ifdef HELP_MATCH_TEXT outputMode(); sollyaPrintf(HELP_MATCH_TEXT); #else outputMode(); sollyaPrintf("match ... with ... construct.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for MATCH" #endif #endif } | WITHTOKEN { #ifdef HELP_WITH_TEXT outputMode(); sollyaPrintf(HELP_WITH_TEXT); #else outputMode(); sollyaPrintf("match ... with ... construct.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for WITH" #endif #endif } | ABSOLUTETOKEN { #ifdef HELP_ABSOLUTE_TEXT outputMode(); sollyaPrintf(HELP_ABSOLUTE_TEXT); #else outputMode(); sollyaPrintf("Consider an absolute error.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ABSOLUTE" #endif #endif } | DECIMALTOKEN { #ifdef HELP_DECIMAL_TEXT outputMode(); sollyaPrintf(HELP_DECIMAL_TEXT); #else outputMode(); sollyaPrintf("Display mode is decimal.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DECIMAL" #endif #endif } | RELATIVETOKEN { #ifdef HELP_RELATIVE_TEXT outputMode(); sollyaPrintf(HELP_RELATIVE_TEXT); #else outputMode(); sollyaPrintf("Consider a relative error.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for RELATIVE" #endif #endif } | FIXEDTOKEN { #ifdef HELP_FIXED_TEXT outputMode(); sollyaPrintf(HELP_FIXED_TEXT); #else outputMode(); sollyaPrintf("Consider fixed-point numbers.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for FIXED" #endif #endif } | FLOATINGTOKEN { #ifdef HELP_FLOATING_TEXT outputMode(); sollyaPrintf(HELP_FLOATING_TEXT); #else outputMode(); sollyaPrintf("Consider floating-point numbers.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for FLOATING" #endif #endif } | ERRORTOKEN { #ifdef HELP_ERROR_TEXT outputMode(); sollyaPrintf(HELP_ERROR_TEXT); #else outputMode(); sollyaPrintf("Type error meta-value.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ERROR" #endif #endif } | QUITTOKEN { #ifdef HELP_QUIT_TEXT outputMode(); sollyaPrintf(HELP_QUIT_TEXT); #else outputMode(); sollyaPrintf("Exit from the tool.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for QUIT" #endif #endif } | FALSEQUITTOKEN { #ifdef HELP_QUIT_TEXT outputMode(); sollyaPrintf(HELP_QUIT_TEXT); #else outputMode(); sollyaPrintf("Exit from the tool - help is called inside a read macro.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for QUIT" #endif #endif } | RESTARTTOKEN { #ifdef HELP_RESTART_TEXT outputMode(); sollyaPrintf(HELP_RESTART_TEXT); #else outputMode(); sollyaPrintf("Restart the tool.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for RESTART" #endif #endif } | LIBRARYTOKEN { #ifdef HELP_LIBRARY_TEXT outputMode(); sollyaPrintf(HELP_LIBRARY_TEXT); #else outputMode(); sollyaPrintf("Library binding dereferencer.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for LIBRARY" #endif #endif } | LIBRARYCONSTANTTOKEN { #ifdef HELP_LIBRARYCONSTANT_TEXT outputMode(); sollyaPrintf(HELP_LIBRARYCONSTANT_TEXT); #else outputMode(); sollyaPrintf("Library constant binding dereferencer.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for LIBRARYCONSTANT" #endif #endif } | DIFFTOKEN { #ifdef HELP_DIFF_TEXT outputMode(); sollyaPrintf(HELP_DIFF_TEXT); #else outputMode(); sollyaPrintf("Differentiation: diff(func).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DIFF" #endif #endif } | BASHEVALUATETOKEN { #ifdef HELP_BASHEVALUATE_TEXT outputMode(); sollyaPrintf(HELP_BASHEVALUATE_TEXT); #else outputMode(); sollyaPrintf("Executes a string as a bash command and returns the output as a string.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for BASHEVALUATE" #endif #endif } | GETSUPPRESSEDMESSAGESTOKEN { #ifdef HELP_GETSUPPRESSEDMESSAGES_TEXT outputMode(); sollyaPrintf(HELP_GETSUPPRESSEDMESSAGES_TEXT); #else outputMode(); sollyaPrintf("Get a list of message numbers that have been suppressed.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for GETSUPPRESSEDMESSAGES" #endif #endif } | GETBACKTRACETOKEN { #ifdef HELP_GETBACKTRACE_TEXT outputMode(); sollyaPrintf(HELP_GETBACKTRACE_TEXT); #else outputMode(); sollyaPrintf("Get a backtrace of the procedure calling stack.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for GETBACKTRACE" #endif #endif } | DIRTYSIMPLIFYTOKEN { #ifdef HELP_DIRTYSIMPLIFY_TEXT outputMode(); sollyaPrintf(HELP_DIRTYSIMPLIFY_TEXT); #else outputMode(); sollyaPrintf("Simplify with floating-point evaluation: dirtysimplify(func).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DIRTYSIMPLIFY" #endif #endif } | REMEZTOKEN { #ifdef HELP_REMEZ_TEXT outputMode(); sollyaPrintf(HELP_REMEZ_TEXT); #else outputMode(); sollyaPrintf("Remez: remez(func,degree|monoms,range[,weight[,quality]]).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for REMEZ" #endif #endif } | ANNOTATEFUNCTIONTOKEN { #ifdef HELP_ANNOTATEFUNCTION_TEXT outputMode(); sollyaPrintf(HELP_ANNOTATEFUNCTION_TEXT); #else outputMode(); sollyaPrintf("Function annotation: annotatefunction(f,p,dom,delta[,t]).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ANNOTATEFUNCTION" #endif #endif } | MINTOKEN { #ifdef HELP_MIN_TEXT outputMode(); sollyaPrintf(HELP_MIN_TEXT); #else outputMode(); sollyaPrintf("min(val1,val2,...,valn): computes the minimum of the constant expressions vali.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for MIN" #endif #endif } | MAXTOKEN { #ifdef HELP_MAX_TEXT outputMode(); sollyaPrintf(HELP_MAX_TEXT); #else outputMode(); sollyaPrintf("max(val1,val2,...,valn): computes the maximum of the constant expressions vali.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for MAX" #endif #endif } | FPMINIMAXTOKEN { #ifdef HELP_FPMINIMAX_TEXT outputMode(); sollyaPrintf(HELP_FPMINIMAX_TEXT); #else outputMode(); sollyaPrintf("Fpminimax: fpminimax(func,degree|monoms,formats,range|pointslist[,absolute|relative[,fixed|floating[,constrainedPart[, minimaxpoly]]]]).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for FPMINIMAX" #endif #endif } | HORNERTOKEN { #ifdef HELP_HORNER_TEXT outputMode(); sollyaPrintf(HELP_HORNER_TEXT); #else outputMode(); sollyaPrintf("Horner: horner(func)\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for HORNER" #endif #endif } | EXPANDTOKEN { #ifdef HELP_EXPAND_TEXT outputMode(); sollyaPrintf(HELP_EXPAND_TEXT); #else outputMode(); sollyaPrintf("Expand: expand(func).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for EXPAND" #endif #endif } | SIMPLIFYSAFETOKEN { #ifdef HELP_SIMPLIFY_TEXT outputMode(); sollyaPrintf(HELP_SIMPLIFY_TEXT); #else outputMode(); sollyaPrintf("Simplification without rounding error: simplify(func).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SIMPLIFY" #endif #endif } | TAYLORTOKEN { #ifdef HELP_TAYLOR_TEXT outputMode(); sollyaPrintf(HELP_TAYLOR_TEXT); #else outputMode(); sollyaPrintf("Taylor expansion: taylor(func,degree,point).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for TAYLOR" #endif #endif } | TAYLORFORMTOKEN { #ifdef HELP_TAYLORFORM_TEXT outputMode(); sollyaPrintf(HELP_TAYLORFORM_TEXT); #else outputMode(); sollyaPrintf("Taylor form computation.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for TAYLORFORM" #endif #endif } | CHEBYSHEVFORMTOKEN { #ifdef HELP_CHEBYSHEVFORM_TEXT outputMode(); sollyaPrintf(HELP_CHEBYSHEVFORM_TEXT); #else outputMode(); sollyaPrintf("Chebyshev form computation.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for CHEBYSHEVFORM" #endif #endif } | AUTODIFFTOKEN { #ifdef HELP_AUTODIFF_TEXT outputMode(); sollyaPrintf(HELP_AUTODIFF_TEXT); #else outputMode(); sollyaPrintf("Automatic differentiation.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for AUTODIFF" #endif #endif } | DEGREETOKEN { #ifdef HELP_DEGREE_TEXT outputMode(); sollyaPrintf(HELP_DEGREE_TEXT); #else outputMode(); sollyaPrintf("Degree of a polynomial: degree(func).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DEGREE" #endif #endif } | NUMERATORTOKEN { #ifdef HELP_NUMERATOR_TEXT outputMode(); sollyaPrintf(HELP_NUMERATOR_TEXT); #else outputMode(); sollyaPrintf("Numerator of an expression: numerator(func).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for NUMERATOR" #endif #endif } | DENOMINATORTOKEN { #ifdef HELP_DENOMINATOR_TEXT outputMode(); sollyaPrintf(HELP_DENOMINATOR_TEXT); #else outputMode(); sollyaPrintf("Denominator of an expression: denominator(func).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DENOMINATOR" #endif #endif } | SUBSTITUTETOKEN { #ifdef HELP_SUBSTITUTE_TEXT outputMode(); sollyaPrintf(HELP_SUBSTITUTE_TEXT); #else outputMode(); sollyaPrintf("Substitute func2 for free variable in func: substitute(func,func2).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SUBSTITUTE" #endif #endif } | COMPOSEPOLYNOMIALSTOKEN { #ifdef HELP_COMPOSEPOLYNOMIALS_TEXT outputMode(); sollyaPrintf(HELP_COMPOSEPOLYNOMIALS_TEXT); #else outputMode(); sollyaPrintf("Compose two polynomials p and q and round coefficients of p(q).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for COMPOSEPOLYNOMIALS" #endif #endif } | COEFFTOKEN { #ifdef HELP_COEFF_TEXT outputMode(); sollyaPrintf(HELP_COEFF_TEXT); #else outputMode(); sollyaPrintf("i-th coefficient of a polynomial: coeff(func,degree).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for COEFF" #endif #endif } | SUBPOLYTOKEN { #ifdef HELP_SUBPOLY_TEXT outputMode(); sollyaPrintf(HELP_SUBPOLY_TEXT); #else outputMode(); sollyaPrintf("Subpolynomial consisting in monomials: subpoly(func,list of degrees).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SUBPOLY" #endif #endif } | ROUNDCOEFFICIENTSTOKEN { #ifdef HELP_ROUNDCOEFFICIENTS_TEXT outputMode(); sollyaPrintf(HELP_ROUNDCOEFFICIENTS_TEXT); #else outputMode(); sollyaPrintf("Round coefficients of a polynomial to format: roundcoefficients(func,list of formats).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ROUNDCOEFFICIENTS" #endif #endif } | RATIONALAPPROXTOKEN { #ifdef HELP_RATIONALAPPROX_TEXT outputMode(); sollyaPrintf(HELP_RATIONALAPPROX_TEXT); #else outputMode(); sollyaPrintf("Rational approximation: rationalapprox(constant).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for RATIONALAPPROX" #endif #endif } | ACCURATEINFNORMTOKEN { #ifdef HELP_ACCURATEINFNORM_TEXT outputMode(); sollyaPrintf(HELP_ACCURATEINFNORM_TEXT); #else outputMode(); sollyaPrintf("Faithful rounded infinity norm: accurateinfnorm(func,bits,range,domains to exclude).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ACCURATEINFNORM" #endif #endif } | ROUNDTOFORMATTOKEN { #ifdef HELP_ROUND_TEXT outputMode(); sollyaPrintf(HELP_ROUND_TEXT); #else outputMode(); sollyaPrintf("Round to a given format: round(constant,precision,rounding mode).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ROUND" #endif #endif } | EVALUATETOKEN { #ifdef HELP_EVALUATE_TEXT outputMode(); sollyaPrintf(HELP_EVALUATE_TEXT); #else outputMode(); sollyaPrintf("Evaluate a function in a point or interval: round(func,constant|range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for EVALUATE" #endif #endif } | LENGTHTOKEN { #ifdef HELP_LENGTH_TEXT outputMode(); sollyaPrintf(HELP_LENGTH_TEXT); #else outputMode(); sollyaPrintf("Length of a list: length(list).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for LENGTH" #endif #endif } | OBJECTNAMETOKEN { #ifdef HELP_OBJECTNAME_TEXT outputMode(); sollyaPrintf(HELP_OBJECTNAME_TEXT); #else outputMode(); sollyaPrintf("Name of an object: objectname(obj).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for OBJECTNAME" #endif #endif } | PARSETOKEN { #ifdef HELP_PARSE_TEXT outputMode(); sollyaPrintf(HELP_PARSE_TEXT); #else outputMode(); sollyaPrintf("Parse a string to function: parse(string).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PARSE" #endif #endif } | PRINTTOKEN { #ifdef HELP_PRINT_TEXT outputMode(); sollyaPrintf(HELP_PRINT_TEXT); #else outputMode(); sollyaPrintf("Print something: print(thing1, thing2, ...).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PRINT" #endif #endif } | PRINTXMLTOKEN { #ifdef HELP_PRINTXML_TEXT outputMode(); sollyaPrintf(HELP_PRINTXML_TEXT); #else outputMode(); sollyaPrintf("Print a function in XML: printxml(func).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PRINTXML" #endif #endif } | READXMLTOKEN { #ifdef HELP_READXML_TEXT outputMode(); sollyaPrintf(HELP_READXML_TEXT); #else outputMode(); sollyaPrintf("Reads a function in XML: readxml(filename).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for READXML" #endif #endif } | PLOTTOKEN { #ifdef HELP_PLOT_TEXT outputMode(); sollyaPrintf(HELP_PLOT_TEXT); #else outputMode(); sollyaPrintf("Plot (a) function(s) in a range: plot(func,func2,...,range).\n"); outputMode(); sollyaPrintf("There are further options.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PLOT" #endif #endif } | PRINTHEXATOKEN { #ifdef HELP_PRINTHEXA_TEXT outputMode(); sollyaPrintf(HELP_PRINTHEXA_TEXT); #else outputMode(); sollyaPrintf("Print a constant in hexadecimal: printhexa(constant).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PRINTHEXA" #endif #endif } | PRINTFLOATTOKEN { #ifdef HELP_PRINTFLOAT_TEXT outputMode(); sollyaPrintf(HELP_PRINTFLOAT_TEXT); #else outputMode(); sollyaPrintf("Print a constant in hexadecimal simple precision: printfloat(constant).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PRINTFLOAT" #endif #endif } | PRINTBINARYTOKEN { #ifdef HELP_PRINTBINARY_TEXT outputMode(); sollyaPrintf(HELP_PRINTBINARY_TEXT); #else outputMode(); sollyaPrintf("Print a constant in binary: printbinary(constant).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PRINTBINARY" #endif #endif } | SUPPRESSMESSAGETOKEN { #ifdef HELP_SUPPRESSMESSAGE_TEXT outputMode(); sollyaPrintf(HELP_SUPPRESSMESSAGE_TEXT); #else outputMode(); sollyaPrintf("Suppress a message with a certain message number.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SUPPRESSMESSAGE" #endif #endif } | UNSUPPRESSMESSAGETOKEN { #ifdef HELP_UNSUPPRESSMESSAGE_TEXT outputMode(); sollyaPrintf(HELP_UNSUPPRESSMESSAGE_TEXT); #else outputMode(); sollyaPrintf("Unsuppress a message with a certain message number.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for UNSUPPRESSMESSAGE" #endif #endif } | PRINTEXPANSIONTOKEN { #ifdef HELP_PRINTEXPANSION_TEXT outputMode(); sollyaPrintf(HELP_PRINTEXPANSION_TEXT); #else outputMode(); sollyaPrintf("Print a polynomial as an expansion of double precision numbers: printexpansion(func).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PRINTEXPANSION" #endif #endif } | BASHEXECUTETOKEN { #ifdef HELP_BASHEXECUTE_TEXT outputMode(); sollyaPrintf(HELP_BASHEXECUTE_TEXT); #else outputMode(); sollyaPrintf("Execute a command in a shell: bashexecute(string).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for BASHEXECUTE" #endif #endif } | EXTERNALPLOTTOKEN { #ifdef HELP_EXTERNALPLOT_TEXT outputMode(); sollyaPrintf(HELP_EXTERNALPLOT_TEXT); #else outputMode(); sollyaPrintf("Here should be some help text.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for EXTERNALPLOT" #endif #endif } | WRITETOKEN { #ifdef HELP_WRITE_TEXT outputMode(); sollyaPrintf(HELP_WRITE_TEXT); #else outputMode(); sollyaPrintf("Write something without adding spaces and newlines: write(thing1, thing2, ...).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for WRITE" #endif #endif } | ASCIIPLOTTOKEN { #ifdef HELP_ASCIIPLOT_TEXT outputMode(); sollyaPrintf(HELP_ASCIIPLOT_TEXT); #else outputMode(); sollyaPrintf("Plot a function in a range using an ASCII terminal: asciiplot(func,range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ASCIIPLOT" #endif #endif } | RENAMETOKEN { #ifdef HELP_RENAME_TEXT outputMode(); sollyaPrintf(HELP_RENAME_TEXT); #else outputMode(); sollyaPrintf("Rename free variable string1 to string2: rename(string1, string2).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for RENAME" #endif #endif } | BINDTOKEN { #ifdef HELP_BIND_TEXT outputMode(); sollyaPrintf(HELP_BIND_TEXT); #else outputMode(); sollyaPrintf("bind(p,ident,term): bind argument ident of procedure p to term, returning a procedure with one argument less.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for BIND" #endif #endif } | INFNORMTOKEN { #ifdef HELP_INFNORM_TEXT outputMode(); sollyaPrintf(HELP_INFNORM_TEXT); #else outputMode(); sollyaPrintf("Certified infinity norm: infnorm(func,range[,prooffile[,list of funcs]]).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for INFNORM" #endif #endif } | SUPNORMTOKEN { #ifdef HELP_SUPNORM_TEXT outputMode(); sollyaPrintf(HELP_SUPNORM_TEXT); #else outputMode(); sollyaPrintf("Validated supremum norm: supnorm(poly,func,range,mode,accuracy).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SUPNORM" #endif #endif } | FINDZEROSTOKEN { #ifdef HELP_FINDZEROS_TEXT outputMode(); sollyaPrintf(HELP_FINDZEROS_TEXT); #else outputMode(); sollyaPrintf("Certified bounding of zeros: findzeros(func,range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for FINDZEROS" #endif #endif } | FPFINDZEROSTOKEN { #ifdef HELP_FPFINDZEROS_TEXT outputMode(); sollyaPrintf(HELP_FPFINDZEROS_TEXT); #else outputMode(); sollyaPrintf("Approximate zeros of a function: fpfindzeros(func,range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for FPFINDZEROS" #endif #endif } | DIRTYINFNORMTOKEN { #ifdef HELP_DIRTYINFNORM_TEXT outputMode(); sollyaPrintf(HELP_DIRTYINFNORM_TEXT); #else outputMode(); sollyaPrintf("Floating-point infinity norm: dirtyinfnorm(func,range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DIRTYINFNORM" #endif #endif } | NUMBERROOTSTOKEN { #ifdef HELP_NUMBERROOTS_TEXT outputMode(); sollyaPrintf(HELP_NUMBERROOTS_TEXT); #else outputMode(); sollyaPrintf("Computes the number of real roots of a polynomial on a domain.\n"); #endif } | INTEGRALTOKEN { #ifdef HELP_INTEGRAL_TEXT outputMode(); sollyaPrintf(HELP_INTEGRAL_TEXT); #else outputMode(); sollyaPrintf("Certified integral: integral(func,range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for INTEGRAL" #endif #endif } | DIRTYINTEGRALTOKEN { #ifdef HELP_DIRTYINTEGRAL_TEXT outputMode(); sollyaPrintf(HELP_DIRTYINTEGRAL_TEXT); #else outputMode(); sollyaPrintf("Floating-point integral: dirtyintegral(func,range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DIRTYINTEGRAL" #endif #endif } | WORSTCASETOKEN { #ifdef HELP_WORSTCASE_TEXT outputMode(); sollyaPrintf(HELP_WORSTCASE_TEXT); #else outputMode(); sollyaPrintf("Print all worst-cases under a certain bound: worstcase(func,constant,range,constant,constant[,file]).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for WORSTCASE" #endif #endif } | IMPLEMENTPOLYTOKEN { #ifdef HELP_IMPLEMENTPOLY_TEXT outputMode(); sollyaPrintf(HELP_IMPLEMENTPOLY_TEXT); #else outputMode(); sollyaPrintf("Implement a polynomial in C: implementpoly(func,range,constant,format,string,string2[,honorcoeffprec[,string3]]).\n"); outputMode(); sollyaPrintf("Implements func in range with error constant with entering format named in function\nstring writing to file string2 honoring the precision of the coefficients or not with a proof in file string3.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for IMPLEMENTPOLY" #endif #endif } | IMPLEMENTCONSTTOKEN { #ifdef HELP_IMPLEMENTCONSTANT_TEXT outputMode(); sollyaPrintf(HELP_IMPLEMENTCONSTANT_TEXT); #else outputMode(); sollyaPrintf("Implement a constant expression in arbitrary precision with MPFR: implementconstant(constant)\n"); outputMode(); sollyaPrintf("Generates code able to evaluate the given constant at any precision, with a guaranteed error.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for IMPLEMENTCONST" #endif #endif } | CHECKINFNORMTOKEN { #ifdef HELP_CHECKINFNORM_TEXT outputMode(); sollyaPrintf(HELP_CHECKINFNORM_TEXT); #else outputMode(); sollyaPrintf("Checks whether an infinity norm is bounded: checkinfnorm(func,range,constant).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for CHECKINFNORM" #endif #endif } | ZERODENOMINATORSTOKEN { #ifdef HELP_ZERODENOMINATORS_TEXT outputMode(); sollyaPrintf(HELP_ZERODENOMINATORS_TEXT); #else outputMode(); sollyaPrintf("Searches floating-point approximations to zeros of denominators: zerodenominators(func,range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ZERODENOMINATORS" #endif #endif } | ISEVALUABLETOKEN { #ifdef HELP_ISEVALUABLE_TEXT outputMode(); sollyaPrintf(HELP_ISEVALUABLE_TEXT); #else outputMode(); sollyaPrintf("Tests if func is evaluable on range: isevaluable(func,range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ISEVALUABLE" #endif #endif } | SEARCHGALTOKEN { #ifdef HELP_SEARCHGAL_TEXT outputMode(); sollyaPrintf(HELP_SEARCHGAL_TEXT); #else outputMode(); sollyaPrintf("Searches Gal values for func (or list of func): searchgal(func|list of func, constant, integer, integer, format|list of formats, constant|list of constants).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SEARCHGAL" #endif #endif } | GUESSDEGREETOKEN { #ifdef HELP_GUESSDEGREE_TEXT outputMode(); sollyaPrintf(HELP_GUESSDEGREE_TEXT); #else outputMode(); sollyaPrintf("Guesses the degree needed for approximating func: guessdegree(func,range,constant[,weight]).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for GUESSDEGREE" #endif #endif } | DIRTYFINDZEROSTOKEN { #ifdef HELP_DIRTYFINDZEROS_TEXT outputMode(); sollyaPrintf(HELP_DIRTYFINDZEROS_TEXT); #else outputMode(); sollyaPrintf("Finds zeros of a function dirtily: dirtyfindzeros(func,range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for DIRTYFINDZEROS" #endif #endif } | IFTOKEN { outputMode(); sollyaPrintf("If construct: if condition then command or if condition then command else command.\n"); } | THENTOKEN { outputMode(); sollyaPrintf("If construct: if condition then command or if condition then command else command.\n"); } | ELSETOKEN { outputMode(); sollyaPrintf("If construct: if condition then command else command\n"); } | FORTOKEN { outputMode(); sollyaPrintf("For construct: for i from const to const2 [by const3] do command\nor for i in list do command.\n"); } | INTOKEN { #ifdef HELP_IN_TEXT outputMode(); sollyaPrintf(HELP_IN_TEXT); #else outputMode(); sollyaPrintf("In construct: for in construct and containment operator.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for IN" #endif #endif } | FROMTOKEN { outputMode(); sollyaPrintf("For construct: for i from const to const2 [by const3] do command.\n"); } | TOTOKEN { outputMode(); sollyaPrintf("For construct: for i from const to const2 [by const3] do command.\n"); } | BYTOKEN { outputMode(); sollyaPrintf("For construct: for i from const to const2 by const3 do command.\n"); } | DOTOKEN { outputMode(); sollyaPrintf("For construct: for i from const to const2 [by const3] do command.\n"); outputMode(); sollyaPrintf("While construct: while condition do command.\n"); } | beginsymbol { outputMode(); sollyaPrintf("Begin-end construct: begin command; command; ... end.\n"); } | endsymbol { outputMode(); sollyaPrintf("Begin-end construct: begin command; command; ... end.\n"); } | WHILETOKEN { outputMode(); sollyaPrintf("While construct: while condition do command.\n"); } | INFTOKEN { #ifdef HELP_INF_TEXT outputMode(); sollyaPrintf(HELP_INF_TEXT); #else outputMode(); sollyaPrintf("Dereferencing the infimum of a range: inf(range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for INF" #endif #endif } | MIDTOKEN { #ifdef HELP_MID_TEXT outputMode(); sollyaPrintf(HELP_MID_TEXT); #else outputMode(); sollyaPrintf("Dereferencing the midpoint of a range: mid(range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for MID" #endif #endif } | SUPTOKEN { #ifdef HELP_SUP_TEXT outputMode(); sollyaPrintf(HELP_SUP_TEXT); #else outputMode(); sollyaPrintf("Dereferencing the supremum of a range: sup(range).\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for SUP" #endif #endif } | EXPONENTTOKEN { #ifdef HELP_EXPONENT_TEXT outputMode(); sollyaPrintf(HELP_EXPONENT_TEXT); #else outputMode(); sollyaPrintf("exponent(constant): returns an integer such that constant scaled by the power of 2\nof this integer is an odd or zero integer.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for EXPONENT" #endif #endif } | MANTISSATOKEN { #ifdef HELP_MANTISSA_TEXT outputMode(); sollyaPrintf(HELP_MANTISSA_TEXT); #else outputMode(); sollyaPrintf("mantissa(constant): returns an odd or zero integer equal to constant scaled by an integer power of 2.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for MANTISSA" #endif #endif } | PRECISIONTOKEN { #ifdef HELP_PRECISION_TEXT outputMode(); sollyaPrintf(HELP_PRECISION_TEXT); #else outputMode(); sollyaPrintf("precision(constant): returns the least number of bits constant can be written on.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PRECISION" #endif #endif } | EXECUTETOKEN { #ifdef HELP_EXECUTE_TEXT outputMode(); sollyaPrintf(HELP_EXECUTE_TEXT); #else outputMode(); sollyaPrintf("execute(string): executes an %s script contained in a file named string.\n",PACKAGE_NAME); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for EXECUTE" #endif #endif } | ISBOUNDTOKEN { #ifdef HELP_ISBOUND_TEXT outputMode(); sollyaPrintf(HELP_ISBOUND_TEXT); #else outputMode(); sollyaPrintf("isbound(identifier): returns a boolean indicating if identifier is bound.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for ISBOUND" #endif #endif } | VERSIONTOKEN { outputMode(); sollyaPrintf("Prints the version of the software.\n"); } | EXTERNALPROCTOKEN { #ifdef HELP_EXTERNALPROC_TEXT outputMode(); sollyaPrintf(HELP_EXTERNALPROC_TEXT); #else outputMode(); sollyaPrintf("externalplot(identifier, file, argumentypes -> resulttype): binds identifier to an external procedure with signature argumenttypes -> resulttype in file.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for EXTERNALPROC" #endif #endif } | VOIDTOKEN { #ifdef HELP_VOID_TEXT outputMode(); sollyaPrintf(HELP_VOID_TEXT); #else outputMode(); sollyaPrintf("Represents the void type for externalproc.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for VOID" #endif #endif } | CONSTANTTYPETOKEN { #ifdef HELP_CONSTANT_TEXT outputMode(); sollyaPrintf(HELP_CONSTANT_TEXT); #else outputMode(); sollyaPrintf("Represents the constant type for externalproc.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for CONSTANT" #endif #endif } | FUNCTIONTOKEN { #ifdef HELP_FUNCTION_TEXT outputMode(); sollyaPrintf(HELP_FUNCTION_TEXT); #else outputMode(); sollyaPrintf("Represents the function type for externalproc or a procedure-based function.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for FUNCTION" #endif #endif } | OBJECTTOKEN { #ifdef HELP_OBJECT_TEXT outputMode(); sollyaPrintf(HELP_OBJECT_TEXT); #else outputMode(); sollyaPrintf("Represents the object type for externalproc.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for OBJECT" #endif #endif } | RANGETOKEN { #ifdef HELP_RANGE_TEXT outputMode(); sollyaPrintf(HELP_RANGE_TEXT); #else outputMode(); sollyaPrintf("Represents the range type for externalproc.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for RANGE" #endif #endif } | INTEGERTOKEN { #ifdef HELP_INTEGER_TEXT outputMode(); sollyaPrintf(HELP_INTEGER_TEXT); #else outputMode(); sollyaPrintf("Represents the integer type for externalproc.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for INTEGER" #endif #endif } | STRINGTYPETOKEN { #ifdef HELP_STRING_TEXT outputMode(); sollyaPrintf(HELP_STRING_TEXT); #else outputMode(); sollyaPrintf("Represents the string type for externalproc.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for STRING" #endif #endif } | BOOLEANTOKEN { #ifdef HELP_BOOLEAN_TEXT outputMode(); sollyaPrintf(HELP_BOOLEAN_TEXT); #else outputMode(); sollyaPrintf("Represents the boolean type for externalproc.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for BOOLEAN" #endif #endif } | LISTTOKEN { #ifdef HELP_LISTOF_TEXT outputMode(); sollyaPrintf(HELP_LISTOF_TEXT); #else outputMode(); sollyaPrintf("Represents the list type for externalproc.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for LISTOF" #endif #endif } | OFTOKEN { #ifdef HELP_LISTOF_TEXT outputMode(); sollyaPrintf(HELP_LISTOF_TEXT); #else outputMode(); sollyaPrintf("Used in list of type for externalproc.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for LISTOF" #endif #endif } | VARTOKEN { #ifdef HELP_VAR_TEXT outputMode(); sollyaPrintf(HELP_VAR_TEXT); #else outputMode(); sollyaPrintf("Declares a local variable.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for VAR" #endif #endif } | NOPTOKEN { #ifdef HELP_NOP_TEXT outputMode(); sollyaPrintf(HELP_NOP_TEXT); #else outputMode(); sollyaPrintf("Does nothing.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for NOP" #endif #endif } | PROCTOKEN { #ifdef HELP_PROC_TEXT outputMode(); sollyaPrintf(HELP_PROC_TEXT); #else outputMode(); sollyaPrintf("Defines a nameless procedure.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PROC" #endif #endif } | PROCEDURETOKEN { #ifdef HELP_PROCEDURE_TEXT outputMode(); sollyaPrintf(HELP_PROCEDURE_TEXT); #else outputMode(); sollyaPrintf("Defines a named procedure.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for PROCEDURE" #endif #endif } | RETURNTOKEN { #ifdef HELP_RETURN_TEXT outputMode(); sollyaPrintf(HELP_RETURN_TEXT); #else outputMode(); sollyaPrintf("Returns an expression in a procedure.\n"); #if defined(WARN_IF_NO_HELP_TEXT) && WARN_IF_NO_HELP_TEXT #warning "No help text for RETURN" #endif #endif } | HELPTOKEN { outputMode(); sollyaPrintf("Type \"help ;\" for help on the keyword .\nFor example type \"help implementpoly;\" for help on the command \"implementpoly\".\n\n"); sollyaPrintf("Possible keywords in %s are:\n",PACKAGE_NAME); sollyaPrintf("- !\n"); sollyaPrintf("- !=\n"); sollyaPrintf("- &&\n"); sollyaPrintf("- (\n"); sollyaPrintf("- )\n"); sollyaPrintf("- *\n"); sollyaPrintf("- +\n"); sollyaPrintf("- ,\n"); sollyaPrintf("- -\n"); sollyaPrintf("- .\n"); sollyaPrintf("- ...\n"); sollyaPrintf("- .:\n"); sollyaPrintf("- /\n"); sollyaPrintf("- :.\n"); sollyaPrintf("- :=\n"); sollyaPrintf("- ; (separator in ranges)\n"); sollyaPrintf("- <\n"); sollyaPrintf("- =\n"); sollyaPrintf("- ==\n"); sollyaPrintf("- >\n"); sollyaPrintf("- @\n"); sollyaPrintf("- {\n"); sollyaPrintf("- [|\n"); sollyaPrintf("- |]\n"); sollyaPrintf("- ||\n"); sollyaPrintf("- }\n"); sollyaPrintf("- ~\n"); sollyaPrintf("- [\n"); sollyaPrintf("- ]\n"); sollyaPrintf("- ^\n"); sollyaPrintf("- _x_\n"); sollyaPrintf("- D\n"); sollyaPrintf("- DD\n"); sollyaPrintf("- DE\n"); sollyaPrintf("- HP\n"); sollyaPrintf("- QD\n"); sollyaPrintf("- Pi\n"); sollyaPrintf("- RD\n"); sollyaPrintf("- RN\n"); sollyaPrintf("- RU\n"); sollyaPrintf("- RZ\n"); sollyaPrintf("- SG\n"); sollyaPrintf("- TD\n"); sollyaPrintf("- abs\n"); sollyaPrintf("- absolute\n"); sollyaPrintf("- accurateinfnorm\n"); sollyaPrintf("- acos\n"); sollyaPrintf("- acosh\n"); sollyaPrintf("- annotatefunction\n"); sollyaPrintf("- asciiplot\n"); sollyaPrintf("- asin\n"); sollyaPrintf("- asinh\n"); sollyaPrintf("- atan\n"); sollyaPrintf("- atanh\n"); sollyaPrintf("- autodiff\n"); sollyaPrintf("- autosimplify\n"); sollyaPrintf("- bashevaluate\n"); sollyaPrintf("- bashexecute\n"); sollyaPrintf("- begin\n"); sollyaPrintf("- binary\n"); sollyaPrintf("- bind\n"); sollyaPrintf("- boolean\n"); sollyaPrintf("- by\n"); sollyaPrintf("- canonical\n"); sollyaPrintf("- ceil\n"); sollyaPrintf("- chebyshevform\n"); sollyaPrintf("- checkinfnorm\n"); sollyaPrintf("- coeff\n"); sollyaPrintf("- composepolynomials\n"); sollyaPrintf("- constant\n"); sollyaPrintf("- cos\n"); sollyaPrintf("- cosh\n"); sollyaPrintf("- decimal\n"); sollyaPrintf("- default\n"); sollyaPrintf("- degree\n"); sollyaPrintf("- denominator\n"); sollyaPrintf("- diam\n"); sollyaPrintf("- dieonerrormode\n"); sollyaPrintf("- diff\n"); sollyaPrintf("- dirtyfindzeros\n"); sollyaPrintf("- dirtyinfnorm\n"); sollyaPrintf("- dirtyintegral\n"); sollyaPrintf("- dirtysimplify\n"); sollyaPrintf("- display\n"); sollyaPrintf("- do\n"); sollyaPrintf("- double\n"); sollyaPrintf("- doubledouble\n"); sollyaPrintf("- doubleextended\n"); sollyaPrintf("- dyadic\n"); sollyaPrintf("- else\n"); sollyaPrintf("- end\n"); sollyaPrintf("- erf\n"); sollyaPrintf("- erfc\n"); sollyaPrintf("- error\n"); sollyaPrintf("- evaluate\n"); sollyaPrintf("- execute\n"); sollyaPrintf("- exp\n"); sollyaPrintf("- expand\n"); sollyaPrintf("- expm1\n"); sollyaPrintf("- exponent\n"); sollyaPrintf("- externalplot\n"); sollyaPrintf("- externalproc\n"); sollyaPrintf("- false\n"); sollyaPrintf("- file\n"); sollyaPrintf("- findzeros\n"); sollyaPrintf("- fixed\n"); sollyaPrintf("- floating\n"); sollyaPrintf("- floor\n"); sollyaPrintf("- for\n"); sollyaPrintf("- fpfindzeros\n"); sollyaPrintf("- fpminimax\n"); sollyaPrintf("- from\n"); sollyaPrintf("- fullparentheses\n"); sollyaPrintf("- function\n"); sollyaPrintf("- getsuppressedmessages\n"); sollyaPrintf("- getbacktrace\n"); sollyaPrintf("- guessdegree\n"); sollyaPrintf("- halfprecision\n"); sollyaPrintf("- head\n"); sollyaPrintf("- help\n"); sollyaPrintf("- hexadecimal\n"); sollyaPrintf("- honorcoeffprec\n"); sollyaPrintf("- hopitalrecursions\n"); sollyaPrintf("- horner\n"); sollyaPrintf("- if\n"); sollyaPrintf("- implementpoly\n"); sollyaPrintf("- implementconstant\n"); sollyaPrintf("- in\n"); sollyaPrintf("- inf\n"); sollyaPrintf("- infnorm\n"); sollyaPrintf("- integer\n"); sollyaPrintf("- integral\n"); sollyaPrintf("- isbound\n"); sollyaPrintf("- isevaluable\n"); sollyaPrintf("- length\n"); sollyaPrintf("- library\n"); sollyaPrintf("- libraryconstant\n"); sollyaPrintf("- list\n"); sollyaPrintf("- log\n"); sollyaPrintf("- log10\n"); sollyaPrintf("- log1p\n"); sollyaPrintf("- log2\n"); sollyaPrintf("- mantissa\n"); sollyaPrintf("- match\n"); sollyaPrintf("- max\n"); sollyaPrintf("- mid\n"); sollyaPrintf("- midpointmode\n"); sollyaPrintf("- min\n"); sollyaPrintf("- nearestint\n"); sollyaPrintf("- numberroots\n"); sollyaPrintf("- nop\n"); sollyaPrintf("- numerator\n"); sollyaPrintf("- object\n"); sollyaPrintf("- objectname\n"); sollyaPrintf("- of\n"); sollyaPrintf("- off\n"); sollyaPrintf("- on\n"); sollyaPrintf("- parse\n"); sollyaPrintf("- perturb\n"); sollyaPrintf("- pi\n"); sollyaPrintf("- plot\n"); sollyaPrintf("- points\n"); sollyaPrintf("- postscript\n"); sollyaPrintf("- postscriptfile\n"); sollyaPrintf("- powers\n"); sollyaPrintf("- prec\n"); sollyaPrintf("- precision\n"); sollyaPrintf("- print\n"); sollyaPrintf("- printbinary\n"); sollyaPrintf("- printdouble\n"); sollyaPrintf("- printexpansion\n"); sollyaPrintf("- printfloat\n"); sollyaPrintf("- printhexa\n"); sollyaPrintf("- printsingle\n"); sollyaPrintf("- printxml\n"); sollyaPrintf("- proc\n"); sollyaPrintf("- procedure\n"); sollyaPrintf("- quad\n"); sollyaPrintf("- quit\n"); sollyaPrintf("- range\n"); sollyaPrintf("- rationalapprox\n"); sollyaPrintf("- rationalmode\n"); sollyaPrintf("- readfile\n"); sollyaPrintf("- readxml\n"); sollyaPrintf("- relative\n"); sollyaPrintf("- remez\n"); sollyaPrintf("- rename\n"); sollyaPrintf("- restart\n"); sollyaPrintf("- return\n"); sollyaPrintf("- revert\n"); sollyaPrintf("- round\n"); sollyaPrintf("- roundcoefficients\n"); sollyaPrintf("- roundcorrectly\n"); sollyaPrintf("- roundingwarnings\n"); sollyaPrintf("- searchgal\n"); sollyaPrintf("- showmessagenumbers\n"); sollyaPrintf("- simplify\n"); sollyaPrintf("- sin\n"); sollyaPrintf("- single\n"); sollyaPrintf("- sinh\n"); sollyaPrintf("- sort\n"); sollyaPrintf("- sqrt\n"); sollyaPrintf("- string\n"); sollyaPrintf("- subpoly\n"); sollyaPrintf("- substitute\n"); sollyaPrintf("- sup\n"); sollyaPrintf("- supnorm\n"); sollyaPrintf("- suppressmessage\n"); sollyaPrintf("- tail\n"); sollyaPrintf("- tan\n"); sollyaPrintf("- tanh\n"); sollyaPrintf("- taylor\n"); sollyaPrintf("- taylorform\n"); sollyaPrintf("- taylorrecursions\n"); sollyaPrintf("- then\n"); sollyaPrintf("- time\n"); sollyaPrintf("- timing\n"); sollyaPrintf("- to\n"); sollyaPrintf("- tripledouble\n"); sollyaPrintf("- true\n"); sollyaPrintf("- unsuppressmessage\n"); sollyaPrintf("- var\n"); sollyaPrintf("- verbosity\n"); sollyaPrintf("- version\n"); sollyaPrintf("- void\n"); sollyaPrintf("- while\n"); sollyaPrintf("- with\n"); sollyaPrintf("- worstcase\n"); sollyaPrintf("- write\n"); sollyaPrintf("- zerodenominators\n"); sollyaPrintf("\n"); } ; sollya-6.0+ds/plot.c000066400000000000000000000407501300174114700144120ustar00rootroot00000000000000/* Copyright 2006-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #define _BSD_SOURCE #define _DEFAULT_SOURCE #include #include #include /* fprintf, fopen, fclose, */ #include /* wait */ #include /* execve, fork, daemon */ #include /* exit, free, mktemp */ #include #include #include "plot.h" #include "expression.h" #include "general.h" #include "infnorm.h" #include "chain.h" #include "printf.h" #include "signalhandling.h" #ifdef HAVE_CONFIG_H #include "config.h" #endif #ifdef HAVE_SYS_IOCTL_H #include #endif extern int fileNumber; int checkFileDescriptor(FILE *fd, char *s) { if (fd == NULL) { printMessage(1,SOLLYA_MSG_PLOT_COULD_NOT_OPEN_FILE,"Error: the file %s requested by plot could not be opened for writing: ",s); printMessage(1,SOLLYA_MSG_CONTINUATION,"\"%s\".\n",strerror(errno)); return 0; } return 1; } void plotTree(chain *treeList, mpfr_t a, mpfr_t b, unsigned long int points, mp_prec_t prec, char *name, int type) { int test, i, flush; chain *list; node *tree; mpfr_t current_x, x, y, step, perturb, cutoff; gmp_randstate_t random_state; double xd, yd, ad, bd; FILE *file; char *gplotname; char *dataname; char *outputname; int tern; mp_prec_t p, pp; int overflow; int plotPossible; int n; plotPossible = 0; pp = prec; if (prec < 64) pp = 64; mpfr_init2(x, pp); mpfr_init2(step, pp); mpfr_init2(y, 64); mpfr_sub(step, b, a, GMP_RNDN); mpfr_div_ui(step, step, points, GMP_RNDN); if (mpfr_sgn(step) == 0) { list = treeList; mpfr_set_prec(y,prec); while(list != NULL) { tree = (node *)(list->value); evaluateFaithful(y,tree,a,prec); if (!mpfr_number_p(y)) { printMessage(1,SOLLYA_MSG_CONSTANT_EXPR_CANNOT_BE_EVALUATED_AT_ALL,"Warning: this constant function is not evaluable by this tool.\n"); } outputMode(); printValue(&y); sollyaPrintf("\n"); list = list->next; } mpfr_clear(x); mpfr_clear(y); mpfr_clear(step); return; } if (mpfr_sgn(step) < 0) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_EMPTY,"Warning: the interval is empty\n"); mpfr_clear(x); mpfr_clear(y); mpfr_clear(step); return; } test=1; list = treeList; while(list != NULL && (test==1)) { tree = (node *)(list->value); if(!isConstant(tree)) test=0; list = list->next; } if (test) { mpfr_set_prec(y,prec); mpfr_set_d(x,1.0,GMP_RNDN); list = treeList; while(list != NULL && (test==1)) { tree = (node *)(list->value); evaluateFaithful(y,tree,x,prec); if (!mpfr_number_p(y)) { printMessage(1,SOLLYA_MSG_CONSTANT_EXPR_CANNOT_BE_EVALUATED_AT_ALL,"Warning: this constant function is not evaluable by this tool.\n"); } outputMode(); printValue(&y); sollyaPrintf("\n"); list = list->next; } mpfr_clear(x); mpfr_clear(y); mpfr_clear(step); return; } if(name==NULL) { n = sollya_snprintf(NULL, 0, "%s/%s%s-%04d", getTempDir(), PACKAGE_NAME, getUniqueId(), fileNumber); gplotname = (char *)safeCalloc(n+3, sizeof(char)); sollya_snprintf(gplotname, n+3, "%s/%s%s-%04d.p",getTempDir(), PACKAGE_NAME, getUniqueId(), fileNumber); dataname = (char *)safeCalloc(n+5, sizeof(char)); sollya_snprintf(dataname, n+5, "%s/%s%s-%04d.dat",getTempDir(),PACKAGE_NAME,getUniqueId(), fileNumber); outputname = (char *)safeCalloc(1, sizeof(char)); fileNumber++; if (fileNumber >= NUMBEROFFILES) fileNumber=0; } else { gplotname = (char *)safeCalloc(strlen(name)+3,sizeof(char)); sprintf(gplotname,"%s.p",name); dataname = (char *)safeCalloc(strlen(name)+5,sizeof(char)); sprintf(dataname,"%s.dat",name); outputname = (char *)safeCalloc(strlen(name)+5,sizeof(char)); if ((type==PLOTPOSTSCRIPT) || (type==PLOTPOSTSCRIPTFILE)) sprintf(outputname,"%s.eps",name); } file = fopen(gplotname, "w"); if (checkFileDescriptor(file, gplotname)) { sollyaFprintf(file, "# Gnuplot script generated by %s\n",PACKAGE_NAME); ad = sollya_mpfr_get_d(a, GMP_RNDD); bd = sollya_mpfr_get_d(b, GMP_RNDU); if ((!(ad-ad == 0.0)) || (!(bd-bd == 0.0))) printMessage(1, SOLLYA_MSG_PLOT_OVERFLOW_OCCURRED_ON_CONVERSION_TO_DOUBLE, "Warning: an overflow occurred in a conversion mpfr to double while plotting.\n"); if (!(ad-ad == 0.0)) ad = -MAX_VALUE_GNUPLOT; if (!(bd-bd == 0.0)) bd = MAX_VALUE_GNUPLOT; if ((type==PLOTPOSTSCRIPT) || (type==PLOTPOSTSCRIPTFILE)) sollyaFprintf(file,"set terminal postscript eps color\nset out \"%s\"\n",outputname); sollyaFprintf(file, "set format x \"%%g\"\n"); sollyaFprintf(file, "set format y \"%%g\"\n"); sollyaFprintf(file, "set xrange [%1.50e:%1.50e]\n", ad, bd); sollyaFprintf(file, "plot "); i=2; list = treeList; while(list != NULL) { sollyaFprintf(file,"\"%s\" using 1:%d with lines t \"\"",dataname,i); if(list->next != NULL) sollyaFprintf(file,","); i++; list = list->next; } sollyaFprintf(file,"\n"); fclose(file); file = fopen(dataname, "w"); if (checkFileDescriptor(file, dataname)) { plotPossible = 1; mpfr_init2(cutoff, pp); mpfr_set_d(cutoff,1.0,GMP_RNDN); p = prec; if (p < 64) p = 64; mpfr_div_2ui(cutoff,cutoff,4*p,GMP_RNDN); overflow = 0; flush = 0; mpfr_init2(current_x, pp); gmp_randinit_default(random_state); gmp_randseed_ui(random_state, 65845285); mpfr_init2(perturb, pp); mpfr_set(current_x,a,GMP_RNDN); mpfr_set(x, current_x, GMP_RNDN); while(mpfr_lessequal_p(x,b)) { xd = sollya_mpfr_get_d(x, GMP_RNDN); if (xd >= MAX_VALUE_GNUPLOT) xd = MAX_VALUE_GNUPLOT; if (xd <= -MAX_VALUE_GNUPLOT) xd = -MAX_VALUE_GNUPLOT; sollyaFprintf(file, "%1.50e",xd); list = treeList; while(list != NULL) { tree = (node *)(list->value); tern = evaluateFaithfulWithCutOff(y, tree, x, cutoff, prec); if (tern == 2) { flush = 1; printMessage(2,SOLLYA_MSG_PLOT_FUNC_PROVEN_LESS_THAN_2_TO_MINUS_PREC,"Information: function image proven to be less than 2^(-%d) on point %s = %v\nThis point will be plotted as the midpoint of the proof interval.\n",(int)p,((variablename == NULL) ? "_x_" : variablename),x); } if (!mpfr_number_p(y)) { printMessage(2,SOLLYA_MSG_PLOT_FUNC_UNDEFINED_OR_UNSTABLE_AT_POINT,"Information: function undefined or not evaluable in point %s = %v\nThis point will not be plotted.\n",((variablename == NULL) ? "_x_" : variablename),x); } yd = sollya_mpfr_get_d(y, GMP_RNDN); if (!(yd-yd == 0.0)) overflow = 1; if (yd >= MAX_VALUE_GNUPLOT) { yd = MAX_VALUE_GNUPLOT; overflow = 1; } if (yd <= -MAX_VALUE_GNUPLOT) { yd = -MAX_VALUE_GNUPLOT; overflow = 1; } sollyaFprintf(file, "\t%1.50e", yd); list = list->next; } sollyaFprintf(file,"\n"); mpfr_add(current_x, current_x,step,GMP_RNDU); mpfr_urandomb(perturb, random_state); mpfr_mul_2ui(perturb, perturb, 1, GMP_RNDN); mpfr_sub_ui(perturb, perturb, 1, GMP_RNDN); mpfr_div_2ui(perturb, perturb, 2, GMP_RNDN); mpfr_mul(perturb, perturb, step, GMP_RNDN); /* perturb \in [-step/4; step/4] */ mpfr_add(x, current_x, perturb, GMP_RNDU); } mpfr_clear(cutoff); mpfr_clear(perturb); mpfr_clear(current_x); gmp_randclear(random_state); fclose(file); if (overflow) printMessage(1, SOLLYA_MSG_PLOT_OVERFLOW_OCCURRED_ON_CONVERSION_TO_DOUBLE, "Warning: an overflow occurred in a conversion mpfr to double while plotting.\n"); if (flush) { printMessage(1,SOLLYA_MSG_PLOT_NOT_FAITHFULLY_EVALUATED_AT_SOME_POINT,"Warning: the evaluation of the image on at least one point of at least one function has not been faithfully accurate.\n"); } } } mpfr_clear(x); mpfr_clear(y); mpfr_clear(step); deferSignalHandling(); fflush(NULL); parserFlushInput(); resumeSignalHandling(); if (plotPossible) { if ((name==NULL) || (type==PLOTFILE)) { if (fork()==0) { if (daemon(1,1) == 0) { if (fork() == 0) { execlp("gnuplot", "gnuplot", "-persist", gplotname, NULL); perror("An error occurred when calling gnuplot "); exit(1); } else { wait(NULL); sleep(1); remove(gplotname); remove(dataname); sleep(1); exit(0); } } else { fprintf(stderr, "Could not create a daemon for gnuplot\n"); if (fork() == 0) { execlp("gnuplot", "gnuplot", "-persist", gplotname, NULL); perror("An error occurred when calling gnuplot "); exit(1); } else { wait(NULL); sleep(2); exit(0); } } } else { wait(NULL); sleep(1); } } else { /* Case we have an output: no daemon */ if (fork()==0) { execlp("gnuplot", "gnuplot", "-persist", gplotname, NULL); perror("An error occurred when calling gnuplot "); exit(1); } else { wait(NULL); if(type==PLOTPOSTSCRIPT) { remove(gplotname); remove(dataname); } sleep(1); } } } wait(NULL); deferSignalHandling(); fflush(NULL); parserFlushInput(); resumeSignalHandling(); safeFree(gplotname); safeFree(dataname); safeFree(outputname); return; } void removePlotFiles(void) { int i; char *name; int n; n = sollya_snprintf(NULL, 0, "%s/%s%s-%04d", getTempDir(), PACKAGE_NAME, getUniqueId(), NUMBEROFFILES); name = (char *)safeCalloc(n+5, sizeof(char)); for(i=0;i= 0) { sizeX = size.ws_col; sizeY = size.ws_row; if ((sizeX < 2) || (sizeY < 2)) { sizeX = 77; sizeY = 25; } if (sizeX > 500) sizeX = 500; if (sizeY > 500) sizeY = 500; } else { sizeX = 77; sizeY = 25; } } #else sizeX = 77; sizeY = 25; #endif values = (mpfr_t *) safeCalloc(sizeX-1,sizeof(mpfr_t)); for (i=0;i 0) { mpfr_set(maxValue, values[i], GMP_RNDN); } } drawXAxis = 0; drawYAxis = 0; xAxis = 0; yAxis = 0; if (mpfr_sgn(minValue) != mpfr_sgn(maxValue)) { drawXAxis = 1; mpfr_neg(x,minValue,GMP_RNDN); mpfr_sub(y,maxValue,minValue,GMP_RNDN); mpfr_div(x,x,y,GMP_RNDN); mpfr_mul_si(x,x,sizeY-2,GMP_RNDN); xAxis = mpfr_get_si(x,GMP_RNDN); if (xAxis < 0) xAxis = 0; if (xAxis > (sizeY - 2)) xAxis = sizeY - 2; } if (mpfr_sgn(a) != mpfr_sgn(b)) { drawYAxis = 1; mpfr_neg(x,a,GMP_RNDN); mpfr_div(x,x,step,GMP_RNDN); yAxis = mpfr_get_si(x,GMP_RNDN); if (yAxis < 0) yAxis = 0; if (yAxis > (sizeX - 2)) yAxis = 2; } for (i=0;i (sizeY - 2)) k = sizeY - 2; lines[(sizeY - 2) - k][i] = 'x'; } saveMode(); for (k=0;k #include "expression.h" #include "chain.h" #define NUMBEROFFILES 10 #define PLOTFILE 0 #define PLOTPOSTSCRIPT 1 #define PLOTPOSTSCRIPTFILE 2 #define MAX_VALUE_GNUPLOT 0.898846567431157854072637118658521783990352837629224983e308 void plotTree(chain *treeList, mpfr_t a, mpfr_t b, unsigned long int points, mp_prec_t prec, char *name, int type); void removePlotFiles(void); void asciiPlotTree(node *tree, mpfr_t a, mpfr_t b, mp_prec_t prec); #endif /* ifdef PLOT_H*/ sollya-6.0+ds/polynomials.c000066400000000000000000010521311300174114700157770ustar00rootroot00000000000000/* Copyright 2014-2016 by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributor Ch. Lauter christoph.lauter@lip6.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "general.h" #include "execute.h" #include "infnorm.h" #include "expression.h" #include "polynomials.h" #include "printf.h" #include "hash.h" #if (!(defined(HAVE_MP_BITCNT_T) && (HAVE_MP_BITCNT_T))) typedef unsigned long int mp_bitcnt_t; #endif /* Helper types */ struct __hash_result_struct_t { uint64_t hash; int hasHash; }; typedef struct __hash_result_struct_t hash_result_t; struct __boolean_result_cache_struct_t { int res; int cached; }; typedef struct __boolean_result_cache_struct_t boolean_result_cache_t; /* Types for constants, sparse polynomials and polynomials */ typedef enum __constant_type_enum_t constant_type_t; enum __constant_type_enum_t { INTEGER = 0, EXPRESSION, MPFR, SCALEDMPQ }; typedef struct __scaled_mpq_struct_t scaled_mpq_t; struct __scaled_mpq_struct_t { mp_exp_t expo; mpq_t significand; }; typedef struct __constant_struct_t * constant_t; struct __constant_struct_t { unsigned int refCount; constant_type_t type; boolean_result_cache_t isZero; boolean_result_cache_t isOne; boolean_result_cache_t isNonNegativeInteger; boolean_result_cache_t isPositive; boolean_result_cache_t isDyadic; boolean_result_cache_t isRational; hash_result_t hash; union { int integer; node *expr; mpfr_t mpfr; scaled_mpq_t scaledMpq; } value; }; typedef struct __sparse_polynomial_struct_t * sparse_polynomial_t; struct __sparse_polynomial_struct_t { unsigned int refCount; constant_t deg; unsigned int monomialCount; hash_result_t hash; constant_t *coeffs; constant_t *monomialDegrees; }; typedef enum __polynomial_type_enum_t polynomial_type_t; enum __polynomial_type_enum_t { SPARSE = 0, ADDITION, SUBTRACTION, MULTIPLICATION, COMPOSITION, NEGATE, POWER }; typedef enum __polynomial_output_type_enum_t polynomial_output_type_t; enum __polynomial_output_type_enum_t { ANY_FORM = 0, HORNER_FORM, CANONICAL_FORM }; struct __polynomial_struct_t { unsigned int refCount; polynomial_type_t type; polynomial_output_type_t outputType; hash_result_t hash; boolean_result_cache_t usesExpressionConstant; union { sparse_polynomial_t sparse; polynomial_t g; struct { polynomial_t g; polynomial_t h; } pair; struct { polynomial_t g; constant_t c; } powering; } value; }; /* Globally defined constants and caches */ #define CONSTANT_INTEGER_CACHE_MIN (-16384) #define CONSTANT_INTEGER_CACHE_MAX (16383) #define CONSTANT_INTEGER_CACHE_SIZE ((CONSTANT_INTEGER_CACHE_MAX) - (CONSTANT_INTEGER_CACHE_MIN) + 1) #define CONSTANT_MALLOC_CACHE_SIZE (4096) typedef struct __cached_constant_struct_t __cached_constant_t; struct __cached_constant_struct_t { constant_t constant; int initialized; }; static int __constant_cache_initialized = 0; static __cached_constant_t __constant_integer_cache[CONSTANT_INTEGER_CACHE_SIZE]; static constant_t __constant_malloc_cache[CONSTANT_MALLOC_CACHE_SIZE]; static int __constant_malloc_cache_index = 0; /* Helper functions */ static inline int mpfr_is_machine_integer(int *intval, mpfr_t op) { long int t, ttt; int tt; if (!mpfr_number_p(op)) return 0; if (!mpfr_integer_p(op)) return 0; if (!mpfr_fits_slong_p(op, GMP_RNDN)) return 0; t = mpfr_get_si(op, GMP_RNDN); /* exact */ tt = t; ttt = tt; if (t != ttt) return 0; *intval = tt; return 1; } static inline int mpfr_is_machine_unsigned_integer(unsigned int *intval, mpfr_t op) { unsigned long int t, ttt; unsigned int tt; if (!mpfr_number_p(op)) return 0; if (mpfr_sgn(op) < 0) return 0; if (!mpfr_integer_p(op)) return 0; if (!mpfr_fits_ulong_p(op, GMP_RNDN)) return 0; t = mpfr_get_ui(op, GMP_RNDN); /* exact */ tt = t; ttt = tt; if (t != ttt) return 0; *intval = tt; return 1; } /* This function supposes that op is canonicalized, i.e. zero is represented as 0/1, that the numerator and the denominator have no common factors and that the denominator is positive. The function guarantees that op is canonicalized in output as well. */ static inline mp_exp_t mpq_remove_powers_of_two(mpq_t op) { mp_bitcnt_t dyadNum, dyadDen; mp_exp_t expo; if (mpq_sgn(op) == 0) return ((mp_exp_t) 0); dyadNum = mpz_scan1(mpq_numref(op), 0); dyadDen = mpz_scan1(mpq_denref(op), 0); mpz_tdiv_q_2exp(mpq_numref(op), mpq_numref(op), dyadNum); mpz_tdiv_q_2exp(mpq_denref(op), mpq_denref(op), dyadDen); expo = dyadNum - dyadDen; return expo; } static inline void scaledMpqAdd(mp_exp_t *EC, mpq_t c, mp_exp_t EA, mpq_t a, mp_exp_t EB, mpq_t b) { if (EB <= EA) { *EC = EB; mpq_mul_2exp(c, a, EA - EB); /* Exponent overflow possible */ mpq_add(c, c, b); } else { *EC = EA; mpq_mul_2exp(c, b, EB - EA); /* Exponent overflow possible */ mpq_add(c, c, a); } *EC += mpq_remove_powers_of_two(c); /* Exponent overflow possible */ } static inline void scaledMpqAddInt(mp_exp_t *EC, mpq_t c, mp_exp_t EA, mpq_t a, int b) { mpq_t t; /* Can be optimized */ mpq_init(t); mpq_set_si(t, b, 1u); mpq_canonicalize(t); scaledMpqAdd(EC, c, EA, a, 0, t); mpq_clear(t); } static inline void scaledMpqSub(mp_exp_t *EC, mpq_t c, mp_exp_t EA, mpq_t a, mp_exp_t EB, mpq_t b) { if (EB <= EA) { *EC = EB; mpq_mul_2exp(c, a, EA - EB); /* Exponent overflow possible */ mpq_sub(c, c, b); } else { *EC = EA; mpq_mul_2exp(c, b, EB - EA); /* Exponent overflow possible */ mpq_sub(c, a, c); } *EC += mpq_remove_powers_of_two(c); /* Exponent overflow possible */ } static inline void scaledMpqSubInt(mp_exp_t *EC, mpq_t c, mp_exp_t EA, mpq_t a, int b) { mpq_t t; /* Can be optimized */ mpq_init(t); mpq_set_si(t, b, 1u); mpq_canonicalize(t); scaledMpqSub(EC, c, EA, a, 0, t); mpq_clear(t); } static inline void scaledMpqIntSub(mp_exp_t *EC, mpq_t c, int a, mp_exp_t EB, mpq_t b) { mpq_t t; /* Can be optimized */ mpq_init(t); mpq_set_si(t, a, 1u); mpq_canonicalize(t); scaledMpqSub(EC, c, 0, t, EB, b); mpq_clear(t); } static inline void scaledMpqMul(mp_exp_t *EC, mpq_t c, mp_exp_t EA, mpq_t a, mp_exp_t EB, mpq_t b) { *EC = EA + EB; /* Exponent overflow possible */ mpq_mul(c, a, b); *EC += mpq_remove_powers_of_two(c); /* Exponent overflow possible */ } static inline void scaledMpqMulInt(mp_exp_t *EC, mpq_t c, mp_exp_t EA, mpq_t a, int b) { mpq_t t; /* Can be optimized */ mpq_init(t); mpq_set_si(t, b, 1u); mpq_canonicalize(t); scaledMpqMul(EC, c, EA, a, 0, t); mpq_clear(t); } static inline int tryScaledMpqDiv(mp_exp_t *EC, mpq_t c, mp_exp_t EA, mpq_t a, mp_exp_t EB, mpq_t b) { if (mpq_sgn(b) == 0) return 0; *EC = EA - EB; /* Exponent overflow possible */ mpq_div(c, a, b); *EC += mpq_remove_powers_of_two(c); /* Exponent overflow possible */ return 1; } static inline int scaledMpqIsInteger(mp_exp_t E, mpq_t a) { mpq_t aa; mp_exp_t EE; int res; /* 0 is an integer */ if (mpq_sgn(a) == 0) return 1; /* If the denominator q is one in magnitude and the exponent E non-negative, 2^E * p/q is integer */ if ((E >= 0) && (mpz_cmpabs_ui(mpq_denref(a),1u) == 0)) return 1; /* If the denominator q is one in magnitude and the exponent E non-negative, 2^E * p/q is integer */ if ((E >= 0) && (mpz_cmpabs_ui(mpq_denref(a),1u) == 0)) return 1; /* We can take short-cuts if the numerator p and the denominator q are both odd. Check that condition. */ if (mpz_odd_p(mpq_numref(a)) && mpz_odd_p(mpq_denref(a))) { /* Here p and q are co-prime and odd. If E is negative, 2^E * p/q is no integer. Otherwise 2^E * p/q is an integer iff abs(p) == abs(q). */ if (E < 0) return 0; return (mpz_cmpabs(mpq_numref(a),mpq_denref(a)) == 0); } /* Here we know that at least one of the numerator and denominator has 2 as a prime factor. */ mpq_init(aa); mpq_set(aa, a); EE = E; mpq_canonicalize(aa); EE += mpq_remove_powers_of_two(aa); /* Exponent overflow possible */ /* Now we have 2^EE * aa = 2^E * a, aa in least factors and all prime factors 2 taken out. */ if (EE < 0) { mpq_clear(aa); return 0; } res = (mpz_cmpabs(mpq_numref(aa),mpq_denref(aa)) == 0); mpq_clear(aa); return res; } static inline int scaledMpqIsDyadic(mp_exp_t E, mpq_t a) { mpq_t aa; int res; UNUSED_PARAM(E); /* 0 is a dyadic */ if (mpq_sgn(a) == 0) return 1; /* If the denominator q is one in magnitude, 2^E * p/q is dyadic. */ if (mpz_cmpabs_ui(mpq_denref(a),1u) == 0) return 1; /* We can take short-cuts if the numerator p and the denominator q are both odd. Check that condition. */ if (mpz_odd_p(mpq_numref(a)) && mpz_odd_p(mpq_denref(a))) { /* Here p and q are co-prime and odd and q is different from 1. The number is not dyadic. */ return 0; } /* Here we know that at least one of the numerator and denominator has 2 as a prime factor. */ mpq_init(aa); mpq_set(aa, a); mpq_canonicalize(aa); mpq_remove_powers_of_two(aa); /* Now we have 2^EE * aa = 2^E * a, aa in least factors and all prime factors 2 taken out. 2^EE * pp/qq with pp and qq odd, co-prime. The number is dyadic iff qq is one in magnitude. */ res = (mpz_cmpabs_ui(mpq_denref(a),1u) == 0); mpq_clear(aa); return res; } /* Determine if 2^EA * a > 2^EB * b */ static inline int scaledMpqIsGreaterThan(mp_exp_t EA, mpq_t a, mp_exp_t EB, mpq_t b) { mp_exp_t E, Emin, Emax, F, D; mpz_t p, q; mpq_t r; int res; /* Handle zero in input */ if (mpq_sgn(a) == 0) { return (mpq_sgn(b) < 0); } if (mpq_sgn(b) == 0) { return (mpq_sgn(a) > 0); } /* Handle inputs of different signs */ if (mpq_sgn(a) * mpq_sgn(b) < 0) { return (mpq_sgn(a) > 0); } /* Here 2^EA * a and 2^EB * b have the same sign The comparison 2^EA * a > 2^EB * b is equivalent to * 2^(EA - EB) > b/a if a is positive * 2^(EA - EB) < b/a otherwise We start by computing Emin and Emax such that 2^Emin < b/a < 2^Emax This way we can then perform an easy, first check based on the order of magnitudes. */ E = (mp_exp_t) ((mpz_sizeinbase(mpq_numref(b),2) + mpz_sizeinbase(mpq_denref(a),2)) - (mpz_sizeinbase(mpq_denref(b),2) + mpz_sizeinbase(mpq_numref(a),2))); /* Exponent overflow possible */ Emin = E - 2; /* Exponent overflow possible */ Emax = E + 2; /* Exponent overflow possible */ /* Perform an easy check based on the magnitudes, taking the sign of a into account. */ if (mpq_sgn(a) > 0) { /* a is positive, so we have to perform the comparison 2^(EA - EB) > b/a knowing that 2^Emin < b/a < 2^Emax. If EA - EB >= Emax, we have 2^(EA - EB) >= 2^Emax > b/a hence the answer surely is "yes, 2^(EA - EB) > b/a is satisfied" If EA - EB <= Emin, we have 2^(EA - EB) <= 2^Emin < b/a hence the answer surely is "no, 2^(EA - EB) > b/a is not satisfied" */ if (EA - EB >= Emax) return 1; /* Exponent overflow possible */ if (EA - EB <= Emin) return 0; /* Exponent overflow possible */ } else { /* a is positive, so we have to perform the comparison 2^(EA - EB) < b/a knowing that 2^Emin < b/a < 2^Emax. If EA - EB >= Emax, we have 2^(EA - EB) >= 2^Emax > b/a hence the answer surely is "no, 2^(EA - EB) < b/a is not satisfied" If EA - EB <= Emin, we have 2^(EA - EB) <= 2^Emin < b/a hence the answer surely is "yes, 2^(EA - EB) < b/a is satisfied" */ if (EA - EB >= Emax) return 0; /* Exponent overflow possible */ if (EA - EB <= Emin) return 1; /* Exponent overflow possible */ } /* Here, b/a is too close to 2^E to allow the comparison to be decided merely on the base of the order of magnitude. However, now it is reasonable to compute the ratio b/a = 2^F * p/q where p and q are co-prime odd integers and q is positive. Then the comparison between 2^(EA - EB) and b/a becomes a comparison between 2^(EA - EB - F) * q and p. Let D = EA - EB - F */ mpq_init(r); mpq_div(r, b, a); F = mpq_remove_powers_of_two(r); mpz_init(p); mpz_init(q); mpq_get_num(p, r); mpq_get_den(q, r); mpq_clear(r); /* Compute D = EA - EB - F */ D = EA - EB - F; /* Exponent overflow possible */ /* Now integrate 2^D into q or p, such that the comparison boils down to comparing p and q. */ if (D >= 0) { mpz_mul_2exp(q, q, (mp_bitcnt_t) D); } else { mpz_mul_2exp(p, p, (mp_bitcnt_t) (-D)); } if (mpq_sgn(a) > 0) { /* a is positive. We have to perform the comparison 2^(EA - EB) > b/a which is equivalent to q > p. */ res = (mpz_cmp(q, p) > 0); mpz_clear(p); mpz_clear(q); return res; } /* a is negative. We have to perform the comparison 2^(EA - EB) < b/a which is equivalent to q < p. */ res = (mpz_cmp(q, p) < 0); mpz_clear(p); mpz_clear(q); return res; } static inline void scaledMpqFloor(mp_exp_t *EB, mpq_t b, mp_exp_t EA, mpq_t a) { mp_exp_t sizeNum, sizeDen, sizeOut, ER, ERP, Erest, Edelta; mp_prec_t precOut; mpfr_t t; mpq_t r, rPrime, one, rest, delta; mpz_t z, num, den; /* If 2^EA * a is an integer, we have nothing to do */ if (scaledMpqIsInteger(EA, a)) { *EB = EA; mpq_set(b, a); return; } /* Here 2^EA * a is not an integer and hence non-zero Get approximate sizes of the numerator and the denominator in bits. */ sizeNum = (mp_exp_t) (mpz_sizeinbase(mpq_numref(a),2) + 1); sizeDen = (mp_exp_t) (mpz_sizeinbase(mpq_denref(a),2)); /* Compute an upper bound on the size of the output */ sizeOut = EA + sizeNum + 5 - sizeDen; /* Integer overflow possible */ if (sizeOut < 12) sizeOut = 12; /* This upper bound on the size of the output gives us an idea of the precision we need to compute a first guess on the output. */ precOut = sizeOut; if (precOut < 12) precOut = 12; /* Compute a first guess on the output */ mpfr_init2(t, precOut); mpfr_set_z_2exp(t, mpq_numref(a), EA, GMP_RNDD); mpfr_div_z(t, t, mpq_denref(a), GMP_RNDD); mpfr_floor(t, t); /* Represent the first guess as a scaled MPQ */ mpq_init(r); mpz_init(z); if (mpfr_zero_p(t)) { ER = EA; mpq_set_si(r, 0, 1u); } else { ER = mpfr_get_z_2exp(z, t); mpq_set_z(r,z); } mpfr_clear(t); mpz_clear(z); mpq_canonicalize(r); ER += mpq_remove_powers_of_two(r); /* Exponent overflow possible */ /* As we computed the first guess in round-down mode, we are sure that 2^ER * r < 2^EA * a. We now check if 2^ER * r > 2^EA * a - 1, i.e. if 2^ER * r + 1 > 2^EA * a This condition should be satisfied in almost all cases. If it is not, the first guess was not accurate enough. Representing 2^ER * r + 1 is in general as memory intensive as representing 2^ER * r. */ mpq_init(rPrime); mpq_init(one); mpq_set_si(one, 1, 1u); scaledMpqAdd(&ERP, rPrime, ER, r, 0, one); mpq_clear(one); if (scaledMpqIsGreaterThan(ERP, rPrime, EA, a)) { mpq_clear(rPrime); *EB = ER; mpq_set(b,r); mpq_clear(r); return; } mpq_clear(rPrime); /* The accuracy of the first guess was not enough. We compute the rest 2^Erest * rest = 2^EA * a - 2^ER * r then we compute floor(2^Erest * rest) in MPQ/MPZ arithmetic. */ mpq_init(rest); scaledMpqSub(&Erest, rest, EA, a, ER, r); mpz_init(num); mpz_init(den); mpq_get_num(num, rest); mpq_get_den(den, rest); mpq_clear(rest); if (Erest > 0) { mpz_mul_2exp(num, num, (mp_bitcnt_t) Erest); } else { mpz_mul_2exp(den, den, (mp_bitcnt_t) (-Erest)); /* Exponent overflow possible */ } /* Now compute floor(num/den). That's a Euclidean division. */ mpz_fdiv_q(num,num,den); mpz_clear(den); /* Represent the correction as a scaled MPQ */ mpq_init(delta); mpq_set_z(delta, num); mpq_canonicalize(delta); Edelta = mpq_remove_powers_of_two(delta); mpz_clear(num); /* The result is 2^ER * r + 2^Edelta * delta */ scaledMpqAdd(EB, b, ER, r, Edelta, delta); mpq_clear(r); mpq_clear(delta); } /* Checks if 2^E * a is an integer that can be represented as an unsigned int and computes that integer. */ static inline int scaledMpqIsUnsignedInt(unsigned int *n, mp_exp_t E, mpq_t a) { mpfr_t t; unsigned long tI, ttI, uIAbs; unsigned int tt; signed long uI; mpz_t r, tmp, u, v; /* First check for zero */ if (mpq_sgn(a) == 0) { *n = 0u; return 1; } /* Then check if 2^E * a is a non-negative integer */ if (!scaledMpqIsInteger(E,a)) return 0; if (mpq_sgn(a) < 0) return 0; /* Here, 2^E * a is a positive integer Compute a first guess on its integer value. We compute t = floor(2^E * p/q * (1 + eps)) with abs(eps) <= 2 * e + e^2 where abs(e) <= 2^(2 * -l - 7 + 1) where l is the number of bits in an unsigned int. */ mpfr_init2(t, 2 * 8 * sizeof(unsigned int) + 7); mpfr_set_z_2exp(t, mpq_numref(a), E, GMP_RNDD); mpfr_div_z(t, t, mpq_denref(a), GMP_RNDD); mpfr_floor(t, t); if (!mpfr_fits_ulong_p(t, GMP_RNDN)) { mpfr_clear(t); return 0; } tI = mpfr_get_ui(t, GMP_RNDN); /* exact */ mpfr_clear(t); /* Now compute the "rest" / (2^E * p - q * t) / q if E >= 0 r/q = 2^E * p/q - t = | \ (p - 2^-E * q * t) / q if E < 0 We can be sure that this computation is not too memory intensive because we know that t is bounded. */ mpz_init(r); if (E >= 0) { mpz_set(r, mpq_numref(a)); mpz_mul_2exp(r, r, (mp_bitcnt_t) E); mpz_init(tmp); mpz_mul_ui(tmp, mpq_denref(a), tI); mpz_sub(r, r, tmp); mpz_clear(tmp); } else { mpz_set(r, mpq_denref(a)); mpz_mul_2exp(r, r, (mp_bitcnt_t) (-E)); /* Exponent overflow possible */ mpz_mul_ui(r, r, tI); mpz_sub(r, mpq_numref(a), r); } /* If the rest is zero, we know the integer value tI = 2^E * a */ if (mpz_sgn(r) == 0) { mpz_clear(r); tt = tI; ttI = tt; if (ttI != tI) return 0; *n = tt; return 1; } /* Here, the rest r/q is not zero. We perform an Euclidean division. u = floor(r/q), q * u + v = r */ mpz_init(u); mpz_init(v); mpz_tdiv_qr(u, v, r, mpq_denref(a)); /* If v is non-zero, 2^E * a is no integer */ if (mpz_sgn(v) != 0) { mpz_clear(v); mpz_clear(u); mpz_clear(r); return 0; } mpz_clear(v); mpz_clear(r); /* Here we know that u + tI = 2^E * a We start by checking if u fits a signed long. */ if (!mpz_fits_slong_p(u)) { mpz_clear(u); return 0; } uI = mpz_get_si(u); mpz_clear(u); /* Here we know that uI + tI = 2^E * a where uI is a signed long and tI is an unsigned long. */ if (uI < 0l) { uIAbs = -uI; if (uIAbs < tI) return 0; tI -= uIAbs; tt = tI; ttI = tt; if (ttI != tI) return 0; *n = tt; return 1; } /* Here we know that uI + tI = 2^E * a and uI >= 0 */ uIAbs = uI; tI += uIAbs; if (tI < uIAbs) return 0; tt = tI; ttI = tt; if (ttI != tI) return 0; *n = tt; return 1; } /* Checks if 2^E * a is an integer that can be represented as an int and computes that integer. */ static inline int scaledMpqIsInt(int *n, mp_exp_t E, mpq_t a) { unsigned int nU, nUU, rMA; int r, rM; mpq_t aAbs; if (mpq_sgn(a) >= 0) { if (!scaledMpqIsUnsignedInt(&nU, E, a)) return 0; r = nU; if (r < 0) return 0; nUU = r; if (nUU != nU) return 0; *n = r; return 1; } mpq_init(aAbs); mpq_neg(aAbs, a); if (!scaledMpqIsUnsignedInt(&nU, E, aAbs)) { mpq_clear(aAbs); return 0; } mpq_clear(aAbs); r = nU; if (r < 0) return 0; nUU = r; if (nUU != nU) return 0; rM = -r; if (rM > 0) return 0; rMA = -rM; if (rMA != nU) return 0; *n = rM; return 1; } static inline int tryScaledMpqPow(mp_exp_t *EC, mpq_t c, mp_exp_t EA, mpq_t a, mp_exp_t EB, mpq_t b) { unsigned int n; mpz_t eaZ, nZ, num, den; signed long int eaI, ecI, ecII; mp_exp_t eaE, ecR; if (!scaledMpqIsUnsignedInt(&n, EB, b)) return 0; if (n == 0u) { *EC = 0; mpq_set_ui(c,1,1u); mpq_canonicalize(c); *EC += mpq_remove_powers_of_two(c); /* Exponent overflow possible */ return 1; } if (n == 1u) { *EC = EA; mpq_set(c, a); mpq_canonicalize(c); *EC += mpq_remove_powers_of_two(c); /* Exponent overflow possible */ return 1; } eaI = EA; eaE = eaI; if (eaE != EA) return 0; mpz_init_set_si(eaZ, eaI); mpz_init_set_ui(nZ, n); mpz_mul(eaZ, eaZ, nZ); if (!mpz_fits_slong_p(eaZ)) { mpz_clear(nZ); mpz_clear(eaZ); return 0; } ecI = mpz_get_si(eaZ); mpz_clear(nZ); mpz_clear(eaZ); ecR = ecI; ecII = ecR; if (ecII != ecI) return 0; mpz_init(num); mpz_init(den); mpq_get_num(num, a); mpq_get_den(den, a); mpz_pow_ui(num, num, n); mpz_pow_ui(den, den, n); *EC = ecR; mpq_set_num(c, num); mpq_set_den(c, den); mpq_canonicalize(c); *EC += mpq_remove_powers_of_two(c); /* Exponent overflow possible */ mpz_clear(den); mpz_clear(num); return 1; } static inline int tryScaledMpqPowInt(mp_exp_t *EC, mpq_t c, mp_exp_t EA, mpq_t a, int b) { unsigned int n; mpz_t eaZ, nZ, num, den; signed long int eaI, ecI, ecII; mp_exp_t eaE, ecR; int bb; if (b < 0) return 0; n = b; bb = n; if (bb < 0) return 0; if (bb != b) return 0; if (n == 0u) { *EC = 0; mpq_set_ui(c,1,1u); mpq_canonicalize(c); *EC += mpq_remove_powers_of_two(c); /* Exponent overflow possible */ return 1; } if (n == 1u) { *EC = EA; mpq_set(c, a); mpq_canonicalize(c); *EC += mpq_remove_powers_of_two(c); /* Exponent overflow possible */ return 1; } eaI = EA; eaE = eaI; if (eaE != EA) return 0; mpz_init_set_si(eaZ, eaI); mpz_init_set_ui(nZ, n); mpz_mul(eaZ, eaZ, nZ); if (!mpz_fits_slong_p(eaZ)) { mpz_clear(nZ); mpz_clear(eaZ); return 0; } ecI = mpz_get_si(eaZ); mpz_clear(nZ); mpz_clear(eaZ); ecR = ecI; ecII = ecR; if (ecII != ecI) return 0; mpz_init(num); mpz_init(den); mpq_get_num(num, a); mpq_get_den(den, a); mpz_pow_ui(num, num, n); mpz_pow_ui(den, den, n); *EC = ecR; mpq_set_num(c, num); mpq_set_den(c, den); mpq_canonicalize(c); *EC += mpq_remove_powers_of_two(c); /* Exponent overflow possible */ mpz_clear(den); mpz_clear(num); return 1; } static inline int tryExactIntAddition(int *c, int a, int b) { int aNeg, bNeg, cNeg, cT; unsigned int aAbs, bAbs, cAbs, cTAbs; if (a >= 0) { aAbs = a; aNeg = 0; } else { aAbs = -a; aNeg = 1; } if (b >= 0) { bAbs = b; bNeg = 0; } else { bAbs = -b; bNeg = 1; } if (aNeg == bNeg) { cNeg = aNeg; cAbs = aAbs + bAbs; if (cAbs < aAbs) return 0; /* Should never happen */ } else { if (aAbs >= bAbs) { cNeg = aNeg; cAbs = aAbs - bAbs; } else { cNeg = bNeg; cAbs = bAbs - aAbs; } } if (cNeg) { cT = -cAbs; if (cT > 0) return 0; cTAbs = -cT; if (cTAbs != cAbs) return 0; } else { cT = cAbs; if (cT < 0) return 0; cTAbs = cT; if (cTAbs != cAbs) return 0; } *c = cT; return 1; } static inline int tryExactIntSubtraction(int *c, int a, int b) { int aNeg, bNeg, cNeg, cT; unsigned int aAbs, bAbs, cAbs, cTAbs; if (a >= 0) { aAbs = a; aNeg = 0; } else { aAbs = -a; aNeg = 1; } if (b >= 0) { bAbs = b; bNeg = 1; } else { bAbs = -b; bNeg = 0; } if (aNeg == bNeg) { cNeg = aNeg; cAbs = aAbs + bAbs; if (cAbs < aAbs) return 0; /* Should never happen */ } else { if (aAbs >= bAbs) { cNeg = aNeg; cAbs = aAbs - bAbs; } else { cNeg = bNeg; cAbs = bAbs - aAbs; } } if (cNeg) { cT = -cAbs; if (cT > 0) return 0; cTAbs = -cT; if (cTAbs != cAbs) return 0; } else { cT = cAbs; if (cT < 0) return 0; cTAbs = cT; if (cTAbs != cAbs) return 0; } *c = cT; return 1; } static inline void exactUint64Mul(uint64_t *ch, uint64_t *cl, uint64_t a, uint64_t b) { uint64_t ah, al, bh, bl; uint64_t ahbh, ahbl, albh, albl; uint64_t ahblh, ahbll, albhh, albhl; uint64_t rh, rl; ah = a >> 32; bh = a >> 32; al = a - (ah << 32); bl = b - (bh << 32); ahbh = ah * bh; ahbl = ah * bl; albh = al * bh; albl = al * bl; ahblh = ahbl >> 32; ahbll = ahbl - (ahblh << 32); albhh = albh >> 32; albhl = albh - (albhh << 32); ahbll <<= 32; albhl <<= 32; rl = albl + ahbll; if (rl < ahbll) ahblh++; rl += albhl; if (rl < albhl) ahblh++; rh = ahbh + ahblh + albhh; *ch = rh; *cl = rl; } static inline int tryExactUint64Multiplication(uint64_t *c, uint64_t a, uint64_t b) { uint64_t cth, ctl; exactUint64Mul(&cth, &ctl, a, b); if (cth == UINT64_C(0)) { *c = ctl; return 1; } return 0; } static inline int tryExactUnsignedIntMultiplication(unsigned int *c, unsigned int a, unsigned int b) { uint64_t a64, b64, c64, cT64; unsigned int aa, bb, cT; a64 = a; aa = a64; if (aa != a) return 0; /* should never happen */ b64 = b; bb = b64; if (bb != b) return 0; /* should never happen */ if (!tryExactUint64Multiplication(&c64, a64, b64)) return 0; cT = c64; cT64 = cT; if (c64 != cT64) return 0; *c = cT; return 1; } static inline int tryExactIntMultiplication(int *c, int a, int b) { int aNeg, bNeg, cNeg; unsigned int aAbs, bAbs, cAbs, cTAbs; int cT; if (a >= 0) { aAbs = a; aNeg = -1; } else { aAbs = -a; aNeg = 1; } if (b >= 0) { bAbs = b; bNeg = -1; } else { bAbs = -b; bNeg = 1; } cNeg = aNeg * bNeg; if (!tryExactUnsignedIntMultiplication(&cAbs, aAbs, bAbs)) return 0; if (cNeg < 0) { cT = -cAbs; if (cT > 0) return 0; cTAbs = -cT; if (cTAbs != cAbs) return 0; } else { cT = cAbs; if (cT < 0) return 0; cTAbs = cT; if (cTAbs != cAbs) return 0; } *c = cT; return 1; } static inline int tryExactUnsignedIntDivision(unsigned int *c, unsigned int a, unsigned int b) { if (b == 0u) return 0; if (a % b != 0u) return 0; *c = a / b; return 1; } static inline int tryExactIntDivision(int *c, int a, int b) { int aNeg, bNeg, cNeg; unsigned int aAbs, bAbs, cAbs, cTAbs; int cT; if (a >= 0) { aAbs = a; aNeg = -1; } else { aAbs = -a; aNeg = 1; } if (b >= 0) { bAbs = b; bNeg = -1; } else { bAbs = -b; bNeg = 1; } cNeg = aNeg * bNeg; if (!tryExactUnsignedIntDivision(&cAbs, aAbs, bAbs)) return 0; if (cNeg < 0) { cT = -cAbs; if (cT > 0) return 0; cTAbs = -cT; if (cTAbs != cAbs) return 0; } else { cT = cAbs; if (cT < 0) return 0; cTAbs = cT; if (cTAbs != cAbs) return 0; } *c = cT; return 1; } static inline int tryExactIntNegation(int *c, int a) { int r, aa; /* Handle zero */ if (a == 0) { *c = a; return 1; } /* Try negation */ r = -a; /* If r is zero or r and a have the same sign, something went wrong */ if (r == 0) return 0; if (!((r > 0) ^ (a > 0))) return 0; /* Now we know that r and a have opposite signs. Handle now clamping. */ aa = -r; /* If aa is zero or aa and r have the same sign, something went wrong */ if (aa == 0) return 0; if (!((aa > 0) ^ (r > 0))) return 0; /* Now we know that aa and a have the same sign. If aa is not equal to a, there has been some clamping. Otherwise, r is the opposite of a. */ if (aa != a) return 0; *c = r; return 1; } static inline int tryExactIntPower(int *c, int a, int b) { unsigned int n; int r, t; if (b < 0) return 0; if (b == 0) { *c = 1; return 1; } n = b; t = a; r = 1; while (n > 0u) { if (n & 1u) { if (!tryExactIntMultiplication(&r,r,t)) return 0; } n >>= 1; if (n > 0u) { if (!tryExactIntMultiplication(&t,t,t)) return 0; } } *c = r; return 1; } /* Computes c = a + b exactly, adapting the precision of c */ static inline void mpfr_add_exact(mpfr_t c, mpfr_t a, mpfr_t b) { mp_exp_t Ea, Eb; mp_prec_t pa, pb, pc; if ((!mpfr_number_p(a)) || (!mpfr_number_p(b))) { mpfr_add(c, a, b, GMP_RNDN); /* Producing NaN or Inf */ return; } if (mpfr_zero_p(a)) { mpfr_set_prec(c, mpfr_get_prec(b)); mpfr_set(c, b, GMP_RNDN); /* exact */ return; } if (mpfr_zero_p(b)) { mpfr_set_prec(c, mpfr_get_prec(a)); mpfr_set(c, a, GMP_RNDN); /* exact */ return; } /* Here, both inputs are non-zero numbers */ Ea = mpfr_get_exp(a); Eb = mpfr_get_exp(b); pa = mpfr_get_prec(a); pb = mpfr_get_prec(b); /* The ulps are the following ulp_pa(a) = 2^(Ea - pa) ulp_pb(b) = 2^(Eb - pb) So the ulp of the sum must be ulp_pc(c) = 2^min(Ea - pa, Eb - pb) The exponent of the result c is bounded by Ec <= max(Ea, Eb) + 1 The + 1 comes from the possible outgoing carry. So we need pc = max(Ea, Eb) - min(Ea - pa, Eb - pb) + 1 bits for c. */ pc = (Ea > Eb? Ea : Eb) - (Ea - pa < Eb - pb ? Ea - pa : Eb - pb) + 1; /* Exponent overflow possible */ mpfr_set_prec(c, pc); /* Perform the addition */ mpfr_add(c, a, b, GMP_RNDN); /* exact */ /* It could be that we actually don't need all the precision of c to keep the result. So we reduce that precision to the minimum. */ pc = mpfr_min_prec(c); if (pc < 12) pc = 12; /* Adjust the precision of c again. */ mpfr_prec_round(c, pc, GMP_RNDN); /* exact */ } /* Computes c = a + b exactly, adapting the precision of c */ static inline void mpfr_add_exact_int(mpfr_t c, mpfr_t a, int b) { mp_exp_t Ea, Eb; mp_prec_t pa, pb, pc; if (!mpfr_number_p(a)) { mpfr_add_si(c, a, b, GMP_RNDN); /* Producing NaN or Inf */ return; } if (mpfr_zero_p(a)) { mpfr_set_prec(c, 8 * sizeof(int) + 5); mpfr_set_si(c, b, GMP_RNDN); /* exact */ return; } if (b == 0) { mpfr_set_prec(c, mpfr_get_prec(a)); mpfr_set(c, a, GMP_RNDN); /* exact */ return; } /* Here, both inputs are non-zero numbers */ Ea = mpfr_get_exp(a); Eb = 8 * sizeof(int); pa = mpfr_get_prec(a); pb = 8 * sizeof(int); /* The ulps are the following ulp_pa(a) = 2^(Ea - pa) ulp_pb(b) = 2^(Eb - pb) So the ulp of the sum must be ulp_pc(c) = 2^min(Ea - pa, Eb - pb) The exponent of the result c is bounded by Ec <= max(Ea, Eb) + 1 The + 1 comes from the possible outgoing carry. So we need pc = max(Ea, Eb) - min(Ea - pa, Eb - pb) + 1 bits for c. */ pc = (Ea > Eb? Ea : Eb) - (Ea - pa < Eb - pb ? Ea - pa : Eb - pb) + 1; /* Exponent overflow possible */ mpfr_set_prec(c, pc); /* Perform the addition */ mpfr_add_si(c, a, b, GMP_RNDN); /* exact */ /* It could be that we actually don't need all the precision of c to keep the result. So we reduce that precision to the minimum. */ pc = mpfr_min_prec(c); if (pc < 12) pc = 12; /* Adjust the precision of c again. */ mpfr_prec_round(c, pc, GMP_RNDN); /* exact */ } /* Computes c = a - b exactly, adapting the precision of c */ static inline void mpfr_sub_exact(mpfr_t c, mpfr_t a, mpfr_t b) { mp_exp_t Ea, Eb; mp_prec_t pa, pb, pc; if ((!mpfr_number_p(a)) || (!mpfr_number_p(b))) { mpfr_sub(c, a, b, GMP_RNDN); /* Producing NaN or Inf */ return; } if (mpfr_zero_p(a)) { mpfr_set_prec(c, mpfr_get_prec(b)); mpfr_neg(c, b, GMP_RNDN); /* exact */ return; } if (mpfr_zero_p(b)) { mpfr_set_prec(c, mpfr_get_prec(a)); mpfr_set(c, a, GMP_RNDN); /* exact */ return; } /* Here, both inputs are non-zero numbers */ Ea = mpfr_get_exp(a); Eb = mpfr_get_exp(b); pa = mpfr_get_prec(a); pb = mpfr_get_prec(b); /* The ulps are the following ulp_pa(a) = 2^(Ea - pa) ulp_pb(b) = 2^(Eb - pb) So the ulp of the sum must be ulp_pc(c) = 2^min(Ea - pa, Eb - pb) The exponent of the result c is bounded by Ec <= max(Ea, Eb) + 1 The + 1 comes from the possible outgoing carry. So we need pc = max(Ea, Eb) - min(Ea - pa, Eb - pb) + 1 bits for c. */ pc = (Ea > Eb? Ea : Eb) - (Ea - pa < Eb - pb ? Ea - pa : Eb - pb) + 1; /* Exponent overflow possible */ mpfr_set_prec(c, pc); /* Perform the subtraction */ mpfr_sub(c, a, b, GMP_RNDN); /* exact */ /* It could be that we actually don't need all the precision of c to keep the result. So we reduce that precision to the minimum. */ pc = mpfr_min_prec(c); if (pc < 12) pc = 12; /* Adjust the precision of c again. */ mpfr_prec_round(c, pc, GMP_RNDN); /* exact */ } /* Computes c = a - b exactly, adapting the precision of c */ static inline void mpfr_sub_exact_int(mpfr_t c, mpfr_t a, int b) { mp_exp_t Ea, Eb; mp_prec_t pa, pb, pc; if (!mpfr_number_p(a)) { mpfr_sub_si(c, a, b, GMP_RNDN); /* Producing NaN or Inf */ return; } if (mpfr_zero_p(a)) { mpfr_set_prec(c, 8 * sizeof(b) + 5); mpfr_set_si(c, b, GMP_RNDN); /* exact */ mpfr_neg(c, c, GMP_RNDN); /* exact */ return; } if (b == 0) { mpfr_set_prec(c, mpfr_get_prec(a)); mpfr_set(c, a, GMP_RNDN); /* exact */ return; } /* Here, both inputs are non-zero numbers */ Ea = mpfr_get_exp(a); Eb = 8 * sizeof(int); pa = mpfr_get_prec(a); pb = 8 * sizeof(int); /* The ulps are the following ulp_pa(a) = 2^(Ea - pa) ulp_pb(b) = 2^(Eb - pb) So the ulp of the sum must be ulp_pc(c) = 2^min(Ea - pa, Eb - pb) The exponent of the result c is bounded by Ec <= max(Ea, Eb) + 1 The + 1 comes from the possible outgoing carry. So we need pc = max(Ea, Eb) - min(Ea - pa, Eb - pb) + 1 bits for c. */ pc = (Ea > Eb? Ea : Eb) - (Ea - pa < Eb - pb ? Ea - pa : Eb - pb) + 1; /* Exponent overflow possible */ mpfr_set_prec(c, pc); /* Perform the subtraction */ mpfr_sub_si(c, a, b, GMP_RNDN); /* exact */ /* It could be that we actually don't need all the precision of c to keep the result. So we reduce that precision to the minimum. */ pc = mpfr_min_prec(c); if (pc < 12) pc = 12; /* Adjust the precision of c again. */ mpfr_prec_round(c, pc, GMP_RNDN); /* exact */ } static inline void mpfr_int_sub_exact(mpfr_t c, int a, mpfr_t b) { mpfr_sub_exact_int(c, b, a); mpfr_neg(c, c, GMP_RNDN); /* exact */ } /* Computes c = a * b exactly, adapting the precision of c */ static inline void mpfr_mul_exact(mpfr_t c, mpfr_t a, mpfr_t b) { mp_prec_t pa, pb, pc; if ((!mpfr_number_p(a)) || (!mpfr_number_p(b))) { mpfr_mul(c, a, b, GMP_RNDN); /* Producing NaN or Inf */ return; } if (mpfr_zero_p(a)) { mpfr_set_prec(c, mpfr_get_prec(a)); mpfr_set(c, a, GMP_RNDN); /* exact */ return; } if (mpfr_zero_p(b)) { mpfr_set_prec(c, mpfr_get_prec(b)); mpfr_set(c, b, GMP_RNDN); /* exact */ return; } if (mpfr_cmp_si(a,1) == 0) { mpfr_set_prec(c, mpfr_get_prec(b)); mpfr_set(c, b, GMP_RNDN); /* exact */ return; } if (mpfr_cmp_si(b,1) == 0) { mpfr_set_prec(c, mpfr_get_prec(a)); mpfr_set(c, a, GMP_RNDN); /* exact */ return; } /* Here, both inputs are non-zero numbers */ pa = mpfr_get_prec(a); pb = mpfr_get_prec(b); /* Need pc = pa + pb bits of precision for an exact product. */ pc = pa + pb; /* Precision overflow possible */ mpfr_set_prec(c, pc); /* Perform the multiplication */ mpfr_mul(c, a, b, GMP_RNDN); /* exact */ /* It could be that we actually don't need all the precision of c to keep the result. So we reduce that precision to the minimum. */ pc = mpfr_min_prec(c); if (pc < 12) pc = 12; /* Adjust the precision of c again. */ mpfr_prec_round(c, pc, GMP_RNDN); /* exact */ } /* Computes c = a * b exactly, adapting the precision of c */ static inline void mpfr_mul_exact_int(mpfr_t c, mpfr_t a, int b) { mp_prec_t pa, pb, pc; if (!mpfr_number_p(a)) { mpfr_mul_si(c, a, b, GMP_RNDN); /* Producing NaN or Inf */ return; } if (mpfr_zero_p(a)) { mpfr_set_prec(c, mpfr_get_prec(a)); mpfr_set(c, a, GMP_RNDN); /* exact */ return; } if (b == 0) { mpfr_set_prec(c, 8 * sizeof(int) + 5); mpfr_set_si(c, b, GMP_RNDN); /* exact */ return; } if (mpfr_cmp_si(a,1) == 0) { mpfr_set_prec(c, 8 * sizeof(int) + 5); mpfr_set_si(c, b, GMP_RNDN); /* exact */ return; } if (b == 1) { mpfr_set_prec(c, mpfr_get_prec(a)); mpfr_set(c, a, GMP_RNDN); /* exact */ return; } /* Here, both inputs are non-zero numbers */ pa = mpfr_get_prec(a); pb = 8 * sizeof(int) + 5; /* Need pc = pa + pb bits of precision for an exact product. */ pc = pa + pb; /* Precision overflow possible */ mpfr_set_prec(c, pc); /* Perform the multiplication */ mpfr_mul_si(c, a, b, GMP_RNDN); /* exact */ /* It could be that we actually don't need all the precision of c to keep the result. So we reduce that precision to the minimum. */ pc = mpfr_min_prec(c); if (pc < 12) pc = 12; /* Adjust the precision of c again. */ mpfr_prec_round(c, pc, GMP_RNDN); /* exact */ } static inline int try_mpfr_pow_exact(mpfr_t c, mpfr_t a, unsigned long int b) { mp_prec_t pa, pc, paR; unsigned int paI, pcI, pcII; unsigned int bI; unsigned long int bb; /* Special input NaN or Inf */ if (!mpfr_number_p(a)) { /* Producing NaN, Inf or 1 */ mpfr_set_prec(c,12); mpfr_pow_ui(c,a,b,GMP_RNDN); return 1; } /* Here, a is a real number. Handle the easy cases b = 0 and b = 1. */ if (b == 0) { mpfr_set_prec(c, 12); mpfr_set_si(c, 1, GMP_RNDN); /* exact */ return 1; } if (b == 1) { mpfr_set_prec(c, mpfr_get_prec(a)); mpfr_set(c, a, GMP_RNDN); /* exact */ return 1; } /* It's so easy to handle b = 2, so let's do that */ if (b == 2) { mpfr_set_prec(c, 2 * mpfr_get_prec(a)); mpfr_mul(c, a, a, GMP_RNDN); /* exact */ pc = mpfr_min_prec(c); if (pc < 12) pc = 12; mpfr_prec_round(c, pc, GMP_RNDN); /* exact */ return 1; } /* Let's see if we can represent b on an unsigned int bI. If we can't, we refuse to do the job. */ bI = b; bb = bI; if (bb != b) return 0; /* Handle the general case */ pa = mpfr_get_prec(a); if (pa <= 1) return 0; /* pa >= 2 > 0 */ paI = pa; paR = paI; if (paR != pa) return 0; /* Now we know that a is on paI bits, where paI is an unsigned int At most, we need paI * bI bits of precision to represent a^bI. We try if we can represent paI * b on an unsigned int. If we can't, we refuse to do the job. */ if (!tryExactUnsignedIntMultiplication(&pcI, paI, bI)) return 0; /* Now we know that we need pcI bits. We check if we can write pcI on an mp_prec_t. We first make sure that pcI is at least 12. */ if (pcI < 12u) pcI = 12u; pc = pcI; if (pc < 12) pc = 12; pcII = pc; if (pcII != pcI) return 0; /* Now we know that we need pc bits for a^b */ mpfr_set_prec(c, pc); mpfr_pow_ui(c,a,b,GMP_RNDN); /* exact */ /* It could be that we actually don't need all the precision of c to keep the result. So we reduce that precision to the minimum. */ pc = mpfr_min_prec(c); if (pc < 12) pc = 12; /* Adjust the precision of c again. */ mpfr_prec_round(c, pc, GMP_RNDN); /* exact */ return 1; } /* Part for constants */ static inline constant_t __polynomialGetIthCoefficientAsConstantIntIndex(polynomial_t, int); static inline constant_t __polynomialGetIthCoefficientAsConstant(polynomial_t, mpz_t); static inline void constantFree(constant_t); static inline constant_t constantFromCopy(constant_t); static inline void constantEvalMpfi(sollya_mpfi_t, constant_t); static inline constant_t constantAdd(constant_t, constant_t); static inline constant_t constantSub(constant_t, constant_t); static inline constant_t constantMul(constant_t, constant_t); static inline constant_t constantDiv(constant_t, constant_t); static inline constant_t constantPow(constant_t, constant_t); static inline constant_t constantNeg(constant_t); static inline int constantIsNonNegativeInteger(constant_t, int); static inline int tryConstantToUnsignedInt(unsigned int *, constant_t); static inline int tryConstantToMpz(mpz_t, constant_t); static inline int constantIsGreater(constant_t, constant_t, int); static inline void constantInitializeCaches() { int i; if (__constant_cache_initialized) return; for (i=0;irefCount = 1; res->isZero.cached = 0; res->isOne.cached = 0; res->isNonNegativeInteger.cached = 0; res->isPositive.cached = 0; res->isDyadic.cached = 0; res->isRational.cached = 0; res->type = INTEGER; res->value.integer = c; res->hash.hasHash = 0; res = __constantAllocatePostTreatment(res); if ((CONSTANT_INTEGER_CACHE_MIN <= c) && (c <= CONSTANT_INTEGER_CACHE_MAX)) { constantInitializeCaches(); if (!(__constant_integer_cache[c - (CONSTANT_INTEGER_CACHE_MIN)].initialized)) { __constant_integer_cache[c - (CONSTANT_INTEGER_CACHE_MIN)].constant = constantFromCopy(res); __constant_integer_cache[c - (CONSTANT_INTEGER_CACHE_MIN)].initialized = 1; } } return res; } static inline mp_prec_t mpfr_get_needed_prec(mpfr_t c) { mp_prec_t p; p = mpfr_min_prec(c); if (p < ((mp_prec_t) 12)) p = ((mp_prec_t) 12); return p; } static inline constant_t constantFromMpfr(mpfr_t c) { constant_t res; int intval; if (mpfr_is_machine_integer(&intval, c)) { return constantFromInt(intval); } res = __constantAllocate(); res->refCount = 1; res->isZero.cached = 0; res->isOne.cached = 0; res->isNonNegativeInteger.cached = 0; res->isPositive.cached = 0; res->isDyadic.cached = 0; res->isRational.cached = 0; res->hash.hasHash = 0; res->type = MPFR; mpfr_init2(res->value.mpfr, mpfr_get_needed_prec(c)); mpfr_set(res->value.mpfr, c, GMP_RNDN); /* exact, enough precision */ return __constantAllocatePostTreatment(res); } static inline constant_t constantFromUnsignedInt(unsigned int c) { constant_t res; int cI; unsigned int cc; mpfr_t t; cI = c; cc = cI; if ((cI < 0) || (cc != c)) { mpfr_init2(t, 8 * sizeof(unsigned int) + 5); mpfr_set_ui(t, c, GMP_RNDN); /* exact */ res = constantFromMpfr(t); mpfr_clear(t); return res; } return constantFromInt(cI); } /* The argument c must be a canonicalized mpq_t number, i.e. zero needs to be represented as 0/1, the numerator and the denominator of c must not have any common factor and the denominator must be positive. */ static inline constant_t constantFromScaledMpq(mp_exp_t e, mpq_t c) { mpz_t num, den; constant_t res; mp_bitcnt_t dyadNum, dyadDen; mp_exp_t expo; mp_prec_t p; mpfr_t mpfrval; if (mpq_sgn(c) == 0) { return constantFromInt(0); } mpz_init(num); mpz_init(den); mpq_get_num(num, c); mpq_get_den(den, c); dyadNum = mpz_scan1(num, 0); dyadDen = mpz_scan1(den, 0); mpz_tdiv_q_2exp(num, num, dyadNum); mpz_tdiv_q_2exp(den, den, dyadDen); expo = e + dyadNum - dyadDen; /* Exponent overflow possible */ if (mpz_cmp_si(den, 1) == 0) { /* The denominator is one, so we can actually use a MPFR (or integer) representation. */ p = mpz_sizeinbase(num, 2); if (p < 12) p = 12; mpfr_init2(mpfrval, p); mpfr_set_z_2exp(mpfrval, num, expo, GMP_RNDN); /* exact as enough precision */ if (mpfr_number_p(mpfrval)) { res = constantFromMpfr(mpfrval); mpfr_clear(mpfrval); mpz_clear(den); mpz_clear(num); return res; } else { mpfr_clear(mpfrval); } } /* Here, we are sure we must use a scaled MPQ representation */ res = __constantAllocate(); res->refCount = 1; res->isZero.cached = 0; res->isOne.cached = 0; res->isNonNegativeInteger.cached = 0; res->isPositive.cached = 0; res->isDyadic.cached = 0; res->isRational.cached = 0; res->type = SCALEDMPQ; res->value.scaledMpq.expo = expo; res->hash.hasHash = 0; mpq_init(res->value.scaledMpq.significand); mpq_set_num(res->value.scaledMpq.significand, num); mpq_set_den(res->value.scaledMpq.significand, den); mpz_clear(den); mpz_clear(num); return __constantAllocatePostTreatment(res); } static inline constant_t constantFromMpq(mpq_t c) { return constantFromScaledMpq((mp_exp_t) 0, c); } static inline constant_t constantFromMpz(mpz_t c) { mpq_t q; constant_t res; mpq_init(q); mpq_set_z(q, c); mpq_canonicalize(q); res = constantFromMpq(q); mpq_clear(q); return res; } static inline constant_t constantFromBinomialUnsignedInt(unsigned int n, unsigned int i) { mpz_t bin; constant_t res; mpz_init(bin); mpz_bin_uiui(bin, n, i); res = constantFromMpz(bin); mpz_clear(bin); return res; } static inline int __constantFromBinomialConstantAndUnsignedIntUnsafe(constant_t *res, constant_t n, unsigned int k) { mpz_t nz, bin; mpz_init(nz); if (!tryConstantToMpz(nz, n)) { mpz_clear(nz); return 0; } mpz_init(bin); mpz_bin_ui(bin, nz, k); *res = constantFromMpz(bin); mpz_clear(bin); mpz_clear(nz); return 1; } static inline int __constantFromBinomialUnsafe(constant_t *bin, constant_t n, constant_t k) { unsigned int nu, ku, ju; constant_t j; /* Check whether both n and k are representable as unsigned machine integers. */ if (tryConstantToUnsignedInt(&nu, n) && tryConstantToUnsignedInt(&ku, k)) { /* Here we can use the special function on machine integers. */ *bin = constantFromBinomialUnsignedInt(nu, ku); return 1; } /* Here, at least one of n or k is not representable as an unsigned machine integer. Continue by checking whether at least k is representable as an unsigned machine integer. */ if (tryConstantToUnsignedInt(&ku, k)) { /* Use the special function for bin(n, k) with k unsigned int */ return __constantFromBinomialConstantAndUnsignedIntUnsafe(bin, n, ku); } /* Compute j = n - k and check if j (and n) are representable as unsigned machine integers. */ j = constantSub(n, k); if (!constantIsNonNegativeInteger(j, 0)) { constantFree(j); return 0; } if (!tryConstantToUnsignedInt(&ju, j)) { constantFree(j); return 0; } constantFree(j); if (tryConstantToUnsignedInt(&nu, n)) { *bin = constantFromBinomialUnsignedInt(nu, ju); return 1; } return __constantFromBinomialConstantAndUnsignedIntUnsafe(bin, n, ju); } static inline int constantFromBinomial(constant_t *bin, constant_t n, constant_t k) { /* Handle stupid input */ if (n == NULL) return 0; if (k == NULL) return 0; /* Check if n and k are both non-negative integers and if k is no greater than n. */ if (constantIsNonNegativeInteger(n, 0) && constantIsNonNegativeInteger(k, 0) && (!constantIsGreater(k, n, 1))) { /* Both n and k are non-negative integers. Use an auxilliary function and return its return value. */ return __constantFromBinomialUnsafe(bin, n, k); } /* Here one of n or k is negative or no integer. Signal failure. */ return 0; } static inline constant_t constantFromCopy(constant_t c) { if (c == NULL) return NULL; c->refCount++; return c; } static inline constant_t constantFromExpression(node *c) { node *simplified, *copy; mpq_t rational; constant_t res; if (c == NULL) return NULL; if (!isConstant(c)) return NULL; if ((c->nodeType == MEMREF) && (c->polynomialRepresentation != NULL)) { /* The expression is a polynomial but is constant. The constant of degree 0 does the job */ return __polynomialGetIthCoefficientAsConstantIntIndex(c->polynomialRepresentation, 0); } if (accessThruMemRef(c)->nodeType == CONSTANT) { return constantFromMpfr(*(accessThruMemRef(c)->value)); } mpq_init(rational); if (tryEvaluateConstantTermToMpq(rational, c)) { mpq_canonicalize(rational); res = constantFromMpq(rational); mpq_clear(rational); return res; } mpq_clear(rational); simplified = simplifyRationalErrorfree(c); if (accessThruMemRef(simplified)->nodeType == CONSTANT) { res = constantFromMpfr(*(accessThruMemRef(simplified)->value)); freeThing(simplified); return res; } if (simplified == c) { copy = addMemRef(copyThing(accessThruMemRef(simplified))); tryCopyTreeAnnotations(copy, simplified); freeThing(simplified); simplified = copy; } res = __constantAllocate(); res->refCount = 1; res->isZero.cached = 0; res->isOne.cached = 0; res->isNonNegativeInteger.cached = 0; res->isPositive.cached = 0; res->isDyadic.cached = 0; res->isRational.cached = 0; res->type = EXPRESSION; res->value.expr = simplified; res->hash.hasHash = 0; return __constantAllocatePostTreatment(res); } static inline void constantFree(constant_t c) { if (c == NULL) return; c->refCount--; if (c->refCount > 0u) return; switch (c->type) { case INTEGER: break; case EXPRESSION: freeThing(c->value.expr); break; case MPFR: mpfr_clear(c->value.mpfr); break; case SCALEDMPQ: mpq_clear(c->value.scaledMpq.significand); break; } __constantFreeMem(c); } static inline int constantIsZero(constant_t a, int defVal) { int s; if (a == NULL) return defVal; if (a->isZero.cached) return a->isZero.res; if (a->isOne.cached && a->isOne.res) return 0; if (a->isPositive.cached && a->isPositive.res) return 0; switch (a->type) { case INTEGER: a->isZero.cached = 1; a->isZero.res = (a->value.integer == 0); return a->isZero.res; break; case EXPRESSION: if (accessThruMemRef(a->value.expr)->nodeType == CONSTANT) { if (!mpfr_number_p(*(accessThruMemRef(a->value.expr)->value))) return defVal; a->isZero.cached = 1; a->isZero.res = mpfr_zero_p(*(accessThruMemRef(a->value.expr)->value)); return a->isZero.res; } if (evaluateSignFast(&s, a->value.expr)) { if (s == 0) { a->isZero.cached = 1; a->isZero.res = 1; return a->isZero.res; } else { a->isZero.cached = 1; a->isZero.res = 0; return a->isZero.res; } } return defVal; break; case MPFR: if (!mpfr_number_p(a->value.mpfr)) return defVal; a->isZero.cached = 1; a->isZero.res = mpfr_zero_p(a->value.mpfr); return a->isZero.res; break; case SCALEDMPQ: a->isZero.cached = 1; a->isZero.res = (mpq_sgn(a->value.scaledMpq.significand) == 0); return a->isZero.res; break; } return defVal; } static inline int constantIsOne(constant_t a, int defVal) { int s; if (a == NULL) return defVal; if (a->isOne.cached) return a->isOne.res; if (a->isZero.cached && a->isZero.res) return 0; switch (a->type) { case INTEGER: a->isOne.cached = 1; a->isOne.res = (a->value.integer == 1); return a->isOne.res; break; case EXPRESSION: if (accessThruMemRef(a->value.expr)->nodeType == CONSTANT) { if (!mpfr_number_p(*(accessThruMemRef(a->value.expr)->value))) return defVal; a->isOne.cached = 1; a->isOne.res = (mpfr_cmp_si(*(accessThruMemRef(a->value.expr)->value),1) == 0); return a->isOne.res; } if (evaluateSignFast(&s, a->value.expr)) { if (s <= 0) { a->isOne.cached = 1; a->isOne.res = 0; return a->isOne.res; } } return defVal; break; case MPFR: if (!mpfr_number_p(a->value.mpfr)) return defVal; a->isOne.cached = 1; a->isOne.res = (mpfr_cmp_si(a->value.mpfr,1) == 0); return a->isOne.res; break; case SCALEDMPQ: /* We have to compare 2^E * n/d == 1. This means checking 2^E * n == d */ if (mpq_sgn(a->value.scaledMpq.significand) <= 0) { a->isOne.cached = 1; a->isOne.res = 0; return a->isOne.res; } if (a->value.scaledMpq.expo == ((mp_exp_t) 0)) { /* Here, E = 0, so we have to check whether n == d */ a->isOne.cached = 1; if (mpz_cmp(mpq_numref(a->value.scaledMpq.significand), mpq_denref(a->value.scaledMpq.significand)) == 0) { a->isOne.res = 1; } else { a->isOne.res = 0; } return a->isOne.res; } /* Here E != 0 */ a->value.scaledMpq.expo += mpq_remove_powers_of_two(a->value.scaledMpq.significand); /* Exponent overflow possible */ if (a->value.scaledMpq.expo != ((mp_exp_t) 0)) { a->isOne.cached = 1; a->isOne.res = 0; return a->isOne.res; } if (mpz_cmp(mpq_numref(a->value.scaledMpq.significand), mpq_denref(a->value.scaledMpq.significand)) == 0) { a->isOne.cached = 1; } else { a->isOne.cached = 0; } return a->isOne.res; break; } return defVal; } static inline int constantIsNonNegativeInteger(constant_t a, int defVal) { int s; node *t, *d; if (a == NULL) return defVal; if (a->isNonNegativeInteger.cached) return a->isNonNegativeInteger.res; if (a->isZero.cached && a->isZero.res) return 1; if (a->isOne.cached && a->isOne.res) return 1; switch (a->type) { case INTEGER: a->isNonNegativeInteger.cached = 1; a->isNonNegativeInteger.res = (a->value.integer >= 0); return a->isNonNegativeInteger.res; break; case EXPRESSION: if (accessThruMemRef(a->value.expr)->nodeType == CONSTANT) { if (!mpfr_number_p(*(accessThruMemRef(a->value.expr)->value))) return defVal; a->isNonNegativeInteger.cached = 1; a->isNonNegativeInteger.res = ((mpfr_sgn(*(accessThruMemRef(a->value.expr)->value)) >= 0) && mpfr_integer_p(*(accessThruMemRef(a->value.expr)->value))); return a->isNonNegativeInteger.res; } if (!evaluateSignFast(&s, a->value.expr)) return defVal; if (s < 0) { a->isNonNegativeInteger.cached = 1; a->isNonNegativeInteger.res = 0; return a->isNonNegativeInteger.res; } t = addMemRef(makeSub(copyThing(a->value.expr), makeNearestInt(copyThing(a->value.expr)))); d = simplifyRationalErrorfree(t); freeThing(t); if (!evaluateSignFast(&s, d)) { freeThing(d); return defVal; } freeThing(d); a->isNonNegativeInteger.cached = 1; a->isNonNegativeInteger.res = (s == 0); return a->isNonNegativeInteger.res; break; case MPFR: if (!mpfr_number_p(a->value.mpfr)) return defVal; a->isNonNegativeInteger.cached = 1; a->isNonNegativeInteger.res = (mpfr_integer_p(a->value.mpfr) && (mpfr_sgn(a->value.mpfr) >= 0)); return a->isNonNegativeInteger.res; break; case SCALEDMPQ: if (mpq_sgn(a->value.scaledMpq.significand) < 0) return 0; a->isNonNegativeInteger.cached = 1; a->isNonNegativeInteger.res = scaledMpqIsInteger(a->value.scaledMpq.expo, a->value.scaledMpq.significand); return a->isNonNegativeInteger.res; break; } return defVal; } static inline int constantIsDyadic(constant_t a, int defVal) { if (a == NULL) return defVal; if (a->isDyadic.cached) return a->isDyadic.res; switch (a->type) { case INTEGER: a->isDyadic.cached = 1; a->isDyadic.res = 1; return a->isDyadic.res; break; case EXPRESSION: if (accessThruMemRef(a->value.expr)->nodeType == CONSTANT) { if (!mpfr_number_p(*(accessThruMemRef(a->value.expr)->value))) return defVal; a->isDyadic.cached = 1; a->isDyadic.res = 1; return a->isDyadic.res; } return defVal; break; case MPFR: if (!mpfr_number_p(a->value.mpfr)) return defVal; a->isDyadic.cached = 1; a->isDyadic.res = 1; return a->isDyadic.res; break; case SCALEDMPQ: a->isDyadic.cached = 1; a->isDyadic.res = scaledMpqIsDyadic(a->value.scaledMpq.expo, a->value.scaledMpq.significand); return a->isDyadic.res; break; } return defVal; } static inline int constantIsRational(constant_t a, int defVal) { if (a == NULL) return defVal; if (a->isRational.cached) return a->isRational.res; switch (a->type) { case INTEGER: a->isRational.cached = 1; a->isRational.res = 1; return a->isRational.res; break; case EXPRESSION: if (accessThruMemRef(a->value.expr)->nodeType == CONSTANT) { if (!mpfr_number_p(*(accessThruMemRef(a->value.expr)->value))) return defVal; a->isRational.cached = 1; a->isRational.res = 1; return a->isRational.res; } return defVal; break; case MPFR: if (!mpfr_number_p(a->value.mpfr)) return defVal; a->isRational.cached = 1; a->isRational.res = 1; return a->isRational.res; break; case SCALEDMPQ: a->isRational.cached = 1; a->isRational.res = 1; return a->isRational.res; break; } return defVal; } static inline int constantHoldsOnPrecBits(constant_t a, mp_prec_t prec, int defVal) { sollya_mpfi_t t; int res; if (a == NULL) return defVal; if (prec < 2) return defVal; sollya_mpfi_init2(t, prec + 15); constantEvalMpfi(t, a); if (sollya_mpfi_has_nan(t) || sollya_mpfi_has_infinity(t)) { res = defVal; } else { res = sollya_mpfi_is_point_and_real(t); } sollya_mpfi_clear(t); return res; } static inline int constantIsEqual(constant_t a, constant_t b, int defVal) { constant_t d; int res, sa, sb; mpq_t t; mp_exp_t G; /* Trivial answers */ if (a == NULL) return defVal; if (b == NULL) return defVal; if (a == b) return 1; /* Using a hash here is actually a bad idea as we are talking about mathematical identity not the structural one. */ if (a->type != b->type) { /* If the constants are not of the same type, compute their difference and compare to zero. */ d = constantSub(a, b); res = constantIsZero(d, defVal); constantFree(d); return res; } /* Here a and b are of the same type */ switch (a->type) { case INTEGER: return (a->value.integer == b->value.integer); break; case EXPRESSION: if ((accessThruMemRef(a->value.expr)->nodeType == CONSTANT) && (accessThruMemRef(b->value.expr)->nodeType == CONSTANT)) { if (!mpfr_number_p(*(accessThruMemRef(a->value.expr)->value))) return defVal; if (!mpfr_number_p(*(accessThruMemRef(b->value.expr)->value))) return defVal; return mpfr_equal_p(*(accessThruMemRef(a->value.expr)->value), *(accessThruMemRef(b->value.expr)->value)); } if (evaluateSignFast(&sa, a->value.expr) && evaluateSignFast(&sb, b->value.expr)) { if ((sa == 0) && (sb == 0)) { /* If both expressions are zero, they are equal */ return 1; } if (sa * sb <= 0) { /* If the expressions are of different sign, they are not equal */ return 0; } } return defVal; break; case MPFR: if (!mpfr_number_p(a->value.mpfr)) return defVal; if (!mpfr_number_p(b->value.mpfr)) return defVal; return mpfr_equal_p(a->value.mpfr,b->value.mpfr); break; case SCALEDMPQ: sa = mpq_sgn(a->value.scaledMpq.significand); sb = mpq_sgn(b->value.scaledMpq.significand); /* Reason upon the sign first */ if ((sa == 0) && (sb == 0)) return 1; if (sa * sb <= 0) return 0; /* Here a and b are of the same sign and none is zero If their exponents are equal and their significands are equal, they are equal. */ if ((a->value.scaledMpq.expo == b->value.scaledMpq.expo) && (mpq_cmp(a->value.scaledMpq.significand, b->value.scaledMpq.significand) == 0)) return 1; /* Here the exponents are unequal or the significands are unequal In order to compare 2^E * n/d to 2^F * p/q, compare 2^(E - F) to (p/q) / (n/d). */ mpq_init(t); mpq_div(t, b->value.scaledMpq.significand, a->value.scaledMpq.significand); G = mpq_remove_powers_of_two(t); /* Here, we have to compare 2^(E - F) to 2^G * t, where t = r/s = 2^-G * (p/q) / (n/d) is a fraction such that both r and s are odd. This means if * E - F != G, a and b are unequal * E - F == G: - if t is equal to one, a and b are equal - otherwise, a and b are unequal. */ if (a->value.scaledMpq.expo - b->value.scaledMpq.expo != G) { /* Exponent overflow possible */ res = 0; } else { res = (mpq_cmp_si(t, 1, 1u) == 0); } mpq_clear(t); return res; break; } return defVal; } static inline int constantIsPositive(constant_t a, int defVal) { int s; if (a == NULL) return defVal; if (a->isPositive.cached) return a->isPositive.res; if (a->isOne.cached && a->isOne.res) return 1; if (a->isZero.cached && a->isZero.res) return 0; switch (a->type) { case INTEGER: a->isPositive.cached = 1; a->isPositive.res = (a->value.integer > 0); return a->isPositive.res; break; case EXPRESSION: if (accessThruMemRef(a->value.expr)->nodeType == CONSTANT) { if (!mpfr_number_p(*(accessThruMemRef(a->value.expr)->value))) return defVal; a->isPositive.cached = 1; a->isPositive.res = (mpfr_sgn(*(accessThruMemRef(a->value.expr)->value)) > 0); return a->isPositive.res; } if (evaluateSignFast(&s, a->value.expr)) { if (s > 0) { a->isPositive.cached = 1; a->isPositive.res = 1; return a->isPositive.res; } } return defVal; break; case MPFR: if (!mpfr_number_p(a->value.mpfr)) return defVal; a->isPositive.cached = 1; a->isPositive.res = (mpfr_sgn(a->value.mpfr) > 0); return a->isPositive.res; break; case SCALEDMPQ: a->isPositive.cached = 1; a->isPositive.res = (mpq_sgn(a->value.scaledMpq.significand) > 0); return a->isPositive.res; break; } return defVal; } static inline int constantIsGreater(constant_t a, constant_t b, int defVal) { constant_t d; int res; node *dn; int sa, sb; /* Handle stupid inputs */ if (a == NULL) return defVal; if (b == NULL) return defVal; if (a == b) return 0; /* If the inputs don't have the same type, compute the difference and compare with 0. */ if (a->type != b->type) { d = constantSub(a, b); res = constantIsPositive(d, defVal); constantFree(d); return res; } /* Here, the inputs have the same representation type */ switch (a->type) { case INTEGER: return (a->value.integer > b->value.integer); break; case EXPRESSION: if ((accessThruMemRef(a->value.expr)->nodeType == CONSTANT) && (accessThruMemRef(b->value.expr)->nodeType == CONSTANT)) { if (!mpfr_number_p(*(accessThruMemRef(a->value.expr)->value))) return defVal; if (!mpfr_number_p(*(accessThruMemRef(b->value.expr)->value))) return defVal; return (mpfr_cmp(*(accessThruMemRef(a->value.expr)->value), *(accessThruMemRef(b->value.expr)->value)) > 0); } if (evaluateSignFast(&sa, a->value.expr) && evaluateSignFast(&sb, b->value.expr)) { if (sa * sb <= 0) { /* The inputs have different sign or are both zero If they are both zero, a is not greater than b. If a is positive, b is negative and a is greater than b. If a is negative, b is positive and a is not greater than b. */ if ((sa == 0) && (sb == 0)) return 0; if (sa > 0) return 1; return 0; } } /* Construct the difference and try to evaluate its sign */ dn = addMemRef(makeSub(copyThing(a->value.expr), copyThing(b->value.expr))); if (evaluateSignFast(&sa, dn)) { freeThing(dn); return (sa > 0); } freeThing(dn); return defVal; break; case MPFR: if (!mpfr_number_p(a->value.mpfr)) return defVal; if (!mpfr_number_p(b->value.mpfr)) return defVal; return (mpfr_cmp(a->value.mpfr,b->value.mpfr) > 0); break; case SCALEDMPQ: return scaledMpqIsGreaterThan(a->value.scaledMpq.expo, a->value.scaledMpq.significand, b->value.scaledMpq.expo, b->value.scaledMpq.significand); break; } return defVal; } static inline int constantIsGreaterOrEqual(constant_t a, constant_t b, int defVal) { int resGreater, resEqual; resGreater = constantIsGreater(a, b, 42); if (resGreater == 42) { resEqual = constantIsEqual(a, b, 42); if (resEqual == 42) return defVal; if (resEqual) return 1; return defVal; } if (resGreater) return 1; return constantIsEqual(a, b, defVal); } static inline node *constantToExpression(constant_t a) { mpfr_t num, den; mp_prec_t p; node *res; mp_exp_t ED, EN, EE; if (a == NULL) return NULL; switch (a->type) { case INTEGER: return addMemRef(makeConstantInt(a->value.integer)); break; case EXPRESSION: return copyThing(a->value.expr); break; case MPFR: return addMemRef(makeConstant(a->value.mpfr)); break; case SCALEDMPQ: if (mpq_sgn(a->value.scaledMpq.significand) == 0) return addMemRef(makeConstantInt(0)); if (mpz_cmp_si(mpq_denref(a->value.scaledMpq.significand),1) == 0) { /* The denominator is 1, so we do not have to take it into account */ p = mpz_sizeinbase(mpq_numref(a->value.scaledMpq.significand), 2); if (p < 12) p = 12; mpfr_init2(num, p); mpfr_set_z_2exp(num, mpq_numref(a->value.scaledMpq.significand), a->value.scaledMpq.expo, GMP_RNDN); /* exact as enough precision */ if (mpfr_number_p(num)) { res = addMemRef(makeConstant(num)); } else { mpfr_set_z(num, mpq_numref(a->value.scaledMpq.significand), GMP_RNDN); /* exact as enough precision */ res = addMemRef(makeMul(makePow(makeConstantInt(2), makeConstantInt(a->value.scaledMpq.expo)), makeConstant(num))); } mpfr_clear(num); return res; } /* Here, we must take both the numerator and the denominator into account. */ p = mpz_sizeinbase(mpq_numref(a->value.scaledMpq.significand), 2); if (p < 12) p = 12; if (a->value.scaledMpq.expo >= 0) { EN = a->value.scaledMpq.expo; ED = 0; } else { ED = -a->value.scaledMpq.expo; /* Exponent overflow possible */ EN = 0; } mpfr_init2(num, p); mpfr_set_z_2exp(num, mpq_numref(a->value.scaledMpq.significand), EN, GMP_RNDN); /* exact as enough precision */ if (mpfr_number_p(num)) { EN = 0; } else { mpfr_set_z(num, mpq_numref(a->value.scaledMpq.significand), GMP_RNDN); /* exact as enough precision */ } p = mpz_sizeinbase(mpq_denref(a->value.scaledMpq.significand), 2); if (p < 12) p = 12; mpfr_init2(den, p); mpfr_set_z_2exp(den, mpq_denref(a->value.scaledMpq.significand), ED, GMP_RNDN); /* exact as enough precision */ if (mpfr_number_p(den)) { ED = 0; } else { mpfr_set_z(den, mpq_denref(a->value.scaledMpq.significand), GMP_RNDN); /* exact as enough precision */ } EE = EN - ED; /* Exponent overflow possible */ if (EE == 0) { res = addMemRef(makeDiv(makeConstant(num),makeConstant(den))); } else { res = addMemRef(makeMul(makePow(makeConstantInt(2),makeConstantInt(EE)),makeDiv(makeConstant(num),makeConstant(den)))); } mpfr_clear(num); mpfr_clear(den); return res; break; } return NULL; } static inline int tryConstantToScaledMpq(mp_exp_t *E, mpq_t rop, constant_t a) { mpq_t t; mpz_t mant; mp_exp_t expo; if (a == NULL) return 0; switch (a->type) { case INTEGER: mpq_set_si(rop, a->value.integer, 1u); mpq_canonicalize(rop); *E = mpq_remove_powers_of_two(rop); return 1; break; case EXPRESSION: mpq_init(t); if (tryEvaluateConstantTermToMpq(t, a->value.expr)) { mpq_set(rop, t); mpq_canonicalize(rop); *E = mpq_remove_powers_of_two(rop); mpq_clear(t); return 1; } mpq_clear(t); return 0; break; case MPFR: if (!mpfr_number_p(a->value.mpfr)) return 0; if (mpfr_zero_p(a->value.mpfr)) { *E = 0; mpq_set_si(rop, 0, 1u); mpq_canonicalize(rop); return 1; } mpz_init(mant); expo = mpfr_get_z_2exp(mant, a->value.mpfr); mpq_set_z(rop, mant); mpq_canonicalize(rop); *E = expo + mpq_remove_powers_of_two(rop); /* Exponent overflow possible */ mpz_clear(mant); return 1; break; case SCALEDMPQ: *E = a->value.scaledMpq.expo; mpq_set(rop, a->value.scaledMpq.significand); mpq_canonicalize(rop); return 1; break; } return 0; } static inline int tryConstantToMpz(mpz_t r, constant_t a) { mpz_t num, den; mpq_t q; mp_exp_t EQ; if (a == NULL) return 0; switch (a->type) { case INTEGER: mpz_set_si(r, a->value.integer); return 1; break; case EXPRESSION: if ((accessThruMemRef(a->value.expr)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(a->value.expr)->value)) && mpfr_integer_p(*(accessThruMemRef(a->value.expr)->value))) { mpfr_get_z(r, *(accessThruMemRef(a->value.expr)->value), GMP_RNDN); /* exact */ return 1; } break; case MPFR: if (!mpfr_number_p(a->value.mpfr)) return 0; if (!mpfr_integer_p(a->value.mpfr)) return 0; mpfr_get_z(r, a->value.mpfr, GMP_RNDN); /* exact */ return 1; break; case SCALEDMPQ: if (!scaledMpqIsInteger(a->value.scaledMpq.expo, a->value.scaledMpq.significand)) return 0; mpz_init(num); mpz_init(den); mpq_get_num(num, a->value.scaledMpq.significand); mpq_get_den(den, a->value.scaledMpq.significand); if (a->value.scaledMpq.expo >= 0) { mpz_mul_2exp(num, num, (mp_bitcnt_t) a->value.scaledMpq.expo); } else { mpz_mul_2exp(den, den, (mp_bitcnt_t) (-a->value.scaledMpq.expo)); /* Exponent overflow possible */ } mpz_fdiv_q(r, num, den); mpz_clear(den); mpz_clear(num); return 1; break; } mpq_init(q); if (!tryConstantToScaledMpq(&EQ, q, a)) { mpq_clear(q); return 0; } if (!scaledMpqIsInteger(EQ, q)) { mpq_clear(q); return 0; } mpz_init(num); mpz_init(den); mpq_get_num(num, a->value.scaledMpq.significand); mpq_get_den(den, a->value.scaledMpq.significand); if (a->value.scaledMpq.expo >= 0) { mpz_mul_2exp(num, num, (mp_bitcnt_t) a->value.scaledMpq.expo); } else { mpz_mul_2exp(den, den, (mp_bitcnt_t) (-a->value.scaledMpq.expo)); /* Exponent overflow possible */ } mpz_fdiv_q(r, num, den); mpz_clear(den); mpz_clear(num); return 1; } static inline int tryConstantToInt(int *r, constant_t a) { mpq_t q; mp_exp_t EQ; int res; if (a == NULL) return 0; switch (a->type) { case INTEGER: *r = a->value.integer; return 1; break; case EXPRESSION: if ((accessThruMemRef(a->value.expr)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(a->value.expr)->value))) { return mpfr_is_machine_integer(r, *(accessThruMemRef(a->value.expr)->value)); } break; case MPFR: return mpfr_is_machine_integer(r, a->value.mpfr); break; default: break; } mpq_init(q); if (!tryConstantToScaledMpq(&EQ, q, a)) { mpq_clear(q); return 0; } if (!scaledMpqIsInt(&res, EQ, q)) { mpq_clear(q); return 0; } *r = res; return 1; } static inline int tryConstantToUnsignedInt(unsigned int *r, constant_t a) { mpq_t q; mp_exp_t EQ; unsigned int res; if (a == NULL) return 0; switch (a->type) { case INTEGER: if (a->value.integer < 0) return 0; *r = a->value.integer; return 1; break; case EXPRESSION: if ((accessThruMemRef(a->value.expr)->nodeType == CONSTANT) && mpfr_number_p(*(accessThruMemRef(a->value.expr)->value))) { return mpfr_is_machine_unsigned_integer(r, *(accessThruMemRef(a->value.expr)->value)); } break; case MPFR: return mpfr_is_machine_unsigned_integer(r, a->value.mpfr); break; default: break; } mpq_init(q); if (!tryConstantToScaledMpq(&EQ, q, a)) { mpq_clear(q); return 0; } if (!scaledMpqIsUnsignedInt(&res, EQ, q)) { mpq_clear(q); return 0; } *r = res; return 1; } void constantFPrintf(FILE *fd, constant_t c) { if (c == NULL) { sollyaFprintf(fd, "(null)"); return; } switch (c->type) { case INTEGER: sollyaFprintf(fd,"%d",c->value.integer); break; case EXPRESSION: sollyaFprintf(fd,"%b",c->value.expr); break; case MPFR: sollyaFprintf(fd,"%v",c->value.mpfr); break; case SCALEDMPQ: if (c->value.scaledMpq.expo == 0) { sollyaFprintf(fd,"%r", c->value.scaledMpq.significand); } else { sollyaFprintf(fd,"2^(%lld) * %r", (long long int) c->value.scaledMpq.expo, c->value.scaledMpq.significand); } break; } } char *constantToString(constant_t c) { char staticStr[8]; char *str; int size, r; if (c == NULL) return NULL; switch (c->type) { case INTEGER: size = sollya_snprintf(staticStr,8,"%d",c->value.integer); break; case EXPRESSION: size = sollya_snprintf(staticStr,8,"%b",c->value.expr); break; case MPFR: size = sollya_snprintf(staticStr,8,"%v",c->value.mpfr); break; case SCALEDMPQ: if (c->value.scaledMpq.expo == 0) { size = sollya_snprintf(staticStr,8,"%r", c->value.scaledMpq.significand); } else { size = sollya_snprintf(staticStr,8,"2^(%lld) * %r", (long long int) c->value.scaledMpq.expo, c->value.scaledMpq.significand); } break; default: return NULL; break; } if (size < 0) return NULL; str = (char *) safeCalloc(size + 2, sizeof(char)); switch (c->type) { case INTEGER: r = sollya_snprintf(str,size,"%d",c->value.integer); break; case EXPRESSION: r = sollya_snprintf(str,size,"%b",c->value.expr); break; case MPFR: r = sollya_snprintf(str,size,"%v",c->value.mpfr); break; case SCALEDMPQ: if (c->value.scaledMpq.expo == 0) { r = sollya_snprintf(str,size,"%r", c->value.scaledMpq.significand); } else { r = sollya_snprintf(str,size,"2^(%lld) * %r", (long long int) c->value.scaledMpq.expo, c->value.scaledMpq.significand); } break; default: safeFree(str); return NULL; break; } if (r < 0) { safeFree(str); return NULL; } return str; } static inline constant_t constantAdd(constant_t a, constant_t b) { node *aExpr, *bExpr, *cExpr; constant_t res; mpq_t aS, bS, cS; mp_exp_t EA, EB, EC; int cI; mpz_t cZ; unsigned long int bAbs; mpfr_t cM; /* Stupid inputs */ if (a == NULL) return NULL; if (b == NULL) return NULL; /* Operation on neutral element */ if (constantIsZero(a, 0)) return constantFromCopy(b); if (constantIsZero(b, 0)) return constantFromCopy(a); /* Handling expression representations */ if ((a->type == EXPRESSION) || (b->type == EXPRESSION)) { /* One of the two constants is an expression. Get expression representations for both, construct the expression for the operation and build the result constant. */ aExpr = constantToExpression(a); bExpr = constantToExpression(b); cExpr = addMemRef(makeAdd(aExpr, bExpr)); res = constantFromExpression(cExpr); freeThing(cExpr); return res; } /* Here, none of the constants a and b is represented by an expression Now handle the case when both constants are represented by the same type. */ if (a->type == b->type) { switch (a->type) { case INTEGER: if (tryExactIntAddition(&cI, a->value.integer, b->value.integer)) { res = constantFromInt(cI); return res; } mpz_init_set_si(cZ, a->value.integer); if (b->value.integer >= 0) { bAbs = b->value.integer; mpz_add_ui(cZ, cZ, bAbs); } else { bAbs = - b->value.integer; mpz_sub_ui(cZ, cZ, bAbs); } res = constantFromMpz(cZ); mpz_clear(cZ); return res; break; case MPFR: mpfr_init2(cM, 12); /* Next call may change the precision of cM */ mpfr_add_exact(cM, a->value.mpfr, b->value.mpfr); if (mpfr_number_p(a->value.mpfr) && mpfr_number_p(b->value.mpfr) && (!mpfr_number_p(cM))) { cExpr = addMemRef(makeAdd(makeConstant(a->value.mpfr), makeConstant(b->value.mpfr))); res = constantFromExpression(cExpr); freeThing(cExpr); } else { res = constantFromMpfr(cM); } mpfr_clear(cM); return res; break; case SCALEDMPQ: mpq_init(cS); scaledMpqAdd(&EC, cS, a->value.scaledMpq.expo, a->value.scaledMpq.significand, b->value.scaledMpq.expo, b->value.scaledMpq.significand); res = constantFromScaledMpq(EC, cS); mpq_clear(cS); return res; break; default: break; } } /* Handle the case when only one of the inputs is a machine integer */ if (a->type == INTEGER) { switch (b->type) { case MPFR: mpfr_init2(cM, 12); /* Next call may change the precision of cM */ mpfr_add_exact_int(cM, b->value.mpfr, a->value.integer); if (mpfr_number_p(b->value.mpfr) && (!mpfr_number_p(cM))) { cExpr = addMemRef(makeAdd(makeConstantInt(a->value.integer), makeConstant(b->value.mpfr))); res = constantFromExpression(cExpr); freeThing(cExpr); } else { res = constantFromMpfr(cM); } mpfr_clear(cM); return res; break; case SCALEDMPQ: mpq_init(cS); scaledMpqAddInt(&EC, cS, b->value.scaledMpq.expo, b->value.scaledMpq.significand, a->value.integer); res = constantFromScaledMpq(EC, cS); mpq_clear(cS); return res; break; default: break; } } if (b->type == INTEGER) { switch (a->type) { case MPFR: mpfr_init2(cM, 12); /* Next call may change the precision of cM */ mpfr_add_exact_int(cM, a->value.mpfr, b->value.integer); if (mpfr_number_p(a->value.mpfr) && (!mpfr_number_p(cM))) { cExpr = addMemRef(makeAdd(makeConstant(a->value.mpfr), makeConstantInt(b->value.integer))); res = constantFromExpression(cExpr); freeThing(cExpr); } else { res = constantFromMpfr(cM); } mpfr_clear(cM); return res; break; case SCALEDMPQ: mpq_init(cS); scaledMpqAddInt(&EC, cS, a->value.scaledMpq.expo, a->value.scaledMpq.significand, b->value.integer); res = constantFromScaledMpq(EC, cS); mpq_clear(cS); return res; break; default: break; } } /* Here, none of the constants a and b is represented by an expression and they are of different types. Convert both constants to scaled rational form, perform the operation and convert back. If one of the conversions to scaled rational form fails, convert to expression form and work with expression form. */ mpq_init(aS); mpq_init(bS); if (tryConstantToScaledMpq(&EA, aS, a) && tryConstantToScaledMpq(&EB, bS, b)) { mpq_init(cS); scaledMpqAdd(&EC, cS, EA, aS, EB, bS); res = constantFromScaledMpq(EC, cS); mpq_clear(aS); mpq_clear(bS); mpq_clear(cS); return res; } mpq_clear(aS); mpq_clear(bS); /* Could not convert to scaled rational form. Convert to expressions. */ aExpr = constantToExpression(a); bExpr = constantToExpression(b); cExpr = addMemRef(makeAdd(aExpr, bExpr)); res = constantFromExpression(cExpr); freeThing(cExpr); return res; } static inline constant_t constantSub(constant_t a, constant_t b) { node *aExpr, *bExpr, *cExpr; constant_t res; mpq_t aS, bS, cS; mp_exp_t EA, EB, EC; int cI; mpz_t cZ; unsigned long int bAbs; mpfr_t cM; /* Stupid inputs */ if (a == NULL) return NULL; if (b == NULL) return NULL; /* Operation on neutral element */ if (constantIsZero(a, 0)) return constantNeg(b); if (constantIsZero(b, 0)) return constantFromCopy(a); /* Handling expression representations */ if ((a->type == EXPRESSION) || (b->type == EXPRESSION)) { /* One of the two constants is an expression. Get expression representations for both, construct the expression for the operation and build the result constant. */ aExpr = constantToExpression(a); bExpr = constantToExpression(b); cExpr = addMemRef(makeSub(aExpr, bExpr)); res = constantFromExpression(cExpr); freeThing(cExpr); return res; } /* Here, none of the constants a and b is represented by an expression Now handle the case when both constants are represented by the same type. */ if (a->type == b->type) { switch (a->type) { case INTEGER: if (tryExactIntSubtraction(&cI, a->value.integer, b->value.integer)) { res = constantFromInt(cI); return res; } mpz_init_set_si(cZ, a->value.integer); if (b->value.integer >= 0) { bAbs = b->value.integer; mpz_sub_ui(cZ, cZ, bAbs); } else { bAbs = - b->value.integer; mpz_add_ui(cZ, cZ, bAbs); } res = constantFromMpz(cZ); mpz_clear(cZ); return res; break; case MPFR: mpfr_init2(cM, 12); /* Next call may change the precision of cM */ mpfr_sub_exact(cM, a->value.mpfr, b->value.mpfr); if (mpfr_number_p(a->value.mpfr) && mpfr_number_p(b->value.mpfr) && (!mpfr_number_p(cM))) { cExpr = addMemRef(makeSub(makeConstant(a->value.mpfr), makeConstant(b->value.mpfr))); res = constantFromExpression(cExpr); freeThing(cExpr); } else { res = constantFromMpfr(cM); } mpfr_clear(cM); return res; break; case SCALEDMPQ: mpq_init(cS); scaledMpqSub(&EC, cS, a->value.scaledMpq.expo, a->value.scaledMpq.significand, b->value.scaledMpq.expo, b->value.scaledMpq.significand); res = constantFromScaledMpq(EC, cS); mpq_clear(cS); return res; break; default: break; } } /* Handle the case when only one of the inputs is a machine integer */ if (a->type == INTEGER) { switch (b->type) { case MPFR: mpfr_init2(cM, 12); /* Next call may change the precision of cM */ mpfr_int_sub_exact(cM, a->value.integer, b->value.mpfr); if (mpfr_number_p(b->value.mpfr) && (!mpfr_number_p(cM))) { cExpr = addMemRef(makeSub(makeConstantInt(a->value.integer), makeConstant(b->value.mpfr))); res = constantFromExpression(cExpr); freeThing(cExpr); } else { res = constantFromMpfr(cM); } mpfr_clear(cM); return res; break; case SCALEDMPQ: mpq_init(cS); scaledMpqIntSub(&EC, cS, a->value.integer, b->value.scaledMpq.expo, b->value.scaledMpq.significand); res = constantFromScaledMpq(EC, cS); mpq_clear(cS); return res; break; default: break; } } if (b->type == INTEGER) { switch (a->type) { case MPFR: mpfr_init2(cM, 12); /* Next call may change the precision of cM */ mpfr_sub_exact_int(cM, a->value.mpfr, b->value.integer); if (mpfr_number_p(a->value.mpfr) && (!mpfr_number_p(cM))) { cExpr = addMemRef(makeSub(makeConstant(a->value.mpfr), makeConstantInt(b->value.integer))); res = constantFromExpression(cExpr); freeThing(cExpr); } else { res = constantFromMpfr(cM); } mpfr_clear(cM); return res; break; case SCALEDMPQ: mpq_init(cS); scaledMpqSubInt(&EC, cS, a->value.scaledMpq.expo, a->value.scaledMpq.significand, b->value.integer); res = constantFromScaledMpq(EC, cS); mpq_clear(cS); return res; break; default: break; } } /* Here, none of the constants a and b is represented by an expression and they are of different types. Convert both constants to scaled rational form, perform the operation and convert back. If one of the conversions to scaled rational form fails, convert to expression form and work with expression form. */ mpq_init(aS); mpq_init(bS); if (tryConstantToScaledMpq(&EA, aS, a) && tryConstantToScaledMpq(&EB, bS, b)) { mpq_init(cS); scaledMpqSub(&EC, cS, EA, aS, EB, bS); res = constantFromScaledMpq(EC, cS); mpq_clear(aS); mpq_clear(bS); mpq_clear(cS); return res; } mpq_clear(aS); mpq_clear(bS); /* Could not convert to scaled rational form. Convert to expressions. */ aExpr = constantToExpression(a); bExpr = constantToExpression(b); cExpr = addMemRef(makeSub(aExpr, bExpr)); res = constantFromExpression(cExpr); freeThing(cExpr); return res; } static inline constant_t constantMul(constant_t a, constant_t b) { node *aExpr, *bExpr, *cExpr; constant_t res; mpq_t aS, bS, cS; mp_exp_t EA, EB, EC; int cI; mpz_t cZ; mpfr_t cM; /* Stupid inputs */ if (a == NULL) return NULL; if (b == NULL) return NULL; /* Operation on neutral element */ if (constantIsOne(a, 0)) return constantFromCopy(b); if (constantIsOne(b, 0)) return constantFromCopy(a); /* Handling expression representations */ if ((a->type == EXPRESSION) || (b->type == EXPRESSION)) { /* One of the two constants is an expression. Get expression representations for both, construct the expression for the operation and build the result constant. */ aExpr = constantToExpression(a); bExpr = constantToExpression(b); cExpr = addMemRef(makeMul(aExpr, bExpr)); res = constantFromExpression(cExpr); freeThing(cExpr); return res; } /* Here, none of the constants a and b is represented by an expression Now handle the case when both constants are represented by the same type. */ if (a->type == b->type) { switch (a->type) { case INTEGER: if (tryExactIntMultiplication(&cI, a->value.integer, b->value.integer)) { res = constantFromInt(cI); return res; } mpz_init_set_si(cZ, a->value.integer); mpz_mul_si(cZ, cZ, b->value.integer); res = constantFromMpz(cZ); mpz_clear(cZ); return res; break; case MPFR: mpfr_init2(cM, 12); /* Next call may change the precision of cM */ mpfr_mul_exact(cM, a->value.mpfr, b->value.mpfr); if (mpfr_number_p(a->value.mpfr) && mpfr_number_p(b->value.mpfr) && (!mpfr_number_p(cM))) { cExpr = addMemRef(makeMul(makeConstant(a->value.mpfr), makeConstant(b->value.mpfr))); res = constantFromExpression(cExpr); freeThing(cExpr); } else { res = constantFromMpfr(cM); } mpfr_clear(cM); return res; break; case SCALEDMPQ: mpq_init(cS); scaledMpqMul(&EC, cS, a->value.scaledMpq.expo, a->value.scaledMpq.significand, b->value.scaledMpq.expo, b->value.scaledMpq.significand); res = constantFromScaledMpq(EC, cS); mpq_clear(cS); return res; break; default: break; } } /* Handle the case when only one of the inputs is a machine integer */ if (a->type == INTEGER) { switch (b->type) { case MPFR: mpfr_init2(cM, 12); /* Next call may change the precision of cM */ mpfr_mul_exact_int(cM, b->value.mpfr, a->value.integer); if (mpfr_number_p(b->value.mpfr) && (!mpfr_number_p(cM))) { cExpr = addMemRef(makeMul(makeConstantInt(a->value.integer), makeConstant(b->value.mpfr))); res = constantFromExpression(cExpr); freeThing(cExpr); } else { res = constantFromMpfr(cM); } mpfr_clear(cM); return res; break; case SCALEDMPQ: mpq_init(cS); scaledMpqMulInt(&EC, cS, b->value.scaledMpq.expo, b->value.scaledMpq.significand, a->value.integer); res = constantFromScaledMpq(EC, cS); mpq_clear(cS); return res; break; default: break; } } if (b->type == INTEGER) { switch (a->type) { case MPFR: mpfr_init2(cM, 12); /* Next call may change the precision of cM */ mpfr_mul_exact_int(cM, a->value.mpfr, b->value.integer); if (mpfr_number_p(a->value.mpfr) && (!mpfr_number_p(cM))) { cExpr = addMemRef(makeMul(makeConstant(a->value.mpfr), makeConstantInt(b->value.integer))); res = constantFromExpression(cExpr); freeThing(cExpr); } else { res = constantFromMpfr(cM); } mpfr_clear(cM); return res; break; case SCALEDMPQ: mpq_init(cS); scaledMpqMulInt(&EC, cS, a->value.scaledMpq.expo, a->value.scaledMpq.significand, b->value.integer); res = constantFromScaledMpq(EC, cS); mpq_clear(cS); return res; break; default: break; } } /* Here, none of the constants a and b is represented by an expression and they are of different types. Convert both constants to scaled rational form, perform the operation and convert back. If one of the conversions to scaled rational form fails, convert to expression form and work with expression form. */ mpq_init(aS); mpq_init(bS); if (tryConstantToScaledMpq(&EA, aS, a) && tryConstantToScaledMpq(&EB, bS, b)) { mpq_init(cS); scaledMpqMul(&EC, cS, EA, aS, EB, bS); res = constantFromScaledMpq(EC, cS); mpq_clear(aS); mpq_clear(bS); mpq_clear(cS); return res; } mpq_clear(aS); mpq_clear(bS); /* Could not convert to scaled rational form. Convert to expressions. */ aExpr = constantToExpression(a); bExpr = constantToExpression(b); cExpr = addMemRef(makeMul(aExpr, bExpr)); res = constantFromExpression(cExpr); freeThing(cExpr); return res; } static inline constant_t constantDiv(constant_t a, constant_t b) { node *aExpr, *bExpr, *cExpr; constant_t res; mpq_t aS, bS, cS, cQ; mp_exp_t EA, EB, EC; int cI; unsigned long int bAbs; /* Stupid inputs */ if (a == NULL) return NULL; if (b == NULL) return NULL; /* Operation on neutral element */ if (constantIsOne(b, 0)) return constantFromCopy(a); /* Handling expression representations */ if ((a->type == EXPRESSION) || (b->type == EXPRESSION)) { /* One of the two constants is an expression. Get expression representations for both, construct the expression for the operation and build the result constant. */ aExpr = constantToExpression(a); bExpr = constantToExpression(b); cExpr = addMemRef(makeDiv(aExpr, bExpr)); res = constantFromExpression(cExpr); freeThing(cExpr); return res; } /* Here, none of the constants a and b is represented by an expression Now handle the case when both constants are represented by the same type. */ if (a->type == b->type) { switch (a->type) { case INTEGER: if (b->value.integer != 0) { if (tryExactIntDivision(&cI, a->value.integer, b->value.integer)) { res = constantFromInt(cI); return res; } mpq_init(cQ); if (b->value.integer >= 0) { bAbs = b->value.integer; mpq_set_si(cQ,a->value.integer,bAbs); mpq_canonicalize(cQ); } else { bAbs = - b->value.integer; mpq_set_si(cQ,a->value.integer,bAbs); mpq_canonicalize(cQ); mpq_neg(cQ, cQ); } res = constantFromMpq(cQ); mpq_clear(cQ); return res; } break; case MPFR: /* Do nothing for this case, let the common scaled MPQ logic handle it below. For cases when the MPFR values are Inf or NaN, the MPQ logic will handle the case over to expression logic. */ break; case SCALEDMPQ: mpq_init(cS); if (tryScaledMpqDiv(&EC, cS, a->value.scaledMpq.expo, a->value.scaledMpq.significand, b->value.scaledMpq.expo, b->value.scaledMpq.significand)) { res = constantFromScaledMpq(EC, cS); mpq_clear(cS); return res; } mpq_clear(cS); break; default: break; } } /* Here, none of the constants a and b is represented by an expression and they are of different types or the division on the same type did not work. Convert both constants to scaled rational form, perform the operation and convert back. If one of the conversions to scaled rational form fails, convert to expression form and work with expression form. */ mpq_init(aS); mpq_init(bS); if (tryConstantToScaledMpq(&EA, aS, a) && tryConstantToScaledMpq(&EB, bS, b)) { mpq_init(cS); if (tryScaledMpqDiv(&EC, cS, EA, aS, EB, bS)) { res = constantFromScaledMpq(EC, cS); mpq_clear(aS); mpq_clear(bS); mpq_clear(cS); return res; } mpq_clear(cS); } mpq_clear(aS); mpq_clear(bS); /* Could not convert to scaled rational form or the division did not work. Convert to expressions. */ aExpr = constantToExpression(a); bExpr = constantToExpression(b); cExpr = addMemRef(makeDiv(aExpr, bExpr)); res = constantFromExpression(cExpr); freeThing(cExpr); return res; } static inline constant_t constantPow(constant_t a, constant_t b) { node *aExpr, *bExpr, *cExpr; constant_t res; mpq_t aS, bS, cS; mp_exp_t EA, EB, EC; int cI; mpfr_t cM; unsigned long int bAbs; int bb; mpz_t cZ; /* Stupid inputs */ if (a == NULL) return NULL; if (b == NULL) return NULL; /* Operation on neutral element */ if (constantIsOne(a, 0)) return constantFromCopy(a); if (constantIsOne(b, 0)) return constantFromCopy(a); if (constantIsZero(b, 0)) return constantFromInt(1); /* Handling expression representations */ if ((a->type == EXPRESSION) || (b->type == EXPRESSION)) { /* One of the two constants is an expression. Get expression representations for both, construct the expression for the operation and build the result constant. */ aExpr = constantToExpression(a); bExpr = constantToExpression(b); cExpr = addMemRef(makePow(aExpr, bExpr)); res = constantFromExpression(cExpr); freeThing(cExpr); return res; } /* Here, none of the constants a and b is represented by an expression Now handle the case when both constants are represented by the same type. */ if (a->type == b->type) { switch (a->type) { case INTEGER: if (tryExactIntPower(&cI, a->value.integer, b->value.integer)) { res = constantFromInt(cI); return res; } if (b->value.integer > 0) { bAbs = b->value.integer; mpz_init_set_si(cZ, a->value.integer); mpz_pow_ui(cZ, cZ, bAbs); res = constantFromMpz(cZ); mpz_clear(cZ); return res; } break; case MPFR: if (mpfr_number_p(a->value.mpfr) && mpfr_number_p(b->value.mpfr) && mpfr_integer_p(b->value.mpfr) && (mpfr_cmp_si(b->value.mpfr, 1) >= 0) && mpfr_fits_ulong_p(b->value.mpfr, GMP_RNDN)) { bAbs = mpfr_get_ui(b->value.mpfr, GMP_RNDN); /* exact */ mpfr_init2(cM, 12); if (try_mpfr_pow_exact(cM, a->value.mpfr, bAbs)) { if (mpfr_number_p(a->value.mpfr) && (!mpfr_number_p(cM))) { cExpr = addMemRef(makePow(makeConstant(a->value.mpfr), makeConstantUnsignedInt(bAbs))); res = constantFromExpression(cExpr); freeThing(cExpr); } else { res = constantFromMpfr(cM); } mpfr_clear(cM); return res; } mpfr_clear(cM); } break; case SCALEDMPQ: mpq_init(cS); if (tryScaledMpqPow(&EC, cS, a->value.scaledMpq.expo, a->value.scaledMpq.significand, b->value.scaledMpq.expo, b->value.scaledMpq.significand)) { res = constantFromScaledMpq(EC, cS); mpq_clear(cS); return res; } mpq_clear(cS); break; default: break; } } /* Handle the case when b is a machine integer and a is not */ if (b->type == INTEGER) { switch (a->type) { case MPFR: if (mpfr_number_p(a->value.mpfr) && (b->value.integer >= 1)) { bAbs = b->value.integer; bb = bAbs; if ((bAbs >= 1) && (bb == b->value.integer)) { mpfr_init2(cM, 12); if (try_mpfr_pow_exact(cM, a->value.mpfr, bAbs)) { if (mpfr_number_p(a->value.mpfr) && (!mpfr_number_p(cM))) { cExpr = addMemRef(makePow(makeConstant(a->value.mpfr), makeConstantInt(b->value.integer))); res = constantFromExpression(cExpr); freeThing(cExpr); } else { res = constantFromMpfr(cM); } mpfr_clear(cM); return res; } mpfr_clear(cM); } } break; case SCALEDMPQ: mpq_init(cS); if (tryScaledMpqPowInt(&EC, cS, a->value.scaledMpq.expo, a->value.scaledMpq.significand, b->value.integer)) { res = constantFromScaledMpq(EC, cS); mpq_clear(cS); return res; } mpq_clear(cS); break; default: break; } } /* Here, none of the constants a and b is represented by an expression and they are of different types or the powering on the same type did not work. Convert both constants to scaled rational form, perform the operation and convert back. If one of the conversions to scaled rational form fails, convert to expression form and work with expression form. */ mpq_init(aS); mpq_init(bS); if (tryConstantToScaledMpq(&EA, aS, a) && tryConstantToScaledMpq(&EB, bS, b)) { mpq_init(cS); if (tryScaledMpqPow(&EC, cS, EA, aS, EB, bS)) { res = constantFromScaledMpq(EC, cS); mpq_clear(aS); mpq_clear(bS); mpq_clear(cS); return res; } mpq_clear(cS); } mpq_clear(aS); mpq_clear(bS); /* Could not convert to scaled rational form or the powering did not work. Convert to expressions. */ aExpr = constantToExpression(a); bExpr = constantToExpression(b); cExpr = addMemRef(makePow(aExpr, bExpr)); res = constantFromExpression(cExpr); freeThing(cExpr); return res; } static inline constant_t constantNeg(constant_t a) { constant_t res; int cI; mpz_t cZ; node *cExpr; mpfr_t cM; mpq_t cQ; if (a == NULL) return NULL; switch (a->type) { case INTEGER: if (tryExactIntNegation(&cI, a->value.integer)) { res = constantFromInt(cI); return res; } mpz_init_set_si(cZ, a->value.integer); mpz_neg(cZ,cZ); res = constantFromMpz(cZ); mpz_clear(cZ); return res; break; case EXPRESSION: cExpr = addMemRef(makeNeg(copyThing(a->value.expr))); res = constantFromExpression(cExpr); freeThing(cExpr); return res; break; case MPFR: mpfr_init2(cM, mpfr_get_prec(a->value.mpfr)); mpfr_neg(cM, a->value.mpfr, GMP_RNDN); /* exact */ res = constantFromMpfr(cM); mpfr_clear(cM); return res; break; case SCALEDMPQ: mpq_init(cQ); mpq_neg(cQ, a->value.scaledMpq.significand); res = constantFromScaledMpq(a->value.scaledMpq.expo, cQ); mpq_clear(cQ); return res; break; } return NULL; } /* Computes q and r such that 2^14 * q + r = a and q = floor(a * 2^-14) */ static inline void constantCutTwo14(constant_t *q, constant_t *r, constant_t a) { int qI, rI; node *qN, *rN; mpfr_t qM, rM; mp_exp_t qE, rE; mpq_t qQ, rQ; /* Handle stupid input */ if (a == NULL) { *q = NULL; *r = NULL; return; } switch (a->type) { case INTEGER: /* The int type is guaranteed to have at least 16 bits. So a shift by 14 bits is guaranteed to work. */ qI = a->value.integer >> 14; rI = a->value.integer - (qI << 14); *q = constantFromInt(qI); *r = constantFromInt(rI); break; case EXPRESSION: qN = addMemRef(makeFloor(makeMul(copyThing(a->value.expr), makePow(makeConstantInt(2), makeConstantInt(-14))))); rN = addMemRef(makeSub(copyThing(a->value.expr), makeMul(makePow(makeConstantInt(2), makeConstantInt(14)), copyThing(qN)))); *q = constantFromExpression(qN); *r = constantFromExpression(rN); freeThing(qN); freeThing(rN); break; case MPFR: mpfr_init2(qM, mpfr_get_prec(a->value.mpfr)); mpfr_init2(rM, mpfr_get_prec(a->value.mpfr)); mpfr_div_2si(qM, a->value.mpfr, 14, GMP_RNDN); /* exact */ mpfr_floor(qM, qM); /* exact */ mpfr_mul_2si(rM, qM, 14, GMP_RNDN); /* exact */ mpfr_sub(rM, a->value.mpfr, rM, GMP_RNDN); /* exact, Sterbenz */ *q = constantFromMpfr(qM); *r = constantFromMpfr(rM); mpfr_clear(rM); mpfr_clear(qM); break; case SCALEDMPQ: mpq_init(qQ); mpq_init(rQ); scaledMpqFloor(&qE, qQ, a->value.scaledMpq.expo - 14, a->value.scaledMpq.significand); scaledMpqSub(&rE, rQ, a->value.scaledMpq.expo, a->value.scaledMpq.significand, qE + 14, qQ); *q = constantFromScaledMpq(qE, qQ); *r = constantFromScaledMpq(rE, rQ); mpq_clear(rQ); mpq_clear(qQ); break; } } static inline void constantEvalMpfr(mpfr_t rop, constant_t c) { mp_prec_t p; mpfr_t cutoff; int res; sollya_mpfi_t y; /* Handle stupid input */ if (c == NULL) { mpfr_set_nan(rop); return; } /* Evaluation depending on the representation type */ switch (c->type) { case INTEGER: mpfr_set_si(rop, c->value.integer, GMP_RNDN); break; case EXPRESSION: mpfr_set_nan(rop); mpfr_init2(cutoff, 12); mpfr_set_si(cutoff, 0, GMP_RNDN); res = evaluateFaithfulWithCutOffFast(rop, c->value.expr, NULL, rop, cutoff, mpfr_get_prec(rop) + 10); if (res == 0) { sollya_mpfi_init2(y, mpfr_get_prec(rop) + 10); evaluateConstantExpressionToInterval(y, c->value.expr); if (!(sollya_mpfi_has_infinity(y) || sollya_mpfi_has_nan(y))) { mpfr_set_si(rop, 0, GMP_RNDN); } sollya_mpfi_clear(y); } mpfr_clear(cutoff); break; case MPFR: mpfr_set(rop, c->value.mpfr, GMP_RNDN); break; case SCALEDMPQ: p = mpfr_get_prec(rop); mpfr_set_prec(rop, p + 10); mpfr_set_z_2exp(rop, mpq_numref(c->value.scaledMpq.significand), c->value.scaledMpq.expo, GMP_RNDN); mpfr_div_z(rop, rop, mpq_denref(c->value.scaledMpq.significand), GMP_RNDN); mpfr_prec_round(rop, p, GMP_RNDN); break; } } static inline void constantEvalMpfi(sollya_mpfi_t rop, constant_t c) { mp_prec_t p; /* Handle stupid input */ if (c == NULL) { sollya_mpfi_set_nan(rop); return; } /* Evaluation depending on the representation type */ switch (c->type) { case INTEGER: sollya_mpfi_set_si(rop, c->value.integer); break; case EXPRESSION: evaluateConstantExpressionToInterval(rop, c->value.expr); break; case MPFR: sollya_mpfi_set_fr(rop, c->value.mpfr); break; case SCALEDMPQ: p = sollya_mpfi_get_prec(rop); sollya_mpfi_set_prec(rop, p + 10); sollya_mpfi_set_z_2exp(rop, mpq_numref(c->value.scaledMpq.significand), c->value.scaledMpq.expo); sollya_mpfi_div_z(rop, rop, mpq_denref(c->value.scaledMpq.significand)); sollya_mpfi_prec_round(rop, p); break; } } static inline constant_t constantRoundDyadic(constant_t c, mp_prec_t prec) { mpfr_t v; constant_t res; /* Handle stupid inputs */ if (c == NULL) return NULL; /* If c is already dyadic, return a copy of c */ if (constantIsDyadic(c, 0)) return constantFromCopy(c); /* Here, c is not dyadic. Allocate an MPFR variable with precision prec and evaluate c to that precision. */ mpfr_init2(v, prec); constantEvalMpfr(v, c); if (mpfr_number_p(v)) { res = constantFromMpfr(v); } else { res = constantFromCopy(c); } mpfr_clear(v); return res; } static inline constant_t constantRoundRational(constant_t c, mp_prec_t prec) { mpfr_t v; constant_t res; /* Handle stupid inputs */ if (c == NULL) return NULL; /* If c is already rational, return a copy of c */ if (constantIsRational(c, 0)) return constantFromCopy(c); /* Here, c is not rational. Allocate an MPFR variable with precision prec and evaluate c to that precision. */ mpfr_init2(v, prec); constantEvalMpfr(v, c); if (mpfr_number_p(v)) { res = constantFromMpfr(v); } else { res = constantFromCopy(c); } mpfr_clear(v); return res; } static inline constant_t constantRound(constant_t c, mp_prec_t prec) { mpfr_t v; constant_t res; /* Handle stupid inputs */ if (c == NULL) return NULL; /* If c holds on prec bits, return a copy of c */ if (constantHoldsOnPrecBits(c, prec, 0)) return constantFromCopy(c); /* Here, c does not hold on prec bits. Allocate an MPFR variable with precision prec and evaluate c to that precision. */ mpfr_init2(v, prec); constantEvalMpfr(v, c); if (mpfr_number_p(v)) { res = constantFromMpfr(v); } else { res = constantFromCopy(c); } mpfr_clear(v); return res; } static inline int constantReferencesExpression(constant_t c, node *expr) { /* Handle stupid input */ if (c == NULL) return 0; /* Evaluation depending on the representation type */ switch (c->type) { case EXPRESSION: if (c->value.expr == expr) return 1; if (accessThruMemRef(c->value.expr) == expr) return 1; return 0; break; case INTEGER: case MPFR: case SCALEDMPQ: return 0; break; } return 0; } static inline int constantUsesExpressionConstant(constant_t c) { /* Handle stupid input */ if (c == NULL) return 0; /* Evaluation depending on the representation type */ return (c->type == EXPRESSION); } static inline uint64_t constantHash(constant_t c) { uint64_t hash; /* Handle stupid input */ if (c == NULL) return hashPointer(NULL); /* Check if the hash has already been computed */ if (c->hash.hasHash) { return c->hash.hash; } /* Compute the hash */ hash = hashInt((int) (c->type)); switch (c->type) { case INTEGER: hash = hashCombine(hash, hashInt(c->value.integer)); break; case EXPRESSION: hash = hashCombine(hash, hashThingNoPolynomialHandling(c->value.expr)); break; case MPFR: hash = hashCombine(hash, hashMpfr(c->value.mpfr)); break; case SCALEDMPQ: hash = hashCombine(hash, hashCombine(hashInt64((int64_t) (c->value.scaledMpq.expo)), hashMpq(c->value.scaledMpq.significand))); break; } /* Cache the result */ c->hash.hash = hash; c->hash.hasHash = 1; /* Return the hash */ return hash; } /* End of part for constants */ /* Start of part for sparse polynomials */ static inline sparse_polynomial_t __polynomialGetSparsePolynomial(polynomial_t); static inline int sparsePolynomialPowConstant(sparse_polynomial_t *, sparse_polynomial_t, constant_t); static inline int sparsePolynomialGetDegreeAsInt(sparse_polynomial_t); static inline int sparsePolynomialCoefficientsAreRational(sparse_polynomial_t, int); static inline sparse_polynomial_t sparsePolynomialPowUnsignedInt(sparse_polynomial_t, unsigned int); static inline sparse_polynomial_t __sparsePolynomialAllocate() { return (sparse_polynomial_t) safeMalloc(sizeof(struct __sparse_polynomial_struct_t)); } static inline void __sparsePolynomialFreeMem(sparse_polynomial_t p) { safeFree(p); } static inline void sparsePolynomialInitializeCaches() { constantInitializeCaches(); } static inline void sparsePolynomialFreeCaches() { constantFreeCaches(); } static inline void __sparsePolynomialAdjustDegree(sparse_polynomial_t p) { unsigned int i, k; if (p == NULL) return; for (k=0u,i=p->monomialCount-1u;i>=1u;i--,k++) { if (!constantIsZero(p->coeffs[i],0)) break; } if (k == 0u) return; for (i=p->monomialCount-k;imonomialCount;i++) { constantFree(p->coeffs[i]); constantFree(p->monomialDegrees[i]); } p->monomialCount -= k; constantFree(p->deg); p->deg = constantFromCopy(p->monomialDegrees[p->monomialCount-1u]); p->coeffs = (constant_t *) safeRealloc(p->coeffs, ((size_t) (p->monomialCount)) * sizeof(constant_t)); p->monomialDegrees = (constant_t *) safeRealloc(p->monomialDegrees, ((size_t) (p->monomialCount)) * sizeof(constant_t)); } static inline int __sparsePolynomialAscendingDegrees(sparse_polynomial_t p, int defVal) { unsigned int i; int ord; if (p == NULL) return defVal; if (p->monomialCount <= 1u) return 1; for (i=1u;imonomialCount;i++) { ord = constantIsGreater(p->monomialDegrees[i], p->monomialDegrees[i-1u], 19); if (ord == 19) return defVal; if (!ord) return 0; } return 1; } /* Given a array a of n constants, sorted in ascending order, find the lowest index of an element greater than or equal to d. If n is zero, return n. Otherwise: - if the 0-th (first) element of the array is greater than or equal to d, return 0. - if the (n-1)-th (last) element of the array is less than d, return n. - otherwise return the lowest index of an element greater than or equal to d. The algorithm is just supposed to work; it can have a ridiculous complexity. */ static inline unsigned int __sparsePolynomialFindDegreeNaive(constant_t d, constant_t *a, unsigned int n) { unsigned int i; if (n == 0u) return n; for (i=0u; i 1. */ for (l=0u, r=n-1u; r - l > 1u; /* nothing */) { /* Compute the middle of the interval between l and r */ t = l; t += r; t >>= 1; m = t; /* Check value at the middle of the interval */ tv = constantIsGreaterOrEqual(a[m],d,42); if (tv == 42) return __sparsePolynomialFindDegreeNaive(d, a, n); if (tv) { /* Here, d <= a[m], so the new interval becomes [l;m] */ r = m; } else { /* Here, a[m] < d, so the new interval becomes [m;r] */ l = m; } } /* Here, we know that a[l] < d and d <= a[r] */ for (i=l; l<=r; i++) { tv = constantIsGreaterOrEqual(a[i],d,42); if (tv == 42) return __sparsePolynomialFindDegreeNaive(d, a, n); if (tv) return i; } /* Can only be reached if comparison not possible */ return __sparsePolynomialFindDegreeNaive(d, a, n); } static inline sparse_polynomial_t sparsePolynomialFromMpfrConstant(mpfr_t c) { sparse_polynomial_t res; res = __sparsePolynomialAllocate(); res->refCount = 1; res->monomialCount = 1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->coeffs[0] = constantFromMpfr(c); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees[0] = constantFromInt(0); res->deg = constantFromCopy(res->monomialDegrees[0]); res->hash.hasHash = 0; return res; } static inline sparse_polynomial_t sparsePolynomialFromMpzConstant(mpz_t c) { sparse_polynomial_t res; res = __sparsePolynomialAllocate(); res->refCount = 1; res->monomialCount = 1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->coeffs[0] = constantFromMpz(c); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees[0] = constantFromInt(0); res->deg = constantFromCopy(res->monomialDegrees[0]); res->hash.hasHash = 0; return res; } static inline sparse_polynomial_t sparsePolynomialFromMpqConstant(mpq_t c) { sparse_polynomial_t res; res = __sparsePolynomialAllocate(); res->refCount = 1; res->monomialCount = 1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); mpq_canonicalize(c); res->coeffs[0] = constantFromMpq(c); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees[0] = constantFromInt(0); res->deg = constantFromCopy(res->monomialDegrees[0]); res->hash.hasHash = 0; return res; } static inline sparse_polynomial_t sparsePolynomialFromConstant(constant_t c) { sparse_polynomial_t res; res = __sparsePolynomialAllocate(); res->refCount = 1; res->monomialCount = 1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->coeffs[0] = constantFromCopy(c); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees[0] = constantFromInt(0); res->deg = constantFromCopy(res->monomialDegrees[0]); res->hash.hasHash = 0; return res; } static inline sparse_polynomial_t sparsePolynomialFromIntConstant(int c) { sparse_polynomial_t res; res = __sparsePolynomialAllocate(); res->refCount = 1; res->monomialCount = 1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->coeffs[0] = constantFromInt(c); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees[0] = constantFromInt(0); res->deg = constantFromCopy(res->monomialDegrees[0]); res->hash.hasHash = 0; return res; } static inline int __sparsePolynomialFromConstantExpression(sparse_polynomial_t *r, node *c) { sparse_polynomial_t res; if (c == NULL) return 0; if (!isConstant(c)) return 0; res = __sparsePolynomialAllocate(); res->refCount = 1; res->monomialCount = 1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->coeffs[0] = constantFromExpression(c); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees[0] = constantFromInt(0); res->deg = constantFromCopy(res->monomialDegrees[0]); res->hash.hasHash = 0; *r = res; return 1; } static inline int __sparsePolynomialFromConstantExpressionOnlyRealCoeffs(sparse_polynomial_t *r, node *c) { sparse_polynomial_t res; if (c == NULL) return 0; if (!isConstant(c)) return 0; if (!containsOnlyRealNumbers(c)) return 0; res = __sparsePolynomialAllocate(); res->refCount = 1; res->monomialCount = 1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->coeffs[0] = constantFromExpression(c); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees[0] = constantFromInt(0); res->deg = constantFromCopy(res->monomialDegrees[0]); res->hash.hasHash = 0; *r = res; return 1; } static inline sparse_polynomial_t sparsePolynomialFromIdentity() { sparse_polynomial_t res; res = __sparsePolynomialAllocate(); res->refCount = 1; res->monomialCount = 1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->coeffs[0] = constantFromInt(1); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees[0] = constantFromCopy(res->coeffs[0]); res->deg = constantFromCopy(res->monomialDegrees[0]); res->hash.hasHash = 0; return res; } static inline sparse_polynomial_t sparsePolynomialFromMpfrCoefficients(mpfr_t *coeffs, unsigned int deg) { unsigned int i, startSize; sparse_polynomial_t res; constant_t c; if (coeffs == NULL) return NULL; res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; startSize = deg + 1u; if (startSize == 0u) startSize = UINT_MAX; res->monomialCount = 0u; res->coeffs = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); for (i=0u;i<=deg;i++) { c = constantFromMpfr(coeffs[i]); if (!constantIsZero(c,0)) { res->coeffs[res->monomialCount] = c; res->monomialDegrees[res->monomialCount] = constantFromUnsignedInt(i); (res->monomialCount)++; } else { constantFree(c); } } /* If res->monomialCount still is zero, we never added anything because the two polynomials multiplied gave zero. We add a zero coefficient in this case. */ if (res->monomialCount == 0u) { res->coeffs[res->monomialCount] = constantFromInt(0); res->monomialDegrees[res->monomialCount] = constantFromInt(0); (res->monomialCount)++; } /* Set the degree of the polynomial */ res->deg = constantFromCopy(res->monomialDegrees[res->monomialCount - 1u]); /* Adjust memory to the real amount of monomials */ if (res->monomialCount != startSize) { res->coeffs = (constant_t *) safeRealloc(res->coeffs, ((size_t) (res->monomialCount)) * sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeRealloc(res->monomialDegrees, ((size_t) (res->monomialCount)) * sizeof(constant_t)); } /* Adjust the degree for zero leading coefficients */ __sparsePolynomialAdjustDegree(res); /* Return the polynomial */ return res; } static inline int sparsePolynomialFromConstantExpressionCoefficients(sparse_polynomial_t *r, node **coeffs, unsigned int deg) { unsigned int i, startSize; sparse_polynomial_t res; constant_t c; if (coeffs == NULL) return 0; for (i=0;i<=deg;i++) { if ((coeffs[i] != NULL) && (!isConstant(coeffs[i]))) return 0; } res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; startSize = deg + 1u; if (startSize == 0u) startSize = UINT_MAX; res->monomialCount = 0u; res->coeffs = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); for (i=0u;i<=deg;i++) { if (coeffs[i] != NULL) { c = constantFromExpression(coeffs[i]); } else { c = constantFromInt(0); } if (!constantIsZero(c,0)) { res->coeffs[res->monomialCount] = c; res->monomialDegrees[res->monomialCount] = constantFromUnsignedInt(i); (res->monomialCount)++; } else { constantFree(c); } } /* If res->monomialCount still is zero, we never added anything because the two polynomials multiplied gave zero. We add a zero coefficient in this case. */ if (res->monomialCount == 0u) { res->coeffs[res->monomialCount] = constantFromInt(0); res->monomialDegrees[res->monomialCount] = constantFromInt(0); (res->monomialCount)++; } /* Set the degree of the polynomial */ res->deg = constantFromCopy(res->monomialDegrees[res->monomialCount - 1u]); /* Adjust memory to the real amount of monomials */ if (res->monomialCount != startSize) { res->coeffs = (constant_t *) safeRealloc(res->coeffs, ((size_t) (res->monomialCount)) * sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeRealloc(res->monomialDegrees, ((size_t) (res->monomialCount)) * sizeof(constant_t)); } /* Adjust the degree for zero leading coefficients */ __sparsePolynomialAdjustDegree(res); /* Return the polynomial */ *r = res; return 1; } static inline sparse_polynomial_t sparsePolynomialFromCopy(sparse_polynomial_t p) { if (p == NULL) return NULL; p->refCount++; return p; } static inline void sparsePolynomialFree(sparse_polynomial_t p) { unsigned int i; if (p == NULL) return; p->refCount--; if (p->refCount > 0u) return; constantFree(p->deg); for (i=0;imonomialCount;i++) { constantFree(p->coeffs[i]); constantFree(p->monomialDegrees[i]); } safeFree(p->coeffs); safeFree(p->monomialDegrees); __sparsePolynomialFreeMem(p); } static inline int sparsePolynomialIsConstant(sparse_polynomial_t p, int defVal) { int degZero; if (p == NULL) return defVal; if (p->monomialCount == 0u) return 1; degZero = constantIsZero(p->deg, 42); if (degZero == 42) return defVal; if (!degZero) return 0; return 1; } static inline int sparsePolynomialConstantGetConstant(constant_t *c, sparse_polynomial_t p) { unsigned int i; constant_t t; if (p == NULL) return 0; if (!sparsePolynomialIsConstant(p, 0)) return 0; if (p->monomialCount == 0u) { *c = constantFromInt(0); return 1; } if (p->monomialCount == 1u) { *c = constantFromCopy(p->coeffs[0]); return 1; } *c = constantFromCopy(p->coeffs[0]); for (i=1;imonomialCount;i++) { t = constantAdd(*c, p->coeffs[i]); constantFree(*c); *c = t; } return 1; } static inline int sparsePolynomialIsConstantZero(sparse_polynomial_t p, int defVal) { int isConst, res; constant_t c; if (p == NULL) return defVal; isConst = sparsePolynomialIsConstant(p, 42); if (isConst == 42) return defVal; if (!isConst) return 0; if (sparsePolynomialConstantGetConstant(&c, p)) { res = constantIsZero(c, defVal); constantFree(c); return res; } return defVal; } static inline int sparsePolynomialIsConstantOne(sparse_polynomial_t p, int defVal) { int isConst, res; constant_t c; if (p == NULL) return defVal; isConst = sparsePolynomialIsConstant(p, 42); if (isConst == 42) return defVal; if (!isConst) return 0; if (sparsePolynomialConstantGetConstant(&c, p)) { res = constantIsOne(c, defVal); constantFree(c); return res; } return defVal; } static inline sparse_polynomial_t sparsePolynomialAdd(sparse_polynomial_t p, sparse_polynomial_t q) { sparse_polynomial_t res; unsigned int i,j,startSize; constant_t newCoeff, newMonomial; /* Handle stupid inputs */ if (p == NULL) return NULL; if (q == NULL) return NULL; /* Handle addition of zero polynomial */ if (sparsePolynomialIsConstantZero(p, 0)) { return sparsePolynomialFromCopy(q); } if (sparsePolynomialIsConstantZero(q, 0)) { return sparsePolynomialFromCopy(p); } /* General case */ res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; startSize = p->monomialCount + q->monomialCount; if (startSize < p->monomialCount) { startSize = UINT_MAX; } res->coeffs = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); res->monomialCount = 0; for (i=0u, j=0u; (imonomialCount) && (jmonomialCount); /* nothing */) { /* We have 3 cases: (i) The degree of the i-th monomial of p and the one of the j-th monomial of q are the same. In this case we add the coefficients and increment both i and j. (ii) The degree of the i-th monomial of p is greater than the one of the j-th monomial of q. In this case we copy the j-th coefficient of q and increment j. (iii) The degree of the i-th monomial of p is less than the one of the j-th monomial of q. In this case we copy the i-th coefficient of p and increment i. In case (i) it is possible that after addition, the coefficient gets zero. In this case we not add the monomial to the polynomial. */ if (constantIsEqual(p->monomialDegrees[i], q->monomialDegrees[j], 0)) { /* Case (i) */ newCoeff = constantAdd(p->coeffs[i], q->coeffs[j]); newMonomial = constantFromCopy(p->monomialDegrees[i]); i++; j++; } else { if (constantIsGreater(p->monomialDegrees[i], q->monomialDegrees[j], 0)) { /* Case (iii) */ newCoeff = constantFromCopy(q->coeffs[j]); newMonomial = constantFromCopy(q->monomialDegrees[j]); j++; } else { /* Case (ii) */ newCoeff = constantFromCopy(p->coeffs[i]); newMonomial = constantFromCopy(p->monomialDegrees[i]); i++; } } /* Now check if we have to add the monomial */ if (!constantIsZero(newCoeff, 0)) { /* Add the coefficient */ res->coeffs[res->monomialCount] = newCoeff; res->monomialDegrees[res->monomialCount] = newMonomial; (res->monomialCount)++; } else { /* Just free the new coefficient */ constantFree(newCoeff); constantFree(newMonomial); } } /* Now add the left-over monomials of p and q */ for (/* nothing */; imonomialCount; i++) { res->coeffs[res->monomialCount] = constantFromCopy(p->coeffs[i]); res->monomialDegrees[res->monomialCount] = constantFromCopy(p->monomialDegrees[i]); (res->monomialCount)++; } for (/* nothing */; jmonomialCount; j++) { res->coeffs[res->monomialCount] = constantFromCopy(q->coeffs[j]); res->monomialDegrees[res->monomialCount] = constantFromCopy(q->monomialDegrees[j]); (res->monomialCount)++; } /* If res->monomialCount still is zero, we never added anything because the two polynomials cancelled out. We add a zero coefficient in this case. */ if (res->monomialCount == 0u) { res->coeffs[res->monomialCount] = constantFromInt(0); res->monomialDegrees[res->monomialCount] = constantFromInt(0); (res->monomialCount)++; } /* Set the degree of the polynomial */ res->deg = constantFromCopy(res->monomialDegrees[res->monomialCount - 1u]); /* Adjust memory to the real amount of monomials */ if (res->monomialCount != startSize) { res->coeffs = (constant_t *) safeRealloc(res->coeffs, ((size_t) (res->monomialCount)) * sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeRealloc(res->monomialDegrees, ((size_t) (res->monomialCount)) * sizeof(constant_t)); } /* Adjust the degree for zero leading coefficients */ __sparsePolynomialAdjustDegree(res); return res; } static inline sparse_polynomial_t sparsePolynomialNeg(sparse_polynomial_t); static inline sparse_polynomial_t sparsePolynomialSub(sparse_polynomial_t p, sparse_polynomial_t q) { sparse_polynomial_t res; unsigned int i,j,startSize; constant_t newCoeff, newMonomial; /* Handle stupid inputs */ if (p == NULL) return NULL; if (q == NULL) return NULL; /* Handle subtraction of zero polynomial */ if (sparsePolynomialIsConstantZero(p, 0)) { return sparsePolynomialNeg(q); } if (sparsePolynomialIsConstantZero(q, 0)) { return sparsePolynomialFromCopy(p); } /* General case */ res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; startSize = p->monomialCount + q->monomialCount; if (startSize < p->monomialCount) { startSize = UINT_MAX; } res->coeffs = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); res->monomialCount = 0; for (i=0u, j=0u; (imonomialCount) && (jmonomialCount); /* nothing */) { /* We have 3 cases: (i) The degree of the i-th monomial of p and the one of the j-th monomial of q are the same. In this case we subtract the coefficients and increment both i and j. (ii) The degree of the i-th monomial of p is greater than the one of the j-th monomial of q. In this case we negate the j-th coefficient of q and increment j. (iii) The degree of the i-th monomial of p is less than the one of the j-th monomial of q. In this case we copy the i-th coefficient of p and increment i. In case (i) it is possible that after addition, the coefficient gets zero. In this case we not add the monomial to the polynomial. */ if (constantIsEqual(p->monomialDegrees[i], q->monomialDegrees[j], 0)) { /* Case (i) */ newCoeff = constantSub(p->coeffs[i], q->coeffs[j]); newMonomial = constantFromCopy(p->monomialDegrees[i]); i++; j++; } else { if (constantIsGreater(p->monomialDegrees[i], q->monomialDegrees[j], 0)) { /* Case (ii) */ newCoeff = constantNeg(q->coeffs[j]); newMonomial = constantFromCopy(q->monomialDegrees[j]); j++; } else { /* Case (iii) */ newCoeff = constantFromCopy(p->coeffs[i]); newMonomial = constantFromCopy(p->monomialDegrees[i]); i++; } } /* Now check if we have to add the monomial */ if (!constantIsZero(newCoeff, 0)) { /* Add the coefficient */ res->coeffs[res->monomialCount] = newCoeff; res->monomialDegrees[res->monomialCount] = newMonomial; (res->monomialCount)++; } else { /* Just free the new coefficient */ constantFree(newCoeff); constantFree(newMonomial); } } /* Now add the left-over monomials of p and q */ for (/* nothing */; imonomialCount; i++) { res->coeffs[res->monomialCount] = constantFromCopy(p->coeffs[i]); res->monomialDegrees[res->monomialCount] = constantFromCopy(p->monomialDegrees[i]); (res->monomialCount)++; } for (/* nothing */; jmonomialCount; j++) { res->coeffs[res->monomialCount] = constantNeg(q->coeffs[j]); res->monomialDegrees[res->monomialCount] = constantFromCopy(q->monomialDegrees[j]); (res->monomialCount)++; } /* If res->monomialCount still is zero, we never added anything because the two polynomials cancelled out. We add a zero coefficient in this case. */ if (res->monomialCount == 0u) { res->coeffs[res->monomialCount] = constantFromInt(0); res->monomialDegrees[res->monomialCount] = constantFromInt(0); (res->monomialCount)++; } /* Set the degree of the polynomial */ res->deg = constantFromCopy(res->monomialDegrees[res->monomialCount - 1u]); /* Adjust memory to the real amount of monomials */ if (res->monomialCount != startSize) { res->coeffs = (constant_t *) safeRealloc(res->coeffs, ((size_t) (res->monomialCount)) * sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeRealloc(res->monomialDegrees, ((size_t) (res->monomialCount)) * sizeof(constant_t)); } /* Adjust the degree for zero leading coefficients */ __sparsePolynomialAdjustDegree(res); return res; } static inline int sparsePolynomialEqual(sparse_polynomial_t p, sparse_polynomial_t q, int defVal) { unsigned int i; int monDegEqual, coeffEqual, degreeEqual; int res; sparse_polynomial_t d; if (p == NULL) return defVal; if (q == NULL) return defVal; if (p == q) return 1; if (p->hash.hasHash && q->hash.hasHash) { if (p->hash.hash != q->hash.hash) return 0; } if (p->monomialCount == 0u) { return sparsePolynomialIsConstantZero(q, defVal); } if (q->monomialCount == 0u) { return sparsePolynomialIsConstantZero(p, defVal); } if (p->monomialCount != q->monomialCount) { if (__sparsePolynomialAscendingDegrees(p, 0) && __sparsePolynomialAscendingDegrees(q, 0)) return 0; d = sparsePolynomialSub(p, q); res = sparsePolynomialIsConstantZero(d, defVal); sparsePolynomialFree(d); return res; } degreeEqual = constantIsEqual(p->deg, q->deg, 42); if (degreeEqual == 42) return defVal; if (!degreeEqual) return 0; for (i=0;imonomialCount;i++) { monDegEqual = constantIsEqual(p->monomialDegrees[i], q->monomialDegrees[i], 42); if (monDegEqual == 42) return defVal; if (!monDegEqual) return 0; coeffEqual = constantIsEqual(p->coeffs[i], q->coeffs[i], 42); if (coeffEqual == 42) return defVal; if (!coeffEqual) return 0; } return 1; } static inline int sparsePolynomialIsIdentity(sparse_polynomial_t p, int defVal) { sparse_polynomial_t q; int res; if (p == NULL) return defVal; if (sparsePolynomialGetDegreeAsInt(p) != 1) return 0; /* Can be optimized */ q = sparsePolynomialFromIdentity(); res = sparsePolynomialEqual(p, q, defVal); sparsePolynomialFree(q); return res; } static inline void __sparsePolynomialAddMonomialToArrays(constant_t *coeffs, constant_t *degrees, unsigned int *n, unsigned int *g, constant_t c, constant_t d) { unsigned int i, j; constant_t t; /* Find the index where to add the coefficient */ j = __sparsePolynomialFindDegree(d, degrees, *n, *g); /* Keep the value of the index as a guess for the next time */ *g = j; /* If the coefficient's degree is greater than all the others, it goes at the end. */ if (j == *n) { /* Adding the coefficient at the end */ coeffs[j] = c; degrees[j] = d; (*n)++; return; } /* Here, we know that 0 <= j <= n - 1 There are two cases: a) degree[j] == d. In this case we add c to degree[j]. We have two subcases: (i) After addition the new coefficient is non-zero. We leave it untouched. (ii) After addition the new coefficient is zero. We remove it by moving all following coefficients one to the left. b) degree[j] > d. In this case we deplace all existing coefficients and degrees of indices j thru n-1 and put the new coefficient and degree at index j. */ if (constantIsEqual(degrees[j],d,0)) { /* Case a) */ t = constantAdd(coeffs[j], c); constantFree(coeffs[j]); if (constantIsZero(t, 0)) { constantFree(t); constantFree(degrees[j]); for (i=j;i<*n;i++) { coeffs[i] = coeffs[i+1u]; degrees[i] = degrees[i+1u]; } (*n)--; } else { coeffs[j] = t; } constantFree(c); constantFree(d); return; } /* Case b) Deplace the existing coefficients and degrees. */ for (i=*n;i>j;i--) { coeffs[i] = coeffs[i-1u]; degrees[i] = degrees[i-1u]; } /* Account for the new entry */ (*n)++; /* Put the new entry */ coeffs[j] = c; degrees[j] = d; } static inline sparse_polynomial_t sparsePolynomialAddConstant(sparse_polynomial_t p, constant_t c) { sparse_polynomial_t t, res; /* Handle the stupid cases */ if (p == NULL) return NULL; if (c == NULL) return NULL; /* Can be optimized */ t = sparsePolynomialFromConstant(c); res = sparsePolynomialAdd(p, t); sparsePolynomialFree(t); return res; } static inline sparse_polynomial_t sparsePolynomialMul(sparse_polynomial_t p, sparse_polynomial_t q) { sparse_polynomial_t res; unsigned int i,j,startSize,g,d; constant_t pp, md, t; /* Handle stupid inputs */ if (p == NULL) return NULL; if (q == NULL) return NULL; /* Handle multiplication of zero polynomial */ if (sparsePolynomialIsConstantZero(p, 0)) { return sparsePolynomialFromCopy(p); } if (sparsePolynomialIsConstantZero(q, 0)) { return sparsePolynomialFromCopy(q); } /* Handle multiplication of polynomial one */ if (sparsePolynomialIsConstantOne(p, 0)) { return sparsePolynomialFromCopy(q); } if (sparsePolynomialIsConstantOne(q, 0)) { return sparsePolynomialFromCopy(p); } /* General case Start by determining the maximum number of coefficients. This number is upper bounded by min(p->monomialCount * q->monomialCount, deg(p) + deg(q) + 1) */ if (!tryExactUnsignedIntMultiplication(&startSize, p->monomialCount, q->monomialCount)) { startSize = UINT_MAX; } t = constantAdd(p->deg, q->deg); if (tryConstantToUnsignedInt(&d, t)) { d++; if (d != 0u) { if (d < startSize) startSize = d; } } constantFree(t); /* Allocate the result polynomial */ res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->coeffs = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); res->monomialCount = 0; /* Produce all partial products p_i * q_i * x^(m_i + n_i) */ g = 0; for (i=0u;imonomialCount;i++) { for (j=0u;jmonomialCount;j++) { pp = constantMul(p->coeffs[i], q->coeffs[j]); if (!constantIsZero(pp, 0)) { md = constantAdd(p->monomialDegrees[i],q->monomialDegrees[j]); __sparsePolynomialAddMonomialToArrays(res->coeffs, res->monomialDegrees, &(res->monomialCount), &g, pp, md); } else { constantFree(pp); } } } /* If res->monomialCount still is zero, we never added anything because the two polynomials multiplied gave zero. We add a zero coefficient in this case. */ if (res->monomialCount == 0u) { res->coeffs[res->monomialCount] = constantFromInt(0); res->monomialDegrees[res->monomialCount] = constantFromInt(0); (res->monomialCount)++; } /* Set the degree of the polynomial */ res->deg = constantFromCopy(res->monomialDegrees[res->monomialCount - 1u]); /* Adjust memory to the real amount of monomials */ if (res->monomialCount != startSize) { res->coeffs = (constant_t *) safeRealloc(res->coeffs, ((size_t) (res->monomialCount)) * sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeRealloc(res->monomialDegrees, ((size_t) (res->monomialCount)) * sizeof(constant_t)); } /* Adjust the degree for zero leading coefficients */ __sparsePolynomialAdjustDegree(res); return res; } static inline sparse_polynomial_t sparsePolynomialNeg(sparse_polynomial_t p) { unsigned int i; sparse_polynomial_t res; if (p == NULL) return NULL; res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->deg = constantFromCopy(p->deg); res->monomialCount = p->monomialCount; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); for (i=0u;imonomialCount;i++) { res->coeffs[i] = constantNeg(p->coeffs[i]); res->monomialDegrees[i] = constantFromCopy(p->monomialDegrees[i]); } __sparsePolynomialAdjustDegree(res); return res; } static inline sparse_polynomial_t sparsePolynomialCompose(sparse_polynomial_t p, sparse_polynomial_t q) { sparse_polynomial_t res, t, m; constant_t d; unsigned int i; /* Handle stupid inputs */ if (p == NULL) return NULL; if (q == NULL) return NULL; /* Handle the strange case when p has no monomials */ if (p->monomialCount == 0u) return sparsePolynomialFromIntConstant(0); /* Perform Horner evaluation of p in q */ res = sparsePolynomialFromConstant(p->coeffs[p->monomialCount-1u]); for (i=p->monomialCount-1u;i>=1u;i--) { d = constantSub(p->monomialDegrees[i], p->monomialDegrees[i-1u]); if (!sparsePolynomialPowConstant(&m, q, d)) { sollyaFprintf(stderr,"Error: sparsePolynomialCompose: monomial degrees not appropriately ordered\n"); exit(1); } t = sparsePolynomialMul(res, m); sparsePolynomialFree(res); res = t; sparsePolynomialFree(m); constantFree(d); t = sparsePolynomialAddConstant(res, p->coeffs[i-1u]); sparsePolynomialFree(res); res = t; } if (!sparsePolynomialPowConstant(&m, q, p->monomialDegrees[0u])) { sollyaFprintf(stderr,"Error: sparsePolynomialCompose: monomial degrees not appropriately ordered\n"); exit(1); } t = sparsePolynomialMul(res, m); sparsePolynomialFree(res); res = t; sparsePolynomialFree(m); return res; } static inline void __sparsePolynomialGetLeadingCoefficient(constant_t *c, constant_t *d, sparse_polynomial_t *r, sparse_polynomial_t p) { sparse_polynomial_t res; unsigned int i; /* Handle stupid cases */ if (p == NULL) { *c = NULL; *d = NULL; *r = NULL; return; } /* Handle a strange case that should never happen */ if (p->monomialCount == 0u) { *c = constantFromInt(0); *d = constantFromInt(0); *r = sparsePolynomialFromIntConstant(0); return; } /* Handle the case where the polynomial has just one monomial */ if (p->monomialCount == 1u) { *c = constantFromCopy(p->coeffs[0]); *d = constantFromCopy(p->monomialDegrees[0]); *r = sparsePolynomialFromIntConstant(0); return; } /* Here, the polynomial has at least two monomials */ *c = constantFromCopy(p->coeffs[p->monomialCount - 1u]); *d = constantFromCopy(p->monomialDegrees[p->monomialCount - 1u]); res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->monomialCount = p->monomialCount - 1u; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); for (i=0u;imonomialCount;i++) { res->coeffs[i] = constantFromCopy(p->coeffs[i]); res->monomialDegrees[i] = constantFromCopy(p->monomialDegrees[i]); } res->deg = constantFromCopy(res->monomialDegrees[res->monomialCount-1u]); __sparsePolynomialAdjustDegree(res); *r = res; } static inline sparse_polynomial_t __sparsePolynomialFromMonomial(constant_t c, constant_t d) { sparse_polynomial_t res; res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->monomialCount = 1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->coeffs[0] = constantFromCopy(c); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees[0] = constantFromCopy(d); res->deg = constantFromCopy(d); return res; } static inline void sparsePolynomialDiv(sparse_polynomial_t *quot, sparse_polynomial_t *rest, sparse_polynomial_t a, sparse_polynomial_t b) { sparse_polynomial_t q, r, rt, bt, t1, t2, qp, recprPB; constant_t rc, rd, bc, bd, qc, qd, recprB, one; /* Handle stupid cases */ if ((a == NULL) || (b == NULL)) { *quot = NULL; *rest = NULL; return; } /* If b is constant, do some special handling */ if (sparsePolynomialConstantGetConstant(&bc, b)) { if (!constantIsZero(bc, 1)) { one = constantFromInt(1); recprB = constantDiv(one, bc); constantFree(one); recprPB = sparsePolynomialFromConstant(recprB); constantFree(recprB); *quot = sparsePolynomialMul(a, recprPB); *rest = sparsePolynomialFromIntConstant(0); sparsePolynomialFree(recprPB); } else { *quot = sparsePolynomialFromIntConstant(0); *rest = sparsePolynomialFromCopy(a); } constantFree(bc); return; } /* Initialize q and r to q = 0 r = a such that a = q * b + r */ q = sparsePolynomialFromIntConstant(0); r = sparsePolynomialFromCopy(a); /* Euclidean division */ __sparsePolynomialGetLeadingCoefficient(&bc,&bd,&bt,b); while ((!constantIsGreater(b->deg,r->deg,1)) && (!sparsePolynomialIsConstantZero(r,1))) { __sparsePolynomialGetLeadingCoefficient(&rc,&rd,&rt,r); qc = constantDiv(rc,bc); constantFree(rc); qd = constantSub(rd,bd); constantFree(rd); qp = __sparsePolynomialFromMonomial(qc,qd); constantFree(qc); constantFree(qd); t1 = sparsePolynomialAdd(q, qp); sparsePolynomialFree(q); q = t1; t1 = sparsePolynomialMul(qp,bt); t2 = sparsePolynomialSub(rt,t1); sparsePolynomialFree(t1); sparsePolynomialFree(rt); sparsePolynomialFree(qp); sparsePolynomialFree(r); r = t2; } constantFree(bc); constantFree(bd); sparsePolynomialFree(bt); /* Set the result polynomials */ *quot = q; *rest = r; } static inline void __sparsePolynomialCutIntoHalves(sparse_polynomial_t *r, sparse_polynomial_t *q, sparse_polynomial_t p) { unsigned int i, monomialCount1, monomialCount2; sparse_polynomial_t res; /* Handle stupid input */ if (p == NULL) { *r = NULL; *q = NULL; return; } /* Handle the case when p has no monomials */ if (p->monomialCount == 0u) { *r = sparsePolynomialFromIntConstant(0); *q = sparsePolynomialFromIntConstant(0); return; } /* Handle the case when p has only one monomial */ if (p->monomialCount == 1u) { *r = sparsePolynomialFromCopy(p); *q = sparsePolynomialFromIntConstant(0); return; } /* Now, we know that we have at least 2 monomials. This implies that both polynomials have at least one monomial. */ monomialCount1 = p->monomialCount >> 1; monomialCount2 = p->monomialCount - monomialCount1; /* Form polynomial p */ res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->monomialCount = monomialCount1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); for (i=0u;icoeffs[i] = constantFromCopy(p->coeffs[i]); res->monomialDegrees[i] = constantFromCopy(p->monomialDegrees[i]); } res->deg = constantFromCopy(res->monomialDegrees[res->monomialCount-1u]); __sparsePolynomialAdjustDegree(res); *r = res; /* Form polynomial q */ res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->monomialCount = monomialCount2; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); for (i=0u;icoeffs[i] = constantFromCopy(p->coeffs[i + monomialCount1]); res->monomialDegrees[i] = constantFromCopy(p->monomialDegrees[i + monomialCount1]); } res->deg = constantFromCopy(res->monomialDegrees[res->monomialCount-1u]); __sparsePolynomialAdjustDegree(res); *q = res; } /* If p is of the form p(x) = x^m * (c + d * x^n) then decompose p into c, m, d and n and return a non-zero value. Otherwise return 0 and don't touch the pointers c, m, d and n. */ static inline int sparsePolynomialDecomposeTwoMonomials(constant_t *c, constant_t *m, constant_t *d, constant_t *n, sparse_polynomial_t p) { /* Handle stupid input */ if (p == NULL) return 0; /* Check if there are really just two monomials */ if (p->monomialCount != 2u) return 0; /* Here we are sure that we only have two monomials. Do the decomposition work. */ *c = constantFromCopy(p->coeffs[0]); *d = constantFromCopy(p->coeffs[1]); *m = constantFromCopy(p->monomialDegrees[0]); *n = constantSub(p->monomialDegrees[1],p->monomialDegrees[0]); /* Signal success */ return 1; } static inline sparse_polynomial_t __sparsePolynomialPowUnsignedIntAlternate(sparse_polynomial_t p, unsigned int n) { constant_t nC, bin; unsigned int i; sparse_polynomial_t r, q, rToTheI, qToTheNMinusI, binPoly, tempPoly1, tempPoly2, tempPoly3, res; /* Handle stupid input */ if (p == NULL) return NULL; /* Handle easy cases */ if (n == 0u) return sparsePolynomialFromIntConstant(1); if (n == 1u) return sparsePolynomialFromCopy(p); if (n == 2u) return sparsePolynomialMul(p,p); /* Handle the case when the polynomial only has one monomial */ if (p->monomialCount == 1u) { nC = constantFromUnsignedInt(n); res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->monomialCount = 1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->coeffs[0] = constantPow(p->coeffs[0],nC); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees[0] = constantMul(p->monomialDegrees[0],nC); res->deg = constantFromCopy(res->monomialDegrees[0]); constantFree(nC); return res; } /* The polynomial has at least two monomials Write p(x) = r(x) + q(x), with r and q having approximately half of the monomials, and obtain (p(x))^n = sum_i=0^n bin(n,i) * (r(x))^i * (q(x))^(n - i) = r(x)^n + sum_i=0^(n-1) bin(n,i) * (r(x))^i * (q(x))^(n - i) */ __sparsePolynomialCutIntoHalves(&r, &q, p); res = sparsePolynomialPowUnsignedInt(r, n); for (i=0u;imonomialCount == 1u) { nC = constantFromUnsignedInt(n); res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->monomialCount = 1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->coeffs[0] = constantPow(p->coeffs[0],nC); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees[0] = constantMul(p->monomialDegrees[0],nC); res->deg = constantFromCopy(res->monomialDegrees[0]); constantFree(nC); return res; } /* Use alternate algorithm for polynomials that might have non-rational coefficients */ if (!sparsePolynomialCoefficientsAreRational(p, 0)) { return __sparsePolynomialPowUnsignedIntAlternate(p, n); } /* Square and multiply loop */ t = sparsePolynomialFromCopy(p); res = sparsePolynomialFromIntConstant(1); while (n > 0u) { if (n & 1u) { tmp = sparsePolynomialMul(res,t); sparsePolynomialFree(res); res = tmp; } n >>= 1; if (n > 0u) { tmp = sparsePolynomialMul(t,t); sparsePolynomialFree(t); t = tmp; } } sparsePolynomialFree(t); return res; } static inline int sparsePolynomialPowConstant(sparse_polynomial_t *r, sparse_polynomial_t p, constant_t n) { unsigned int nI; constant_t k, l, m; sparse_polynomial_t res, a, b, t; /* Make compiler happy */ k = NULL; l = NULL; /* End of compiler happiness */ if (p == NULL) return 0; if (n == NULL) return 0; if (!constantIsNonNegativeInteger(n,0)) return 0; /* Handle the cases n = 0 and n = 1 */ if (constantIsZero(n,0)) { *r = sparsePolynomialFromIntConstant(1); return 1; } if (constantIsOne(n,0)) { *r = sparsePolynomialFromCopy(p); return 1; } /* Handle the case when p only has one monomial */ if (p->monomialCount == 1u) { res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->monomialCount = 1; res->coeffs = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->coeffs[0] = constantPow(p->coeffs[0],n); res->monomialDegrees = (constant_t *) safeCalloc(res->monomialCount, sizeof(constant_t)); res->monomialDegrees[0] = constantMul(p->monomialDegrees[0],n); res->deg = constantFromCopy(res->monomialDegrees[0]); *r = res; return 1; } /* Try to use the powering function with an unsigned int argument */ if (tryConstantToUnsignedInt(&nI, n)) { *r = sparsePolynomialPowUnsignedInt(p, nI); return 1; } /* If we are here, n does not hold on an unsigned int Chances are low that we actually have enough memory but we still try to handle the case. We rewrite p^n as p^n = p^(2^14 * k + l) = (p^k)^(2^14) * p^l In order to compute t = p^k, t^(2^14) and p^l, we call ourselves recursively. As we know that l is integer and l <= 2^14-1 < 2^16-1 and 2^14 < 2^16 - 1, we know that for these exponents, we will be able to use the branch where the exponent holds on an unsigned int. */ constantCutTwo14(&k, &l, n); m = constantFromInt(1 << 14); if (!sparsePolynomialPowConstant(&t,p,k)) { constantFree(k); constantFree(l); constantFree(m); return 0; } constantFree(k); if (!sparsePolynomialPowConstant(&a,t,m)) { sparsePolynomialFree(t); constantFree(l); constantFree(m); return 0; } sparsePolynomialFree(t); constantFree(m); if (!sparsePolynomialPowConstant(&b,p,l)) { sparsePolynomialFree(a); constantFree(l); return 0; } constantFree(l); *r = sparsePolynomialMul(a,b); sparsePolynomialFree(b); sparsePolynomialFree(a); return 1; } static inline int sparsePolynomialPow(sparse_polynomial_t *r, sparse_polynomial_t p, sparse_polynomial_t q) { constant_t n; int res; if (p == NULL) return 0; if (q == NULL) return 0; if (!sparsePolynomialConstantGetConstant(&n, q)) return 0; if (!constantIsNonNegativeInteger(n,0)) { constantFree(n); return 0; } res = sparsePolynomialPowConstant(r, p, n); constantFree(n); return res; } static inline sparse_polynomial_t sparsePolynomialDeriv(sparse_polynomial_t p) { unsigned int i; sparse_polynomial_t res; constant_t one; /* Handle stupid input */ if (p == NULL) return NULL; /* Handle the strange case when p has no monomials */ if (p->monomialCount == 0u) { return sparsePolynomialFromIntConstant(0); } /* Handle the case when p is a constant polynomial */ if (sparsePolynomialIsConstant(p, 0)) { return sparsePolynomialFromIntConstant(0); } /* Handle the general case */ res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->coeffs = (constant_t *) safeCalloc(p->monomialCount, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(p->monomialCount, sizeof(constant_t)); one = constantFromInt(1); res->monomialCount = 0u; for (i=0u;imonomialCount;i++) { if (constantIsGreaterOrEqual(p->monomialDegrees[i], one, 1)) { res->coeffs[res->monomialCount] = constantMul(p->coeffs[i],p->monomialDegrees[i]); res->monomialDegrees[res->monomialCount] = constantSub(p->monomialDegrees[i],one); (res->monomialCount)++; } } constantFree(one); /* If res->monomialCount still is zero, we never added anything. We add a zero coefficient in this case. */ if (res->monomialCount == 0u) { res->coeffs[res->monomialCount] = constantFromInt(0); res->monomialDegrees[res->monomialCount] = constantFromInt(0); (res->monomialCount)++; } /* Set the degree of the polynomial */ res->deg = constantFromCopy(res->monomialDegrees[res->monomialCount - 1u]); /* Adjust memory to the real amount of monomials */ if (res->monomialCount != p->monomialCount) { res->coeffs = (constant_t *) safeRealloc(res->coeffs, ((size_t) (res->monomialCount)) * sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeRealloc(res->monomialDegrees, ((size_t) (res->monomialCount)) * sizeof(constant_t)); } /* Adjust the degree for zero leading coefficients */ __sparsePolynomialAdjustDegree(res); return res; } int sparsePolynomialFromExpression(sparse_polynomial_t *r, node *p) { sparse_polynomial_t a, b, quot, rest; int res; /* Handle stupid inputs */ if (p == NULL) return 0; /* Try to decompose expressions built on c, x, +, -, *, /, -, ^ */ switch (p->nodeType) { case MEMREF: if (p->polynomialRepresentation != NULL) { *r = __polynomialGetSparsePolynomial(p->polynomialRepresentation); return 1; } return sparsePolynomialFromExpression(r, getMemRefChild(p)); break; case VARIABLE: *r = sparsePolynomialFromIdentity(); return 1; break; case CONSTANT: *r = sparsePolynomialFromMpfrConstant(*(p->value)); return 1; break; case NEG: if (!sparsePolynomialFromExpression(&a, p->child1)) break; *r = sparsePolynomialNeg(a); sparsePolynomialFree(a); return 1; break; case ADD: case SUB: case MUL: case DIV: case POW: if (!sparsePolynomialFromExpression(&a, p->child1)) break; if (!sparsePolynomialFromExpression(&b, p->child2)) { sparsePolynomialFree(a); break; } res = 0; switch (p->nodeType) { case ADD: *r = sparsePolynomialAdd(a, b); res = 1; break; case SUB: *r = sparsePolynomialSub(a, b); res = 1; break; case MUL: *r = sparsePolynomialMul(a, b); res = 1; break; case DIV: if (sparsePolynomialIsConstantZero(b, 1)) { res = 0; } else { sparsePolynomialDiv(", &rest, a, b); if (sparsePolynomialIsConstantZero(rest, 0)) { *r = quot; res = 1; } else { sparsePolynomialFree(quot); res = 0; } sparsePolynomialFree(rest); } break; case POW: res = sparsePolynomialPow(r, a, b); break; } sparsePolynomialFree(a); sparsePolynomialFree(b); if (res) return 1; break; } /* Here, the expression contains some other basic function. It can be a polynomial only if it is a constant expression. */ if (isConstant(p)) { if (!__sparsePolynomialFromConstantExpression(r, p)) return 0; return 1; } return 0; } static inline void sparsePolynomialGetDegree(mpz_t deg, sparse_polynomial_t p) { if (p == NULL) { mpz_set_si(deg, -1); return; } if (!tryConstantToMpz(deg, p->deg)) { mpz_set_si(deg, -1); } } static inline int sparsePolynomialGetDegreeAsInt(sparse_polynomial_t p) { int deg; /* Make compiler happy */ deg = -1; /* End of compiler happiness */ if (p == NULL) return -1; if (!tryConstantToInt(°, p->deg)) return -1; return deg; } static inline constant_t sparsePolynomialGetIthCoefficientAsConstant(sparse_polynomial_t p, mpz_t i) { constant_t ic, coeffsum, t; unsigned int j, k; /* Handle stupid inputs */ if (p == NULL) return NULL; /* The index must be non-negative */ if (mpz_sgn(i) < 0) { return constantFromInt(0); } /* Handle the strange case when p has no monomials */ if (p->monomialCount == 0u) { return constantFromInt(0); } /* Construct a constant from i */ ic = constantFromMpz(i); /* The index must be no greater than the degree of p */ if (constantIsGreater(ic, p->deg, 0)) { constantFree(ic); return constantFromInt(0); } /* Get the index j where the coefficients for degree i might start */ j = __sparsePolynomialFindDegree(ic, p->monomialDegrees, p->monomialCount, 0u); /* If j is greater than the last index of the monomials of p, there exists no monomial of degree i. */ if (j >= p->monomialCount) { constantFree(ic); return constantFromInt(0); } /* Here, we know that 0 <= j <= n - 1. We add up all coefficients associated with a degree equal to i. */ coeffsum = constantFromInt(0); for (k=j;kmonomialCount;k++) { if (!constantIsEqual(ic, p->monomialDegrees[k], 0)) break; t = constantAdd(coeffsum, p->coeffs[k]); constantFree(coeffsum); coeffsum = t; } constantFree(ic); return coeffsum; } node *sparsePolynomialGetIthCoefficient(sparse_polynomial_t p, mpz_t i) { constant_t c; node *res; /* Handle stupid inputs */ if (p == NULL) return NULL; /* Get coefficient as a constant */ c = sparsePolynomialGetIthCoefficientAsConstant(p, i); /* Convert to an expression */ res = addMemRef(constantToExpression(c)); constantFree(c); /* Return the result */ return res; } node *sparsePolynomialGetIthCoefficientIntIndex(sparse_polynomial_t p, int i) { constant_t ic, coeffsum, t; unsigned int j, k; node *res; /* Handle stupid inputs */ if (p == NULL) return NULL; /* The index must be non-negative */ if (i < 0) { return addMemRef(makeConstantInt(0)); } /* Handle the strange case when p has no monomials */ if (p->monomialCount == 0u) { return addMemRef(makeConstantInt(0)); } /* Construct a constant from i */ ic = constantFromInt(i); /* The index must be no greater than the degree of p */ if (constantIsGreater(ic, p->deg, 0)) { constantFree(ic); return addMemRef(makeConstantInt(0)); } /* Get the index j where the coefficients for degree i might start */ j = __sparsePolynomialFindDegree(ic, p->monomialDegrees, p->monomialCount, 0u); /* If j is greater than the last index of the monomials of p, there exists no monomial of degree i. */ if (j >= p->monomialCount) { constantFree(ic); return addMemRef(makeConstantInt(0)); } /* Here, we know that 0 <= j <= n - 1. We add up all coefficients associated with a degree equal to i. */ coeffsum = constantFromInt(0); for (k=j;kmonomialCount;k++) { if (!constantIsEqual(ic, p->monomialDegrees[k], 0)) break; t = constantAdd(coeffsum, p->coeffs[k]); constantFree(coeffsum); coeffsum = t; } constantFree(ic); res = constantToExpression(coeffsum); constantFree(coeffsum); return res; } static inline constant_t sparsePolynomialGetIthCoefficientAsConstantIntIndex(sparse_polynomial_t p, int i) { constant_t ic, coeffsum, t; unsigned int j, k; /* Handle stupid inputs */ if (p == NULL) return NULL; /* The index must be non-negative */ if (i < 0) { return constantFromInt(0); } /* Handle the strange case when p has no monomials */ if (p->monomialCount == 0u) { return constantFromInt(0); } /* Construct a constant from i */ ic = constantFromInt(i); /* The index must be no greater than the degree of p */ if (constantIsGreater(ic, p->deg, 0)) { constantFree(ic); return constantFromInt(0); } /* Get the index j where the coefficients for degree i might start */ j = __sparsePolynomialFindDegree(ic, p->monomialDegrees, p->monomialCount, 0u); /* If j is greater than the last index of the monomials of p, there exists no monomial of degree i. */ if (j >= p->monomialCount) { constantFree(ic); return constantFromInt(0); } /* Here, we know that 0 <= j <= n - 1. We add up all coefficients associated with a degree equal to i. */ coeffsum = constantFromInt(0); for (k=j;kmonomialCount;k++) { if (!constantIsEqual(ic, p->monomialDegrees[k], 0)) break; t = constantAdd(coeffsum, p->coeffs[k]); constantFree(coeffsum); coeffsum = t; } constantFree(ic); return coeffsum; } static inline int sparsePolynomialGetCoefficients(node ***coeffs, unsigned int *deg, sparse_polynomial_t p) { unsigned int degree, size, i, j, d, k; node **coefficients; constant_t c, t; /* Handle stupid inputs */ if (p == NULL) { return 0; } /* Handle the strange case when p has no monomials */ if (p->monomialCount == 0u) { *deg = 0u; *coeffs = (node **) safeCalloc(1, sizeof(node *)); (*coeffs)[0] = addMemRef(makeConstantInt(0)); return 1; } /* Check if the degree of the polynomial holds on an unsigned int. */ if (!tryConstantToUnsignedInt(°ree, p->deg)) { return 0; } /* Check if the size of the output (degree + 1) holds on an unsigned int. */ size = degree + 1u; if (size == 0u) return 0; /* Allocate the output array and initialize all its elements to NULL. */ coefficients = (node **) safeCalloc(size, sizeof(node *)); for (i=0u;i<=degree;i++) { coefficients[i] = NULL; } /* Go over all monomials, add up equal degrees and set the output coefficients. If ever there is a degree we can't place, desallocate everything and signal failure. */ for (i=0u;imonomialCount;i++) { if (!tryConstantToUnsignedInt(&d, p->monomialDegrees[i])) { for (j=0u;j<=degree;j++) { if (coefficients[j] != NULL) freeThing(coefficients[j]); } safeFree(coefficients); return 0; } if (d > degree) { for (j=0u;j<=degree;j++) { if (coefficients[j] != NULL) freeThing(coefficients[j]); } safeFree(coefficients); return 0; } for (j=i;jmonomialCount-1u;j++) { if (!constantIsEqual(p->monomialDegrees[i], p->monomialDegrees[j+1u], 0)) break; } if (i == j) { c = constantFromCopy(p->coeffs[i]); } else { c = constantFromInt(0); for (k=i;k<=j;k++) { t = constantAdd(c, p->coeffs[k]); constantFree(c); c = t; } i = j; } if (coefficients[d] == NULL) { coefficients[d] = constantToExpression(c); } else { coefficients[d] = addMemRef(makeAdd(coefficients[d], constantToExpression(c))); } constantFree(c); } /* Fill in the holes in the output coefficient array and set the output */ for (i=0u;i<=degree;i++) { if (coefficients[i] == NULL) { coefficients[i] = addMemRef(makeConstantInt(0)); } } *coeffs = coefficients; *deg = degree; return 1; } static inline unsigned int sparsePolynomialGetNumberOfNonZeroCoefficients(sparse_polynomial_t p) { /* Handle stupid inputs */ if (p == NULL) { return 0u; } /* General case */ return p->monomialCount; } static inline void __sparsePolynomialEvalMpfr(mpfr_t y, sparse_polynomial_t p, mpfr_t x, mpfr_t scratch) { unsigned int i, a, b, d; mp_prec_t prec; constant_t dc; /* Handle stupid inputs */ if (p == NULL) { mpfr_set_nan(y); return; } /* Handle the strange case when p has no monomials */ if (p->monomialCount == 0u) { mpfr_set_si(y, 0, GMP_RNDN); return; } /* Save precision of y and increase it for a moment */ prec = mpfr_get_prec(y); mpfr_set_prec(y, prec + 25); mpfr_set_prec(y, prec + 10); /* Set precision of scratch variable */ mpfr_set_prec(scratch, prec + 25); mpfr_set_prec(scratch, prec + 10); /* Perform Horner evaluation of p in x */ constantEvalMpfr(y, p->coeffs[p->monomialCount-1u]); for (i=p->monomialCount-1u;i>=1u;i--) { /* y <- x^(p->monomialDegrees[i] - p->monomialDegrees[i-1u]) * y */ if (tryConstantToUnsignedInt(&a, p->monomialDegrees[i]) && tryConstantToUnsignedInt(&b, p->monomialDegrees[i-1u])) { if (a < b) { sollyaFprintf(stderr,"Error: __sparsePolynomialEvalMpfr: monomial degrees not appropriately ordered\n"); exit(1); } d = a - b; if (d != 0u) { if (d == 1u) { mpfr_mul(y, x, y, GMP_RNDN); } else { mpfr_pow_ui(scratch, x, d, GMP_RNDN); mpfr_mul(y, scratch, y, GMP_RNDN); } } } else { dc = constantSub(p->monomialDegrees[i], p->monomialDegrees[i-1u]); constantEvalMpfr(scratch, dc); constantFree(dc); mpfr_pow(scratch, x, scratch, GMP_RNDN); mpfr_mul(y, scratch, y, GMP_RNDN); } /* y <- p->coeffs[i-1u] + y */ constantEvalMpfr(scratch, p->coeffs[i-1u]); mpfr_add(y, y, scratch, GMP_RNDN); } /* y <- x^(p->monomialDegrees[0u]) * y */ if (tryConstantToUnsignedInt(&a, p->monomialDegrees[0u])) { if (a != 0u) { if (a == 1u) { mpfr_mul(y, x, y, GMP_RNDN); } else { mpfr_pow_ui(scratch, x, a, GMP_RNDN); mpfr_mul(y, scratch, y, GMP_RNDN); } } } else { constantEvalMpfr(scratch, p->monomialDegrees[0u]); mpfr_pow(scratch, x, scratch, GMP_RNDN); mpfr_mul(y, scratch, y, GMP_RNDN); } /* Round result to original precision of y */ mpfr_prec_round(y, prec, GMP_RNDN); } static inline void sparsePolynomialEvalMpfr(mpfr_t y, sparse_polynomial_t p, mpfr_t x) { mpfr_t scratch, Y; /* Handle stupid inputs */ if (p == NULL) { mpfr_set_nan(y); return; } /* Handle the strange case when p has no monomials */ if (p->monomialCount == 0u) { mpfr_set_si(y, 0, GMP_RNDN); return; } /* Cover the case when x and y are the same MPFR variable */ if (x == y) { mpfr_init2(Y, mpfr_get_prec(y)); sparsePolynomialEvalMpfr(Y, p, x); mpfr_set(y, Y, GMP_RNDN); /* exact */ mpfr_clear(Y); return; } /* Try to use a global variable as scratch space */ if (__sparsePolynomialEvalMpfr_var_used) { /* The global scratch space is taken; use new scratch space on the stack */ mpfr_init2(scratch, mpfr_get_prec(y) + 25); /* Use inner evaluation function */ __sparsePolynomialEvalMpfr(y, p, x, scratch); /* Clear the scratch variable */ mpfr_clear(scratch); return; } /* Here the global scratch space variable still is free; so start using it. */ __sparsePolynomialEvalMpfi_var_used = 1; /* Initialize the global scratch variable */ if (__sparsePolynomialEvalMpfr_scratch_initialized) { mpfr_set_prec(__sparsePolynomialEvalMpfr_scratch, mpfr_get_prec(y) + 25); } else { mpfr_init2(__sparsePolynomialEvalMpfr_scratch, mpfr_get_prec(y) + 25); __sparsePolynomialEvalMpfr_scratch_initialized = 1; } /* Use inner evaluation function */ __sparsePolynomialEvalMpfr(y, p, x, __sparsePolynomialEvalMpfr_scratch); /* Free the access to the global scratch space variable again */ __sparsePolynomialEvalMpfi_var_used = 0; } static inline void __sparsePolynomialEvalMpfi(sollya_mpfi_t y, sparse_polynomial_t p, sollya_mpfi_t x, sollya_mpfi_t scratch) { unsigned int i, a, b, d; mp_prec_t prec; constant_t dc; /* Handle stupid inputs */ if (p == NULL) { sollya_mpfi_set_nan(y); return; } /* Handle the strange case when p has no monomials */ if (p->monomialCount == 0u) { sollya_mpfi_set_si(y, 0); return; } /* Save precision of y and increase it for a moment */ prec = sollya_mpfi_get_prec(y); sollya_mpfi_set_prec(y, prec + 25); sollya_mpfi_set_prec(y, prec + 10); /* Set precision of scratch variable */ sollya_mpfi_set_prec(scratch, prec + 25); sollya_mpfi_set_prec(scratch, prec + 10); /* Perform Horner evaluation of p in x */ constantEvalMpfi(y, p->coeffs[p->monomialCount-1u]); for (i=p->monomialCount-1u;i>=1u;i--) { /* y <- x^(p->monomialDegrees[i] - p->monomialDegrees[i-1u]) * y */ if (tryConstantToUnsignedInt(&a, p->monomialDegrees[i]) && tryConstantToUnsignedInt(&b, p->monomialDegrees[i-1u])) { if (a < b) { sollyaFprintf(stderr,"Error: __sparsePolynomialEvalMpfi: monomial degrees not appropriately ordered\n"); exit(1); } d = a - b; if (d != 0u) { if (d == 1u) { sollya_mpfi_mul(y, x, y); } else { sollya_mpfi_pow_ulong(scratch, x, d); sollya_mpfi_mul(y, scratch, y); } } } else { dc = constantSub(p->monomialDegrees[i], p->monomialDegrees[i-1u]); constantEvalMpfi(scratch, dc); constantFree(dc); sollya_mpfi_pow(scratch, x, scratch); sollya_mpfi_mul(y, scratch, y); } /* y <- p->coeffs[i-1u] + y */ constantEvalMpfi(scratch, p->coeffs[i-1u]); sollya_mpfi_add(y, y, scratch); } /* y <- x^(p->monomialDegrees[0u]) * y */ if (tryConstantToUnsignedInt(&a, p->monomialDegrees[0u])) { if (a != 0u) { if (a == 1u) { sollya_mpfi_mul(y, x, y); } else { sollya_mpfi_pow_ulong(scratch, x, a); sollya_mpfi_mul(y, scratch, y); } } } else { constantEvalMpfi(scratch, p->monomialDegrees[0u]); sollya_mpfi_pow(scratch, x, scratch); sollya_mpfi_mul(y, scratch, y); } /* Round result to original precision of y */ sollya_mpfi_prec_round(y, prec); } static inline void sparsePolynomialEvalMpfi(sollya_mpfi_t y, sparse_polynomial_t p, sollya_mpfi_t x) { sollya_mpfi_t scratch, Y; /* Handle stupid inputs */ if (p == NULL) { sollya_mpfi_set_nan(y); return; } /* Handle the strange case when p has no monomials */ if (p->monomialCount == 0u) { sollya_mpfi_set_si(y, 0); return; } /* Cover the case when x and y are the same MPFI variable */ if (x == y) { sollya_mpfi_init2(Y, sollya_mpfi_get_prec(y)); sparsePolynomialEvalMpfi(Y, p, x); sollya_mpfi_set(y, Y); sollya_mpfi_clear(Y); return; } /* Try to use a global variable as scratch space */ if (__sparsePolynomialEvalMpfi_var_used) { /* The global scratch space is taken; use new scratch space on the stack */ sollya_mpfi_init2(scratch, sollya_mpfi_get_prec(y) + 25); /* Use inner evaluation function */ __sparsePolynomialEvalMpfi(y, p, x, scratch); /* Clear the scratch variable */ sollya_mpfi_clear(scratch); return; } /* Here the global scratch space variable still is free; so start using it. */ __sparsePolynomialEvalMpfi_var_used = 1; /* Initialize the global scratch variable */ if (__sparsePolynomialEvalMpfi_scratch_initialized) { sollya_mpfi_set_prec(__sparsePolynomialEvalMpfi_scratch, sollya_mpfi_get_prec(y) + 25); } else { sollya_mpfi_init2(__sparsePolynomialEvalMpfi_scratch, sollya_mpfi_get_prec(y) + 25); __sparsePolynomialEvalMpfi_scratch_initialized = 1; } /* Use inner evaluation function */ __sparsePolynomialEvalMpfi(y, p, x, __sparsePolynomialEvalMpfi_scratch); /* Free the access to the global scratch space variable again */ __sparsePolynomialEvalMpfi_var_used = 0; } static inline node *__sparsePolynomialGetExpressionCanonical(sparse_polynomial_t p) { node *res, *temp; unsigned int i; /* Handle stupid input */ if (p == NULL) return NULL; /* Handle the case when p has no monomials */ if (p->monomialCount == 0u) { return addMemRef(makeConstantInt(0)); } /* Handle the case when p only has one monomial */ if (p->monomialCount == 1u) { if (constantIsZero(p->monomialDegrees[0],0)) { return addMemRef(constantToExpression(p->coeffs[0])); } if (constantIsOne(p->monomialDegrees[0],0)) { if (constantIsOne(p->coeffs[0],0)) { return addMemRef(makeVariable()); } return addMemRef(makeMul(constantToExpression(p->coeffs[0]), makeVariable())); } if (constantIsOne(p->coeffs[0],0)) { return addMemRef(makePow(makeVariable(), constantToExpression(p->monomialDegrees[0]))); } return addMemRef(makeMul(constantToExpression(p->coeffs[0]), makePow(makeVariable(), constantToExpression(p->monomialDegrees[0])))); } /* Here, p has at least two monomials */ if (constantIsZero(p->monomialDegrees[0],0)) { res = constantToExpression(p->coeffs[0]); } else { if (constantIsOne(p->monomialDegrees[0],0)) { if (constantIsOne(p->coeffs[0], 0)) { res = makeVariable(); } else { res = makeMul(constantToExpression(p->coeffs[0]), makeVariable()); } } else { if (constantIsOne(p->coeffs[0], 0)) { res = makePow(makeVariable(), constantToExpression(p->monomialDegrees[0])); } else { res = makeMul(constantToExpression(p->coeffs[0]), makePow(makeVariable(), constantToExpression(p->monomialDegrees[0]))); } } } for (i=1u;imonomialCount;i++) { if (constantIsZero(p->monomialDegrees[i],0)) { temp = constantToExpression(p->coeffs[i]); } else { if (constantIsOne(p->monomialDegrees[i],0)) { if (constantIsOne(p->coeffs[i], 0)) { temp = makeVariable(); } else { temp = makeMul(constantToExpression(p->coeffs[i]), makeVariable()); } } else { if (constantIsOne(p->coeffs[i], 0)) { temp = makePow(makeVariable(), constantToExpression(p->monomialDegrees[i])); } else { temp = makeMul(constantToExpression(p->coeffs[i]), makePow(makeVariable(), constantToExpression(p->monomialDegrees[i]))); } } } res = makeAdd(res, temp); } return addMemRef(res); } static inline node *__sparsePolynomialGetExpressionHorner(sparse_polynomial_t p) { unsigned int i, a, b, d; constant_t dc; node *res; /* Handle stupid inputs */ if (p == NULL) return NULL; /* Handle the strange case when p has no monomials */ if (p->monomialCount == 0u) return addMemRef(makeConstantInt(0)); /* Handle the case when the polynomial only has one monomial */ if (p->monomialCount == 1u) { if (constantIsZero(p->monomialDegrees[0u], 0)) { return addMemRef(constantToExpression(p->coeffs[0u])); } else { if (constantIsOne(p->monomialDegrees[0u], 0)) { if (constantIsOne(p->coeffs[0u], 0)) { return addMemRef(makeVariable()); } else { return addMemRef(makeMul(makeVariable(), constantToExpression(p->coeffs[0u]))); } } else { if (constantIsOne(p->coeffs[0u], 0)) { return addMemRef(makePow(makeVariable(), constantToExpression(p->monomialDegrees[0u]))); } else { return addMemRef(makeMul(makePow(makeVariable(), constantToExpression(p->monomialDegrees[0u])), constantToExpression(p->coeffs[0u]))); } } } } /* Perform Horner "evaluation" of p Here, the polynomial has at least 2 monomials. */ if (constantIsOne(p->coeffs[p->monomialCount-1u], 0)) { /* Use NULL as a marker for a coefficient equal to one */ res = NULL; } else { res = constantToExpression(p->coeffs[p->monomialCount-1u]); } for (i=p->monomialCount-1u;i>=1u;i--) { /* y <- x^(p->monomialDegrees[i] - p->monomialDegrees[i-1u]) * y */ if (tryConstantToUnsignedInt(&a, p->monomialDegrees[i]) && tryConstantToUnsignedInt(&b, p->monomialDegrees[i-1u])) { if (a < b) { sollyaFprintf(stderr,"Error: __sparsePolynomialGetExpressionHorner: monomial degrees not appropriately ordered\n"); exit(1); } d = a - b; if (d != 0u) { if (d == 1u) { if (res == NULL) { res = makeVariable(); } else { res = makeMul(makeVariable(), res); } } else { if (res == NULL) { res = makePow(makeVariable(),makeConstantInt(d)); } else { res = makeMul(makePow(makeVariable(),makeConstantInt(d)),res); } } } } else { dc = constantSub(p->monomialDegrees[i], p->monomialDegrees[i-1u]); if (!constantIsZero(dc,0)) { if (constantIsOne(dc,0)) { if (res == NULL) { res = makeVariable(); } else { res = makeMul(makeVariable(), res); } } else { if (res == NULL) { res = makePow(makeVariable(),constantToExpression(dc)); } else { res = makeMul(makePow(makeVariable(),constantToExpression(dc)),res); } } } constantFree(dc); } /* y <- p->coeffs[i-1u] + y */ if (res == NULL) { res = makeAdd(constantToExpression(p->coeffs[i-1u]), makeConstantInt(1)); } else { res = makeAdd(constantToExpression(p->coeffs[i-1u]), res); } } /* y <- x^(p->monomialDegrees[0u]) * y */ if (tryConstantToUnsignedInt(&a, p->monomialDegrees[0u])) { if (a != 0u) { if (a == 1u) { if (res == NULL) { res = makeVariable(); } else { res = makeMul(makeVariable(), res); } } else { if (res == NULL) { res = makePow(makeVariable(), makeConstantInt(a)); } else { res = makeMul(makePow(makeVariable(), makeConstantInt(a)), res); } } } } else { if (!constantIsZero(p->monomialDegrees[0u],0)) { if (constantIsOne(p->monomialDegrees[0u],0)) { if (res == NULL) { res = makeVariable(); } else { res = makeMul(makeVariable(), res); } } else { if (res == NULL) { res = makePow(makeVariable(), constantToExpression(p->monomialDegrees[0u])); } else { res = makeMul(makePow(makeVariable(), constantToExpression(p->monomialDegrees[0u])), res); } } } } if (res == NULL) { res = makeConstantInt(1); } /* Return the result */ return addMemRef(res); } static inline node *sparsePolynomialGetExpression(sparse_polynomial_t p, int canonical) { if (canonical) return __sparsePolynomialGetExpressionCanonical(p); return __sparsePolynomialGetExpressionHorner(p); } void sparsePolynomialFPrintf(FILE *fd, sparse_polynomial_t p, int canonical) { node *t; /* Handle stupid cases */ if (p == NULL) { sollyaFprintf(fd, "(null)"); } /* Handle the general case. Can be optimized. */ t = sparsePolynomialGetExpression(p,canonical); sollyaFprintf(fd, "%b",t); freeThing(t); } char *sparsePolynomialToString(sparse_polynomial_t p, int canonical) { node *t; char *str; char staticStr[8]; int size, r; /* Handle stupid cases */ if (p == NULL) return NULL; /* Handle the general case. Can be optimized. */ t = sparsePolynomialGetExpression(p,canonical); size = sollya_snprintf(staticStr,8,"%b",t); if (size < 0) { freeThing(t); return NULL; } str = (char *) safeCalloc(size + 2, sizeof(char)); r = sollya_snprintf(str,size,"%b",t); if (r < 0) { freeThing(t); safeFree(str); return NULL; } /* Return the string */ return str; } static inline unsigned int sparsePolynomialGetMonomialCount(sparse_polynomial_t p) { /* Handle stupid input */ if (p == NULL) return 0u; /* Return the number of monomials */ return p->monomialCount; } static inline int sparsePolynomialCoefficientsAreDyadic(sparse_polynomial_t p, int defVal) { unsigned int i; int t; /* Handle stupid input */ if (p == NULL) return 0; /* Handle the case when the polynomial has no monomials */ if (p->monomialCount == 0u) return 1; /* Go over the coefficients and check if they are dyadic */ for (i=0u;imonomialCount;i++) { t = constantIsDyadic(p->coeffs[i], 99); if (t == 99) return defVal; if (!t) return 0; } return 1; } static inline int sparsePolynomialCoefficientsAreRational(sparse_polynomial_t p, int defVal) { unsigned int i; int t; /* Handle stupid input */ if (p == NULL) return 0; /* Handle the case when the polynomial has no monomials */ if (p->monomialCount == 0u) return 1; /* Go over the coefficients and check if they are rational */ for (i=0u;imonomialCount;i++) { t = constantIsRational(p->coeffs[i], 99); if (t == 99) return defVal; if (!t) return 0; } return 1; } static inline int sparsePolynomialCoefficientsHoldOnPrecBits(sparse_polynomial_t p, mp_prec_t prec, int defVal) { unsigned int i; int t; /* Handle stupid input */ if (p == NULL) return 0; /* Handle the case when the polynomial has no monomials */ if (p->monomialCount == 0u) return 1; /* Go over the coefficients and check if they hold on prec bits */ for (i=0u;imonomialCount;i++) { t = constantHoldsOnPrecBits(p->coeffs[i], prec, 99); if (t == 99) return defVal; if (!t) return 0; } return 1; } static inline sparse_polynomial_t sparsePolynomialRoundDyadic(sparse_polynomial_t p, mp_prec_t prec) { sparse_polynomial_t res; unsigned int startSize, i; constant_t c; /* Handle stupid input */ if (p == NULL) return NULL; /* If the polynomial only has dyadic coefficients, just return a copy of it. */ if (sparsePolynomialCoefficientsAreDyadic(p, 0)) return sparsePolynomialFromCopy(p); /* Here, at least one of the coefficients is not dyadic. Perform a "deep" copy while rounding the coefficients that are not dyadic. */ res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->monomialCount = 0u; startSize = p->monomialCount; res->coeffs = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); for (i=0u;imonomialCount;i++) { c = constantRoundDyadic(p->coeffs[i], prec); if (!constantIsZero(c, 0)) { res->coeffs[res->monomialCount] = c; res->monomialDegrees[res->monomialCount] = constantFromCopy(p->monomialDegrees[i]); (res->monomialCount)++; } else { constantFree(c); } } /* If res->monomialCount still is zero, we never added anything because the two polynomials multiplied gave zero. We add a zero coefficient in this case. */ if (res->monomialCount == 0u) { res->coeffs[res->monomialCount] = constantFromInt(0); res->monomialDegrees[res->monomialCount] = constantFromInt(0); (res->monomialCount)++; } /* Set the degree of the polynomial */ res->deg = constantFromCopy(res->monomialDegrees[res->monomialCount - 1u]); /* Adjust memory to the real amount of monomials */ if (res->monomialCount != startSize) { res->coeffs = (constant_t *) safeRealloc(res->coeffs, ((size_t) (res->monomialCount)) * sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeRealloc(res->monomialDegrees, ((size_t) (res->monomialCount)) * sizeof(constant_t)); } /* Adjust the degree for zero leading coefficients */ __sparsePolynomialAdjustDegree(res); /* Return the polynomial */ return res; } static inline sparse_polynomial_t sparsePolynomialRoundRational(sparse_polynomial_t p, mp_prec_t prec) { sparse_polynomial_t res; unsigned int startSize, i; constant_t c; /* Handle stupid input */ if (p == NULL) return NULL; /* If the polynomial only has rational coefficients, just return a copy of it. */ if (sparsePolynomialCoefficientsAreRational(p, 0)) return sparsePolynomialFromCopy(p); /* Here, at least one of the coefficients is not rational. Perform a "deep" copy while rounding the coefficients that are not rational. */ res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->monomialCount = 0u; startSize = p->monomialCount; res->coeffs = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); for (i=0u;imonomialCount;i++) { c = constantRoundRational(p->coeffs[i], prec); if (!constantIsZero(c, 0)) { res->coeffs[res->monomialCount] = c; res->monomialDegrees[res->monomialCount] = constantFromCopy(p->monomialDegrees[i]); (res->monomialCount)++; } else { constantFree(c); } } /* If res->monomialCount still is zero, we never added anything because the two polynomials multiplied gave zero. We add a zero coefficient in this case. */ if (res->monomialCount == 0u) { res->coeffs[res->monomialCount] = constantFromInt(0); res->monomialDegrees[res->monomialCount] = constantFromInt(0); (res->monomialCount)++; } /* Set the degree of the polynomial */ res->deg = constantFromCopy(res->monomialDegrees[res->monomialCount - 1u]); /* Adjust memory to the real amount of monomials */ if (res->monomialCount != startSize) { res->coeffs = (constant_t *) safeRealloc(res->coeffs, ((size_t) (res->monomialCount)) * sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeRealloc(res->monomialDegrees, ((size_t) (res->monomialCount)) * sizeof(constant_t)); } /* Adjust the degree for zero leading coefficients */ __sparsePolynomialAdjustDegree(res); /* Return the polynomial */ return res; } static inline sparse_polynomial_t sparsePolynomialRound(sparse_polynomial_t p, mp_prec_t prec) { sparse_polynomial_t res; unsigned int startSize, i; constant_t c; /* Handle stupid input */ if (p == NULL) return NULL; /* If the polynomial only has coefficients that hold on prec bits, just return a copy of it. */ if (sparsePolynomialCoefficientsHoldOnPrecBits(p, prec, 0)) return sparsePolynomialFromCopy(p); /* Here, at least one of the coefficients does not hold on prec bits. Perform a "deep" copy while rounding the coefficients that are not dyadic. */ res = __sparsePolynomialAllocate(); res->refCount = 1; res->hash.hasHash = 0; res->monomialCount = 0u; startSize = p->monomialCount; res->coeffs = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeCalloc(startSize, sizeof(constant_t)); for (i=0u;imonomialCount;i++) { c = constantRound(p->coeffs[i], prec); if (!constantIsZero(c, 0)) { res->coeffs[res->monomialCount] = c; res->monomialDegrees[res->monomialCount] = constantFromCopy(p->monomialDegrees[i]); (res->monomialCount)++; } else { constantFree(c); } } /* If res->monomialCount still is zero, we never added anything because the two polynomials multiplied gave zero. We add a zero coefficient in this case. */ if (res->monomialCount == 0u) { res->coeffs[res->monomialCount] = constantFromInt(0); res->monomialDegrees[res->monomialCount] = constantFromInt(0); (res->monomialCount)++; } /* Set the degree of the polynomial */ res->deg = constantFromCopy(res->monomialDegrees[res->monomialCount - 1u]); /* Adjust memory to the real amount of monomials */ if (res->monomialCount != startSize) { res->coeffs = (constant_t *) safeRealloc(res->coeffs, ((size_t) (res->monomialCount)) * sizeof(constant_t)); res->monomialDegrees = (constant_t *) safeRealloc(res->monomialDegrees, ((size_t) (res->monomialCount)) * sizeof(constant_t)); } /* Adjust the degree for zero leading coefficients */ __sparsePolynomialAdjustDegree(res); /* Return the polynomial */ return res; } static inline unsigned int sparsePolynomialGetReferenceCount(sparse_polynomial_t p) { if (p == NULL) return 0u; return p->refCount; } static inline int sparsePolynomialUsesExpressionConstant(sparse_polynomial_t p) { unsigned int i; /* Handle stupid input */ if (p == NULL) return 0; /* Handle the case when the polynomial has no monomials */ if (p->monomialCount == 0u) return 0; /* Go over all monomials and check the constants */ for (i=0u;imonomialCount;i++) { if (constantUsesExpressionConstant(p->coeffs[i])) return 1; if (constantUsesExpressionConstant(p->monomialDegrees[i])) return 1; } if (constantUsesExpressionConstant(p->deg)) return 1; /* The expression has nowhere been found */ return 0; } static inline int sparsePolynomialReferencesExpression(sparse_polynomial_t p, node *expr) { unsigned int i; /* Handle stupid input */ if (p == NULL) return 0; /* If the polynomial does not use any expression, it cannot reference the given expression */ if (!sparsePolynomialUsesExpressionConstant(p)) { return 0; } /* Handle the case when the polynomial has no monomials */ if (p->monomialCount == 0u) return 0; /* Go over all monomials and check the constants */ for (i=0u;imonomialCount;i++) { if (constantReferencesExpression(p->coeffs[i], expr)) return 1; if (constantReferencesExpression(p->monomialDegrees[i], expr)) return 1; } if (constantReferencesExpression(p->deg, expr)) return 1; /* The expression has nowhere been found */ return 0; } static inline uint64_t sparsePolynomialHash(sparse_polynomial_t p) { uint64_t hash; unsigned int i; /* Handle stupid input */ if (p == NULL) return hashPointer(NULL); /* Check if the hash has already been computed */ if (p->hash.hasHash) { return p->hash.hash; } /* Compute the hash */ hash = hashUnsignedInt(p->monomialCount); hash = hashCombine(hash, constantHash(p->deg)); for (i=0u;imonomialCount;i++) { hash = hashCombine(hash, constantHash(p->coeffs[i])); hash = hashCombine(hash, constantHash(p->monomialDegrees[i])); } /* Cache the result */ p->hash.hash = hash; p->hash.hasHash = 1; /* Return the hash */ return hash; } /* End of part for sparse polynomials */ /* Start of part for general (composed) polynomials */ static inline void __polynomialSparsify(polynomial_t); int polynomialUsesExpressionConstant(polynomial_t p); static inline polynomial_t __polynomialAllocate() { return (polynomial_t) safeMalloc(sizeof(struct __polynomial_struct_t)); } static inline void __polynomialFreeMem(polynomial_t p) { safeFree(p); } void polynomialInitializeCaches() { sparsePolynomialInitializeCaches(); } void polynomialFreeCaches() { sparsePolynomialFreeCaches(); } static inline polynomial_t __polynomialBuildFromSparse(sparse_polynomial_t p) { polynomial_t res; /* Handle stupid input */ if (p == NULL) return NULL; /* Handle general case */ res = __polynomialAllocate(); res->refCount = 1u; res->type = SPARSE; res->outputType = ANY_FORM; res->value.sparse = p; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; /* Return the newly built polynomial */ return res; } static inline sparse_polynomial_t __polynomialSparsifyComposition(polynomial_t p, sparse_polynomial_t q) { sparse_polynomial_t g, h, r; /* Handle stupid input */ if (p == NULL) return NULL; if (q == NULL) return NULL; /* Consider the structure of p */ switch (p->type) { case SPARSE: return sparsePolynomialCompose(p->value.sparse, q); break; case ADDITION: g = __polynomialSparsifyComposition(p->value.pair.g, q); h = __polynomialSparsifyComposition(p->value.pair.h, q); r = sparsePolynomialAdd(g, h); sparsePolynomialFree(g); sparsePolynomialFree(h); return r; break; case SUBTRACTION: g = __polynomialSparsifyComposition(p->value.pair.g, q); h = __polynomialSparsifyComposition(p->value.pair.h, q); r = sparsePolynomialSub(g, h); sparsePolynomialFree(g); sparsePolynomialFree(h); return r; break; case MULTIPLICATION: g = __polynomialSparsifyComposition(p->value.pair.g, q); h = __polynomialSparsifyComposition(p->value.pair.h, q); r = sparsePolynomialMul(g, h); sparsePolynomialFree(g); sparsePolynomialFree(h); return r; break; case COMPOSITION: h = __polynomialSparsifyComposition(p->value.pair.h, q); r = __polynomialSparsifyComposition(p->value.pair.g, h); sparsePolynomialFree(h); return r; break; case NEGATE: g = __polynomialSparsifyComposition(p->value.g, q); r = sparsePolynomialNeg(g); sparsePolynomialFree(g); return r; break; case POWER: g = __polynomialSparsifyComposition(p->value.powering.g, q); if (!sparsePolynomialPowConstant(&r, g, p->value.powering.c)) { sollyaFprintf(stderr,"Error: __polynomialSparsifyComposition: could not compute power of sparse polynomial\n"); exit(1); } sparsePolynomialFree(g); return r; break; default: break; } __polynomialSparsify(p); return sparsePolynomialCompose(p->value.sparse, q); } static inline void __polynomialSparsify(polynomial_t p) { sparse_polynomial_t sp; /* Handle stupid input */ if (p == NULL) return; /* General case */ switch (p->type) { case SPARSE: /* Nothing to do */ return; break; case ADDITION: __polynomialSparsify(p->value.pair.g); __polynomialSparsify(p->value.pair.h); sp = sparsePolynomialAdd(p->value.pair.g->value.sparse, p->value.pair.h->value.sparse); polynomialFree(p->value.pair.g); polynomialFree(p->value.pair.h); p->value.sparse = sp; break; case SUBTRACTION: __polynomialSparsify(p->value.pair.g); __polynomialSparsify(p->value.pair.h); sp = sparsePolynomialSub(p->value.pair.g->value.sparse, p->value.pair.h->value.sparse); polynomialFree(p->value.pair.g); polynomialFree(p->value.pair.h); p->value.sparse = sp; break; case MULTIPLICATION: __polynomialSparsify(p->value.pair.g); __polynomialSparsify(p->value.pair.h); sp = sparsePolynomialMul(p->value.pair.g->value.sparse, p->value.pair.h->value.sparse); polynomialFree(p->value.pair.g); polynomialFree(p->value.pair.h); p->value.sparse = sp; break; case COMPOSITION: __polynomialSparsify(p->value.pair.h); sp = __polynomialSparsifyComposition(p->value.pair.g, p->value.pair.h->value.sparse); polynomialFree(p->value.pair.g); polynomialFree(p->value.pair.h); p->value.sparse = sp; break; case NEGATE: __polynomialSparsify(p->value.g); sp = sparsePolynomialNeg(p->value.g->value.sparse); polynomialFree(p->value.g); p->value.sparse = sp; break; case POWER: __polynomialSparsify(p->value.powering.g); if (!sparsePolynomialPowConstant(&sp, p->value.powering.g->value.sparse, p->value.powering.c)) { sollyaFprintf(stderr,"Error: __polynomialSparsify: could not compute power of sparse polynomial\n"); exit(1); } polynomialFree(p->value.powering.g); constantFree(p->value.powering.c); p->value.sparse = sp; break; } if (p->usesExpressionConstant.cached) { if (p->usesExpressionConstant.res) { p->usesExpressionConstant.cached = 0; } } p->type = SPARSE; } static inline polynomial_t __polynomialExecuteCompositionCompose(polynomial_t p, polynomial_t q) { polynomial_t res, t; /* Make compiler happy */ res = NULL; /* End of compiler happiness */ /* Handle stupid input */ if (p == NULL) return NULL; if (q == NULL) return NULL; /* General case */ switch (p->type) { case SPARSE: __polynomialSparsify(q); res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->outputType = ANY_FORM; res->value.sparse = sparsePolynomialCompose(p->value.sparse, q->value.sparse); res->type = SPARSE; break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->outputType = ANY_FORM; res->type = p->type; res->value.pair.g = __polynomialExecuteCompositionCompose(p->value.pair.g, q); res->value.pair.h = __polynomialExecuteCompositionCompose(p->value.pair.h, q); break; case COMPOSITION: t = __polynomialExecuteCompositionCompose(p->value.pair.h, q); res = __polynomialExecuteCompositionCompose(p->value.pair.g, t); polynomialFree(t); break; case NEGATE: res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->outputType = ANY_FORM; res->type = NEGATE; res->value.g = __polynomialExecuteCompositionCompose(p->value.g, q); break; case POWER: res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->outputType = ANY_FORM; res->type = POWER; res->value.powering.g = __polynomialExecuteCompositionCompose(p->value.powering.g, q); res->value.powering.c = constantFromCopy(p->value.powering.c); break; } return res; } static inline void __polynomialExecuteComposition(polynomial_t p) { sparse_polynomial_t sp; constant_t c; polynomial_type_t t; polynomial_t g, h; /* Handle stupid input */ if (p == NULL) return; /* General case */ switch (p->type) { case SPARSE: /* Nothing to do */ return; break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: __polynomialExecuteComposition(p->value.pair.g); __polynomialExecuteComposition(p->value.pair.h); break; case COMPOSITION: __polynomialExecuteComposition(p->value.pair.g); __polynomialExecuteComposition(p->value.pair.h); t = p->value.pair.g->type; switch (t) { case SPARSE: __polynomialSparsify(p->value.pair.h); sp = sparsePolynomialCompose(p->value.pair.g->value.sparse, p->value.pair.h->value.sparse); polynomialFree(p->value.pair.g); polynomialFree(p->value.pair.h); p->value.sparse = sp; p->type = SPARSE; return; break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: g = __polynomialExecuteCompositionCompose(p->value.pair.g->value.pair.g, p->value.pair.h); h = __polynomialExecuteCompositionCompose(p->value.pair.g->value.pair.h, p->value.pair.h); polynomialFree(p->value.pair.g); polynomialFree(p->value.pair.h); p->value.pair.g = g; p->value.pair.h = h; p->type = t; return; break; case COMPOSITION: /* Should never happen */ __polynomialSparsify(p); return; break; case NEGATE: g = __polynomialExecuteCompositionCompose(p->value.pair.g->value.g, p->value.pair.h); polynomialFree(p->value.pair.g); polynomialFree(p->value.pair.h); p->value.g = g; p->type = NEGATE; return; break; case POWER: g = __polynomialExecuteCompositionCompose(p->value.pair.g->value.powering.g, p->value.pair.h); c = constantFromCopy(p->value.pair.g->value.powering.c); polynomialFree(p->value.pair.g); polynomialFree(p->value.pair.h); p->value.powering.g = g; p->value.powering.c = c; p->type = POWER; return; break; } break; case NEGATE: __polynomialExecuteComposition(p->value.g); break; case POWER: __polynomialExecuteComposition(p->value.powering.g); break; } } polynomial_t polynomialFromMpfrConstant(mpfr_t c) { return __polynomialBuildFromSparse(sparsePolynomialFromMpfrConstant(c)); } polynomial_t polynomialFromMpzConstant(mpz_t c) { return __polynomialBuildFromSparse(sparsePolynomialFromMpzConstant(c)); } polynomial_t polynomialFromMpqConstant(mpq_t c) { return __polynomialBuildFromSparse(sparsePolynomialFromMpqConstant(c)); } polynomial_t polynomialFromIntConstant(int c) { return __polynomialBuildFromSparse(sparsePolynomialFromIntConstant(c)); } polynomial_t polynomialFromIdentity() { return __polynomialBuildFromSparse(sparsePolynomialFromIdentity()); } polynomial_t polynomialFromMpfrCoefficients(mpfr_t *coeffs, unsigned int deg) { return __polynomialBuildFromSparse(sparsePolynomialFromMpfrCoefficients(coeffs, deg)); } static inline polynomial_t __polynomialFromConstant(constant_t c) { return __polynomialBuildFromSparse(sparsePolynomialFromConstant(c)); } int polynomialFromConstantExpressionCoefficients(polynomial_t *r, node **coeffs, unsigned int deg) { sparse_polynomial_t sp; if (!sparsePolynomialFromConstantExpressionCoefficients(&sp, coeffs, deg)) return 0; *r = __polynomialBuildFromSparse(sp); return 1; } polynomial_t polynomialFromCopy(polynomial_t p) { if (p == NULL) return NULL; p->refCount++; return p; } void polynomialFree(polynomial_t p) { if (p == NULL) return; p->refCount--; if (p->refCount > 0u) return; switch (p->type) { case SPARSE: sparsePolynomialFree(p->value.sparse); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: case COMPOSITION: polynomialFree(p->value.pair.g); polynomialFree(p->value.pair.h); break; case NEGATE: polynomialFree(p->value.g); break; case POWER: polynomialFree(p->value.powering.g); constantFree(p->value.powering.c); break; } __polynomialFreeMem(p); } static inline int __polynomialGetDegreeAsIntCheap(polynomial_t p) { int gd, hd, res; unsigned int u, gdu, tu, ttu; /* Handle stupid input */ if (p == NULL) return -1; /* Try to handle the case without sparsifying the polynomial. */ switch (p->type) { case SPARSE: return sparsePolynomialGetDegreeAsInt(p->value.sparse); break; case ADDITION: case SUBTRACTION: gd = __polynomialGetDegreeAsIntCheap(p->value.pair.g); hd = __polynomialGetDegreeAsIntCheap(p->value.pair.h); if ((gd == 0) && (hd == 0)) return 0; if ((gd >= 0) && (hd >= 0) && (gd != hd)) return (hd > gd ? hd : gd); break; case MULTIPLICATION: gd = __polynomialGetDegreeAsIntCheap(p->value.pair.g); hd = __polynomialGetDegreeAsIntCheap(p->value.pair.h); if ((gd != 0) && (hd != 0)) { if ((gd < 0) || (hd < 0)) return -1; if (tryExactIntAddition(&res, gd, hd)) { return res; } else { return -1; } } break; case COMPOSITION: gd = __polynomialGetDegreeAsIntCheap(p->value.pair.g); hd = __polynomialGetDegreeAsIntCheap(p->value.pair.h); if ((gd == 0) || (hd == 0)) return 0; if ((gd < 0) || (hd < 0)) return -1; if (tryExactIntMultiplication(&res, gd, hd)) { return res; } else { return -1; } break; case NEGATE: return __polynomialGetDegreeAsIntCheap(p->value.g); break; case POWER: gd = __polynomialGetDegreeAsIntCheap(p->value.powering.g); if (gd == 0) return 0; if (tryConstantToUnsignedInt(&u, p->value.powering.c)) { if (u == 0u) { return 0; } else { if (gd < 0) return -1; gdu = gd; if (tryExactUnsignedIntMultiplication(&tu,gdu,u)) { res = tu; if (res < 0) return -1; ttu = res; if (ttu != tu) return -1; return res; } else { return -1; } } } else { return -1; } break; } /* The fallback would be too expensive */ return -1; } static inline int __polynomialEqualCheap(polynomial_t p, polynomial_t q) { if (p == NULL) return 0; if (q == NULL) return 0; if (p == q) return 1; if (p->type != q->type) return 0; switch (p->type) { case SPARSE: return sparsePolynomialEqual(p->value.sparse, q->value.sparse, 0); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: case COMPOSITION: return (__polynomialEqualCheap(p->value.pair.g, q->value.pair.g) && __polynomialEqualCheap(p->value.pair.h, q->value.pair.h)); break; case NEGATE: return __polynomialEqualCheap(p->value.g, q->value.g); break; case POWER: return (__polynomialEqualCheap(p->value.powering.g, q->value.powering.g) && constantIsEqual(p->value.powering.c, q->value.powering.c, 0)); break; } return 0; } static inline int __polynomialStructurallyEqualCheap(polynomial_t p, polynomial_t q) { if (p == NULL) return 0; if (q == NULL) return 0; if (p == q) return 1; if (p->type != q->type) return 0; if (p->outputType != q->outputType) return 0; switch (p->type) { case SPARSE: return sparsePolynomialEqual(p->value.sparse, q->value.sparse, 0); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: case COMPOSITION: return (__polynomialStructurallyEqualCheap(p->value.pair.g, q->value.pair.g) && __polynomialStructurallyEqualCheap(p->value.pair.h, q->value.pair.h)); break; case NEGATE: return __polynomialStructurallyEqualCheap(p->value.g, q->value.g); break; case POWER: return (__polynomialStructurallyEqualCheap(p->value.powering.g, q->value.powering.g) && constantIsEqual(p->value.powering.c, q->value.powering.c, 0)); break; } return 0; } static inline int __polynomialIsConstantCheap(polynomial_t p) { if (p == NULL) return 0; switch (p->type) { case SPARSE: return sparsePolynomialIsConstant(p->value.sparse, 0); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: return (__polynomialIsConstantCheap(p->value.pair.g) && __polynomialIsConstantCheap(p->value.pair.h)); break; case COMPOSITION: return (__polynomialIsConstantCheap(p->value.pair.g) || __polynomialIsConstantCheap(p->value.pair.h)); break; case NEGATE: return __polynomialIsConstantCheap(p->value.g); break; case POWER: return (__polynomialIsConstantCheap(p->value.powering.g) || constantIsZero(p->value.powering.c, 0)); break; } return 0; } static inline void __polynomialUnifyEqual(polynomial_t p, polynomial_t q) { if (p == NULL) return; if (q == NULL) return; if (p == q) return; if ((p->type == SPARSE) && (q->type == SPARSE)) { if (p->value.sparse == q->value.sparse) return; if (sparsePolynomialGetReferenceCount(p->value.sparse) > sparsePolynomialGetReferenceCount(q->value.sparse)) { sparsePolynomialFree(q->value.sparse); q->value.sparse = sparsePolynomialFromCopy(p->value.sparse); } else { sparsePolynomialFree(p->value.sparse); p->value.sparse = sparsePolynomialFromCopy(q->value.sparse); } return; } if ((p->type == SPARSE) && (q->type != SPARSE)) { switch (q->type) { case ADDITION: case SUBTRACTION: case MULTIPLICATION: case COMPOSITION: polynomialFree(q->value.pair.g); polynomialFree(q->value.pair.h); break; case NEGATE: polynomialFree(q->value.g); break; case POWER: polynomialFree(q->value.powering.g); constantFree(q->value.powering.c); break; default: return; } q->type = SPARSE; q->value.sparse = sparsePolynomialFromCopy(p->value.sparse); return; } if ((q->type == SPARSE) && (p->type != SPARSE)) { switch (p->type) { case ADDITION: case SUBTRACTION: case MULTIPLICATION: case COMPOSITION: polynomialFree(p->value.pair.g); polynomialFree(p->value.pair.h); break; case NEGATE: polynomialFree(p->value.g); break; case POWER: polynomialFree(p->value.powering.g); constantFree(p->value.powering.c); break; default: return; } p->type = SPARSE; p->value.sparse = sparsePolynomialFromCopy(q->value.sparse); return; } } int polynomialEqual(polynomial_t p, polynomial_t q, int defVal) { int dp, dq, res; /* Handle stupid inputs */ if (p == NULL) return defVal; if (q == NULL) return defVal; /* Pointer equality */ if (p == q) return 1; /* If both polynomials are in sparse form, just use this */ if ((p->type == SPARSE) && (q->type == SPARSE)) { res = sparsePolynomialEqual(p->value.sparse, q->value.sparse, 51); if (res == 51) return defVal; if (!res) return 0; __polynomialUnifyEqual(p,q); return 1; } /* Try to cheaply compute the degrees. If both degrees can be computed but are different, we know that the polynomials are different. */ dp = __polynomialGetDegreeAsIntCheap(p); dq = __polynomialGetDegreeAsIntCheap(q); if ((dp >= 0) && (dq >= 0) && (dp != dq)) return 0; /* If p and q are written the same way and each sub-polynomial is the same, they are the same. */ if (__polynomialEqualCheap(p, q)) { __polynomialUnifyEqual(p, q); return 1; } /* General case Can perhaps be optimized still a little bit. */ __polynomialSparsify(p); __polynomialSparsify(q); res = sparsePolynomialEqual(p->value.sparse, q->value.sparse, 51); if (res == 51) return defVal; if (!res) return 0; __polynomialUnifyEqual(p, q); return 1; } unsigned int polynomialGetNumberOfNonZeroCoefficients(polynomial_t p) { /* Handle stupid inputs */ if (p == NULL) return 0u; /* General case */ __polynomialSparsify(p); return sparsePolynomialGetNumberOfNonZeroCoefficients(p->value.sparse); } int polynomialStructurallyEqual(polynomial_t p, polynomial_t q, int defVal) { constant_t c0, cd; mpz_t deg; unsigned int nzc; /* Handle stupid inputs */ if (p == NULL) return defVal; if (q == NULL) return defVal; /* Pointer equality */ if (p == q) return 1; /* Use hashes if we have them already computed */ if (p->hash.hasHash && q->hash.hasHash) { /* Both polynomials have a hash. If the hashes are different, they are structurally different. */ if (p->hash.hash != q->hash.hash) return 0; } /* Do a first check using a cheap function */ if (__polynomialStructurallyEqualCheap(p, q)) return 1; /* If the polynomials are not mathematically equal, they cannot be structurally equal. */ if (!polynomialEqual(p, q, 1)) return 0; /* Try with the other default value */ if (!polynomialEqual(p, q, 0)) { __polynomialSparsify(p); __polynomialSparsify(q); } /* Retry */ if (!polynomialEqual(p, q, 1)) return 0; /* Here the polynomials are mathematically equal or their mathematical equality cannot be decided. Start by assuring us that we know that they are mathematically equal. */ if (polynomialEqual(p, q, 0)) { /* Here, the polynomials are mathematically equal. If they have the same output form and that output form is canonical or hornerized, they are structurally equal. If they have the same output form and that output form is ANY_FORM, we sparsify both polynomials and can then answer that they are structurally equal. */ if (p->outputType == q->outputType) { if (p->outputType == ANY_FORM) { __polynomialSparsify(p); __polynomialSparsify(q); } return 1; } /* Here, the polynomials have different output forms. Start by checking if one of them is constant. As the other one is mathematically equal, it is constant, too. If the polynomials are constant, they are structurally the same. */ if (polynomialIsConstant(p, 0)) return 1; /* Now check if the polynomials (testing one is sufficient as they are mathematically equal) have a non-zero constant coefficient, a leading coefficient equal to 1 and only two non-zero coefficients. In this particular case the hornerized form c_0 + x^d is structurally the same as the canonical form c_0 + x^d. */ c0 = __polynomialGetIthCoefficientAsConstantIntIndex(p, 0); if (!constantIsZero(c0, 1)) { mpz_init(deg); polynomialGetDegree(deg, p); cd = __polynomialGetIthCoefficientAsConstant(p, deg); mpz_clear(deg); if (constantIsOne(cd, 0)) { nzc = polynomialGetNumberOfNonZeroCoefficients(p); if (nzc == 2u) { constantFree(cd); constantFree(c0); return 1; } } constantFree(cd); } constantFree(c0); /* Here, the polynomials have different output forms and are not constant. If none of these output forms is ANY_FORM, they are structurally different. */ if ((p->outputType != ANY_FORM) && (q->outputType != ANY_FORM)) { return 0; } /* Here at least one of the output forms is ANY_FORM and the other output form is not ANY_FORM. We sparsify both polynomials. Then they are structurally equal iff none of them is in CANONICAL_FORM as the output for sparsified ANY_FORMS is HORNER_FORM. */ __polynomialSparsify(p); __polynomialSparsify(q); if ((p->outputType != CANONICAL_FORM) && (q->outputType != CANONICAL_FORM)) { return 1; } /* Here the polynomials are structurally different */ return 0; } /* Here, we don't know if the polynomials are mathematically the same and we already retried. We return the default answer. */ return defVal; } int polynomialIsIdentity(polynomial_t p, int defVal) { int dp; /* Handle stupid inputs */ if (p == NULL) return defVal; /* If the polynomial is sparse, just use the test function on sparse polynomials */ if (p->type == SPARSE) return sparsePolynomialIsIdentity(p->value.sparse, defVal); /* If the polynomial is constant, it is not the identity function */ if (__polynomialIsConstantCheap(p)) return 0; /* If the degree of the polynomial can be computed easily and it is not 1, the polynomial can't be the identity function. */ dp = __polynomialGetDegreeAsIntCheap(p); if ((dp >= 0) && (dp != 1)) return 0; /* Some optimisations are still possible */ /* Sparsify the polynomial and use the test function on sparse polynomials */ __polynomialSparsify(p); return sparsePolynomialIsIdentity(p->value.sparse, defVal); } int polynomialIsConstant(polynomial_t p, int defVal) { int deg; constant_t c; /* Handle stupid inputs */ if (p == NULL) return defVal; /* If the polynomial is sparse, just use the test function on sparse polynomials. */ if (p->type == SPARSE) return sparsePolynomialIsConstant(p->value.sparse, defVal); /* Try a cheap function to determine if the polynomial is constant */ if (__polynomialIsConstantCheap(p)) return 1; /* Here, we still do not know if the polynomial is constant. We compute its degree. If the degree is larger than the largest machine integer, the function will return a negative value instead of the degree. In this case, we sparsify the polynomial and call the test function on the sparsified polynomial. Otherwise, * if the degree is zero, we are sure the polynomial is constant, * otherwise, we get the coefficient corresponding to the degree and check if it is non-zero. If we cannot show it is non-zero, we return the default answer. Otherwise, we are sure that the polynomial is not constant. */ deg = polynomialGetDegreeAsInt(p); if (deg < 0) { __polynomialSparsify(p); return sparsePolynomialIsConstant(p->value.sparse, defVal); } /* Here the degree of the polynomial holds on a machine integer. If it is zero, the polynomial is constant. */ if (deg == 0) return 1; /* Get the coefficient of the degree of the polynomial */ c = __polynomialGetIthCoefficientAsConstantIntIndex(p, deg); /* Check if coefficient of degree is zero. */ if (constantIsZero(c, 1)) { /* Here the coefficient of the polynomial corresponding to its degree is said to be zero. This means it cannot be shown to be non-zero. We return the default value, as we do not know if the polynomial is constant or not. */ constantFree(c); return defVal; } /* Free the constant corresponding to coefficient */ constantFree(c); /* Here the coefficient of degree deg != 0 is shown to be non-zero. Hence, the polynomial is not constant. */ return 0; } void polynomialDiv(polynomial_t *quot, polynomial_t *rest, polynomial_t a, polynomial_t b) { sparse_polynomial_t sq, sr; polynomial_t q, r, qg, qh, rg, rh, t, rcp; constant_t one, tc, c, recprC; /* Handle stupid inputs */ if ((a == NULL) || (b == NULL)) { *quot = NULL; *rest = NULL; return; } /* If a and b are both sparse, just use the sparse division */ if ((a->type == SPARSE) && (b->type == SPARSE)) { sparsePolynomialDiv(&sq, &sr, a->value.sparse, b->value.sparse); *quot = __polynomialBuildFromSparse(sq); *rest = __polynomialBuildFromSparse(sr); return; } /* If b is constant, do some special handling */ if (polynomialGetDegreeAsInt(b) == 0) { /* Get the constant corresponding to b */ c = __polynomialGetIthCoefficientAsConstantIntIndex(b, 0); /* If we are sure that b = c is non-zero, we are sure we can compute 1/c and replace the division by a multiplication */ if (!constantIsZero(c, 1)) { /* Compute 1/c and represent it as a polynomial */ one = constantFromInt(1); recprC = constantDiv(one, c); constantFree(one); rcp = __polynomialFromConstant(recprC); constantFree(recprC); *quot = polynomialMul(rcp, a); *rest = polynomialFromIntConstant(0); polynomialFree(rcp); } else { /* Here b = c = 0. We take q = 0 and r = a */ *quot = polynomialFromIntConstant(0); *rest = polynomialFromCopy(a); } constantFree(c); return; } /* If a and b are equal, the answer is easy */ if (__polynomialEqualCheap(a, b)) { *quot = polynomialFromIntConstant(1); *rest = polynomialFromIntConstant(0); return; } /* If a is a negation, do the division recursively and negate the quotient and rest. */ if (a->type == NEGATE) { polynomialDiv(&q, &r, a->value.g, b); *quot = polynomialNeg(q); *rest = polynomialNeg(r); polynomialFree(q); polynomialFree(r); return; } /* If a is an addition, just do the division recursively. */ if (a->type == ADDITION) { polynomialDiv(&qg, &rg, a->value.pair.g, b); polynomialDiv(&qh, &rh, a->value.pair.h, b); *quot = polynomialAdd(qg, qh); *rest = polynomialAdd(rg, rh); polynomialFree(qg); polynomialFree(rg); return; } /* If a is a subtraction, just do the division recursively. */ if (a->type == SUBTRACTION) { polynomialDiv(&qg, &rg, a->value.pair.g, b); polynomialDiv(&qh, &rh, a->value.pair.h, b); *quot = polynomialSub(qg, qh); *rest = polynomialSub(rg, rh); polynomialFree(qg); polynomialFree(rg); return; } /* If a is of the form a = p^c with c >= 2 and b = p, the result is q = p^(c - 1) and r = 0. */ if (a->type == POWER) { if ((!constantIsZero(a->value.powering.c,1)) && (!constantIsOne(a->value.powering.c,1))) { if (polynomialEqual(a->value.powering.g, b, 0)) { one = constantFromInt(1); tc = constantSub(a->value.powering.c, one); constantFree(one); t = __polynomialFromConstant(tc); constantFree(tc); if (polynomialPow(quot, b, t)) { *rest = polynomialFromIntConstant(0); polynomialFree(t); return; } polynomialFree(t); } } } /* General case Some cases can still be optimized. */ __polynomialSparsify(a); __polynomialSparsify(b); sparsePolynomialDiv(&sq, &sr, a->value.sparse, b->value.sparse); *quot = __polynomialBuildFromSparse(sq); *rest = __polynomialBuildFromSparse(sr); } polynomial_t polynomialHornerize(polynomial_t p) { polynomial_t res; /* Handle stupid input */ if (p == NULL) return NULL; /* If p is already hornerized, return a plain copy. */ if (p->outputType == HORNER_FORM) { return polynomialFromCopy(p); } /* Here we have work to do. We perform a "deep" copy and set the output form to "hornerized". */ res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = p->type; res->outputType = HORNER_FORM; switch (p->type) { case SPARSE: res->value.sparse = sparsePolynomialFromCopy(p->value.sparse); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: case COMPOSITION: res->value.pair.g = polynomialFromCopy(p->value.pair.g); res->value.pair.h = polynomialFromCopy(p->value.pair.h); break; case NEGATE: res->value.g = polynomialFromCopy(p->value.g); break; case POWER: res->value.powering.g = polynomialFromCopy(p->value.powering.g); res->value.powering.c = constantFromCopy(p->value.powering.c); break; } return res; } polynomial_t polynomialCanonicalize(polynomial_t p) { polynomial_t res; /* Handle stupid input */ if (p == NULL) return NULL; /* If p is already canonical, return a plain copy. */ if (p->outputType == CANONICAL_FORM) { return polynomialFromCopy(p); } /* Here we have work to do. We perform a "deep" copy and set the output form to "canonical". */ res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = p->type; res->outputType = CANONICAL_FORM; switch (p->type) { case SPARSE: res->value.sparse = sparsePolynomialFromCopy(p->value.sparse); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: case COMPOSITION: res->value.pair.g = polynomialFromCopy(p->value.pair.g); res->value.pair.h = polynomialFromCopy(p->value.pair.h); break; case NEGATE: res->value.g = polynomialFromCopy(p->value.g); break; case POWER: res->value.powering.g = polynomialFromCopy(p->value.powering.g); res->value.powering.c = constantFromCopy(p->value.powering.c); break; } return res; } void polynomialGetDegree(mpz_t deg, polynomial_t p) { mpz_t gd, hd; /* Handle stupid input */ if (p == NULL) { mpz_set_si(deg,-1); return; } /* Try to handle the case without sparsifying the polynomial. */ switch (p->type) { case SPARSE: sparsePolynomialGetDegree(deg, p->value.sparse); return; break; case ADDITION: case SUBTRACTION: mpz_init(gd); mpz_init(hd); polynomialGetDegree(gd, p->value.pair.g); polynomialGetDegree(hd, p->value.pair.h); if ((mpz_sgn(gd) < 0) || (mpz_sgn(hd) < 0)) { mpz_clear(gd); mpz_clear(hd); mpz_set_si(deg,-1); return; } if (mpz_cmp(gd, hd) != 0) { if (mpz_cmp(gd, hd) > 0) { mpz_set(deg, gd); } else { mpz_set(deg, hd); } mpz_clear(gd); mpz_clear(hd); return; } mpz_clear(gd); mpz_clear(hd); break; case MULTIPLICATION: mpz_init(gd); mpz_init(hd); polynomialGetDegree(gd, p->value.pair.g); polynomialGetDegree(hd, p->value.pair.h); if ((mpz_sgn(gd) < 0) || (mpz_sgn(hd) < 0)) { mpz_clear(gd); mpz_clear(hd); mpz_set_si(deg,-1); return; } if ((mpz_sgn(gd) > 0) && (mpz_sgn(hd) > 0)) { mpz_add(deg, gd, hd); mpz_clear(gd); mpz_clear(hd); return; } mpz_clear(gd); mpz_clear(hd); break; case COMPOSITION: mpz_init(gd); mpz_init(hd); polynomialGetDegree(gd, p->value.pair.g); polynomialGetDegree(hd, p->value.pair.h); if ((mpz_sgn(gd) < 0) || (mpz_sgn(hd) < 0)) { mpz_clear(gd); mpz_clear(hd); mpz_set_si(deg,-1); return; } mpz_mul(deg, hd, gd); mpz_clear(gd); mpz_clear(hd); return; break; case NEGATE: polynomialGetDegree(deg,p->value.g); return; break; case POWER: mpz_init(gd); polynomialGetDegree(gd, p->value.powering.g); if (mpz_sgn(gd) < 0) { mpz_clear(gd); mpz_set_si(deg,-1); return; } if (mpz_sgn(gd) == 0) { mpz_clear(gd); mpz_set_si(deg,0); return; } mpz_init(hd); if (!tryConstantToMpz(hd, p->value.powering.c)) { mpz_clear(gd); mpz_clear(hd); mpz_set_si(deg,-1); return; } if (mpz_sgn(hd) < 0) { mpz_clear(hd); mpz_clear(gd); mpz_set_si(deg,-1); return; } mpz_mul(deg, gd, hd); mpz_clear(gd); mpz_clear(hd); return; break; } /* Fall-back case */ __polynomialSparsify(p); sparsePolynomialGetDegree(deg, p->value.sparse); } int polynomialGetDegreeAsInt(polynomial_t p) { int gd, hd, res; mpz_t degz; signed long t, tt; unsigned int u, gdu, tu, ttu; /* Handle stupid input */ if (p == NULL) return -1; /* Try to handle the case without sparsifying the polynomial. */ switch (p->type) { case SPARSE: return sparsePolynomialGetDegreeAsInt(p->value.sparse); break; case ADDITION: case SUBTRACTION: gd = polynomialGetDegreeAsInt(p->value.pair.g); hd = polynomialGetDegreeAsInt(p->value.pair.h); if ((gd == 0) && (hd == 0)) return 0; if ((gd >= 0) && (hd >= 0) && (gd != hd)) return (hd > gd ? hd : gd); break; case MULTIPLICATION: gd = polynomialGetDegreeAsInt(p->value.pair.g); hd = polynomialGetDegreeAsInt(p->value.pair.h); if ((gd != 0) && (hd != 0)) { if ((gd < 0) || (hd < 0)) return -1; if (tryExactIntAddition(&res, gd, hd)) { return res; } else { return -1; } } break; case COMPOSITION: gd = polynomialGetDegreeAsInt(p->value.pair.g); hd = polynomialGetDegreeAsInt(p->value.pair.h); if ((gd == 0) || (hd == 0)) return 0; if ((gd < 0) || (hd < 0)) return -1; if (tryExactIntMultiplication(&res, gd, hd)) { return res; } else { return -1; } break; case NEGATE: return polynomialGetDegreeAsInt(p->value.g); break; case POWER: gd = polynomialGetDegreeAsInt(p->value.powering.g); if (gd == 0) return 0; if (tryConstantToUnsignedInt(&u, p->value.powering.c)) { if (u == 0u) { return 0; } else { if (gd < 0) return -1; gdu = gd; if (tryExactUnsignedIntMultiplication(&tu,gdu,u)) { res = tu; if (res < 0) return -1; ttu = res; if (ttu != tu) return -1; return res; } else { return -1; } } } else { return -1; } break; } /* Fall-back case */ mpz_init(degz); polynomialGetDegree(degz, p); if (!mpz_fits_slong_p(degz)) { res = -1; } else { t = mpz_get_si(degz); res = t; tt = res; if (t != tt) { res = -1; } } mpz_clear(degz); return res; } /* Try to compute the i-th coefficient c of p^k, fail if this computation is not easy to perform. */ static inline int __polynomialGetIthCoefficientAsConstantIntIndexPowerCheap(constant_t *c, polynomial_t p, constant_t k, int i) { constant_t ic, mk, t, j, a, b, m, n, r, bin, aPowj, bPowr, prod; /* Make compiler happy */ bin = NULL; /* Handle stupid inputs */ if (p == NULL) return 0; if (k == NULL) return 0; if (i < 0) return 0; /* Sparsify the polynomial p */ __polynomialSparsify(p); /* Try to decompose p into p = x^m * (a + b * x^n) */ if (!sparsePolynomialDecomposeTwoMonomials(&a, &m, &b, &n, p->value.sparse)) return 0; /* Here we have to compute the coefficient of degree i of x^(m * k) * (a + b * x^n)^k This means we have to get the coefficient of degree t = i - m * k of the polynomial (a + b * x^n)^k. If t = i - m * k is less than 0, we can simply return 0. */ ic = constantFromInt(i); mk = constantMul(m, k); t = constantSub(ic, mk); /* Check if t is less than 0 */ if (!(constantIsPositive(t, 1) || constantIsZero(t, 1))) { /* Here t = i - m * k is less than 0. Assign 0 to c and return success. */ *c = constantFromInt(0); constantFree(ic); constantFree(mk); constantFree(t); constantFree(a); constantFree(m); constantFree(b); constantFree(n); return 1; } /* Here t = i - m * k is greater than or equal to 0 We have to compute the coefficient of degree t of the polynomial (a + b * x^n)^k. Since (a + b * x^n)^k = sum_j=0^k bin(k,j) * a^j * b^(k - j) * x^(n * j) the coefficient of degree t is * equal to bin(k,j) * a^j * b^(k - j) if t is divisible by n and j = t / n * equal to 0 if t is not divisible by n. We start by computing j = t / n and then test if j is a non-negative integer (hence if t is divisible by n). */ j = constantDiv(t, n); /* Check if j is integer */ if (constantIsNonNegativeInteger(j, 0)) { /* The value j = t / n is a non-negative integer. Hence t is divisible by n. We have to return c = bin(k,j) * a^j * b^(k - j). We first start by computing r = k - j. We then check if r is positive or zero. In this case we compute and return c = bin(k,j) * a^j * b^(k - j). Otherwise we return c = 0. */ r = constantSub(k, j); if (constantIsZero(r, 0) || constantIsPositive(r,0)) { /* Here r >= 0 and we have to return c = bin(k,j) * a^j * b^r. If we can compute the binomial coefficient bin(k,j) we use it, otherwise we simply signal failure. */ if (constantFromBinomial(&bin, k, j)) { /* We have bin = bin(k, j). Compute c = bin * a^j * b^r. */ aPowj = constantPow(a, j); bPowr = constantPow(b, r); prod = constantMul(aPowj, bPowr); *c = constantMul(bin, prod); constantFree(bin); constantFree(aPowj); constantFree(bPowr); constantFree(prod); } else { /* Signal failure. */ constantFree(ic); constantFree(mk); constantFree(t); constantFree(a); constantFree(m); constantFree(b); constantFree(n); constantFree(j); constantFree(r); return 0; } } else { /* Here, r < 0 and we have to return c = 0. */ *c = constantFromInt(0); } constantFree(r); } else { /* The value j = t / n is no non-negative integer. Hence t is not divisible by n and the coefficient of degree t of (a + b * x^n)^k is zero. */ *c = constantFromInt(0); } /* Free the intermediate values */ constantFree(ic); constantFree(mk); constantFree(t); constantFree(a); constantFree(m); constantFree(b); constantFree(n); constantFree(j); /* Return success */ return 1; } static inline constant_t __polynomialGetIthCoefficientAsConstantIntIndex(polynomial_t p, int i) { int deg; constant_t a, b, res; /* Handle stupid input */ if (p == NULL) return NULL; /* Handle case when i < 0 */ if (i < 0) { return constantFromInt(0); } /* Handle case when i > degree */ deg = polynomialGetDegreeAsInt(p); if ((deg >= 0) && (i > deg)) { return constantFromInt(0); } /* General case */ switch (p->type) { case SPARSE: return sparsePolynomialGetIthCoefficientAsConstantIntIndex(p->value.sparse, i); break; case ADDITION: case SUBTRACTION: a = __polynomialGetIthCoefficientAsConstantIntIndex(p->value.pair.g,i); b = __polynomialGetIthCoefficientAsConstantIntIndex(p->value.pair.h,i); if (p->type == ADDITION) { res = constantAdd(a, b); } else { res = constantSub(a, b); } constantFree(a); constantFree(b); return res; break; case NEGATE: a = __polynomialGetIthCoefficientAsConstantIntIndex(p->value.g,i); res = constantNeg(a); constantFree(a); return res; break; case POWER: if (__polynomialGetIthCoefficientAsConstantIntIndexPowerCheap(&res, p->value.powering.g, p->value.powering.c, i)) { return res; } break; default: break; } /* Fall-back case */ __polynomialSparsify(p); return sparsePolynomialGetIthCoefficientAsConstantIntIndex(p->value.sparse, i); } static inline constant_t __polynomialGetIthCoefficientAsConstant(polynomial_t p, mpz_t i) { mpz_t deg; signed long int t, ttt; int tt; /* Handle stupid input */ if (p == NULL) return NULL; /* Handle case when i < 0 */ if (mpz_sgn(i) < 0) { return constantFromInt(0); } /* Handle case when i > degree */ mpz_init(deg); polynomialGetDegree(deg, p); if ((mpz_sgn(deg) >= 0) && (mpz_cmp(i,deg) > 0)) { mpz_clear(deg); return constantFromInt(0); } /* Check if index i holds on a machine int */ if (mpz_fits_slong_p(i)) { t = mpz_get_si(i); tt = (int) t; ttt = (signed long int) tt; if (ttt == t) { /* Here i holds on a signed long int and is equal t, which is equal to tt. */ return __polynomialGetIthCoefficientAsConstantIntIndex(p, tt); } } /* General case */ __polynomialSparsify(p); return sparsePolynomialGetIthCoefficientAsConstant(p->value.sparse, i); } node *polynomialGetIthCoefficient(polynomial_t p, mpz_t i) { constant_t c; node *res; /* Handle stupid inputs */ if (p == NULL) return NULL; /* Get coefficient as a constant */ c = __polynomialGetIthCoefficientAsConstant(p, i); /* Convert to an expression */ res = addMemRef(constantToExpression(c)); constantFree(c); /* Return the result */ return res; } node *polynomialGetIthCoefficientIntIndex(polynomial_t p, int i) { constant_t c; node *res; /* Handle stupid inputs */ if (p == NULL) return NULL; /* Get coefficient as a constant */ c = __polynomialGetIthCoefficientAsConstantIntIndex(p, i); /* Convert to an expression */ res = addMemRef(constantToExpression(c)); constantFree(c); /* Return the result */ return res; } int polynomialGetCoefficients(node ***coeffs, unsigned int *deg, polynomial_t p) { /* Handle stupid input */ if (p == NULL) return 0; /* General case */ __polynomialSparsify(p); return sparsePolynomialGetCoefficients(coeffs, deg, p->value.sparse); } static inline node *__polynomialGetExpressionAnyForm(polynomial_t p) { /* Handle stupid input */ if (p == NULL) return NULL; /* Handle composition */ if (p->type == COMPOSITION) { __polynomialExecuteComposition(p); return __polynomialGetExpressionAnyForm(p); } /* General case */ switch (p->type) { case SPARSE: return sparsePolynomialGetExpression(p->value.sparse, 0); /* This must be Horner form */ break; case ADDITION: return addMemRef(makeAdd(__polynomialGetExpressionAnyForm(p->value.pair.g), __polynomialGetExpressionAnyForm(p->value.pair.h))); break; case SUBTRACTION: return addMemRef(makeSub(__polynomialGetExpressionAnyForm(p->value.pair.g), __polynomialGetExpressionAnyForm(p->value.pair.h))); break; case MULTIPLICATION: return addMemRef(makeMul(__polynomialGetExpressionAnyForm(p->value.pair.g), __polynomialGetExpressionAnyForm(p->value.pair.h))); break; case NEGATE: return addMemRef(makeNeg(__polynomialGetExpressionAnyForm(p->value.g))); break; case POWER: return addMemRef(makePow(__polynomialGetExpressionAnyForm(p->value.powering.g), constantToExpression(p->value.powering.c))); break; default: break; } /* Cannot be reached */ return NULL; } node *polynomialGetExpressionExplicit(polynomial_t p) { /* Handle stupid input */ if (p == NULL) return NULL; /* If we can output the polynomial in any form, we do so. */ if ((p->outputType == ANY_FORM) || __polynomialIsConstantCheap(p)) { return __polynomialGetExpressionAnyForm(p); } /* Here, we have to output a "hornerized" or "canonicalized" form. */ __polynomialSparsify(p); return sparsePolynomialGetExpression(p->value.sparse, (p->outputType == CANONICAL_FORM)); } node *polynomialGetExpression(polynomial_t p) { node *res; /* Handle stupid input */ if (p == NULL) return polynomialGetExpressionExplicit(p); /* Try to build a lazy memrefed expression */ res = addMemRefEvenOnNull(NULL); if (res != NULL) { if (res->nodeType == MEMREF) { res->polynomialRepresentation = polynomialFromCopy(p); return res; } else { freeThing(res); } } /* Could not create a lazy memrefed expression */ return polynomialGetExpressionExplicit(p); } void polynomialFPrintf(FILE *fd, polynomial_t p) { node *t; /* Handle stupid cases */ if (p == NULL) { sollyaFprintf(fd, "(null)"); } /* Handle the general case. Can be optimized. */ t = polynomialGetExpressionExplicit(p); sollyaFprintf(fd, "%b", t); freeThing(t); } char *polynomialToString(polynomial_t p) { node *t; char *str; char staticStr[8]; int size, r; /* Handle stupid cases */ if (p == NULL) return NULL; /* Handle the general case. Can be optimized. */ t = polynomialGetExpressionExplicit(p); size = sollya_snprintf(staticStr,8,"%b",t); if (size < 0) { freeThing(t); return NULL; } str = (char *) safeCalloc(size + 2, sizeof(char)); r = sollya_snprintf(str,size,"%b",t); if (r < 0) { freeThing(t); safeFree(str); return NULL; } /* Return the string */ return str; } void polynomialEvalMpfr(mpfr_t y, polynomial_t p, mpfr_t x) { mpfr_t scratch, Y; /* Handle stupid inputs */ if (p == NULL) { mpfr_set_nan(y); return; } /* If the polynomial is in sparse form, use the evaluation routine for sparse forms. */ if (p->type == SPARSE) { sparsePolynomialEvalMpfr(y, p->value.sparse, x); return; } /* If the polynomial is in negation form, call ourselves recursively and negate y. */ if (p->type == NEGATE) { polynomialEvalMpfr(y, p->value.g, x); mpfr_neg(y, y, GMP_RNDN); return; } /* Check if we can use y as a scratch space for recursion */ if (x == y) { /* We can't. Call ourselves recursively. */ mpfr_init2(Y, mpfr_get_prec(y)); polynomialEvalMpfr(Y, p, x); mpfr_set(y, Y, GMP_RNDN); mpfr_clear(Y); return; } /* Here, we have an addition, subtraction, multiplication, composition or power form to handle and we may use y as a scratch space. We need another scratch variable. */ mpfr_init2(scratch, mpfr_get_prec(y)); /* Handle composition apart */ if (p->type == COMPOSITION) { polynomialEvalMpfr(scratch, p->value.pair.h, x); polynomialEvalMpfr(y, p->value.pair.g, scratch); } else { /* Everything else but composition */ switch (p->type) { case ADDITION: case SUBTRACTION: case MULTIPLICATION: polynomialEvalMpfr(y, p->value.pair.g, x); polynomialEvalMpfr(scratch, p->value.pair.h, x); break; case POWER: polynomialEvalMpfr(y, p->value.powering.g, x); constantEvalMpfr(scratch, p->value.powering.c); break; default: break; } switch (p->type) { case ADDITION: mpfr_add(y, y, scratch, GMP_RNDN); break; case SUBTRACTION: mpfr_sub(y, y, scratch, GMP_RNDN); break; case MULTIPLICATION: mpfr_mul(y, y, scratch, GMP_RNDN); break; case POWER: mpfr_pow(y, y, scratch, GMP_RNDN); break; default: break; } } mpfr_clear(scratch); } void polynomialEvalMpfi(sollya_mpfi_t y, polynomial_t p, sollya_mpfi_t x) { mp_prec_t prec; sollya_mpfi_t scr, Y; sollya_mpfi_t *scratch; sollya_mpfi_t *reusedVars; int usingReused; /* Handle stupid inputs */ if (p == NULL) { sollya_mpfi_set_nan(y); return; } /* If the polynomial is in sparse form, use the evaluation routine for sparse forms. */ if (p->type == SPARSE) { sparsePolynomialEvalMpfi(y, p->value.sparse, x); return; } /* If the polynomial is in negation form, call ourselves recursively and negate y. */ if (p->type == NEGATE) { polynomialEvalMpfi(y, p->value.g, x); sollya_mpfi_neg(y, y); return; } /* Check if we can use y as a scratch space for recursion */ if (x == y) { /* We can't. Call ourselves recursively. */ sollya_mpfi_init2(Y, sollya_mpfi_get_prec(y)); polynomialEvalMpfi(Y, p, x); sollya_mpfi_set(y, Y); sollya_mpfi_clear(Y); return; } /* Here, we have an addition, subtraction, multiplication, composition or power form to handle and we may use y as a scratch space. We need another scratch variable. We can try to get it by two means. */ prec = sollya_mpfi_get_prec(y); reusedVars = getReusedGlobalMPFIVars(1, prec); if (reusedVars == NULL) { usingReused = 0; mpfi_init2(scr, prec); scratch = &scr; } else { usingReused = 1; scratch = reusedVars; } /* Handle composition apart */ if (p->type == COMPOSITION) { polynomialEvalMpfi(*scratch, p->value.pair.h, x); polynomialEvalMpfi(y, p->value.pair.g, *scratch); } else { /* Everything else but composition */ switch (p->type) { case ADDITION: case SUBTRACTION: case MULTIPLICATION: polynomialEvalMpfi(y, p->value.pair.g, x); polynomialEvalMpfi(*scratch, p->value.pair.h, x); break; case POWER: polynomialEvalMpfi(y, p->value.powering.g, x); constantEvalMpfi(*scratch, p->value.powering.c); break; default: break; } switch (p->type) { case ADDITION: sollya_mpfi_add(y, y, *scratch); break; case SUBTRACTION: sollya_mpfi_sub(y, y, *scratch); break; case MULTIPLICATION: sollya_mpfi_mul(y, y, *scratch); break; case POWER: sollya_mpfi_pow(y, y, *scratch); break; default: break; } } if (usingReused) { returnReusedGlobalMPIVars(1); } else { sollya_mpfi_clear(scr); } } static inline int __polynomialCheapCheckConstantZero(polynomial_t p) { /* Handle stupid inputs */ if (p == NULL) return 0; /* General case */ switch (p->type) { case SPARSE: return sparsePolynomialIsConstantZero(p->value.sparse, 0); break; case ADDITION: case SUBTRACTION: /* We don't know easily */ return 0; break; case MULTIPLICATION: return (__polynomialCheapCheckConstantZero(p->value.pair.g) || __polynomialCheapCheckConstantZero(p->value.pair.h)); break; case COMPOSITION: /* We don't know easily */ return 0; break; case NEGATE: return __polynomialCheapCheckConstantZero(p->value.g); break; case POWER: return __polynomialCheapCheckConstantZero(p->value.powering.g); break; } return 0; } polynomial_t polynomialAdd(polynomial_t p, polynomial_t q) { polynomial_t res; /* Handle stupid inputs */ if (p == NULL) return NULL; if (q == NULL) return NULL; /* If an easy check shows that p or q are constant zero, return a copy of the other */ if (__polynomialCheapCheckConstantZero(p)) return polynomialFromCopy(q); if (__polynomialCheapCheckConstantZero(q)) return polynomialFromCopy(p); /* If both polynomials are sparse, perform the operation on sparse polynomials. */ if ((p->type == SPARSE) && (q->type == SPARSE)) { return __polynomialBuildFromSparse(sparsePolynomialAdd(p->value.sparse, q->value.sparse)); } /* General case: construct the addition polynomial */ res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = ADDITION; res->outputType = ANY_FORM; res->value.pair.g = polynomialFromCopy(p); res->value.pair.h = polynomialFromCopy(q); /* Return the result polynomial */ return res; } polynomial_t polynomialSub(polynomial_t p, polynomial_t q) { polynomial_t res; /* Handle stupid inputs */ if (p == NULL) return NULL; if (q == NULL) return NULL; /* If an easy check shows that p or q are constant zero, return a copy of the other or its negation */ if (__polynomialCheapCheckConstantZero(p)) return polynomialNeg(q); if (__polynomialCheapCheckConstantZero(q)) return polynomialFromCopy(p); /* If both polynomials are sparse, perform the operation on sparse polynomials. */ if ((p->type == SPARSE) && (q->type == SPARSE)) { return __polynomialBuildFromSparse(sparsePolynomialSub(p->value.sparse, q->value.sparse)); } /* General case: construct the addition polynomial */ res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = SUBTRACTION; res->outputType = ANY_FORM; res->value.pair.g = polynomialFromCopy(p); res->value.pair.h = polynomialFromCopy(q); /* Return the result polynomial */ return res; } polynomial_t polynomialMul(polynomial_t p, polynomial_t q) { polynomial_t res; /* Handle stupid inputs */ if (p == NULL) return NULL; if (q == NULL) return NULL; /* If an easy check shows that p or q are constant zero, return a copy of them. */ if (__polynomialCheapCheckConstantZero(p)) return polynomialFromCopy(p); if (__polynomialCheapCheckConstantZero(q)) return polynomialFromCopy(q); /* If an easy check shows that p or q are constant one, return a copy of the other one. */ if (__polynomialCheapCheckConstantZero(p)) return polynomialFromCopy(q); if (__polynomialCheapCheckConstantZero(q)) return polynomialFromCopy(p); /* If both polynomials are sparse, and at least one of them has only one monomial (or less), perform the operation on sparse polynomials. */ if ((p->type == SPARSE) && (q->type == SPARSE)) { if ((sparsePolynomialGetMonomialCount(p->value.sparse) <= 1u) || (sparsePolynomialGetMonomialCount(q->value.sparse) <= 1u)) { return __polynomialBuildFromSparse(sparsePolynomialMul(p->value.sparse, q->value.sparse)); } } /* General case: construct the multiplication polynomial */ res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = MULTIPLICATION; res->outputType = ANY_FORM; res->value.pair.g = polynomialFromCopy(p); res->value.pair.h = polynomialFromCopy(q); /* Return the result polynomial */ return res; } polynomial_t polynomialNeg(polynomial_t p) { polynomial_t res; /* Handle stupid inputs */ if (p == NULL) return NULL; /* Handle certain cases in an ad-hoc way */ switch (p->type) { case SPARSE: return __polynomialBuildFromSparse(sparsePolynomialNeg(p->value.sparse)); break; case SUBTRACTION: res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = SUBTRACTION; res->outputType = ANY_FORM; res->value.pair.g = polynomialFromCopy(p->value.pair.h); res->value.pair.h = polynomialFromCopy(p->value.pair.g); return res; break; case NEGATE: return polynomialFromCopy(p->value.g); break; default: break; } /* General case: construct the negation polynomial */ res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = NEGATE; res->outputType = ANY_FORM; res->value.g = polynomialFromCopy(p); /* Return the result polynomial */ return res; } polynomial_t polynomialCompose(polynomial_t p, polynomial_t q) { polynomial_t res, g, h; /* Handle stupid inputs */ if (p == NULL) return NULL; if (q == NULL) return NULL; /* If q easily proves constant, just construct the composition polynomial. This takes almost no space and no time and allows for later approximate evaluation of the constructed constant. */ if (__polynomialIsConstantCheap(q)) { res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = COMPOSITION; res->outputType = ANY_FORM; res->value.pair.g = polynomialFromCopy(p); res->value.pair.h = polynomialFromCopy(q); return res; } /* If both polynomials are sparse, and polynomial q only has one monomial, perform the operation on sparse polynomials. */ if ((p->type == SPARSE) && (q->type == SPARSE)) { if (sparsePolynomialGetMonomialCount(q->value.sparse) <= 1u) { return __polynomialBuildFromSparse(sparsePolynomialCompose(p->value.sparse, q->value.sparse)); } } /* If q is sparse and the identity polynomial, just return a copy of p. */ if ((q->type == SPARSE) && (sparsePolynomialIsIdentity(q->value.sparse, 0))) { return polynomialFromCopy(p); } /* If p is of the form p = r^c, we have p(q) = (r(q))^c */ if (p->type == POWER) { res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = POWER; res->outputType = ANY_FORM; res->value.powering.g = polynomialCompose(p->value.powering.g, q); res->value.powering.c = constantFromCopy(p->value.powering.c); return res; } /* If q is sparse and only has one monomial but is not constant, perform the composition by recursion. */ if ((q->type == SPARSE) && (sparsePolynomialGetMonomialCount(q->value.sparse) <= 1u) && (!sparsePolynomialIsConstant(q->value.sparse,0))) { switch (p->type) { case SPARSE: return __polynomialBuildFromSparse(sparsePolynomialCompose(p->value.sparse, q->value.sparse)); break; case ADDITION: g = polynomialCompose(p->value.pair.g, q); h = polynomialCompose(p->value.pair.h, q); res = polynomialAdd(g, h); polynomialFree(g); polynomialFree(h); break; case SUBTRACTION: g = polynomialCompose(p->value.pair.g, q); h = polynomialCompose(p->value.pair.h, q); res = polynomialSub(g, h); polynomialFree(g); polynomialFree(h); break; case MULTIPLICATION: g = polynomialCompose(p->value.pair.g, q); h = polynomialCompose(p->value.pair.h, q); res = polynomialMul(g, h); polynomialFree(g); polynomialFree(h); break; case COMPOSITION: h = polynomialCompose(p->value.pair.h, q); res = polynomialCompose(p->value.pair.g, h); polynomialFree(h); return res; break; case NEGATE: g = polynomialCompose(p->value.g, q); res = polynomialNeg(g); polynomialFree(g); break; case POWER: res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = POWER; res->outputType = ANY_FORM; res->value.powering.g = polynomialCompose(p->value.powering.g, q); res->value.powering.c = constantFromCopy(p->value.powering.c); return res; break; default: break; } } /* General case: construct the composed polynomial */ res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = COMPOSITION; res->outputType = ANY_FORM; res->value.pair.g = polynomialFromCopy(p); res->value.pair.h = polynomialFromCopy(q); /* Return the result polynomial */ return res; } polynomial_t polynomialDeriv(polynomial_t p) { polynomial_t res; constant_t one; /* Handle stupid inputs */ if (p == NULL) return NULL; /* Easy check if the polynomial actually is constant */ if (__polynomialIsConstantCheap(p)) { return polynomialFromIntConstant(0); } /* Handle certain cases in an ad-hoc way */ switch (p->type) { case SPARSE: return __polynomialBuildFromSparse(sparsePolynomialDeriv(p->value.sparse)); break; case ADDITION: case SUBTRACTION: res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = p->type; res->outputType = ANY_FORM; res->value.pair.g = polynomialDeriv(p->value.pair.h); res->value.pair.h = polynomialDeriv(p->value.pair.g); return res; break; case NEGATE: res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = NEGATE; res->outputType = ANY_FORM; res->value.g = polynomialDeriv(p->value.g); return res; break; case POWER: if ((!constantIsZero(p->value.powering.c, 1)) && (!constantIsOne(p->value.powering.c, 1))) { one = constantFromInt(1); res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = MULTIPLICATION; res->outputType = ANY_FORM; res->value.pair.g = __polynomialFromConstant(p->value.powering.c); res->value.pair.h = __polynomialAllocate(); res->value.pair.h->refCount = 1u; res->value.pair.h->hash.hasHash = 0; res->value.pair.h->usesExpressionConstant.cached = 0; res->value.pair.h->type = POWER; res->value.pair.h->outputType = ANY_FORM; res->value.pair.h->value.powering.g = polynomialFromCopy(p->value.powering.g); res->value.pair.h->value.powering.c = constantSub(p->value.powering.c, one); constantFree(one); return res; } break; default: break; } /* General case: sparsify the polynomial and return the derivative of the sparse polynomial. */ __polynomialSparsify(p); return __polynomialBuildFromSparse(sparsePolynomialDeriv(p->value.sparse)); } static inline int __polynomialFromExpressionInner(polynomial_t *r, node *p, node *t) { polynomial_t a, b, quot, rest, zero; sparse_polynomial_t sr; int res; constant_t c; node *pp; /* Handle stupid inputs */ if (p == NULL) return 0; /* Try to decompose expressions built on c, x, +, -, *, /, -, ^ */ switch (p->nodeType) { case MEMREF: if (p->polynomialRepresentation != NULL) { *r = polynomialFromCopy(p->polynomialRepresentation); return 1; } res = __polynomialFromExpressionInner(r, getMemRefChild(p), p); if (res && (p->polynomialRepresentation == NULL) && (!polynomialReferencesExpression(*r, p))) { p->polynomialRepresentation = polynomialFromCopy(*r); } return res; break; case VARIABLE: *r = polynomialFromIdentity(); return 1; break; case CONSTANT: *r = polynomialFromMpfrConstant(*(p->value)); return 1; break; case NEG: if (!__polynomialFromExpressionInner(&a, p->child1, NULL)) break; *r = polynomialNeg(a); polynomialFree(a); return 1; break; case ADD: case SUB: case MUL: case DIV: case POW: if (!__polynomialFromExpressionInner(&a, p->child1, NULL)) break; if (!__polynomialFromExpressionInner(&b, p->child2, NULL)) { polynomialFree(a); break; } res = 0; switch (p->nodeType) { case ADD: *r = polynomialAdd(a, b); res = 1; break; case SUB: *r = polynomialSub(a, b); res = 1; break; case MUL: *r = polynomialMul(a, b); res = 1; break; case DIV: polynomialDiv(", &rest, a, b); zero = polynomialFromIntConstant(0); if (polynomialEqual(rest, zero, 0)) { if (polynomialGetDegreeAsInt(b) == 0) { c = __polynomialGetIthCoefficientAsConstantIntIndex(b, 0); if (!constantIsZero(c, 1)) { *r = quot; res = 1; } else { polynomialFree(quot); res = 0; } constantFree(c); } else { *r = quot; res = 1; } } else { polynomialFree(quot); res = 0; } polynomialFree(rest); polynomialFree(zero); break; case POW: res = polynomialPow(r, a, b); break; } polynomialFree(a); polynomialFree(b); if (res) return 1; break; } /* Here, the expression contains some other basic function. It can be a polynomial only if it is a constant expression. */ if (t != NULL) { pp = t; } else { pp = p; } if (isConstant(pp)) { if (!__sparsePolynomialFromConstantExpression(&sr, pp)) return 0; *r = __polynomialBuildFromSparse(sr); return 1; } return 0; } int polynomialFromExpression(polynomial_t *r, node *p) { return __polynomialFromExpressionInner(r, p, NULL); } static inline int __polynomialFromExpressionOnlyRealCoeffsInner(polynomial_t *r, node *p, node *t) { polynomial_t a, b, quot, rest, zero; sparse_polynomial_t sr; int res; constant_t c; node *pp; /* Handle stupid inputs */ if (p == NULL) return 0; /* Try to decompose expressions built on c, x, +, -, *, /, -, ^ */ switch (p->nodeType) { case MEMREF: if (p->polynomialRepresentation != NULL) { *r = polynomialFromCopy(p->polynomialRepresentation); return 1; } res = __polynomialFromExpressionOnlyRealCoeffsInner(r, getMemRefChild(p), p); if (res && (p->polynomialRepresentation == NULL) && (!polynomialReferencesExpression(*r, p))) { p->polynomialRepresentation = polynomialFromCopy(*r); } return res; break; case VARIABLE: *r = polynomialFromIdentity(); return 1; break; case CONSTANT: if (mpfr_number_p(*(p->value))) { *r = polynomialFromMpfrConstant(*(p->value)); return 1; } else { return 0; } break; case NEG: if (!__polynomialFromExpressionOnlyRealCoeffsInner(&a, p->child1, NULL)) break; *r = polynomialNeg(a); polynomialFree(a); return 1; break; case ADD: case SUB: case MUL: case DIV: case POW: if (!__polynomialFromExpressionOnlyRealCoeffsInner(&a, p->child1, NULL)) break; if (!__polynomialFromExpressionOnlyRealCoeffsInner(&b, p->child2, NULL)) { polynomialFree(a); break; } res = 0; switch (p->nodeType) { case ADD: *r = polynomialAdd(a, b); res = 1; break; case SUB: *r = polynomialSub(a, b); res = 1; break; case MUL: *r = polynomialMul(a, b); res = 1; break; case DIV: polynomialDiv(", &rest, a, b); zero = polynomialFromIntConstant(0); if (polynomialEqual(rest, zero, 0)) { if (polynomialGetDegreeAsInt(b) == 0) { c = __polynomialGetIthCoefficientAsConstantIntIndex(b, 0); if (!constantIsZero(c, 1)) { *r = quot; res = 1; } else { polynomialFree(quot); res = 0; } constantFree(c); } else { *r = quot; res = 1; } } else { polynomialFree(quot); res = 0; } polynomialFree(rest); polynomialFree(zero); break; case POW: res = polynomialPow(r, a, b); break; } polynomialFree(a); polynomialFree(b); if (res) return 1; break; } /* Here, the expression contains some other basic function. It can be a polynomial only if it is a constant expression. */ if (t != NULL) { pp = t; } else { pp = p; } if (isConstant(pp)) { if (!__sparsePolynomialFromConstantExpressionOnlyRealCoeffs(&sr, pp)) return 0; *r = __polynomialBuildFromSparse(sr); return 1; } return 0; } int polynomialFromExpressionOnlyRealCoeffs(polynomial_t *r, node *p) { return __polynomialFromExpressionOnlyRealCoeffsInner(r, p, NULL); } polynomial_t polynomialPowUnsignedInt(polynomial_t p, unsigned int n) { polynomial_t res; /* Handle stupid case */ if (p == NULL) return NULL; /* If n is zero, return the polynomial 1. */ if (n == 0u) return polynomialFromIntConstant(1); /* If n is one, return a copy of the polynomial p. */ if (n == 1u) return polynomialFromCopy(p); /* If n is two, return p * p. */ if (n == 2u) return polynomialMul(p, p); /* If p is sparse and only has one monomial (or less), immediately perform the operation */ if (p->type == SPARSE) { if (sparsePolynomialGetMonomialCount(p->value.sparse) <= 1u) { return __polynomialBuildFromSparse(sparsePolynomialPowUnsignedInt(p->value.sparse, n)); } } /* General case: construct the powering polynomial */ res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = POWER; res->outputType = ANY_FORM; res->value.powering.g = polynomialFromCopy(p); res->value.powering.c = constantFromUnsignedInt(n); /* Return the result polynomial */ return res; } int polynomialPow(polynomial_t *r, polynomial_t p, polynomial_t q) { constant_t n, two14; polynomial_t res; sparse_polynomial_t sp; /* Handle stupid inputs */ if (p == NULL) return 0; if (q == NULL) return 0; /* Get the degree of q If the integer-output degree accessor function indicates failure, this means that q has a degree so huge that it does not hold on an integer. In this case, p^q is not a polynomial. If the integer-output degress accessor function indicates success but a degree of at least one, p^q is not a polynomial. So the only way that q is a constant is that the integer-output degree accessor function returns 0. */ if (polynomialGetDegreeAsInt(q) != 0) return 0; /* Here we know that the degree of q is 0, i.e. that it is a constant. We get its coefficient of degree 0 to get its constant value. */ n = __polynomialGetIthCoefficientAsConstantIntIndex(q, 0); if (!constantIsNonNegativeInteger(n,0)) { constantFree(n); return 0; } /* Handle the cases n = 0, n = 1 */ if (constantIsZero(n, 0)) { constantFree(n); *r = polynomialFromIntConstant(1); return 1; } if (constantIsOne(n, 0)) { constantFree(n); *r = polynomialFromCopy(p); return 1; } /* If p is sparse and only has one monomial (or less) and n is reasonably small (say n <= 2^14), immediately perform the operation. */ if (p->type == SPARSE) { if (sparsePolynomialGetMonomialCount(p->value.sparse) <= 1u) { two14 = constantFromUnsignedInt(1u << 14); if (!constantIsGreater(n, two14, 1)) { if (sparsePolynomialPowConstant(&sp, p->value.sparse, n)) { constantFree(n); constantFree(two14); *r = __polynomialBuildFromSparse(sp); return 1; } } constantFree(two14); } } /* General case: construct the powering polynomial */ res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = POWER; res->outputType = ANY_FORM; res->value.powering.g = polynomialFromCopy(p); res->value.powering.c = n; /* Set the output and return success */ *r = res; return 1; } int polynomialCoefficientsAreDyadic(polynomial_t p, int defVal) { /* Handle stupid input */ if (p == NULL) return defVal; /* Try to handle the case without sparsifying the polynomial */ switch (p->type) { case SPARSE: return sparsePolynomialCoefficientsAreDyadic(p->value.sparse, defVal); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: case COMPOSITION: if (polynomialCoefficientsAreDyadic(p->value.pair.g, 0) && polynomialCoefficientsAreDyadic(p->value.pair.h, 0)) return 1; break; case NEGATE: return polynomialCoefficientsAreDyadic(p->value.g, defVal); break; case POWER: if (constantIsZero(p->value.powering.c, 0)) return 1; if (polynomialCoefficientsAreDyadic(p->value.powering.g, 0)) return 1; break; } /* We couldn't decide the case. Sparsify the polynomial. */ __polynomialSparsify(p); return sparsePolynomialCoefficientsAreDyadic(p->value.sparse, defVal); } int polynomialCoefficientsAreRational(polynomial_t p, int defVal) { /* Handle stupid input */ if (p == NULL) return defVal; /* Try to handle the case without sparsifying the polynomial */ switch (p->type) { case SPARSE: return sparsePolynomialCoefficientsAreRational(p->value.sparse, defVal); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: case COMPOSITION: if (polynomialCoefficientsAreRational(p->value.pair.g, 0) && polynomialCoefficientsAreRational(p->value.pair.h, 0)) return 1; break; case NEGATE: return polynomialCoefficientsAreRational(p->value.g, defVal); break; case POWER: if (constantIsZero(p->value.powering.c, 0)) return 1; if (polynomialCoefficientsAreRational(p->value.powering.g, 0)) return 1; break; } /* We couldn't decide the case. Sparsify the polynomial. */ __polynomialSparsify(p); return sparsePolynomialCoefficientsAreRational(p->value.sparse, defVal); } int polynomialCoefficientsHoldOnPrecBits(polynomial_t p, mp_prec_t prec, int defVal) { /* Handle stupid input */ if (p == NULL) return defVal; if (prec < 2) return defVal; /* Try to handle the case without sparsifying the polynomial */ switch (p->type) { case SPARSE: return sparsePolynomialCoefficientsHoldOnPrecBits(p->value.sparse, prec, defVal); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: case COMPOSITION: if (polynomialCoefficientsHoldOnPrecBits(p->value.pair.g, prec, 0) && polynomialCoefficientsHoldOnPrecBits(p->value.pair.h, prec, 0)) return 1; break; case NEGATE: return polynomialCoefficientsHoldOnPrecBits(p->value.g, prec, defVal); break; case POWER: if (constantIsZero(p->value.powering.c, 0)) return 1; if (polynomialCoefficientsHoldOnPrecBits(p->value.powering.g, prec, 0)) return 1; break; } /* We couldn't decide the case. Sparsify the polynomial. */ __polynomialSparsify(p); return sparsePolynomialCoefficientsHoldOnPrecBits(p->value.sparse, prec, defVal); } static inline polynomial_t __polynomialRoundDyadicAnyForm(polynomial_t p, mp_prec_t prec) { polynomial_t res; /* Handle stupid input */ if (p == NULL) return NULL; /* If the polynomial only has dyadic coefficients, just return a copy of it. */ if (polynomialCoefficientsAreDyadic(p, 0)) return polynomialFromCopy(p); /* Handle composition */ if (p->type == COMPOSITION) { __polynomialExecuteComposition(p); return __polynomialRoundDyadicAnyForm(p, prec); } /* Handle the problem recursively, keeping the expression structure of the polynomial */ res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = p->type; res->outputType = ANY_FORM; switch (p->type) { case SPARSE: res->value.sparse = sparsePolynomialRoundDyadic(p->value.sparse, prec); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: res->value.pair.g = __polynomialRoundDyadicAnyForm(p->value.pair.g, prec); res->value.pair.h = __polynomialRoundDyadicAnyForm(p->value.pair.h, prec); break; case NEGATE: res->value.g = __polynomialRoundDyadicAnyForm(p->value.g, prec); break; case POWER: res->value.powering.g = __polynomialRoundDyadicAnyForm(p->value.powering.g, prec); res->value.powering.c = constantFromCopy(p->value.powering.c); break; default: break; } return res; } polynomial_t polynomialRoundDyadic(polynomial_t p, mp_prec_t prec) { /* Handle stupid input */ if (p == NULL) return NULL; /* If the output type is "any form", use a special algorithm */ if ((p->outputType == ANY_FORM) || __polynomialIsConstantCheap(p)) { return __polynomialRoundDyadicAnyForm(p, prec); } /* If the polynomial only has dyadic coefficients, just return a copy of it. */ if (polynomialCoefficientsAreDyadic(p, 0)) return polynomialFromCopy(p); /* Here, at least one of the coefficients is not dyadic. Round it to dyadic, by sparsifying it because the output form is "hornerized" or "canonicalized". */ __polynomialSparsify(p); return __polynomialBuildFromSparse(sparsePolynomialRoundDyadic(p->value.sparse, prec)); } static inline polynomial_t __polynomialRoundRationalAnyForm(polynomial_t p, mp_prec_t prec) { polynomial_t res; /* Handle stupid input */ if (p == NULL) return NULL; /* If the polynomial only has rational coefficients, just return a copy of it. */ if (polynomialCoefficientsAreRational(p, 0)) return polynomialFromCopy(p); /* Handle composition */ if (p->type == COMPOSITION) { __polynomialExecuteComposition(p); return __polynomialRoundRationalAnyForm(p, prec); } /* Handle the problem recursively, keeping the expression structure of the polynomial */ res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = p->type; res->outputType = ANY_FORM; switch (p->type) { case SPARSE: res->value.sparse = sparsePolynomialRoundRational(p->value.sparse, prec); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: res->value.pair.g = __polynomialRoundRationalAnyForm(p->value.pair.g, prec); res->value.pair.h = __polynomialRoundRationalAnyForm(p->value.pair.h, prec); break; case NEGATE: res->value.g = __polynomialRoundRationalAnyForm(p->value.g, prec); break; case POWER: res->value.powering.g = __polynomialRoundRationalAnyForm(p->value.powering.g, prec); res->value.powering.c = constantFromCopy(p->value.powering.c); break; default: break; } return res; } polynomial_t polynomialRoundRational(polynomial_t p, mp_prec_t prec) { /* Handle stupid input */ if (p == NULL) return NULL; /* If the output type is "any form", use a special algorithm */ if ((p->outputType == ANY_FORM) || __polynomialIsConstantCheap(p)) { return __polynomialRoundRationalAnyForm(p, prec); } /* If the polynomial only has rational coefficients, just return a copy of it. */ if (polynomialCoefficientsAreRational(p, 0)) return polynomialFromCopy(p); /* Here, at least one of the coefficients is not rational. Round it to rational, by sparsifying it because the output form is "hornerized" or "canonicalized". */ __polynomialSparsify(p); return __polynomialBuildFromSparse(sparsePolynomialRoundRational(p->value.sparse, prec)); } static inline polynomial_t __polynomialRoundAnyForm(polynomial_t p, mp_prec_t prec) { polynomial_t res; /* Handle stupid input */ if (p == NULL) return NULL; /* If the polynomial only has coefficients that hold on prec bits, just return a copy of it. */ if (polynomialCoefficientsHoldOnPrecBits(p, prec, 0)) return polynomialFromCopy(p); /* Handle composition */ if (p->type == COMPOSITION) { __polynomialExecuteComposition(p); return __polynomialRoundAnyForm(p, prec); } /* Handle the problem recursively, keeping the expression structure of the polynomial */ res = __polynomialAllocate(); res->refCount = 1u; res->hash.hasHash = 0; res->usesExpressionConstant.cached = 0; res->type = p->type; res->outputType = ANY_FORM; switch (p->type) { case SPARSE: res->value.sparse = sparsePolynomialRound(p->value.sparse, prec); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: res->value.pair.g = __polynomialRoundAnyForm(p->value.pair.g, prec); res->value.pair.h = __polynomialRoundAnyForm(p->value.pair.h, prec); break; case NEGATE: res->value.g = __polynomialRoundAnyForm(p->value.g, prec); break; case POWER: res->value.powering.g = __polynomialRoundAnyForm(p->value.powering.g, prec); res->value.powering.c = constantFromCopy(p->value.powering.c); break; default: break; } return res; } polynomial_t polynomialRound(polynomial_t p, mp_prec_t prec) { /* Handle stupid input */ if (p == NULL) return NULL; /* If the output type is "any form", use a special algorithm */ if ((p->outputType == ANY_FORM) || __polynomialIsConstantCheap(p)) { return __polynomialRoundAnyForm(p, prec); } /* If the polynomial only has coefficients that hold on prec bits, just return a copy of it. */ if (polynomialCoefficientsHoldOnPrecBits(p, prec, 0)) return polynomialFromCopy(p); /* Here, at least one of the coefficients is not rational. Round it to rational, by sparsifying it because the output form is "hornerized" or "canonicalized". */ __polynomialSparsify(p); return __polynomialBuildFromSparse(sparsePolynomialRound(p->value.sparse, prec)); } int polynomialIsHornerized(polynomial_t p) { if (p == NULL) return 0; return (p->outputType == HORNER_FORM); } int polynomialIsCanonicalized(polynomial_t p) { if (p == NULL) return 0; return (p->outputType == CANONICAL_FORM); } static inline sparse_polynomial_t __polynomialGetSparsePolynomial(polynomial_t p) { /* Handle stupid input */ if (p == NULL) return NULL; /* Sparsify the polynomial and return a copy */ __polynomialSparsify(p); return sparsePolynomialFromCopy(p->value.sparse); } static inline int __polynomialUsesExpressionConstantInner(polynomial_t p) { /* Handle stupid input */ if (p == NULL) return 0; /* Handle the problem recursively */ switch (p->type) { case SPARSE: return sparsePolynomialUsesExpressionConstant(p->value.sparse); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: case COMPOSITION: if (polynomialUsesExpressionConstant(p->value.pair.g)) return 1; if (polynomialUsesExpressionConstant(p->value.pair.h)) return 1; return 0; break; case NEGATE: return polynomialUsesExpressionConstant(p->value.g); break; case POWER: if (constantUsesExpressionConstant(p->value.powering.c)) return 1; if (polynomialUsesExpressionConstant(p->value.powering.g)) return 1; return 0; break; } return 0; } int polynomialUsesExpressionConstant(polynomial_t p) { int res; /* Handle stupid input */ if (p == NULL) return 0; /* Check if the result is in the cache */ if (p->usesExpressionConstant.cached) { return p->usesExpressionConstant.res; } /* Call inner function */ res = __polynomialUsesExpressionConstantInner(p); /* Put the result into the cache */ p->usesExpressionConstant.res = res; p->usesExpressionConstant.cached = 1; /* Return the result */ return res; } int polynomialReferencesExpression(polynomial_t p, node *expr) { /* Handle stupid input */ if (p == NULL) return 0; /* If the polynomial does not use any expression, it cannot reference the given expression */ if (!polynomialUsesExpressionConstant(p)) { return 0; } /* Handle the problem recursively */ switch (p->type) { case SPARSE: return sparsePolynomialReferencesExpression(p->value.sparse, expr); break; case ADDITION: case SUBTRACTION: case MULTIPLICATION: case COMPOSITION: if (polynomialReferencesExpression(p->value.pair.g, expr)) return 1; if (polynomialReferencesExpression(p->value.pair.h, expr)) return 1; return 0; break; case NEGATE: return polynomialReferencesExpression(p->value.g, expr); break; case POWER: if (constantReferencesExpression(p->value.powering.c, expr)) return 1; if (polynomialReferencesExpression(p->value.powering.g, expr)) return 1; return 0; break; } return 0; } uint64_t polynomialHash(polynomial_t p) { uint64_t hash; /* Handle stupid input */ if (p == NULL) return hashPointer(NULL); /* Check if the hash has already been computed */ if (p->hash.hasHash) { return p->hash.hash; } /* Sparsify the polynomial and return a copy */ __polynomialSparsify(p); hash = sparsePolynomialHash(p->value.sparse); /* Cache the result */ p->hash.hash = hash; p->hash.hasHash = 1; /* Return the hash */ return hash; } sollya-6.0+ds/polynomials.h000066400000000000000000000127531300174114700160110ustar00rootroot00000000000000/* Copyright 2014-2016 by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributor Ch. Lauter christoph.lauter@lip6.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef POLYNOMIALS_H #define POLYNOMIALS_H #include #include #include #include #include "mpfi-compat.h" /* An abstract type for polynomials */ typedef struct __polynomial_struct_t * polynomial_t; /* Operations on polynomials */ /* Cache handling */ void polynomialInitializeCaches(); void polynomialFreeCaches(); /* Constructors */ polynomial_t polynomialFromMpfrConstant(mpfr_t); polynomial_t polynomialFromMpzConstant(mpz_t); polynomial_t polynomialFromMpqConstant(mpq_t); polynomial_t polynomialFromIntConstant(int); polynomial_t polynomialFromIdentity(); polynomial_t polynomialFromMpfrCoefficients(mpfr_t *, unsigned int); int polynomialFromConstantExpressionCoefficients(polynomial_t *, struct nodeStruct **, unsigned int); int polynomialFromExpression(polynomial_t *, struct nodeStruct *); int polynomialFromExpressionOnlyRealCoeffs(polynomial_t *, struct nodeStruct *); /* Copy-Constructor */ polynomial_t polynomialFromCopy(polynomial_t); /* Destructor */ void polynomialFree(polynomial_t); /* Comparisons */ int polynomialEqual(polynomial_t, polynomial_t, int); int polynomialIsIdentity(polynomial_t, int); int polynomialIsConstant(polynomial_t, int); int polynomialStructurallyEqual(polynomial_t, polynomial_t, int); /* Arithmetical operations */ polynomial_t polynomialAdd(polynomial_t, polynomial_t); polynomial_t polynomialSub(polynomial_t, polynomial_t); polynomial_t polynomialMul(polynomial_t, polynomial_t); polynomial_t polynomialNeg(polynomial_t); polynomial_t polynomialCompose(polynomial_t, polynomial_t); void polynomialDiv(polynomial_t *, polynomial_t *, polynomial_t, polynomial_t); int polynomialPow(polynomial_t *, polynomial_t, polynomial_t); polynomial_t polynomialPowUnsignedInt(polynomial_t, unsigned int); polynomial_t polynomialDeriv(polynomial_t); /* Rewrite operations */ polynomial_t polynomialHornerize(polynomial_t); polynomial_t polynomialCanonicalize(polynomial_t); /* Tests for rewrite operations */ int polynomialIsHornerized(polynomial_t); int polynomialIsCanonicalized(polynomial_t); /* Accessors */ void polynomialGetDegree(mpz_t, polynomial_t); int polynomialGetDegreeAsInt(polynomial_t); struct nodeStruct *polynomialGetIthCoefficient(polynomial_t, mpz_t); struct nodeStruct *polynomialGetIthCoefficientIntIndex(polynomial_t, int); int polynomialGetCoefficients(struct nodeStruct ***, unsigned int *, polynomial_t); struct nodeStruct *polynomialGetExpression(polynomial_t); struct nodeStruct *polynomialGetExpressionExplicit(polynomial_t); /* Displaying and conversion to strings */ void polynomialFPrintf(FILE *, polynomial_t); char *polynomialToString(polynomial_t); /* Evaluation */ void polynomialEvalMpfr(mpfr_t, polynomial_t, mpfr_t); void polynomialEvalMpfi(sollya_mpfi_t, polynomial_t, sollya_mpfi_t); /* Rounding of coefficients */ int polynomialCoefficientsAreDyadic(polynomial_t, int); int polynomialCoefficientsAreRational(polynomial_t, int); polynomial_t polynomialRoundDyadic(polynomial_t, mp_prec_t); polynomial_t polynomialRoundRational(polynomial_t, mp_prec_t); polynomial_t polynomialRound(polynomial_t, mp_prec_t); /* A function to prevent memory reference loops */ int polynomialReferencesExpression(polynomial_t, struct nodeStruct *); /* A hashing function */ uint64_t polynomialHash(polynomial_t); #endif /* ifdef POLYNOMIALS_H*/ sollya-6.0+ds/printf.c000066400000000000000000001407531300174114700147420ustar00rootroot00000000000000/* Copyright 2011-2015 by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France Contributor Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #define _BSD_SOURCE #define _DEFAULT_SOURCE #include #include #include #include #include #include #include #include #include #include #include "expression.h" #include "general.h" #include "mpfi-compat.h" #include "execute.h" #include "printf.h" #include "infnorm.h" #include "execute.h" #include "sturm.h" #include "signalhandling.h" /* Some flag constants used only in this file */ #define SOLLYA_PRINTF_IMPL_FLAG_ALTERNATE_FORM 1 #define SOLLYA_PRINTF_IMPL_FLAG_ZERO_PADDING 2 #define SOLLYA_PRINTF_IMPL_FLAG_LEFT_ADJUSTMENT 4 #define SOLLYA_PRINTF_IMPL_FLAG_POSITIVE_LEAVE_SPACE 8 #define SOLLYA_PRINTF_IMPL_FLAG_POSITIVE_GET_PLUS 16 #define SOLLYA_PRINTF_IMPL_FLAG_GROUP_THOUSANDS 32 #define SOLLYA_PRINTF_IMPL_FLAG_ALTERNATE_DIGITS 64 /* Size of a static buffer */ #define SOLLYA_PRINTF_STATIC_BUF_SIZE 1024 /* Remark: we don't really know how large the maximum precision could ever be and if we should apply some modulo behavior. Anyway, we can't test the whole thing so the precision is stored on a uint64_t for now. */ static inline int analyzePrecModifier(uint64_t *analyzedPrec, int *analyzedStar, char *startBuf, char *endBuf) { char *curr; char *myStart, *myEnd, *endBufBeforeNull; uint64_t prec; endBufBeforeNull = endBuf; while ((endBufBeforeNull > startBuf) && (*endBufBeforeNull == '\0')) endBufBeforeNull--; /* Check if first character is a dot */ if (*startBuf != '.') return 0; /* Check if last character is a format specifier that may come with a precision modifier */ switch (*endBufBeforeNull) { case 'v': case 'w': case 'b': case 'r': case 'k': break; default: return 0; } /* Check that between the first and the last character there is at least one other character. If not, the analyzed precision is 0. */ myStart = startBuf + 1; myEnd = endBufBeforeNull - 1; if (myStart > myEnd) { *analyzedPrec = 0; return 1; } /* Check if there is exactly one character between the first and the last character and if it is a star. */ if ((myStart == myEnd) && (*myStart == '*')) { /* Here, we have a correct dynamic precision modifier */ *analyzedStar = 1; return 1; } /* If we are here, all characters between the first and the last character must be decimal digits. Check this condition first. */ for (curr=myStart;curr<=myEnd;curr++) { if ((*curr < '0') || (*curr > '9')) return 0; } /* Here, we know that all characters between the first and the last character are decimal digits. We convert them to a 64 unsigned int. */ prec = 0; for (curr=myStart;curr<=myEnd;curr++) { prec *= 10; prec += ((uint64_t) (*curr)) - ((uint64_t) '0'); } *analyzedPrec = prec; return 1; } /* Remark: we don't really know how large the maximum width could ever be and if we should apply some modulo behavior. Anyway, we can't test the whole thing so the width is stored on a uint64_t for now. */ static inline int analyzeWidthModifier(uint64_t *analyzedWidth, int *setAnalyzedWidth, int *analyzedStar, uint64_t *analyzedFlags, char *startBuf, char *endBuf) { char *myStartBuf, *myEndBuf; char *curr; int gottaBreak; uint64_t flags, width; /* Trim off a possible leading '%' and a possible trailing '\0'. */ myStartBuf = startBuf; if (*myStartBuf == '%') myStartBuf++; myEndBuf = endBuf; if (*myEndBuf == '\0') myEndBuf--; /* Now check if we have at least one character to analyze between myStartBuf and myEndBuf */ if (myEndBuf < myStartBuf) return 0; /* Trim off a possible trailing '.', 'b', 'v', 'w', 'r' or 'k'. */ switch (*myEndBuf) { case '.': case 'b': case 'v': case 'w': case 'r': case 'k': myEndBuf--; break; default: break; } /* Now check if we have at least one character to analyze between myStartBuf and myEndBuf */ if (myEndBuf < myStartBuf) return 0; /* Now analyze the flag characters */ flags = (uint64_t) 0; for (curr = myStartBuf; curr <= myEndBuf; curr++) { gottaBreak = 0; switch (*curr) { case '#': flags |= SOLLYA_PRINTF_IMPL_FLAG_ALTERNATE_FORM; break; case '0': flags |= SOLLYA_PRINTF_IMPL_FLAG_ZERO_PADDING; break; case '-': flags |= SOLLYA_PRINTF_IMPL_FLAG_LEFT_ADJUSTMENT; break; case ' ': flags |= SOLLYA_PRINTF_IMPL_FLAG_POSITIVE_LEAVE_SPACE; break; case '+': flags |= SOLLYA_PRINTF_IMPL_FLAG_POSITIVE_GET_PLUS; break; case '\'': flags |= SOLLYA_PRINTF_IMPL_FLAG_GROUP_THOUSANDS; break; case 'I': flags |= SOLLYA_PRINTF_IMPL_FLAG_ALTERNATE_DIGITS; break; default: gottaBreak = 1; } if (gottaBreak) break; } /* Check for flags that override each other. */ if (flags & SOLLYA_PRINTF_IMPL_FLAG_LEFT_ADJUSTMENT) { /* Left adjustment overrides zero padding */ flags &= ~SOLLYA_PRINTF_IMPL_FLAG_ZERO_PADDING; } if (flags & SOLLYA_PRINTF_IMPL_FLAG_POSITIVE_GET_PLUS) { /* Plus-sign display overrides space display for signed conversions. */ flags &= ~SOLLYA_PRINTF_IMPL_FLAG_POSITIVE_LEAVE_SPACE; } /* Check if we already got everything (because there are only flags, no width) and return. */ if (curr > myEndBuf) { *analyzedFlags = flags; *setAnalyzedWidth = 0; *analyzedStar = 0; return 1; } /* Analyze now the width field, which can either be a '*' or a decimal number. If the field is a star, this character must be the only one left. Otherwise all characters must be decimal digits. */ if ((curr == myEndBuf) && (*curr == '*')) { *analyzedFlags = flags; *setAnalyzedWidth = 0; *analyzedStar = 1; return 1; } /* Here all characters must be decimal digits. */ width = (uint64_t) 0; for (; curr <= myEndBuf; curr++) { /* If a character is not a decimal digit, return failure */ if ((*curr < '0') || (*curr > '9')) return 0; width *= (uint64_t) 10; width += (uint64_t) (*curr - '0'); } /* Here, everthing went fine and we have an analyzed width */ *analyzedFlags = flags; *analyzedWidth = width; *setAnalyzedWidth = 1; *analyzedStar = 0; return 1; } static inline char *justifyString(char *str, int justify, int justifyLeft, size_t width) { size_t len, num; char *res, *curr1, *curr2; /* Nothing to do if we don't justify at all or if the string is already longer than the field */ if (!justify) return str; len = strlen(str); if (len >= width) return str; /* Compute number of justification characters */ num = width - len; /* Allocate string for the output */ res = safeCalloc(width + 1, sizeof(char)); /* Justify to the left or to the right */ if (justifyLeft) { for (curr1=str,curr2=res;*curr1!='\0';curr1++,curr2++) { *curr2 = *curr1; } for (;num>0;num--,curr2++) { *curr2 = ' '; } } else { for (curr2=res;num>0;num--,curr2++) { *curr2 = ' '; } for (curr1=str;*curr1!='\0';curr1++,curr2++) { *curr2 = *curr1; } } /* Free the old string */ safeFree(str); /* Return the new justified string */ return res; } static inline void initAndCopyMpfr(mpfr_t rop, mpfr_srcptr op) { mpfr_init2(rop,mpfr_get_prec(op)); mpfr_set(rop,op,GMP_RNDN); } static inline void initAndCopyMpfi(sollya_mpfi_t rop, sollya_mpfi_srcptr op) { sollya_mpfi_init2(rop,sollya_mpfi_get_prec(op)); sollya_mpfi_set(rop,op); } static inline void initAndCopyMpq(mpq_t rop, mpq_srcptr op) { mpq_init(rop); mpq_set(rop,op); } static inline void initAndCopyMpz(mpz_t rop, mpz_srcptr op) { mpz_init(rop); mpz_set(rop,op); } static inline int specialSnFprintf(FILE *fd, int useFd, char *str, size_t size, int offset, int useSize, const char *format, ...) { va_list varlist; size_t actualSize; char *actualStr; int res = -1; if (useFd) { va_start(varlist, format); deferSignalHandling(); res = vfprintf(fd, format, varlist); resumeSignalHandling(); va_end(varlist); return res; } if (offset < 0) return offset; if ((size_t) offset > size) { actualSize = 0; actualStr = NULL; } else { actualSize = size - offset; actualStr = str + offset; } va_start(varlist, format); if (useSize) { if (actualSize >= 1) { deferSignalHandling(); res = vsnprintf(actualStr, actualSize, format, varlist); resumeSignalHandling(); } else { deferSignalHandling(); res = vsnprintf(actualStr, 0, format, varlist); resumeSignalHandling(); } } else { deferSignalHandling(); res = vsprintf(str + offset, format, varlist); resumeSignalHandling(); } va_end(varlist); return res; } static inline int sollyaInternalBaseSnFprintf(FILE *fd, int useFd, char *str, size_t size, int useSize, const char *format, va_list varlist) { int res = 0; char *buf; char staticBuf[SOLLYA_PRINTF_STATIC_BUF_SIZE]; const char *currFormat; char *currBuf; char *dotBuf, *percentBuf, *percentEndBuf; int r, shiftedState, starModifiers, hModifiers; int lModifiers, LModifier, jModifier, zModifier; int tModifier, dotModifier; char c; int tempInt; ssize_t tempSsize_t; intmax_t tempIntmax_t; ptrdiff_t tempPtrdiff_t; long int tempLongInt; long long int tempLongLongInt; short int tempShortInt; signed char tempSignedChar; int firstStarInt, secondStarInt; unsigned int tempUInt; size_t tempSize_t; uintmax_t tempUintmax_t; unsigned long int tempULongInt; unsigned long long int tempULongLongInt; unsigned short int tempUShortInt; unsigned char tempUnsignedChar; double tempDouble; long double tempLongDouble; wint_t tempWint_t; char *tempCharPtr; wchar_t *tempWCharPtr; void *tempVoidPtr; int *tempIntPtr; intmax_t *tempIntMaxTPtr; ssize_t *tempSSizePtr; ptrdiff_t *tempPtrDiffTPtr; signed char *tempSignedCharPtr; short int *tempShortIntPtr; long int *tempLongIntPtr; long long int *tempLongLongIntPtr; char *tempString; int isPercent; mpfr_t tempMpfrOrig; sollya_mpfi_t tempMpfiOrig; node *tempNode; mpq_t tempMpqOrig; mpz_t tempMpzOrig; int correctPrecModifier, analyzedStar, correctWidthModifier, analyzedWidthStar; int setAnalyzedWidth; uint64_t analyzedWidth, analyzedFlags; uint64_t analyzedPrec; int precisionSpecified; mp_prec_t prec; mpfr_t tempMpfr; sollya_mpfi_t tempMpfi; size_t frmtLen; /* Make compiler happy */ prec = 12; analyzedWidth = UINT64_C(18446744073709551615); analyzedPrec = UINT64_C(18446744073709551615); /* End of compiler happiness */ frmtLen = strlen(format); if (frmtLen + 1 > SOLLYA_PRINTF_STATIC_BUF_SIZE) { buf = (char *) safeCalloc(frmtLen + 1, sizeof(char)); } else { buf = staticBuf; sollya_memset(buf, '\0', frmtLen + 1 + 7); } currBuf = buf; *currBuf = '\0'; shiftedState = 0; currFormat = format; while (*currFormat != '\0') { switch (*currFormat) { case '%': *currBuf = *currFormat; currBuf++; *currBuf = '\0'; currFormat++; shiftedState = 1; starModifiers = 0; hModifiers = 0; lModifiers = 0; LModifier = 0; jModifier = 0; zModifier = 0; tModifier = 0; dotModifier = 0; while ((*currFormat != '\0') && (shiftedState != 0)) { *currBuf = *currFormat; currBuf++; *currBuf = '\0'; c = *currFormat; currFormat++; switch (c) { case '*': starModifiers++; break; case '.': dotModifier = 1; break; case 'h': hModifiers++; break; case 'l': lModifiers++; break; case 'L': LModifier = 1; break; case 'q': lModifiers += 2; break; case 'j': jModifier = 1; break; case 'z': zModifier = 1; break; case 't': tModifier = 1; break; case 'd': case 'i': switch (starModifiers) { case 0: /* No star modifier given We do not have to read an extra int */ switch (hModifiers) { case 0: switch (lModifiers) { case 0: if (jModifier) { /* intmax_t integer conversion, no star */ tempIntmax_t = va_arg(varlist,intmax_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempIntmax_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (zModifier) { /* ssize_t integer conversion, no star */ tempSsize_t = va_arg(varlist,ssize_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempSsize_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (tModifier) { /* ptrdiff_t integer conversion, no star */ tempPtrdiff_t = va_arg(varlist,ptrdiff_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempPtrdiff_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { /* int integer conversion, no star */ tempInt = va_arg(varlist,int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } } } break; case 1: /* long int integer conversion, no star */ tempLongInt = va_arg(varlist,long int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempLongInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* long long int integer conversion, no star */ tempLongLongInt = va_arg(varlist,long long int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempLongLongInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; case 1: /* short int integer conversion, no star short int integers get promoted to int when passed through variable args. */ tempShortInt = (short int) (va_arg(varlist,int)); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempShortInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* signed char integer conversion, no star signed char integers get promoted to int when passed through variable args. */ tempSignedChar = (signed char) (va_arg(varlist,int)); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempSignedChar); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; case 1: /* One star modifier given We have to read an extra int */ firstStarInt = va_arg(varlist,int); switch (hModifiers) { case 0: switch (lModifiers) { case 0: if (jModifier) { /* intmax_t integer conversion, one star */ tempIntmax_t = va_arg(varlist,intmax_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempIntmax_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (zModifier) { /* ssize_t integer conversion, one star */ tempSsize_t = va_arg(varlist,ssize_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempSsize_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (tModifier) { /* ptrdiff_t integer conversion, one star */ tempPtrdiff_t = va_arg(varlist,ptrdiff_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempPtrdiff_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { /* int integer conversion, one star */ tempInt = va_arg(varlist,int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } } } break; case 1: /* long int integer conversion, one star */ tempLongInt = va_arg(varlist,long int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempLongInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* long long int integer conversion, one star */ tempLongLongInt = va_arg(varlist,long long int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempLongLongInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; case 1: /* short int integer conversion, one star short int integers get promoted to int when passed through variable args. */ tempShortInt = (short int) (va_arg(varlist,int)); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempShortInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* signed char integer conversion, one star signed char integers get promoted to int when passed through variable args. */ tempSignedChar = (signed char) (va_arg(varlist,int)); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempSignedChar); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; default: /* Two (or more) star modifiers given We have to read two extra ints */ firstStarInt = va_arg(varlist,int); secondStarInt = va_arg(varlist,int); switch (hModifiers) { case 0: switch (lModifiers) { case 0: if (jModifier) { /* intmax_t integer conversion, one star */ tempIntmax_t = va_arg(varlist,intmax_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempIntmax_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (zModifier) { /* ssize_t integer conversion, one star */ tempSsize_t = va_arg(varlist,ssize_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempSsize_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (tModifier) { /* ptrdiff_t integer conversion, one star */ tempPtrdiff_t = va_arg(varlist,ptrdiff_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempPtrdiff_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { /* int integer conversion, one star */ tempInt = va_arg(varlist,int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } } } break; case 1: /* long int integer conversion, one star */ tempLongInt = va_arg(varlist,long int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempLongInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* long long int integer conversion, one star */ tempLongLongInt = va_arg(varlist,long long int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempLongLongInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; case 1: /* short int integer conversion, one star short int integers get promoted to int when passed through variable args. */ tempShortInt = (short int) (va_arg(varlist,int)); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempShortInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* signed char integer conversion, one star signed char integers get promoted to int when passed through variable args. */ tempSignedChar = (signed char) (va_arg(varlist,int)); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempSignedChar); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; } shiftedState = 0; break; case 'o': case 'u': case 'x': case 'X': switch (starModifiers) { case 0: /* No star modifier given We do not have to read an extra int */ switch (hModifiers) { case 0: switch (lModifiers) { case 0: if (jModifier) { /* uintmax_t integer conversion, no star */ tempUintmax_t = va_arg(varlist,uintmax_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempUintmax_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (zModifier) { /* size_t integer conversion, no star */ tempSize_t = va_arg(varlist,size_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempSize_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (tModifier) { /* ptrdiff_t integer conversion, no star */ tempPtrdiff_t = va_arg(varlist,ptrdiff_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempPtrdiff_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { /* unsigned int integer conversion, no star */ tempUInt = va_arg(varlist,unsigned int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempUInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } } } break; case 1: /* unsigned long int integer conversion, no star */ tempULongInt = va_arg(varlist,unsigned long int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempULongInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* unsigned long long int integer conversion, no star */ tempULongLongInt = va_arg(varlist,unsigned long long int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempULongLongInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; case 1: /* unsigned short int integer conversion, no star unsigned short int integers get promoted to unsigned int when passed through variable args. */ tempUShortInt = (unsigned short int) (va_arg(varlist,unsigned int)); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempUShortInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* unsigned char integer conversion, no star unsigned char integers get promoted to unsigned int when passed through variable args. */ tempUnsignedChar = (unsigned char) (va_arg(varlist,unsigned int)); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempUnsignedChar); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; case 1: /* One star modifier given We have to read an extra int */ firstStarInt = va_arg(varlist,int); switch (hModifiers) { case 0: switch (lModifiers) { case 0: if (jModifier) { /* uintmax_t integer conversion, one star */ tempUintmax_t = va_arg(varlist,uintmax_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempUintmax_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (zModifier) { /* size_t integer conversion, one star */ tempSize_t = va_arg(varlist,size_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempSize_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (tModifier) { /* ptrdiff_t integer conversion, one star */ tempPtrdiff_t = va_arg(varlist,ptrdiff_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempPtrdiff_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { /* unsigned int integer conversion, one star */ tempUInt = va_arg(varlist,unsigned int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempUInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } } } break; case 1: /* unsigned long int integer conversion, one star */ tempULongInt = va_arg(varlist,unsigned long int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempULongInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* unsigned long long int integer conversion, one star */ tempULongLongInt = va_arg(varlist,unsigned long long int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempULongLongInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; case 1: /* unsigned short int integer conversion, one star unsigned short int integers get promoted to unsigned int when passed through variable args. */ tempUShortInt = (unsigned short int) (va_arg(varlist,unsigned int)); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempUShortInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* unsigned char integer conversion, one star unsigned char integers get promoted to unsigned int when passed through variable args. */ tempUnsignedChar = (unsigned char) (va_arg(varlist,unsigned int)); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempUnsignedChar); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; default: /* Two (or more) star modifiers given We have to read two extra ints */ firstStarInt = va_arg(varlist,int); secondStarInt = va_arg(varlist,int); switch (hModifiers) { case 0: switch (lModifiers) { case 0: if (jModifier) { /* uintmax_t integer conversion, one star */ tempUintmax_t = va_arg(varlist,uintmax_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempUintmax_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (zModifier) { /* size_t integer conversion, one star */ tempSize_t = va_arg(varlist,size_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempSize_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (tModifier) { /* ptrdiff_t integer conversion, one star */ tempPtrdiff_t = va_arg(varlist,ptrdiff_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempPtrdiff_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { /* unsigned int integer conversion, one star */ tempUInt = va_arg(varlist,unsigned int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempUInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } } } break; case 1: /* unsigned long int integer conversion, one star */ tempULongInt = va_arg(varlist,unsigned long int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempULongInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* unsigned long long int integer conversion, one star */ tempULongLongInt = va_arg(varlist,unsigned long long int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempULongLongInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; case 1: /* unsigned short int integer conversion, one star unsigned short int integers get promoted to unsigned int when passed through variable args. */ tempUShortInt = (unsigned short int) (va_arg(varlist,unsigned int)); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempUShortInt); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* unsigned char integer conversion, one star unsigned char integers get promoted to unsigned int when passed through variable args. */ tempUnsignedChar = (unsigned char) (va_arg(varlist,unsigned int)); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempUnsignedChar); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; } shiftedState = 0; break; case 'e': case 'E': case 'f': case 'F': case 'g': case 'G': case 'a': case 'A': switch (starModifiers) { case 0: /* No star modifier given We do not have to read an extra int */ if (LModifier) { /* The floating-point conversion takes a long double argument */ tempLongDouble = va_arg(varlist,long double); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempLongDouble); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { /* The floating-point conversion takes a double argument */ tempDouble = va_arg(varlist,double); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempDouble); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } break; case 1: /* One star modifier given We have to read one extra int */ firstStarInt = va_arg(varlist,int); if (LModifier) { /* The floating-point conversion takes a long double argument */ tempLongDouble = va_arg(varlist,long double); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempLongDouble); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { /* The floating-point conversion takes a double argument */ tempDouble = va_arg(varlist,double); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempDouble); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } break; default: /* Two (or more) star modifiers given We have to read two extra ints */ firstStarInt = va_arg(varlist,int); secondStarInt = va_arg(varlist,int); if (LModifier) { /* The floating-point conversion takes a long double argument */ tempLongDouble = va_arg(varlist,long double); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempLongDouble); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { /* The floating-point conversion takes a double argument */ tempDouble = va_arg(varlist,double); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, secondStarInt, tempDouble); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } break; } shiftedState = 0; break; case 'C': lModifiers++; /* Fall-through... */ case 'c': if (lModifiers == 0) { tempUnsignedChar = (unsigned char) va_arg(varlist,int); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempUnsignedChar); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { tempWint_t = va_arg(varlist,wint_t); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempWint_t); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } shiftedState = 0; break; case 'S': lModifiers++; /* Fall-through... */ case 's': if (starModifiers == 0) { /* No star modifier given We do not have to read an extra int */ if (lModifiers == 0) { tempCharPtr = va_arg(varlist,char *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempCharPtr); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { tempWCharPtr = va_arg(varlist,wchar_t *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempWCharPtr); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } } else { /* One star modifier given We have to read one extra int */ firstStarInt = va_arg(varlist,int); if (lModifiers == 0) { tempCharPtr = va_arg(varlist,char *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempCharPtr); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { tempWCharPtr = va_arg(varlist,wchar_t *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, firstStarInt, tempWCharPtr); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } } shiftedState = 0; break; case 'p': tempVoidPtr = va_arg(varlist,void *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempVoidPtr); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; shiftedState = 0; break; case 'n': switch (hModifiers) { case 0: switch (lModifiers) { case 0: if (jModifier) { /* intmax_t * argument */ tempIntMaxTPtr = va_arg(varlist,intmax_t *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, &tempIntmax_t); if (res >= 0) { *tempIntMaxTPtr = tempIntmax_t + res; } else { *tempIntMaxTPtr = 0; } if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (zModifier) { /* ssize_t * argument */ tempSSizePtr = va_arg(varlist,ssize_t *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, &tempSsize_t); if (res >= 0) { *tempSSizePtr = tempSsize_t + res; } else { *tempSSizePtr = 0; } if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { if (tModifier) { /* ptrdiff_t * argument */ tempPtrDiffTPtr = va_arg(varlist,ptrdiff_t *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, &tempPtrdiff_t); if (res >= 0) { *tempPtrDiffTPtr = tempPtrdiff_t + res; } else { *tempPtrDiffTPtr = 0; } if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } else { /* int * argument */ tempIntPtr = va_arg(varlist,int *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, &tempInt); if (res >= 0) { *tempIntPtr = tempInt + res; } else { *tempIntPtr = 0; } if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; } } } break; case 1: /* long int * argument */ tempLongIntPtr = va_arg(varlist,long int *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, &tempLongInt); if (res >= 0) { *tempLongIntPtr = tempLongInt + res; } else { *tempLongIntPtr = 0; } if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* long long int * */ tempLongLongIntPtr = va_arg(varlist,long long int *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, &tempLongLongInt); if (res >= 0) { *tempLongLongIntPtr = tempLongLongInt + res; } else { *tempLongLongIntPtr = 0; } if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } break; case 1: /* short int * argument */ tempShortIntPtr = va_arg(varlist,short int *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, &tempShortInt); if (res >= 0) { *tempShortIntPtr = tempShortInt + res; } else { *tempShortIntPtr = 0; } if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; default: /* signed char * argument */ tempSignedCharPtr = va_arg(varlist,signed char *); r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, &tempSignedChar); if (res >= 0) { *tempSignedCharPtr = tempSignedChar + res; } else { *tempSignedCharPtr = 0; } if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; break; } shiftedState = 0; break; case 'm': case '%': r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; shiftedState = 0; break; case 'v': case 'w': case 'b': case 'r': case 'k': /* Still free, too: y */ correctPrecModifier = 0; analyzedStar = 0; percentBuf = currBuf; percentEndBuf = currBuf; while (percentBuf > buf) { percentBuf--; if (*percentBuf == '%') break; } if (dotModifier) { dotBuf = currBuf; while (dotBuf > buf) { dotBuf--; if (*dotBuf == '.') break; } if (*dotBuf == '.') { percentEndBuf = dotBuf; correctPrecModifier = analyzePrecModifier(&analyzedPrec,&analyzedStar,dotBuf,currBuf); } } correctWidthModifier = 0; analyzedFlags = (uint64_t) 0; setAnalyzedWidth = 0; analyzedWidthStar = 0; if (percentBuf < percentEndBuf - 1) { correctWidthModifier = analyzeWidthModifier(&analyzedWidth,&setAnalyzedWidth,&analyzedWidthStar,&analyzedFlags,percentBuf,percentEndBuf); } while (currBuf > buf) { currBuf--; isPercent = (*currBuf == '%'); *currBuf = '\0'; if (isPercent) break; } *currBuf = '%'; currBuf++; *currBuf = 's'; currBuf++; *currBuf = '\0'; if (correctWidthModifier) { if (analyzedWidthStar) { firstStarInt = va_arg(varlist,int); if (firstStarInt >= 0) { analyzedWidth = firstStarInt; } else { firstStarInt = -firstStarInt; analyzedWidth = firstStarInt; analyzedFlags |= SOLLYA_PRINTF_IMPL_FLAG_LEFT_ADJUSTMENT; } setAnalyzedWidth = 1; } } precisionSpecified = 0; if (correctPrecModifier) { if (analyzedStar) { firstStarInt = va_arg(varlist,int); if (firstStarInt >= 1) { analyzedPrec = firstStarInt; } else { analyzedPrec = 1; } precisionSpecified = 1; prec = (mp_prec_t) (((double) analyzedPrec) * 3.32192809488736234787031942948939017586483139302458); /* Digits to bits */ if (prec < 4) prec = 4; } else { precisionSpecified = 1; prec = (mp_prec_t) (((double) analyzedPrec) * 3.32192809488736234787031942948939017586483139302458); /* Digits to bits */ if (prec < 4) prec = 4; } } switch (c) { case 'v': initAndCopyMpfr(tempMpfrOrig,va_arg(varlist,mpfr_srcptr)); if (precisionSpecified) { mpfr_init2(tempMpfr,prec); mpfr_set(tempMpfr,tempMpfrOrig,GMP_RNDN); tempString = sprintValue(&tempMpfr); mpfr_clear(tempMpfr); } else { tempString = sprintValue(&tempMpfrOrig); } mpfr_clear(tempMpfrOrig); break; case 'w': initAndCopyMpfi(tempMpfiOrig,va_arg(varlist,sollya_mpfi_srcptr)); if (precisionSpecified) { sollya_mpfi_init2(tempMpfi,prec); sollya_mpfi_set(tempMpfi,tempMpfiOrig); tempString = sprintInterval(tempMpfi); sollya_mpfi_clear(tempMpfi); } else { tempString = sprintInterval(tempMpfiOrig); } sollya_mpfi_clear(tempMpfiOrig); break; case 'r': initAndCopyMpq(tempMpqOrig,va_arg(varlist,mpq_srcptr)); tempString = sprintMpq(tempMpqOrig); mpq_clear(tempMpqOrig); break; case 'k': initAndCopyMpz(tempMpzOrig,va_arg(varlist,mpz_srcptr)); tempString = sprintMpz(tempMpzOrig); mpz_clear(tempMpzOrig); break; case 'b': tempNode = va_arg(varlist,node *); if (tempNode != NULL) { tempString = sPrintThing(tempNode); } else { tempString = safeCalloc(5,sizeof(char)); sprintf(tempString,"NULL"); } break; default: tempString = (char *) safeCalloc(1,sizeof(char)); break; } tempString = justifyString(tempString, setAnalyzedWidth, ((analyzedFlags & SOLLYA_PRINTF_IMPL_FLAG_LEFT_ADJUSTMENT) != ((uint64_t) 0)), (size_t) analyzedWidth); /* Does not leak memory */ r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf, tempString); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } currBuf = buf; *currBuf = '\0'; safeFree(tempString); shiftedState = 0; break; default: break; } } break; default: *currBuf = *currFormat; currBuf++; *currBuf = '\0'; currFormat++; break; } } if (currBuf != buf) { r = specialSnFprintf(fd, useFd, str, size, res, useSize, buf); if (r >= 0) { if (res >= 0) { res += r; } } else { res = r; } } if (buf != staticBuf) { safeFree(buf); } return res; } int sollyaInternalVfprintf(FILE *fd, const char *format, va_list ap) { return sollyaInternalBaseSnFprintf(fd, 1, NULL, 0, 0, format, ap); } int sollyaInternalVsnprintf(char *str, size_t size, const char *format, va_list ap) { return sollyaInternalBaseSnFprintf(NULL, 0, str, size, 1, format, ap); } int sollyaInternalVsprintf(char *str, const char *format, va_list ap) { return sollyaInternalBaseSnFprintf(NULL, 0, str, 0, 0, format, ap); } int sollya_snprintf(char *str, size_t size, const char *format, ...) { va_list varlist; int res; va_start(varlist,format); res = sollyaInternalVsnprintf(str, size, format, varlist); va_end(varlist); return res; } sollya-6.0+ds/printf.h000066400000000000000000000047421300174114700147440ustar00rootroot00000000000000/* Copyright 2011-2013 by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, Contributor Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef PRINTF_H #define PRINTF_H #include #include int sollyaInternalVfprintf(FILE *, const char *, va_list); int sollyaInternalVsnprintf(char *, size_t, const char *, va_list); int sollyaInternalVsprintf(char *, const char *, va_list); int sollya_snprintf(char *, size_t, const char *, ...); #endif /* ifdef PRINTF_H*/ sollya-6.0+ds/proof.c000066400000000000000000002542301300174114700145610ustar00rootroot00000000000000/* Copyright 2006-2013 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include "proof.h" #include /* fprintf, fopen, fclose, */ #include /* exit, free, mktemp */ #include #include #include "expression.h" #include "infnorm.h" #include "general.h" void nothing(void *arg) { UNUSED_PARAM(arg); return; } void freeExprBoundTheo(exprBoundTheo *theo) { if (theo == NULL) return; if (theo->function != NULL) { free_memory(theo->function); } if (theo->x != NULL) { sollya_mpfi_clear(*(theo->x)); safeFree(theo->x); } if (theo->boundLeft != NULL) { sollya_mpfi_clear(*(theo->boundLeft)); safeFree(theo->boundLeft); } if (theo->boundRight != NULL) { sollya_mpfi_clear(*(theo->boundRight)); safeFree(theo->boundRight); } if (theo->y != NULL) { sollya_mpfi_clear(*(theo->y)); safeFree(theo->y); } if (theo->theoLeft != NULL) { freeExprBoundTheo(theo->theoLeft); } if (theo->theoRight != NULL) { freeExprBoundTheo(theo->theoRight); } if (theo->xZ != NULL) { sollya_mpfi_clear(*(theo->xZ)); safeFree(theo->xZ); } if (theo->xMXZ != NULL) { sollya_mpfi_clear(*(theo->xMXZ)); safeFree(theo->xMXZ); } if (theo->leftDerivative != NULL) { free_memory(theo->leftDerivative); } if (theo->rightDerivative != NULL) { free_memory(theo->rightDerivative); } if (theo->theoLeftLinear != NULL) { freeExprBoundTheo(theo->theoLeftLinear); } if (theo->theoRightLinear != NULL) { freeExprBoundTheo(theo->theoRightLinear); } if (theo->theoLeftConstant != NULL) { freeExprBoundTheo(theo->theoLeftConstant); } if (theo->theoRightConstant != NULL) { freeExprBoundTheo(theo->theoRightConstant); } if (theo->boundLeftLinear != NULL) { sollya_mpfi_clear(*(theo->boundLeftLinear)); safeFree(theo->boundLeftLinear); } if (theo->boundRightLinear != NULL) { sollya_mpfi_clear(*(theo->boundRightLinear)); safeFree(theo->boundRightLinear); } if (theo->boundLeftConstant != NULL) { sollya_mpfi_clear(*(theo->boundLeftConstant)); safeFree(theo->boundLeftConstant); } if (theo->boundRightConstant != NULL) { sollya_mpfi_clear(*(theo->boundRightConstant)); safeFree(theo->boundRightConstant); } safeFree(theo); } void nullifyExprBoundTheo(exprBoundTheo *theo) { theo->function = NULL; theo->functionType = 0; theo->x = NULL; theo->boundLeft = NULL; theo->boundRight = NULL; theo->y = NULL; theo->theoLeft = NULL; theo->theoRight = NULL; theo->simplificationUsed = 0; theo->leftDerivative = NULL; theo->rightDerivative = NULL; theo->xZ = NULL; theo->xMXZ = NULL; theo->theoLeftConstant = NULL; theo->theoRightConstant = NULL; theo->boundLeftConstant = NULL; theo->boundRightConstant = NULL; theo->theoLeftLinear = NULL; theo->theoRightLinear = NULL; theo->boundLeftLinear = NULL; theo->boundRightLinear = NULL; theo->number = 0; } int exprBoundTheoIsTrivial(exprBoundTheo *theo) { if (theo->function == NULL) return 0; if ((accessThruMemRef(theo->function)->nodeType == CONSTANT) || (accessThruMemRef(theo->function)->nodeType == VARIABLE)) return 1; return 0; } void fprintDerivativeLemma(FILE *fd, node *func, node *deriv, int theoNumber, int subNumber) { if (func == NULL) return; if (deriv == NULL) return; sollyaFprintf(fd,"Lemma %d.%d:\n",theoNumber,subNumber); sollyaFprintf(fd,"The first derivative of\nf(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,func); sollyaFprintf(fd,"\nwith respect to %s is\nf\'(%s) = ",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,deriv); sollyaFprintf(fd,"\n\n"); } int fprintExprBoundTheo(FILE *fd, exprBoundTheo *theo, int start) { int nextnumber; char *fx, *gx; if (theo == NULL) return start; if (exprBoundTheoIsTrivial(theo)) return start; nextnumber = start; if (theo->theoLeft != NULL) nextnumber = fprintExprBoundTheo(fd,theo->theoLeft,nextnumber); if (theo->theoRight != NULL) nextnumber = fprintExprBoundTheo(fd,theo->theoRight,nextnumber); if (theo->theoLeftConstant != NULL) nextnumber = fprintExprBoundTheo(fd,theo->theoLeftConstant,nextnumber); if (theo->theoRightConstant != NULL) nextnumber = fprintExprBoundTheo(fd,theo->theoRightConstant,nextnumber); if (theo->theoLeftLinear != NULL) nextnumber = fprintExprBoundTheo(fd,theo->theoLeftLinear, nextnumber); if (theo->theoRightLinear != NULL) nextnumber = fprintExprBoundTheo(fd,theo->theoRightLinear,nextnumber); theo->number = nextnumber; nextnumber++; if ((theo->simplificationUsed == TAYLORPROOF) || (theo->simplificationUsed == MONOTONOCITY)) { fprintDerivativeLemma(fd, theo->function, theo->leftDerivative, theo->number, 1); } if ((theo->simplificationUsed == DECORRELATE) || (theo->simplificationUsed == HOPITAL) || (theo->simplificationUsed == HOPITAL_ON_POINT)) { fprintDerivativeLemma(fd, theo->theoLeft->function, theo->leftDerivative, theo->number, 1); fprintDerivativeLemma(fd, theo->theoRight->function, theo->rightDerivative, theo->number, 2); } sollyaFprintf(fd,"Theorem %d:\nFor all %s in ",theo->number,((variablename == NULL) ? "_x_" : variablename)); if (theo->x != NULL) fprintInterval(fd,*(theo->x)); sollyaFprintf(fd,". "); fprintTree(fd,theo->function); sollyaFprintf(fd," is in "); if (theo->y != NULL) fprintInterval(fd,*(theo->y)); sollyaFprintf(fd,"\nProof:\n"); if (theo->functionType == POLYNOMIAL) { sollyaFprintf(fd,"The given expression is a polynomial. The given bound can be verified by the Gappa tool.\n"); } else { switch (theo->simplificationUsed) { case TAYLORPROOF: sollyaFprintf(fd,"Theorem %d shows that for all %s in the given domain the given expression is bounded by ", theo->theoLeft->number, ((variablename == NULL) ? "_x_" : variablename)); fprintInterval(fd,*(theo->boundLeft)); sollyaFprintf(fd,".\nFurther lemma %d.%d shows that the derivative of the given expression is ", theo->number,1); fprintTree(fd,theo->leftDerivative); sollyaFprintf(fd,".\nOn the given domain, the values taken by this derivative are bounded by "); fprintInterval(fd,*(theo->boundLeftLinear)); if (!exprBoundTheoIsTrivial(theo->theoLeftLinear)) { sollyaFprintf(fd," as shown by theorem %d.\n",theo->theoLeftLinear->number); } else { sollyaFprintf(fd," as is trivially clear.\n"); } sollyaFprintf(fd,"The (quasi-) point interval _xZ = "); fprintInterval(fd,*(theo->xZ)); sollyaFprintf(fd, " is contained in the given domain.\nFor values %s in this interval _xZ, the given expression is bounded by ", ((variablename == NULL) ? "_x_" : variablename)); fprintInterval(fd,*(theo->boundLeftConstant)); if (!exprBoundTheoIsTrivial(theo->theoLeftConstant)) { sollyaFprintf(fd," as shown by theorem %d.\n",theo->theoLeftConstant->number); } else { sollyaFprintf(fd," as is trivially clear.\n"); } sollyaFprintf(fd,"Let _X be the given domain. The interval evaluation of (_X - _xZ) is bounded by "); fprintInterval(fd,*(theo->xMXZ)); sollyaFprintf(fd,".\nBy Taylor\'s theorem the given expression is therefore bounded by "); fprintInterval(fd,*(theo->boundRight)); sollyaFprintf(fd,".\nThe bounding domain for the expression given in this theorem is the intersection of\n"); sollyaFprintf(fd,"the bound obtained by directly bounding the expression given above and the bound by\n"); sollyaFprintf(fd,"Taylor\'s theorem.\n"); break; case DECORRELATE: fx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); gx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); sprintf(fx,"f(%s)",((variablename == NULL) ? "_x_" : variablename)); sprintf(gx,"g(%s)",((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"The given expression is of the form "); fprintHeadFunction(fd,theo->function,fx,gx); safeFree(fx); safeFree(gx); sollyaFprintf(fd,"\nwhere f(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoLeft->function); sollyaFprintf(fd,"\nand g(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoRight->function); if (!exprBoundTheoIsTrivial(theo->theoLeft)) { sollyaFprintf(fd,"\nAs per theorem %d, for %s in the given domain, f(%s) is bounded by ", theo->theoLeft->number,((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); } else { sollyaFprintf(fd,"\nTrivially for %s in the given domain, f(%s) is bounded by ", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); } fprintInterval(fd,*(theo->boundLeft)); if (!exprBoundTheoIsTrivial(theo->theoRight)) { sollyaFprintf(fd,"\nAs per theorem %d, for %s in the given domain, g(%s) is bounded by ", theo->theoRight->number,((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); } else { sollyaFprintf(fd,"\nTrivially for %s in the given domain, g(%s) is bounded by ", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); } fprintInterval(fd,*(theo->boundRight)); sollyaFprintf(fd,"\nAs shown by lemma %d.%d, the derivative of f(%s) is ", theo->number,1,((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->leftDerivative); sollyaFprintf(fd,"\nFurther by lemma %d.%d, we know that the derivative of g(%s) is ", theo->number,2,((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->rightDerivative); sollyaFprintf(fd,"\nThe (quasi-) point interval _xZ = "); fprintInterval(fd,*(theo->xZ)); sollyaFprintf(fd," is contained in the given domain.\n"); if (!exprBoundTheoIsTrivial(theo->theoLeftConstant)) { sollyaFprintf(fd,"As per theorem %d, for %s in this interval _xZ, f(%s) is bounded by\n_xC = ", theo->theoLeftConstant->number, ((variablename == NULL) ? "_x_" : variablename), ((variablename == NULL) ? "_x_" : variablename)); } else { sollyaFprintf(fd,"Trivially, for %s in this interval _xZ, f(%s) is bounded by\n_xC = ", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); } fprintInterval(fd,*(theo->boundLeftConstant)); sollyaFprintf(fd,"\n"); if (!exprBoundTheoIsTrivial(theo->theoRightConstant)) { sollyaFprintf(fd,"As per theorem %d, for %s in the interval _xZ, g(%s) is bounded by\n_yC = ", theo->theoRightConstant->number, ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); } else { sollyaFprintf(fd,"Trivially, for %s in this interval _xZ, g(%s) is bounded by\n_yC = ", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); } fprintInterval(fd,*(theo->boundRightConstant)); sollyaFprintf(fd,".\nLet _X be the given domain. The interval evaluation of (_X - _xZ) gives "); fprintInterval(fd,*(theo->xMXZ)); sollyaFprintf(fd,".\n"); if (!exprBoundTheoIsTrivial(theo->theoLeftLinear)) { sollyaFprintf(fd,"As per theorem %d, for %s in the given domain, the derivative of f(%s) is bounded by\n_xL = ", theo->theoLeftLinear->number, ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); } else { sollyaFprintf(fd,"Trivially, for %s in the given domain, the derivative of f(%s) is bounded by\n_xL = ", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); } fprintInterval(fd,*(theo->boundLeftLinear)); sollyaFprintf(fd,".\n"); if (!exprBoundTheoIsTrivial(theo->theoRightLinear)) { sollyaFprintf(fd,"As per theorem %d, for %s in the given domain, the derivative of g(%s) is bounded by\n_yL = ", theo->theoRightLinear->number, ((variablename == NULL) ? "_x_" : variablename), ((variablename == NULL) ? "_x_" : variablename)); } else { sollyaFprintf(fd,"Trivially, for %s in the given domain, the derivative of g(%s) is bounded by\n_yL = ", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); } fprintInterval(fd,*(theo->boundRightLinear)); sollyaFprintf(fd,".\nUsing Taylor\'s theorem, one verifies that the images of the given expression, function in %s,\n", ((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"for %s in the given domain, are contained in the intersection of the interval evaluation of\n", ((variablename == NULL) ? "_x_" : variablename)); fx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); gx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); sprintf(fx,"f(%s)",((variablename == NULL) ? "_x_" : variablename)); sprintf(gx,"g(%s)",((variablename == NULL) ? "_x_" : variablename)); fprintHeadFunction(fd,theo->function,fx,gx); safeFree(fx); safeFree(gx); sollyaFprintf(fd," and of ("); fprintHeadFunction(fd,theo->function,"_xC","_yC"); sollyaFprintf(fd,") + (X - _xZ) * ("); fprintHeadFunction(fd,theo->function,"_xL","_yL"); sollyaFprintf(fd,").\nThey are therefore included in the bound\n"); fprintInterval(fd,*(theo->y)); sollyaFprintf(fd,"\nthat has had to be shown.\n"); break; case HOPITAL_ON_POINT: fx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); gx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); sprintf(fx,"f(%s)",((variablename == NULL) ? "_x_" : variablename)); sprintf(gx,"g(%s)",((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"The given expression is of the form "); fprintHeadFunction(fd,theo->function,fx,gx); safeFree(fx); safeFree(gx); sollyaFprintf(fd,"\nwhere f(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoLeft->function); sollyaFprintf(fd,"\nand g(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoRight->function); if (!exprBoundTheoIsTrivial(theo->theoLeft)) { sollyaFprintf(fd,"As per theorem %d, ",theo->theoLeft->number); } else { sollyaFprintf(fd,"Trivially, "); } sollyaFprintf(fd,"for all %s in the given domain, f(%s) is bounded by the point interval ",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintInterval(fd,*(theo->boundLeft)); sollyaFprintf(fd," and therefore constant zero.\n"); if (!exprBoundTheoIsTrivial(theo->theoRight)) { sollyaFprintf(fd,"As per theorem %d, ",theo->theoRight->number); } else { sollyaFprintf(fd,"Trivially, "); } sollyaFprintf(fd,"for all %s in the given domain, g(%s) is bounded by the point interval ",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintInterval(fd,*(theo->boundLeft)); sollyaFprintf(fd," and therefore constant zero, too.\nBy Hopital's rule, the given expression"); sollyaFprintf(fd," is bounded by the interval division of boundings\n"); sollyaFprintf(fd,"of the derivatives of the numerator f(%s) and denominator g(%s) of the given expression.\n", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"As per lemma %d.%d, the derivative of f(%s) is ",theo->number,1,((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->leftDerivative); sollyaFprintf(fd,"As per lemma %d.%d, the derivative of g(%s) is ",theo->number,2,((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->rightDerivative); if (!exprBoundTheoIsTrivial(theo->theoLeftLinear)) { sollyaFprintf(fd,"As shown by theorem %d, ",theo->theoLeftLinear->number); } else { sollyaFprintf(fd,"Trivially, "); } sollyaFprintf(fd,"this derivative of f(%s) for %s in the given domain is bounded by ",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintInterval(fd,*(theo->theoLeftLinear->y)); sollyaFprintf(fd,".\n"); if (!exprBoundTheoIsTrivial(theo->theoRightLinear)) { sollyaFprintf(fd,"As shown by theorem %d, ",theo->theoRightLinear->number); } else { sollyaFprintf(fd,"Trivially, "); } sollyaFprintf(fd,"the given derivative of g(%s) for %s in the given domain is bounded by ",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintInterval(fd,*(theo->theoRightLinear->y)); sollyaFprintf(fd,".\n"); sollyaFprintf(fd,"This yields to the following bound for the given expression with %s in the given domain: ", ((variablename == NULL) ? "_x_" : variablename)); fprintInterval(fd,*(theo->y)); sollyaFprintf(fd,".\nThis is the bound that has had to be shown.\n"); break; case NUMERATOR_IS_ZERO: fx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); gx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); sprintf(fx,"f(%s)",((variablename == NULL) ? "_x_" : variablename)); sprintf(gx,"g(%s)",((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"The given expression is of the form "); fprintHeadFunction(fd,theo->function,fx,gx); safeFree(fx); safeFree(gx); sollyaFprintf(fd,"\nwhere f(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoLeft->function); sollyaFprintf(fd,"\nand g(%s) is some function in %s.\n",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); if (exprBoundTheoIsTrivial(theo->theoLeft)) { sollyaFprintf(fd,"Trivially, "); } else { sollyaFprintf(fd,"As per theorem %d, ",theo->theoLeft->number); } sollyaFprintf(fd,"for %s in the given domain, f(%s) is in ",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintInterval(fd,*(theo->boundLeft)); sollyaFprintf(fd,", i.e. constant zero.\n"); sollyaFprintf(fd,"Therefore the given expression is constant zero, i.e. bounded by "); fprintInterval(fd,*(theo->y)); sollyaFprintf(fd,".\n"); break; case HOPITAL: sollyaFprintf(fd,"The given expression is of the form "); fx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); gx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); sprintf(fx,"f(%s)",((variablename == NULL) ? "_x_" : variablename)); sprintf(gx,"g(%s)",((variablename == NULL) ? "_x_" : variablename)); fprintHeadFunction(fd,theo->function,fx,gx); sollyaFprintf(fd,"\nwhere f(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoLeft->function); sollyaFprintf(fd,"\nand g(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoRight->function); sollyaFprintf(fd,"\nLet _xZ be the point interval _xZ = "); fprintInterval(fd,*(theo->xZ)); sollyaFprintf(fd,". This interval is contained in the given domain.\n"); if (!exprBoundTheoIsTrivial(theo->theoLeftConstant)) { sollyaFprintf(fd,"As per theorem %d, ",theo->theoLeftConstant->number); } else { sollyaFprintf(fd,"Trivially, "); } sollyaFprintf(fd,"the images of f(%s) for %s in _xZ are in the point interval [0;0].\n", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"f(%s) is therefore constant zero in this interval _xZ.\n", ((variablename == NULL) ? "_x_" : variablename)); if (!exprBoundTheoIsTrivial(theo->theoRightConstant)) { sollyaFprintf(fd,"As per theorem %d, ",theo->theoRightConstant->number); } else { sollyaFprintf(fd,"Trivially, "); } sollyaFprintf(fd,"the images of g(%s) for %s in _xZ are in the point interval [0;0].\n", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"g(%s) is therefore constant zero in this interval _xZ.\n", ((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"Hopital's rule, i.e. a first order Taylor expansion of f(%s) and g(%s), can therefore\n", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"be used for bounding the given expression, which will be replaced by f'(%s)/g'(%s).\n", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"Lemma %d.%d shows that f'(%s) is\nf'(%s) = ",theo->number,1,((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->leftDerivative); sollyaFprintf(fd,"\nLemma %d.%d shows that g'(%s) is\ng'(%s) = ",theo->number,2,((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->rightDerivative); sollyaFprintf(fd,"\n"); if (!exprBoundTheoIsTrivial(theo->theoLeftLinear)) { sollyaFprintf(fd,"As per theorem %d, ",theo->theoLeftLinear->number); } else { sollyaFprintf(fd,"Trivially, "); } sollyaFprintf(fd,"f'(%s)/g'(%s) is bounded by ",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintInterval(fd,*(theo->boundLeftLinear)); sollyaFprintf(fd,".\nThis is bound that has had to be proven.\n"); safeFree(fx); safeFree(gx); break; case IMPLICATION: sollyaFprintf(fd,"The theorem is a direct consequence of theorem %d.\n",theo->theoLeft->number); break; default: sollyaFprintf(fd,"The given expression is of the form "); fx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); gx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); sprintf(fx,"f(%s)",((variablename == NULL) ? "_x_" : variablename)); sprintf(gx,"g(%s)",((variablename == NULL) ? "_x_" : variablename)); fprintHeadFunction(fd,theo->function,fx,gx); safeFree(fx); safeFree(gx); sollyaFprintf(fd,".\n"); switch (arity(theo->function)) { case 1: if (!exprBoundTheoIsTrivial(theo->theoLeft)) { sollyaFprintf(fd,"As per theorem %d, for %s in the given domain, f(%s) = ", theo->theoLeft->number,((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoLeft->function); sollyaFprintf(fd," is bounded by "); } else { sollyaFprintf(fd,"For %s in the given domain, the value of f(%s) = ",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoLeft->function); sollyaFprintf(fd," is trivially bounded by "); } fprintInterval(fd,*(theo->boundLeft)); sollyaFprintf(fd,"\nUsing this bound for the argument f(%s) of ",((variablename == NULL) ? "_x_" : variablename)); break; case 2: if (!exprBoundTheoIsTrivial(theo->theoLeft)) { sollyaFprintf(fd,"As per theorem %d, for %s in the given domain, f(%s) = ", theo->theoLeft->number,((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoLeft->function); sollyaFprintf(fd," is bounded by "); } else { sollyaFprintf(fd,"For %s in the given domain, the value of f(%s) = ",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoLeft->function); sollyaFprintf(fd," is trivially bounded by "); } fprintInterval(fd,*(theo->boundLeft)); sollyaFprintf(fd,".\n"); if (!exprBoundTheoIsTrivial(theo->theoRight)) { sollyaFprintf(fd,"As per theorem %d, for %s in the given domain, g(%s) = ", theo->theoRight->number,((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoRight->function); sollyaFprintf(fd," is bounded by "); } else { sollyaFprintf(fd,"For %s in the given domain, the value of g(%s) = ",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->theoRight->function); sollyaFprintf(fd," is trivially bounded by "); } fprintInterval(fd,*(theo->boundRight)); sollyaFprintf(fd,"\nUsing these bounds for the arguments f(%s) and g(%s) of ",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); break; case MONOTONOCITY: sollyaFprintf(fd,"Lemma %d.%d shows that the derivative of the given expression is ", theo->number,1); fprintTree(fd,theo->leftDerivative); sollyaFprintf(fd,".\nOn the given domain, the values taken by this derivative are bounded by "); fprintInterval(fd,*(theo->boundLeftLinear)); if (!exprBoundTheoIsTrivial(theo->theoLeftLinear)) { sollyaFprintf(fd," as shown by theorem %d.\n",theo->theoLeftLinear->number); } else { sollyaFprintf(fd," as is trivially clear.\n"); } sollyaFprintf(fd,"Zero does not lie in this interval and the function is thus monotone on this interval.\n"); sollyaFprintf(fd,"On the left endpoint of the interval, the function is bounded by "); fprintInterval(fd,*(theo->boundLeft)); if (!exprBoundTheoIsTrivial(theo->theoLeft)) { sollyaFprintf(fd," as shown by theorem %d.\n",theo->theoLeft->number); } else { sollyaFprintf(fd," as is trivially clear.\n"); } sollyaFprintf(fd,"On the right endpoint of the interval, the function is bounded by "); fprintInterval(fd,*(theo->boundRight)); if (!exprBoundTheoIsTrivial(theo->theoRight)) { sollyaFprintf(fd," as shown by theorem %d.\n",theo->theoRight->number); } else { sollyaFprintf(fd," as is trivially clear.\n"); } sollyaFprintf(fd,"The given interval is the convex hull of these two intervals bounding the function on the endpoints.\n"); break; default: sollyaFprintf(fd,"The expression is a constant. Its bounding is trivial. Using this constant value\n"); } fx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); gx = (char *) safeCalloc(strlen(((variablename == NULL) ? "_x_" : variablename))+4,sizeof(char)); sprintf(fx,"f(%s)",((variablename == NULL) ? "_x_" : variablename)); sprintf(gx,"g(%s)",((variablename == NULL) ? "_x_" : variablename)); fprintHeadFunction(fd,theo->function,fx,gx); safeFree(fx); safeFree(gx); sollyaFprintf(fd,", one can show the given bound for the given function.\n"); } } sollyaFprintf(fd,"\n"); return nextnumber; } int equalityTheoIsTrivial(equalityTheo *theo) { return isSyntacticallyEqual(theo->expr1,theo->expr2); } int fprintEqualityTheo(FILE *fd, equalityTheo *theo, int start) { if (theo == NULL) return start; if (equalityTheoIsTrivial(theo)) return start; theo->number = start; sollyaFprintf(fd,"Theorem %d:\n",start); fprintTree(fd,theo->expr1); sollyaFprintf(fd," = "); fprintTree(fd,theo->expr2); sollyaFprintf(fd,"\n\n"); return start+1; } void freeEqualityTheo(equalityTheo *theo) { if (theo == NULL) return; free_memory(theo->expr1); free_memory(theo->expr2); safeFree(theo); } void fprintNumeratorSufficesLemma(FILE *fd, node *func, node *numerator, int theoNumber, int subNumber) { if (func == NULL) return; if (numerator == NULL) return; sollyaFprintf(fd,"Lemma %d.%d:\n",theoNumber,subNumber); sollyaFprintf(fd,"The set of the zeros of the function\nf(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,func); sollyaFprintf(fd,"\nis included in the set of the zeros of the function\ng(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,numerator); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"Proof:\n"); if (accessThruMemRef(func)->nodeType == DIV) { sollyaFprintf(fd,"The function f(%s) is a fraction. The function g(%s) is the numerator of this fraction.\n", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); } else { if (isSyntacticallyEqual(func,numerator)) sollyaFprintf(fd,"The functions f(%s) and g(%s) are equal.\n",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); else sollyaFprintf(fd,"The functions f(%s) and g(%s) can be shown to be equal.\n",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); } sollyaFprintf(fd,"\n"); } int fprintNoZeroTheo(FILE *fd, noZeroTheo *theo, int start) { int nextNumber; chain *curr, *zeroFree, *joinedZeroFree, *temp; if (theo == NULL) return start; nextNumber = start; nextNumber = fprintEqualityTheo(fd,theo->funcEqual,nextNumber); nextNumber = fprintEqualityTheo(fd,theo->derivEqual,nextNumber); curr = theo->exprBoundTheos; while (curr != NULL) { nextNumber = fprintExprBoundTheo(fd,((exprBoundTheo *) (curr->value)),nextNumber); curr = curr->next; } theo->number = nextNumber; fprintDerivativeLemma(fd,theo->function,theo->derivative,theo->number,1); nextNumber++; sollyaFprintf(fd,"Theorem %d:\n",theo->number); sollyaFprintf(fd,"The function f(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->function); sollyaFprintf(fd," has no zeros in the following domain(s):\n"); curr = theo->exprBoundTheos; while (curr != NULL) { fprintInterval(fd,*(((exprBoundTheo *) (curr->value))->x)); sollyaFprintf(fd,"\n"); curr = curr->next; } sollyaFprintf(fd,"Further, more strictly speaking, the function f(%s) has no zero in the following domains:\n",((variablename == NULL) ? "_x_" : variablename)); zeroFree = NULL; curr = theo->exprBoundTheos; while (curr != NULL) { zeroFree = addElement(zeroFree,((exprBoundTheo *) (curr->value))->x); curr = curr->next; } temp = copyChain(zeroFree,copyMpfiPtr); freeChain(zeroFree,nothing); zeroFree = temp; joinedZeroFree = joinAdjacentIntervalsMaximally(zeroFree); freeChain(zeroFree,freeMpfiPtr); curr = joinedZeroFree; while (curr != NULL) { fprintInterval(fd,*((sollya_mpfi_t *) (curr->value))); sollyaFprintf(fd,"\n"); curr = curr->next; } freeChain(joinedZeroFree,freeMpfiPtr); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"Proof:\n"); sollyaFprintf(fd,"As per lemma %d.%d, the derivative of f(%s) is f\'(%s) = ",theo->number,1,((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->derivative); sollyaFprintf(fd,".\n"); if (!equalityTheoIsTrivial(theo->derivEqual)) { sollyaFprintf(fd,"As per theorem %d, f'(%s) can be written also ",theo->derivEqual->number,((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->derivEqual->expr2); sollyaFprintf(fd,"\nIn the following assume this equality.\n"); } if (!equalityTheoIsTrivial(theo->funcEqual)) { sollyaFprintf(fd,"As per theorem %d, f(%s) can be written also ",theo->funcEqual->number,((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->funcEqual->expr2); sollyaFprintf(fd,"\nIn the following assume this equality.\n"); } sollyaFprintf(fd,"Theorem(s) "); curr = theo->exprBoundTheos; while (curr != NULL) { if ((curr->next == NULL) && (curr != theo->exprBoundTheos)) sollyaFprintf(fd,"and "); sollyaFprintf(fd,"%d",((exprBoundTheo *) (curr->value))->number); if (curr->next != NULL) sollyaFprintf(fd,", "); curr = curr->next; } sollyaFprintf(fd,"\nshow(s) (using f'(%s)) that all images f(%s) for %s in one of the domains\n", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"given in this theorem are contained in (the union of) the following interval(s)\n"); curr = theo->exprBoundTheos; while (curr != NULL) { fprintInterval(fd,*(((exprBoundTheo *) (curr->value))->y)); sollyaFprintf(fd,"\n"); curr = curr->next; } sollyaFprintf(fd,"Clearly, none of these intervals (this interval) contains zero.\n"); sollyaFprintf(fd,"Thus f(%s) has no zero in the given intervals.\n",((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"Concerning the second (shorter) list of intervals, on remarks that it is a union of the\n"); sollyaFprintf(fd,"intervals in the first list."); sollyaFprintf(fd,"\n\n"); return nextNumber; } void freeExprBoundTheoOnVoid(void *theo) { freeExprBoundTheo((exprBoundTheo *) theo); } void freeNoZeroTheo(noZeroTheo *theo) { if (theo == NULL) return; free_memory(theo->function); free_memory(theo->derivative); freeEqualityTheo(theo->funcEqual); freeEqualityTheo(theo->derivEqual); freeChain(theo->exprBoundTheos,freeExprBoundTheoOnVoid); safeFree(theo); } int fprintInfnormTheo(FILE *fd, infnormTheo *theo, int start) { int nextNumber, innerLeftNumber, innerRightNumber, num; chain *curr, *zeroFree, *joinedZeroFree, *temp; mpfr_t a, b, l, u, fr, fl, tl, tr; mp_prec_t p, prec; sollya_mpfi_t *currMpfi; if (theo == NULL) return start; nextNumber = start; nextNumber = fprintNoZeroTheo(fd,theo->noZeros,nextNumber); nextNumber = fprintExprBoundTheo(fd,theo->evalLeftBound,nextNumber); nextNumber = fprintExprBoundTheo(fd,theo->evalRightBound,nextNumber); curr = theo->evalOnZeros; while (curr != NULL) { nextNumber = fprintExprBoundTheo(fd,((exprBoundTheo *) (curr->value)),nextNumber); curr = curr->next; } theo->number = nextNumber; fprintDerivativeLemma(fd,theo->function,theo->derivative,theo->number,1); fprintNumeratorSufficesLemma(fd,theo->derivative,theo->numeratorOfDerivative,theo->number,2); fprintDerivativeLemma(fd,theo->numeratorOfDerivative,theo->derivativeOfNumeratorOfDerivative,theo->number,3); nextNumber++; sollyaFprintf(fd,"Theorem %d:\n",theo->number); sollyaFprintf(fd,"Assuming that f is C^2, the infinity norm of\nf(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->function); sollyaFprintf(fd,"\nfor %s in ",((variablename == NULL) ? "_x_" : variablename)); if (theo->domain != NULL) fprintInterval(fd,*(theo->domain)); sollyaFprintf(fd," "); if (theo->excludedIntervals != NULL) { sollyaFprintf(fd,"without the (union of the) following interval(s)\n"); curr = theo->excludedIntervals; while (curr != NULL) { fprintInterval(fd,*((sollya_mpfi_t *) (curr->value))); sollyaFprintf(fd,"\n"); curr = curr->next; } } sollyaFprintf(fd,"is bounded by "); if (theo->infnorm != NULL) fprintInterval(fd,*(theo->infnorm)); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"Proof:\n"); sollyaFprintf(fd,"As per lemma %d.%d, the derivative f'(%s) of the given function f(%s) is\nf'(%s) = ", theo->number,1,((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->derivative); sollyaFprintf(fd, ".\nLemma %d.%d shows that the set of the zeros of f'(%s), i.e. of the local extrema of f(%s) (since f is C^2), is a\n", theo->number,2,((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"subset of the zeros of\ng(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->numeratorOfDerivative); sollyaFprintf(fd,".\nThe derivative of g(%s) is g'(%s) = ",((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); fprintTree(fd,theo->derivativeOfNumeratorOfDerivative); sollyaFprintf(fd," as shown by lemma %d.%d.\n",theo->number,3); sollyaFprintf(fd,"As per theorem %d, g(%s) has no zero in the following domains:\n", theo->noZeros->number,((variablename == NULL) ? "_x_" : variablename)); zeroFree = NULL; curr = theo->noZeros->exprBoundTheos; while (curr != NULL) { zeroFree = addElement(zeroFree,((exprBoundTheo *) (curr->value))->x); curr = curr->next; } temp = copyChain(zeroFree,copyMpfiPtr); freeChain(zeroFree,nothing); zeroFree = temp; joinedZeroFree = joinAdjacentIntervalsMaximally(zeroFree); freeChain(zeroFree,freeMpfiPtr); curr = joinedZeroFree; while (curr != NULL) { fprintInterval(fd,*((sollya_mpfi_t *) (curr->value))); sollyaFprintf(fd,"\n"); curr = curr->next; } freeChain(joinedZeroFree,freeMpfiPtr); sollyaFprintf(fd,"This intervals and the following, whose set will be notated Z,\n"); curr = theo->evalOnZeros; while (curr != NULL) { fprintInterval(fd,*(((exprBoundTheo *) (curr->value))->x)); sollyaFprintf(fd,"\n"); curr = curr->next; } sollyaFprintf(fd,"are a complete partitioning of the domain "); fprintInterval(fd,*(theo->domain)); if (theo->excludedIntervals != NULL) { sollyaFprintf(fd," without the (union of the) following interval(s)\n"); curr = theo->excludedIntervals; while (curr != NULL) { fprintInterval(fd,*((sollya_mpfi_t *) (curr->value))); sollyaFprintf(fd,"\n"); curr = curr->next; } } sollyaFprintf(fd,".\nTheorems %d and %d show that the absolute value of f(%s) on the bounds of the given domain a = ", theo->evalLeftBound->number, theo->evalRightBound->number, ((variablename == NULL) ? "_x_" : variablename)); mpfr_init2(a,sollya_mpfi_get_prec(*(theo->domain))); mpfr_init2(b,sollya_mpfi_get_prec(*(theo->domain))); sollya_mpfi_get_left(a,*(theo->domain)); sollya_mpfi_get_right(b,*(theo->domain)); fprintValue(fd,a); sollyaFprintf(fd," and b = "); fprintValue(fd,b); sollyaFprintf(fd,"\nis less than or equal to the upper bound u = "); mpfr_init2(u,sollya_mpfi_get_prec(*(theo->infnorm))); mpfr_init2(l,sollya_mpfi_get_prec(*(theo->infnorm))); sollya_mpfi_get_left(l,*(theo->infnorm)); sollya_mpfi_get_right(u,*(theo->infnorm)); fprintValue(fd,u); sollyaFprintf(fd," given for the infinity norm.\nTheorem(s) "); curr = theo->evalOnZeros; while (curr != NULL) { if ((curr->next == NULL) && (curr != theo->evalOnZeros)) sollyaFprintf(fd,"and "); sollyaFprintf(fd,"%d",((exprBoundTheo *) (curr->value))->number); if (curr->next != NULL) sollyaFprintf(fd,", "); curr = curr->next; } sollyaFprintf(fd," show(s) using f'(%s) that the absolute value of f(%s) is less than or equal to this upper bound u\n", ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"on all domains Z where g(%s) may have a zero, i.e. where f'(%s) may have a zero and f(%s) a local extremum.\n", ((variablename == NULL) ? "_x_" : variablename), ((variablename == NULL) ? "_x_" : variablename),((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"Theorem %d shows that there are no other domains with zeros of f'(%s) and we have shown that\n", theo->noZeros->number,((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"the partitioning is complete.\n"); prec = sollya_mpfi_get_prec(*(theo->evalLeftBound->y)); p = sollya_mpfi_get_prec(*(theo->evalRightBound->y)); if (p > prec) prec = p; curr = theo->evalOnZeros; while (curr != NULL) { p = sollya_mpfi_get_prec(*(((exprBoundTheo *) (curr->value))->y)); if (p > prec) prec = p; curr = curr->next; } mpfr_init2(fl,prec); mpfr_init2(fr,prec); mpfr_init2(tl,prec); mpfr_init2(tr,prec); sollya_mpfi_get_left(fr,*(theo->evalLeftBound->y)); sollya_mpfi_get_right(fl,*(theo->evalLeftBound->y)); innerLeftNumber = theo->evalLeftBound->number; innerRightNumber = theo->evalLeftBound->number; sollya_mpfi_get_left(tl,*(theo->evalRightBound->y)); sollya_mpfi_get_right(tr,*(theo->evalRightBound->y)); if (mpfr_less_p(tr,fl)) { mpfr_set(fl,tr,GMP_RNDN); innerLeftNumber = theo->evalRightBound->number; } if (mpfr_greater_p(tl,fr)) { mpfr_set(fr,tl,GMP_RNDN); innerRightNumber = theo->evalRightBound->number; } curr = theo->evalOnZeros; while (curr != NULL) { currMpfi = ((exprBoundTheo *) curr->value)->y; sollya_mpfi_get_left(tl,*currMpfi); sollya_mpfi_get_right(tr,*currMpfi); if (mpfr_less_p(tr,fl)) { mpfr_set(fl,tr,GMP_RNDN); innerLeftNumber = ((exprBoundTheo *) curr->value)->number; } if (mpfr_greater_p(tl,fr)) { mpfr_set(fr,tl,GMP_RNDN); innerRightNumber = ((exprBoundTheo *) curr->value)->number; } curr = curr->next; } if (mpfr_greater_p(fl,fr)) { sollyaFprintf(fd,"Theorem %d shows that on a domain bound or a domain containing a zero of f'(%s)\n", innerLeftNumber,((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"the value of f(%s) can principally be as great as ",((variablename == NULL) ? "_x_" : variablename)); fprintValue(fd,fl); sollyaFprintf(fd,".\nTheorem %d shows that on a domain bound or a domain containing a zero of f'(%s)\n", innerRightNumber,((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"the value of f(%s) can principally as small as ",((variablename == NULL) ? "_x_" : variablename)); fprintValue(fd,fr); sollyaFprintf(fd,".\nThe lower bound for the infinity norm on f(%s) in the given domain l = ",((variablename == NULL) ? "_x_" : variablename)); fprintValue(fd,l); sollyaFprintf(fd," is therefore the best lower bound that can be shown in this proof.\n"); } else { mpfr_neg(fl,fl,GMP_RNDN); if (mpfr_greater_p(fl,fr)) { mpfr_set(fr,fl,GMP_RNDN); num = innerLeftNumber; } else { num = innerRightNumber; } sollyaFprintf(fd,"Theorem %d shows that on a domain bound or a domain containing a zero of f'(%s)\n", num,((variablename == NULL) ? "_x_" : variablename)); sollyaFprintf(fd,"the absolute value of f(%s) is not less than the lower bound l = ",((variablename == NULL) ? "_x_" : variablename)); fprintValue(fd,l); sollyaFprintf(fd," given for the infinity norm."); } sollyaFprintf(fd,"\n\n"); mpfr_clear(a); mpfr_clear(b); mpfr_clear(u); mpfr_clear(l); mpfr_clear(fr); mpfr_clear(fl); mpfr_clear(tr); mpfr_clear(tl); return nextNumber; } void freeInfnormTheo(infnormTheo *theo) { if (theo == NULL) return; free_memory(theo->function); freeMpfiPtr(theo->domain); freeMpfiPtr(theo->infnorm); free_memory(theo->derivative); free_memory(theo->numeratorOfDerivative); free_memory(theo->derivativeOfNumeratorOfDerivative); freeChain(theo->excludedIntervals,freeMpfiPtr); freeNoZeroTheo(theo->noZeros); freeExprBoundTheo(theo->evalLeftBound); freeExprBoundTheo(theo->evalRightBound); freeChain(theo->evalOnZeros,freeExprBoundTheoOnVoid); safeFree(theo); } gappaAssignment *newGappaOperation(int opType, int relErrBits, int resultType, int resultOverlap, char *resultVariable, int operand1UsedType, int operand1ComingType, char *operand1Variable, int operand2UsedType, int operand2ComingType, char *operand2Variable) { gappaAssignment *newAssignment; newAssignment = (gappaAssignment *) safeCalloc(1,sizeof(gappaAssignment)); newAssignment->opType = opType; newAssignment->relErrBits = relErrBits; newAssignment->resultType = resultType; newAssignment->resultOverlap = resultOverlap; if (resultVariable != NULL) { newAssignment->resultVariable = (char *) safeCalloc(strlen(resultVariable)+1,sizeof(char)); strcpy(newAssignment->resultVariable,resultVariable); } else { newAssignment->resultVariable = NULL; } newAssignment->operand1UsedType = operand1UsedType; newAssignment->operand1ComingType = operand1ComingType; if (operand1Variable != NULL) { newAssignment->operand1Variable = (char *) safeCalloc(strlen(operand1Variable)+1,sizeof(char)); strcpy(newAssignment->operand1Variable,operand1Variable); } else { newAssignment->operand1Variable = NULL; } newAssignment->operand2UsedType = operand2UsedType; newAssignment->operand2ComingType = operand2ComingType; if (operand2Variable != NULL) { newAssignment->operand2Variable = (char *) safeCalloc(strlen(operand2Variable)+1,sizeof(char)); strcpy(newAssignment->operand2Variable,operand2Variable); } else { newAssignment->operand2Variable = NULL; } return newAssignment; } gappaAssignment *newGappaConstant(int resultType, char *resultVariable, double constHi, double constMi, double constLo) { gappaAssignment *newAssignment; newAssignment = (gappaAssignment *) safeCalloc(1,sizeof(gappaAssignment)); newAssignment->opType = GAPPA_CONST; newAssignment->resultType = resultType; newAssignment->resultOverlap = 53; newAssignment->resultVariable = (char *) safeCalloc(strlen(resultVariable)+1,sizeof(char)); strcpy(newAssignment->resultVariable,resultVariable); newAssignment->constHi = constHi; newAssignment->constMi = constMi; newAssignment->constLo = constLo; return newAssignment; } void freeGappaAssignment(gappaAssignment *assign) { if (assign == NULL) return; safeFree(assign->resultVariable); safeFree(assign->operand1Variable); safeFree(assign->operand2Variable); safeFree(assign->operand3Variable); safeFree(assign); } void freeGappaAssignmentOnVoid(void *assign) { freeGappaAssignment((gappaAssignment *) assign); } void freeGappaProof(gappaProof *proof) { int i; if (proof == NULL) return; mpfr_clear(proof->a); mpfr_clear(proof->b); mpfr_clear(proof->eps); safeFree(proof->variableName); safeFree(proof->resultName); free_memory(proof->polynomToImplement); free_memory(proof->polynomImplemented); for (i=0;iassignmentsNumber;i++) { freeGappaAssignment(proof->assignments[i]); } safeFree(proof->assignments); safeFree(proof); } void fprintGappaAssignmentAsMaths(FILE *fd, gappaAssignment *assign) { switch (assign->opType) { case GAPPA_CONST: switch (assign->resultType) { case 3: sollyaFprintf(fd,"M%s = %shml;\n",assign->resultVariable,assign->resultVariable); break; case 2: sollyaFprintf(fd,"M%s = %shm;\n",assign->resultVariable,assign->resultVariable); break; case 1: sollyaFprintf(fd,"M%s = %sh;\n",assign->resultVariable,assign->resultVariable); break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsMaths: unknown result type (%d) in the assignment\n",assign->opType); exit(1); } break; case GAPPA_ADD_EXACT: sollyaFprintf(fd,"M%s = M%s + M%s;\n",assign->resultVariable,assign->operand1Variable,assign->operand2Variable); break; case GAPPA_MUL_EXACT: sollyaFprintf(fd,"M%s = M%s * M%s;\n",assign->resultVariable,assign->operand1Variable,assign->operand2Variable); break; case GAPPA_ADD_DOUBLE: sollyaFprintf(fd,"M%s = M%s + M%s;\n",assign->resultVariable,assign->operand1Variable,assign->operand2Variable); break; case GAPPA_MUL_DOUBLE: sollyaFprintf(fd,"M%s = M%s * M%s;\n",assign->resultVariable,assign->operand1Variable,assign->operand2Variable); break; case GAPPA_RENORMALIZE: sollyaFprintf(fd,"M%s = M%s;\n",assign->resultVariable,assign->operand1Variable); break; case GAPPA_ADD_REL: sollyaFprintf(fd,"M%s = M%s + M%s;\n",assign->resultVariable,assign->operand1Variable,assign->operand2Variable); break; case GAPPA_MUL_REL: sollyaFprintf(fd,"M%s = M%s * M%s;\n",assign->resultVariable,assign->operand1Variable,assign->operand2Variable); break; case GAPPA_FMA_REL: sollyaFprintf(fd,"M%s = (M%s * M%s) + M%s;\n", assign->resultVariable,assign->operand3Variable,assign->operand2Variable,assign->operand1Variable); break; case GAPPA_COPY: sollyaFprintf(fd,"M%s = M%s;\n",assign->resultVariable,assign->operand1Variable); break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsMaths: unknown operation type (%d) in the assignment\n",assign->opType); exit(1); } } void fprintExpansionSuffix(FILE *fd, int type) { switch (type) { case 3: sollyaFprintf(fd,"hml"); break; case 2: sollyaFprintf(fd,"hm"); break; case 1: sollyaFprintf(fd,"h"); break; default: sollyaFprintf(stderr,"Error: fprintExpansionSuffix: unknown result type (%d) to print\n",type); exit(1); } } void fprintGappaAssignmentAsArith(FILE *fd, gappaAssignment *assign) { switch (assign->opType) { case GAPPA_CONST: switch (assign->resultType) { case 3: sollyaFprintf(fd,"%sh = double(%1.80e);\n",assign->resultVariable,assign->constHi); sollyaFprintf(fd,"%sm = double(%1.80e);\n",assign->resultVariable,assign->constMi); sollyaFprintf(fd,"%sl = double(%1.80e);\n",assign->resultVariable,assign->constLo); sollyaFprintf(fd,"%shml = %sh + %sm + %sl;\n\n",assign->resultVariable, assign->resultVariable,assign->resultVariable,assign->resultVariable); break; case 2: sollyaFprintf(fd,"%sh = double(%1.80e);\n",assign->resultVariable,assign->constHi); sollyaFprintf(fd,"%sm = double(%1.80e);\n",assign->resultVariable,assign->constMi); sollyaFprintf(fd,"%shm = %sh + %sm;\n\n",assign->resultVariable, assign->resultVariable,assign->resultVariable); break; case 1: sollyaFprintf(fd,"%sh = double(%1.80e);\n\n",assign->resultVariable,assign->constHi); break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsArith: unknown result type (%d) in the assignment\n",assign->resultType); exit(1); } break; case GAPPA_ADD_EXACT: sollyaFprintf(fd,"%shm = %s",assign->resultVariable,assign->operand1Variable); fprintExpansionSuffix(fd,assign->operand1UsedType); sollyaFprintf(fd," + %s",assign->operand2Variable); fprintExpansionSuffix(fd,assign->operand2UsedType); sollyaFprintf(fd,";\n"); sollyaFprintf(fd,"%sh = double(%shm);\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm = %shm - %sh;\n\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); break; case GAPPA_MUL_EXACT: sollyaFprintf(fd,"%shm = %s",assign->resultVariable,assign->operand1Variable); fprintExpansionSuffix(fd,assign->operand1UsedType); sollyaFprintf(fd," * %s",assign->operand2Variable); fprintExpansionSuffix(fd,assign->operand2UsedType); sollyaFprintf(fd,";\n"); sollyaFprintf(fd,"%sh = double(%shm);\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm = %shm - %sh;\n\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); break; case GAPPA_ADD_DOUBLE: if ((assign->operand1UsedType == 2) && (assign->operand2UsedType == 2)) { sollyaFprintf(fd,"%sh double= (%sh + %sm) + (%sh + %sm);\n", assign->resultVariable, assign->operand1Variable,assign->operand1Variable, assign->operand2Variable,assign->operand2Variable); } else { if (assign->operand1UsedType == 2) { sollyaFprintf(fd,"%sh double= (%sh + %sm) + %sm;\n", assign->resultVariable,assign->operand1Variable,assign->operand1Variable,assign->operand2Variable); } else { if (assign->operand2UsedType == 2) { sollyaFprintf(fd,"%sh double= %sh + (%sh + %sm);\n", assign->resultVariable,assign->operand1Variable,assign->operand2Variable,assign->operand2Variable); } else { sollyaFprintf(fd,"%sh = double(%sh + %sh);\n", assign->resultVariable,assign->operand1Variable,assign->operand2Variable); } } } break; case GAPPA_MUL_DOUBLE: if ((assign->operand1UsedType == 2) && (assign->operand2UsedType == 2)) { sollyaFprintf(fd,"%sh double= (%sh + %sm) * (%sh + %sm);\n", assign->resultVariable, assign->operand1Variable,assign->operand1Variable, assign->operand2Variable,assign->operand2Variable); } else { if (assign->operand1UsedType == 2) { sollyaFprintf(fd,"%sh double= (%sh + %sm) * %sm;\n", assign->resultVariable,assign->operand1Variable,assign->operand1Variable,assign->operand2Variable); } else { if (assign->operand2UsedType == 2) { sollyaFprintf(fd,"%sh double= %sh * (%sh + %sm);\n", assign->resultVariable,assign->operand1Variable,assign->operand2Variable,assign->operand2Variable); } else { sollyaFprintf(fd,"%sh = double(%sh * %sh);\n", assign->resultVariable,assign->operand1Variable,assign->operand2Variable); } } } break; case GAPPA_RENORMALIZE: sollyaFprintf(fd,"%shml = %shml;\n",assign->resultVariable,assign->operand1Variable); sollyaFprintf(fd,"%sml = %shml - %sh;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm = double(%sml);\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sl = %sml - %sm;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%shm = %sh + %sm;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"overlap_%s = %sm / %sh;\n\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); break; case GAPPA_ADD_REL: sollyaFprintf(fd,"%s",assign->resultVariable); fprintExpansionSuffix(fd,assign->resultType); sollyaFprintf(fd," = add_rel<%d>(%s",assign->relErrBits,assign->operand1Variable); fprintExpansionSuffix(fd,assign->operand1UsedType); sollyaFprintf(fd,",%s",assign->operand2Variable); fprintExpansionSuffix(fd,assign->operand2UsedType); sollyaFprintf(fd,");\n"); switch (assign->resultType) { case 3: sollyaFprintf(fd,"%sml = %shml - %sh;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm = double(%sml);\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sl = %sml - %sm;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%shm = %sh + %sm;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"overlap_%s = %sm / %sh;\n\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); break; case 2: sollyaFprintf(fd,"%sh = double(%shm);\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm = %shm - %sh;\n\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsArith: unhandlable result type (%d) in the assignment\n",assign->resultType); exit(1); } break; case GAPPA_MUL_REL: sollyaFprintf(fd,"%s",assign->resultVariable); fprintExpansionSuffix(fd,assign->resultType); sollyaFprintf(fd," = mul_rel<%d>(%s",assign->relErrBits,assign->operand1Variable); fprintExpansionSuffix(fd,assign->operand1UsedType); sollyaFprintf(fd,",%s",assign->operand2Variable); fprintExpansionSuffix(fd,assign->operand2UsedType); sollyaFprintf(fd,");\n"); switch (assign->resultType) { case 3: sollyaFprintf(fd,"%sml = %shml - %sh;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm = double(%sml);\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sl = %sml - %sm;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%shm = %sh + %sm;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"overlap_%s = %sm / %sh;\n\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); break; case 2: sollyaFprintf(fd,"%sh = double(%shm);\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm = %shm - %sh;\n\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsArith: unhandlable result type (%d) in the assignment\n",assign->resultType); exit(1); } break; case GAPPA_FMA_REL: sollyaFprintf(fd,"%s",assign->resultVariable); fprintExpansionSuffix(fd,assign->resultType); sollyaFprintf(fd," = fma_rel<%d>(%s",assign->relErrBits,assign->operand3Variable); fprintExpansionSuffix(fd,assign->operand3UsedType); sollyaFprintf(fd,",%s",assign->operand2Variable); fprintExpansionSuffix(fd,assign->operand2UsedType); sollyaFprintf(fd,",%s",assign->operand1Variable); fprintExpansionSuffix(fd,assign->operand1UsedType); sollyaFprintf(fd,");\n"); switch (assign->resultType) { case 3: sollyaFprintf(fd,"%sml = %shml - %sh;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm = double(%sml);\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sl = %sml - %sm;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%shm = %sh + %sm;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"overlap_%s = %sm / %sh;\n\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); break; case 2: sollyaFprintf(fd,"%sh = double(%shm);\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm = %shm - %sh;\n\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsArith: unhandlable result type (%d) in the assignment\n",assign->resultType); exit(1); } break; case GAPPA_COPY: switch (assign->resultType) { case 3: sollyaFprintf(fd,"%shml = %shml;\n",assign->resultVariable,assign->operand1Variable); sollyaFprintf(fd,"%shm = %shm;\n",assign->resultVariable,assign->operand1Variable); sollyaFprintf(fd,"%sml = %sml;\n",assign->resultVariable,assign->operand1Variable); sollyaFprintf(fd,"%sh = %sh;\n",assign->resultVariable,assign->operand1Variable); sollyaFprintf(fd,"%sm = %sm;\n",assign->resultVariable,assign->operand1Variable); sollyaFprintf(fd,"%sl = %sl;\n",assign->resultVariable,assign->operand1Variable); sollyaFprintf(fd,"overlap_%s = overlap_%s;\n\n",assign->resultVariable,assign->operand1Variable); break; case 2: sollyaFprintf(fd,"%shm = %shm;\n",assign->resultVariable,assign->operand1Variable); sollyaFprintf(fd,"%sh = %sh;\n",assign->resultVariable,assign->operand1Variable); sollyaFprintf(fd,"%sm = %sm;\n\n",assign->resultVariable,assign->operand1Variable); break; case 1: sollyaFprintf(fd,"%sh = %sh;\n\n",assign->resultVariable,assign->operand1Variable); break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsArith: unknown result type (%d) in the assignment\n",assign->resultType); exit(1); } break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsArith: unknown operation type (%d) in the assignment\n",assign->opType); exit(1); } } void fprintGappaAssignmentAsHint(FILE *fd, gappaAssignment *assign) { switch (assign->opType) { case GAPPA_CONST: break; case GAPPA_ADD_EXACT: sollyaFprintf(fd,"%sh ~ %shm;\n",assign->resultVariable,assign->resultVariable); break; case GAPPA_MUL_EXACT: sollyaFprintf(fd,"%sh ~ %shm;\n",assign->resultVariable,assign->resultVariable); break; case GAPPA_ADD_DOUBLE: break; case GAPPA_MUL_DOUBLE: break; case GAPPA_RENORMALIZE: sollyaFprintf(fd,"%shm ~ %shml;\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sh ~ %shm;\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sh ~ %shml;\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm -> %sh * overlap_%s;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sl / %sm -> - ((%sm - %sml) / %sml) / (1 + ((%sm - %sml) / %sml));\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"(%shm - %shml) / %shml -> - (%sl / %sm) * (1 / (1 / overlap_%s + 1 + (%sl / %sm)));\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sml -> %shml / ((1 + ((%sm - %sml) / %sml)) / overlap_%s + 1);\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"(%sh - %shm) / %shm -> - 1 / (1 / overlap_%s + 1);\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sh -> %shml / (overlap_%s / (1 + ((%sm - %sml) / %sml)) + 1);\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable); break; case GAPPA_ADD_REL: switch (assign->resultType) { case 3: sollyaFprintf(fd,"%shm ~ %shml;\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sh ~ %shm;\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sh ~ %shml;\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm -> %sh * overlap_%s;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sl / %sm -> - ((%sm - %sml) / %sml) / (1 + ((%sm - %sml) / %sml));\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"(%shm - %shml) / %shml -> - (%sl / %sm) * (1 / (1 / overlap_%s + 1 + (%sl / %sm)));\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sml -> %shml / ((1 + ((%sm - %sml) / %sml)) / overlap_%s + 1);\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"(%sh - %shm) / %shm -> - 1 / (1 / overlap_%s + 1);\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sh -> %shml / (overlap_%s / (1 + ((%sm - %sml) / %sml)) + 1);\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable); break; case 2: sollyaFprintf(fd,"%sh ~ %shm;\n",assign->resultVariable,assign->resultVariable); break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsHint: unhandlable result type (%d) in the assignment\n",assign->resultType); exit(1); } break; case GAPPA_MUL_REL: switch (assign->resultType) { case 3: sollyaFprintf(fd,"%shm ~ %shml;\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sh ~ %shm;\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sh ~ %shml;\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm -> %sh * overlap_%s;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sl / %sm -> - ((%sm - %sml) / %sml) / (1 + ((%sm - %sml) / %sml));\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"(%shm - %shml) / %shml -> - (%sl / %sm) * (1 / (1 / overlap_%s + 1 + (%sl / %sm)));\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sml -> %shml / ((1 + ((%sm - %sml) / %sml)) / overlap_%s + 1);\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"(%sh - %shm) / %shm -> - 1 / (1 / overlap_%s + 1);\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sh -> %shml / (overlap_%s / (1 + ((%sm - %sml) / %sml)) + 1);\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable); break; case 2: sollyaFprintf(fd,"%sh ~ %shm;\n",assign->resultVariable,assign->resultVariable); break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsHint: unhandlable result type (%d) in the assignment\n",assign->resultType); exit(1); } break; case GAPPA_FMA_REL: switch (assign->resultType) { case 3: sollyaFprintf(fd,"%shm ~ %shml;\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sh ~ %shm;\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sh ~ %shml;\n",assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sm -> %sh * overlap_%s;\n",assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sl / %sm -> - ((%sm - %sml) / %sml) / (1 + ((%sm - %sml) / %sml));\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"(%shm - %shml) / %shml -> - (%sl / %sm) * (1 / (1 / overlap_%s + 1 + (%sl / %sm)));\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sml -> %shml / ((1 + ((%sm - %sml) / %sml)) / overlap_%s + 1);\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"(%sh - %shm) / %shm -> - 1 / (1 / overlap_%s + 1);\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable); sollyaFprintf(fd,"%sh -> %shml / (overlap_%s / (1 + ((%sm - %sml) / %sml)) + 1);\n", assign->resultVariable,assign->resultVariable,assign->resultVariable,assign->resultVariable, assign->resultVariable,assign->resultVariable); break; case 2: sollyaFprintf(fd,"%sh ~ %shm;\n",assign->resultVariable,assign->resultVariable); break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsHint: unhandlable result type (%d) in the assignment\n",assign->resultType); exit(1); } break; case GAPPA_COPY: break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsHint: unknown operation type (%d) in the assignment\n",assign->opType); exit(1); } } void fprintGappaAssignmentAsDichotomy(FILE *fd, gappaAssignment *assign) { switch (assign->opType) { case GAPPA_CONST: break; case GAPPA_ADD_EXACT: break; case GAPPA_MUL_EXACT: break; case GAPPA_ADD_DOUBLE: break; case GAPPA_MUL_DOUBLE: break; case GAPPA_RENORMALIZE: sollyaFprintf(fd,"$ %shml in (0);\n",assign->resultVariable); sollyaFprintf(fd,"$ %sml in (0);\n",assign->resultVariable); break; case GAPPA_ADD_REL: switch (assign->resultType) { case 3: sollyaFprintf(fd,"$ %shml in (0);\n",assign->resultVariable); sollyaFprintf(fd,"$ %sml in (0);\n",assign->resultVariable); break; case 2: break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsDichotomy: unhandlable result type (%d) in the assignment\n",assign->resultType); exit(1); } break; case GAPPA_MUL_REL: switch (assign->resultType) { case 3: sollyaFprintf(fd,"$ %shml in (0);\n",assign->resultVariable); sollyaFprintf(fd,"$ %sml in (0);\n",assign->resultVariable); break; case 2: break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsDichotomy: unhandlable result type (%d) in the assignment\n",assign->resultType); exit(1); } break; case GAPPA_FMA_REL: switch (assign->resultType) { case 3: sollyaFprintf(fd,"$ %shml in (0);\n",assign->resultVariable); sollyaFprintf(fd,"$ %sml in (0);\n",assign->resultVariable); break; case 2: break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsDichotomy: unhandlable result type (%d) in the assignment\n",assign->resultType); exit(1); } break; case GAPPA_COPY: break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsDichtomy: unknown operation type (%d) in the assignment\n",assign->opType); exit(1); } } void fprintGappaAssignmentAsMetaHint(FILE *fd, gappaAssignment *assign) { switch (assign->opType) { case GAPPA_CONST: break; case GAPPA_ADD_EXACT: sollyaFprintf(fd,"%shm ~ M%s;\n",assign->resultVariable,assign->resultVariable); break; case GAPPA_MUL_EXACT: sollyaFprintf(fd,"%shm ~ M%s;\n",assign->resultVariable,assign->resultVariable); break; case GAPPA_ADD_DOUBLE: sollyaFprintf(fd,"%sh ~ M%s;\n",assign->resultVariable,assign->resultVariable); break; case GAPPA_MUL_DOUBLE: sollyaFprintf(fd,"%sh ~ M%s;\n",assign->resultVariable,assign->resultVariable); break; case GAPPA_RENORMALIZE: sollyaFprintf(fd,"%shml ~ M%s;\n",assign->resultVariable,assign->resultVariable); break; case GAPPA_ADD_REL: sollyaFprintf(fd,"%s",assign->resultVariable); fprintExpansionSuffix(fd,assign->resultType); sollyaFprintf(fd," ~ M%s;\n",assign->resultVariable); break; case GAPPA_MUL_REL: sollyaFprintf(fd,"%s",assign->resultVariable); fprintExpansionSuffix(fd,assign->resultType); sollyaFprintf(fd," ~ M%s;\n",assign->resultVariable); break; case GAPPA_FMA_REL: sollyaFprintf(fd,"%s",assign->resultVariable); fprintExpansionSuffix(fd,assign->resultType); sollyaFprintf(fd," ~ M%s;\n",assign->resultVariable); break; case GAPPA_COPY: sollyaFprintf(fd,"%s",assign->resultVariable); fprintExpansionSuffix(fd,assign->resultType); sollyaFprintf(fd," ~ M%s;\n",assign->resultVariable); break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsMetaHint: unknown operation type (%d) in the assignment\n",assign->opType); exit(1); } } void fprintGappaAssignmentAsOverlapBound(FILE *fd, gappaAssignment *assign) { switch (assign->opType) { case GAPPA_CONST: break; case GAPPA_ADD_EXACT: break; case GAPPA_MUL_EXACT: break; case GAPPA_ADD_DOUBLE: break; case GAPPA_MUL_DOUBLE: break; case GAPPA_RENORMALIZE: sollyaFprintf(fd,"/\\ |overlap_%s| in [1b-400,1b-%d] # Verify the lower bound\n", assign->resultVariable,assign->resultOverlap); sollyaFprintf(fd,"/\\ |%sml| in [1b-1021,1b1023]\n", assign->resultVariable); break; case GAPPA_ADD_REL: if (assign->resultType == 3) { sollyaFprintf(fd,"/\\ |overlap_%s| in [1b-400,1b-%d] # Verify the lower bound\n", assign->resultVariable,assign->resultOverlap); sollyaFprintf(fd,"/\\ |%sml| in [1b-1021,1b1023]\n", assign->resultVariable); } break; case GAPPA_MUL_REL: if (assign->resultType == 3) { sollyaFprintf(fd,"/\\ |overlap_%s| in [1b-400,1b-%d] # Verify the lower bound\n", assign->resultVariable,assign->resultOverlap); sollyaFprintf(fd,"/\\ |%sml| in [1b-1021,1b1023]\n", assign->resultVariable); } break; case GAPPA_FMA_REL: if (assign->resultType == 3) { sollyaFprintf(fd,"/\\ |overlap_%s| in [1b-400,1b-%d] # Verify the lower bound\n", assign->resultVariable,assign->resultOverlap); sollyaFprintf(fd,"/\\ |%sml| in [1b-1021,1b1023]\n", assign->resultVariable); } break; case GAPPA_COPY: break; default: sollyaFprintf(stderr,"Error: fprintGappaAssignmentAsOverlapBound: unknown operation type (%d) in the assignment\n",assign->opType); exit(1); } } void fprintGappaProof(FILE *fd, gappaProof *proof) { int i; mpfr_t temp, temp2; mp_prec_t prec, p; prec = mpfr_get_prec(proof->a); p = mpfr_get_prec(proof->b); if (p > prec) prec = p; mpfr_init2(temp,prec); sollyaFprintf(fd,"# The polynomial to implement is: "); fprintTree(fd, proof->polynomToImplement); sollyaFprintf(fd,"\n# The polynomial implemented is: "); fprintTree(fd, proof->polynomImplemented); sollyaFprintf(fd,"\n# The domain is ["); fprintValue(fd, proof->a); sollyaFprintf(fd,";"); fprintValue(fd, proof->b); sollyaFprintf(fd,"]\n# The free variable %s is a ",proof->variableName); switch (proof->variableType) { case 3: sollyaFprintf(fd,"triple-double"); break; case 2: sollyaFprintf(fd,"double-double"); break; case 1: sollyaFprintf(fd,"double precision"); break; default: sollyaFprintf(fd,"unknown precision"); } sollyaFprintf(fd," number, the result %s* is stored on a ",proof->resultName); switch (proof->resultType) { case 3: sollyaFprintf(fd,"triple-double"); break; case 2: sollyaFprintf(fd,"double-double"); break; case 1: sollyaFprintf(fd,"double precision"); break; default: sollyaFprintf(fd,"unknown precision"); } sollyaFprintf(fd," number.\n"); sollyaFprintf(fd,"# The code produces %d intermediate and final arithmetical approximations.\n\n",proof->assignmentsNumber); sollyaFprintf(fd,"# Double precision rounding operator:\n@double = float;\n\n"); sollyaFprintf(fd,"# Disable some annoying warnings:\n#@-Wno-dichotomy-failure\n\n"); sollyaFprintf(fd,"# Helper definitions for decomposing the free variable\n"); switch (proof->variableType) { case 3: sollyaFprintf(fd,"%sml = %shml - %sh;\n",proof->variableName,proof->variableName,proof->variableName); sollyaFprintf(fd,"%sm = double(%sml);\n",proof->variableName,proof->variableName); sollyaFprintf(fd,"%sl = %sml - %sm;\n",proof->variableName,proof->variableName,proof->variableName); sollyaFprintf(fd,"%shm = %sh + %sm;\n",proof->variableName,proof->variableName,proof->variableName); sollyaFprintf(fd,"overlap_%s = %sm / %sh;\n",proof->variableName,proof->variableName,proof->variableName); break; case 2: sollyaFprintf(fd,"%sh = double(%shm);\n",proof->variableName,proof->variableName); sollyaFprintf(fd,"%sm = %shm - %sh;\n",proof->variableName,proof->variableName,proof->variableName); break; case 1: sollyaFprintf(fd,"%sh = %s;\n",proof->variableName,proof->variableName); break; default: sollyaFprintf(stderr,"Error: fprintGappaProof: unknown variable type (%d) in the proof\n",proof->variableType); exit(1); } sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"# Transcription of the C code\n"); for (i=0;iassignmentsNumber;i++) { fprintGappaAssignmentAsArith(fd, proof->assignments[i]); } sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"# Mathematical equivalents\n"); switch (proof->variableType) { case 3: sollyaFprintf(fd,"M%s = %shml;\n",proof->variableName,proof->variableName); break; case 2: sollyaFprintf(fd,"M%s = %shm;\n",proof->variableName,proof->variableName); break; case 1: sollyaFprintf(fd,"M%s = %s;\n",proof->variableName,proof->variableName); break; default: sollyaFprintf(stderr,"Error: fprintGappaProof: unknown variable type (%d) in the proof\n",proof->variableType); exit(1); } for (i=0;iassignmentsNumber;i++) { fprintGappaAssignmentAsMaths(fd, proof->assignments[i]); } sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"# Definition of the relative arithmetical error\n"); switch (proof->resultType) { case 3: sollyaFprintf(fd,"epsilon = (%shml - M%s) / M%s;\n",proof->resultName,proof->resultName,proof->resultName); break; case 2: sollyaFprintf(fd,"epsilon = (%shm - M%s) / M%s;\n",proof->resultName,proof->resultName,proof->resultName); break; case 1: sollyaFprintf(fd,"epsilon = (%sh - M%s) / M%s;\n",proof->resultName,proof->resultName,proof->resultName); break; default: sollyaFprintf(stderr,"Error: fprintGappaProof: unknown result type (%d) in the proof\n",proof->resultType); exit(1); } sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"# Implication to prove\n"); if ((mpfr_sgn(proof->a) != mpfr_sgn(proof->b)) && (!mpfr_zero_p(proof->a)) && (!mpfr_zero_p(proof->b))) { sollyaFprintf(fd,"{(\n"); switch (proof->variableType) { case 3: sollyaFprintf(fd," %shml",proof->variableName); break; case 2: sollyaFprintf(fd," %shm",proof->variableName); break; case 1: sollyaFprintf(fd," %s",proof->variableName); break; default: sollyaFprintf(stderr,"Error: fprintGappaProof: unknown variable type (%d) in the proof\n",proof->variableType); exit(1); } sollyaFprintf(fd," in ["); fprintValue(fd, proof->a); sollyaFprintf(fd,","); fprintValue(fd, proof->b); sollyaFprintf(fd,"]\n"); sollyaFprintf(fd,"/\\ not "); switch (proof->variableType) { case 3: sollyaFprintf(fd," %shml",proof->variableName); break; case 2: sollyaFprintf(fd," %shm",proof->variableName); break; case 1: sollyaFprintf(fd," %s",proof->variableName); break; default: sollyaFprintf(stderr,"Error: fprintGappaProof: unknown variable type (%d) in the proof\n",proof->variableType); exit(1); } sollyaFprintf(fd," in ["); mpfr_set(temp, proof->a, GMP_RNDN); mpfr_div_2ui(temp,temp,400,GMP_RNDN); fprintValue(fd, temp); sollyaFprintf(fd,","); mpfr_set(temp, proof->b, GMP_RNDN); mpfr_div_2ui(temp,temp,400,GMP_RNDN); fprintValue(fd, temp); sollyaFprintf(fd,"]\n"); if (proof->variableType == 3) { sollyaFprintf(fd,"/\\ |overlap_%s| in [1b-400, 1b-52] # Verify the lower bound for the overlap interval\n",proof->variableName); sollyaFprintf(fd,"/\\ |%sml| in [1b-1021, 1b1023]\n",proof->variableName); } for (i=0;iassignmentsNumber;i++) { fprintGappaAssignmentAsOverlapBound(fd, proof->assignments[i]); } mpfr_init2(temp2, mpfr_get_prec(proof->eps)); mpfr_set_si(temp2, 1, GMP_RNDN); /* exact */ mpfr_div_2si(temp2, temp2, 50, GMP_RNDN); /* exact */ if (mpfr_cmpabs(proof->eps, temp2) > 0) { sollyaFprintf(fd,")\n->\n(\n epsilon in ["); mpfr_neg(temp2, proof->eps, GMP_RNDD); /* exact */ fprintValue(fd, temp2); sollyaFprintf(fd,","); fprintValue(fd, proof->eps); sollyaFprintf(fd,"]\n)}\n"); } else { sollyaFprintf(fd,")\n->\n(\n epsilon in ?\n)}\n"); } mpfr_clear(temp2); } else { sollyaFprintf(fd,"{(\n"); switch (proof->variableType) { case 3: sollyaFprintf(fd," %shml",proof->variableName); break; case 2: sollyaFprintf(fd," %shm",proof->variableName); break; case 1: sollyaFprintf(fd," %s",proof->variableName); break; default: sollyaFprintf(stderr,"Error: fprintGappaProof: unknown variable type (%d) in the proof\n",proof->variableType); exit(1); } sollyaFprintf(fd," in ["); fprintValue(fd, proof->a); sollyaFprintf(fd,","); fprintValue(fd, proof->b); sollyaFprintf(fd,"]\n"); if (proof->variableType == 3) { sollyaFprintf(fd,"/\\ |overlap_%s| in [1b-400, 1b-52] # Verify the lower bound for the overlap interval\n",proof->variableName); sollyaFprintf(fd,"/\\ |%sml| in [1b-1021, 1b1023]\n",proof->variableName); } for (i=0;iassignmentsNumber;i++) { fprintGappaAssignmentAsOverlapBound(fd, proof->assignments[i]); } sollyaFprintf(fd,")\n->\n(\n epsilon in ?\n)}\n"); } sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"# Hints and Meta-Hints for expansion decomposition\n"); switch (proof->variableType) { case 3: sollyaFprintf(fd,"%sh ~ %shm;\n",proof->variableName,proof->variableName); sollyaFprintf(fd,"%shm ~ %shml;\n",proof->variableName,proof->variableName); sollyaFprintf(fd,"%sm -> %sh * overlap_%s;\n",proof->variableName,proof->variableName,proof->variableName); sollyaFprintf(fd,"%sl / %sm -> - ((%sm - %sml) / %sml) / (1 + ((%sm - %sml) / %sml));\n", proof->variableName,proof->variableName,proof->variableName,proof->variableName, proof->variableName,proof->variableName,proof->variableName,proof->variableName); sollyaFprintf(fd,"(%shm - %shml) / %shml -> - (%sl / %sm) * (1 / (1 / overlap_%s + 1 + (%sl / %sm)));\n", proof->variableName,proof->variableName,proof->variableName,proof->variableName, proof->variableName,proof->variableName,proof->variableName,proof->variableName); sollyaFprintf(fd,"%sml -> %shml / ((1 + ((%sm - %sml) / %sml)) / overlap_%s + 1);\n", proof->variableName,proof->variableName,proof->variableName,proof->variableName, proof->variableName,proof->variableName); sollyaFprintf(fd,"(%sh - %shm) / %shm -> - 1 / (1 / overlap_%s + 1);\n", proof->variableName,proof->variableName,proof->variableName,proof->variableName); sollyaFprintf(fd,"%sh -> %shml / (overlap_%s / (1 + ((%sm - %sml) / %sml)) + 1);\n", proof->variableName,proof->variableName,proof->variableName,proof->variableName, proof->variableName,proof->variableName); break; case 2: sollyaFprintf(fd,"%sh ~ %shm;\n",proof->variableName,proof->variableName); break; case 1: break; default: sollyaFprintf(stderr,"Error: fprintGappaProof: unknown variable type (%d) in the proof\n",proof->variableType); exit(1); } sollyaFprintf(fd,"\n"); for (i=0;iassignmentsNumber;i++) { fprintGappaAssignmentAsHint(fd, proof->assignments[i]); } sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"# Meta-Hints for Horner scheme\n"); for (i=0;iassignmentsNumber;i++) { fprintGappaAssignmentAsMetaHint(fd, proof->assignments[i]); } sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"# Dichotomies for triple-double decomposition\n"); if (proof->variableType == 3) { sollyaFprintf(fd,"$ %shml in (0);\n",proof->variableName); sollyaFprintf(fd,"$ %sml in (0);\n",proof->variableName); sollyaFprintf(fd,"\n"); } for (i=0;iassignmentsNumber;i++) { fprintGappaAssignmentAsDichotomy(fd, proof->assignments[i]); } sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"# Dichotomy for the error bound\n"); sollyaFprintf(fd,"epsilon $ %s",proof->variableName); fprintExpansionSuffix(fd,proof->resultType); sollyaFprintf(fd,";\n\n"); mpfr_clear(temp); } sollya-6.0+ds/proof.h000066400000000000000000000134261300174114700145660ustar00rootroot00000000000000/* Copyright 2006-2013 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributor Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef PROOF_H #define PROOF_H #include #include "mpfi-compat.h" #include #include "expression.h" #include "chain.h" #define TAYLORPROOF 1 #define HOPITAL_ON_POINT 2 #define NUMERATOR_IS_ZERO 3 #define HOPITAL 4 #define IMPLICATION 5 #define DECORRELATE 6 #define MONOTONOCITY 7 typedef struct exprBoundTheoStruct exprBoundTheo; struct exprBoundTheoStruct { node *function; int functionType; sollya_mpfi_t *x; sollya_mpfi_t *boundLeft; sollya_mpfi_t *boundRight; sollya_mpfi_t *y; exprBoundTheo *theoLeft; exprBoundTheo *theoRight; int simplificationUsed; node *leftDerivative; node *rightDerivative; sollya_mpfi_t *xZ; sollya_mpfi_t *xMXZ; exprBoundTheo *theoLeftConstant; exprBoundTheo *theoRightConstant; sollya_mpfi_t *boundLeftConstant; sollya_mpfi_t *boundRightConstant; exprBoundTheo *theoLeftLinear; exprBoundTheo *theoRightLinear; sollya_mpfi_t *boundLeftLinear; sollya_mpfi_t *boundRightLinear; int number; }; typedef struct equalityTheoStruct equalityTheo; struct equalityTheoStruct { node *expr1; node *expr2; int number; }; typedef struct noZeroTheoStruct noZeroTheo; struct noZeroTheoStruct { node *function; node *derivative; equalityTheo *funcEqual; equalityTheo *derivEqual; chain *exprBoundTheos; int number; }; typedef struct infnormTheoStruct infnormTheo; struct infnormTheoStruct { node *function; sollya_mpfi_t *domain; sollya_mpfi_t *infnorm; node *derivative; node *numeratorOfDerivative; node *derivativeOfNumeratorOfDerivative; chain *excludedIntervals; noZeroTheo *noZeros; exprBoundTheo *evalLeftBound; exprBoundTheo *evalRightBound; chain *evalOnZeros; int number; }; #define GAPPA_CONST 1 #define GAPPA_ADD_EXACT 2 #define GAPPA_MUL_EXACT 3 #define GAPPA_ADD_DOUBLE 4 #define GAPPA_MUL_DOUBLE 5 #define GAPPA_RENORMALIZE 6 #define GAPPA_ADD_REL 7 #define GAPPA_MUL_REL 8 #define GAPPA_FMA_REL 9 #define GAPPA_COPY 10 typedef struct gappaAssignmentStruct gappaAssignment; struct gappaAssignmentStruct { int opType; int relErrBits; int resultType; int resultOverlap; char *resultVariable; int operand1UsedType; int operand1ComingType; char *operand1Variable; int operand2UsedType; int operand2ComingType; char *operand2Variable; int operand3UsedType; int operand3ComingType; char *operand3Variable; double constHi; double constMi; double constLo; }; typedef struct gappaProofStruct gappaProof; struct gappaProofStruct { char *variableName; char *resultName; mpfr_t a, b, eps; int variableType; int resultType; node *polynomToImplement; node *polynomImplemented; int assignmentsNumber; gappaAssignment **assignments; }; int fprintExprBoundTheo(FILE *fd, exprBoundTheo *theo, int start); void freeExprBoundTheo(exprBoundTheo *theo); void nullifyExprBoundTheo(exprBoundTheo *theo); int fprintNoZeroTheo(FILE *fd, noZeroTheo *theo, int start); void freeNoZeroTheo(noZeroTheo *theo); int fprintInfnormTheo(FILE *fd, infnormTheo *theo, int start); void freeInfnormTheo(infnormTheo *theo); gappaAssignment *newGappaOperation(int opType, int relErrBits, int resultType, int resultOverlap, char *resultVariable, int operand1UsedType, int operand1ComingType, char *operand1Variable, int operand2UsedType, int operand2ComingType, char *operand2Variable); gappaAssignment *newGappaConstant(int resultType, char *resultVariable, double constHi, double constMi, double constLo); void freeGappaProof(gappaProof *proof); void fprintGappaProof(FILE *fd, gappaProof *proof); #endif /* ifdef PROOF_H*/ sollya-6.0+ds/remez.c000066400000000000000000002604451300174114700145630ustar00rootroot00000000000000/* Copyright 2006-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also herefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include "chain.h" #include "general.h" #include "infnorm.h" #include "execute.h" #include "remez.h" #include /* fprintf, fopen, fclose, */ #include /* exit, free, mktemp */ #include #define coeff(i,j,n) ((i)-1)*(n)+(j)-1 #define NEWTON_STEPS 2 void myPrintValue(mpfr_t *x, mp_prec_t prec) { mpfr_t y; mpfr_init2(y,prec); mpfr_set(y,*x,GMP_RNDN); printValue(&y); mpfr_clear(y); } void printMatrix(mpfr_t *M, int n) { int i,j; sollyaPrintf("["); for(i=1;i<=n;i++) { for(j=1;j<=n;j++) { myPrintValue(&M[coeff(i,j,n)],53); if(j!=n) sollyaPrintf(", "); } if(i!=n) sollyaPrintf(";\n"); } sollyaPrintf("]\n"); return; } void printMessageMatrix(int verb, mpfr_t *M, int n) { int i,j; printMessage(verb,SOLLYA_MSG_CONTINUATION,"["); for(i=1;i<=n;i++) { for(j=1;j<=n;j++) { printMessage(verb,SOLLYA_MSG_CONTINUATION,"%.15v",M[coeff(i,j,n)]); if(j!=n) printMessage(verb,SOLLYA_MSG_CONTINUATION,", "); } if(i!=n) printMessage(verb,SOLLYA_MSG_CONTINUATION,";\n"); } printMessage(verb,SOLLYA_MSG_CONTINUATION,"]\n"); return; } void system_solve(mpfr_t *res, mpfr_t *M, mpfr_t *b, int n, mp_prec_t prec) { chain *i_list=NULL; chain *j_list=NULL; chain *curri; chain *currj; int i0, j0, i, j, k; int *var; mpfr_t max,lambda; int *order_i = safeMalloc(n*sizeof(int)); int *order_j = safeMalloc(n*sizeof(int)); mpfr_init2(max, 53); mpfr_init2(lambda, prec); for(i=1;i<=n;i++) { var = safeMalloc(sizeof(int)); *var = i; i_list = addElement(i_list, (void *)var); } for(j=1;j<=n;j++) { var = safeMalloc(sizeof(int)); *var = j; j_list = addElement(j_list, (void *)var); } /* Triangulation by Gaussian elimination */ i0 = j0 = -1; for(k=1;k<=n;k++) { mpfr_set_d(max, 0., GMP_RNDN); /* exact */ /* In this part, we search for the bigger element of the matrix */ curri = i_list; while(curri!=NULL) { currj = j_list; while(currj!=NULL) { i = *(int *)(curri->value); j = *(int *)(currj->value); if(mpfr_cmpabs(M[coeff(i,j,n)],max)>=0) { i0 = i; j0 = j; mpfr_set(max, M[coeff(i,j,n)], GMP_RNDN); } currj = currj->next; } curri = curri->next; } i_list = removeInt(i_list, i0); j_list = removeInt(j_list, j0); order_i[k-1] = i0; order_j[k-1] = j0; /* Here we update the matrix and the second member */ curri = i_list; while(curri!=NULL) { i = *(int *)(curri->value); mpfr_div(lambda, M[coeff(i,j0,n)], M[coeff(i0,j0,n)], GMP_RNDN); mpfr_neg(lambda, lambda, GMP_RNDN); currj = j_list; while(currj!=NULL) { j = *(int *)(currj->value); mpfr_fma(M[coeff(i,j,n)], lambda, M[coeff(i0,j,n)], M[coeff(i,j,n)], GMP_RNDN); currj = currj->next; } mpfr_fma(b[i-1], lambda, b[i0-1], b[i-1], GMP_RNDN); mpfr_set_d(M[coeff(i,j0,n)], 0., GMP_RNDN); /* this line is not useful strictly speaking */ curri = curri->next; } } /*********************************************************************/ /* Resolution of the system itself */ for(i=1;i<=n;i++) { var = safeMalloc(sizeof(int)); *var = i; i_list = addElement(i_list, (void *)var); } for(k=n;k>=1;k--) { i0 = order_i[k-1]; j0 = order_j[k-1]; mpfr_div(res[j0-1], b[i0-1], M[coeff(i0,j0,n)], GMP_RNDN); i_list = removeInt(i_list, i0); curri = i_list; while(curri!=NULL) { i = *(int *)(curri->value); mpfr_neg(M[coeff(i,j0,n)], M[coeff(i,j0,n)], GMP_RNDN); mpfr_fma(b[i-1], M[coeff(i,j0,n)], res[j0-1], b[i-1], GMP_RNDN); curri=curri->next; } } safeFree(order_i); safeFree(order_j); freeChain(i_list, freeIntPtr); freeChain(j_list, freeIntPtr); mpfr_clear(max); mpfr_clear(lambda); return; } /* Bubble sort */ void mpfr_sort(mpfr_t *vect, int n, mp_prec_t prec) { int i,j; mpfr_t var; mpfr_init2(var, prec); for(i=1;i<=n-1;i++) { for(j=n;j>=i+1;j--) { if(mpfr_cmp(vect[j-1], vect[j-2])<=0) { mpfr_set(var, vect[j-1], GMP_RNDN); mpfr_set(vect[j-1], vect[j-2], GMP_RNDN); mpfr_set(vect[j-2], var, GMP_RNDN); } } } mpfr_clear(var); return; } /* Constructs the tree corresponding to p = sum(coeff(i) X^monomials[i]) The array coeff is supposed to have at least as many elements as monomials */ node *constructPolynomial(mpfr_t *coeff, chain *monomials, mp_prec_t prec) { int i=1; int n; chain *curr; node *poly; UNUSED_PARAM(prec); poly = makeConstantDouble(0.0); curr = monomials; while(curr != NULL) { n = *((int *)(curr->value)); poly = makeAdd( makeMul( makeConstant(coeff[i-1]), makePow(makeVariable(), makeConstantInt(n)) ), poly ); i++; curr = curr->next; } return addMemRef(poly); } /* This function finds an approximate zero of a function f (which derivative is f_diff) in the interval [a;b] using x0 as an initial guess of the zero If n=0 the algorithm stops when the computed zero is an estimation of the real zero, with an accuracy of approximately prec bits. If n<>0, n steps are computed. The algorithm uses Newton's method. It is assumed that f(a)f(b)<=0 and x0 in [a;b] If x0=NULL the algorithm is free to use any initial guess */ void findZero(mpfr_t res, node *f, node *f_diff, mpfr_t a, mpfr_t b, int sgnfa, mpfr_t *x0, int n, mp_prec_t prec) { /* Sketch of the algorithm : During the algorithm, we will work with an interval [u,v] that surely contains a zero of f. Whenever a step of Newton's algorithm does not work, we perform a bisection step on [u,v] to ensure the convergence of the algorithm. 1) It is necessary that [u,v] does not contain 0. This ensures that the range of possible exponents for x is bounded. So, if 0 f(0)=0 exactly ( 0 * * ) -> f(epsa)=0 exactly ( * * 0 ) -> f(epsb)=0 exactly (-sgnfa * * ) -> we can set [u,v] = [a, epsa] (note that epsa<0 in this case) ( * * sgnfa) -> we can set [u,v] = [epsb, b] (note that epsb>0 in this case) ( * sgnfa -sgnfa) -> f changes its sign in [0,epsb] but f(0) != 0. The zero of f cannot be determined accurately. We can return epsb for instance with an error message. ( sgnfa -sgnfa * ) -> idem with [epsa,0] ( sgnfa NaN -sgnfa) -> f changes its sign in [epsa, epsb]. It is likely that f(0)=0 but we cannot prove it. We can return 0 with an error message. ( sgnfa NaN NaN ) -> This case is likely to be b=0 (hence epsb=0) We cannot prove much but it is reasonnable to return 0 ( NaN NaN -sgnfa) -> idem with a=0 ( NaN NaN NaN ) -> idem with a=0=b ( * sgnfa NaN ) -> We are really in trouble here since f(0) is provably non zero but we do not know if f vanishes in [0,epsb] or [epsb, b]. We should better stop with a huge ERROR ( NaN -sgnfa * ) -> idem with [a, epsa] or [epsa, 0] 2) Now we are sure that [u,v] does not contain 0. During the algorithm, we will consider an approximation x of the zero z of f. From x, we compute a new approximation xNew. We assume that xNew is a very good approximation of z. Thus we can estimate the relative error between x and z by |xNew-x|/|xNew|. If this error is smaller than 2^(-prec), x is an accurate estimation of z and a fortiori xNew is accurate as well. Let x be somewhere in [u,v] (in the beginning, x=x0 if x0 is defined and lies in [u,v]). We compute xNew = iterator(x) = x - f(x)/f'(x) If (xNewv) or xNew=NaN, we perform a bisection step: replaced by either [u, m] of [m, u] where m=(u+v)/2 and xNew is defined as the middle of the new interval Otherwise: xNew gives a valid new value. We compute yNew=f(xNew). We have 4 cases depending on sgn(yNew): sgnfa -> we can replace [u,v] by [xNew,v] -sgnfa -> we can replace [u,v] by [u, xNew] 0 -> xNew is an exact zero of f. We can stop NaN -> we leave [u,v] as is. Most likely the iterator(xNew) will be NaN and the next step will be a bisection step. */ mpfr_t zero_mpfr, cutoff; mpfr_t u, v, epsa, fepsa, epsb, fepsb, f0; int sgnfepsa, sgnfepsb, sgnf0; int codefa, codeNegfa; int stop_algo = 0; int skip_step1 = 0; mp_prec_t prec_bounds; int r; node *iterator; node *temp; mpfr_t x, xNew, yNew, tmp_mpfr; int estim_prec, estim_prec2; int nbr_iter; /* Make compiler happy: */ estim_prec = 12; nbr_iter = 2; /* End of compiler happiness */ if (x0 != NULL) { printMessage(8,SOLLYA_MSG_ENTERING_NEWTONS_ALGORITHM,"Information (Newton's algorithm): entering in Newton's algorithm. Parameters are:\nInformation (Newton's algorithm): f = %b\nInformation (Newton's algorithm): a = %v\nInformation (Newton's algorithm): b = %v\nInformation (Newton's algorithm): x0 = %v\n",f,a,b,*x0); } else { printMessage(8,SOLLYA_MSG_ENTERING_NEWTONS_ALGORITHM,"Information (Newton's algorithm): entering in Newton's algorithm. Parameters are:\nInformation (Newton's algorithm): f = %b\nInformation (Newton's algorithm): a = %v\nInformation (Newton's algorithm): b = %v\n",f,a,b); } prec_bounds = (mpfr_get_prec(a)>mpfr_get_prec(b)) ? mpfr_get_prec(a) : mpfr_get_prec(b); if (prec>prec_bounds) prec_bounds = prec; mpfr_init2(u, prec_bounds); mpfr_init2(v, prec_bounds); mpfr_init2(zero_mpfr, prec); mpfr_init2(cutoff, 12); mpfr_set_si(zero_mpfr, 0, GMP_RNDN); mpfr_set_si(cutoff, 0, GMP_RNDN); if ( (mpfr_cmp_ui(a,0)>0) || mpfr_cmp_ui(b,0)<0 ) { mpfr_set(u, a, GMP_RNDU); /* exact */ mpfr_set(v, b, GMP_RNDD); /* exact */ skip_step1 = 1; } /************** STEP 1 : removing zero from the range **************/ if (!skip_step1) { mpfr_init2(epsa, prec); mpfr_init2(epsb, prec); mpfr_init2(fepsa, 12); mpfr_init2(fepsb, 12); mpfr_init2(f0, 12); mpfr_set_si(epsa, -1, GMP_RNDU); mpfr_div_2ui(epsa, epsa, 2*prec, GMP_RNDU); if (mpfr_cmp(a,epsa)>0) mpfr_set(epsa, a, GMP_RNDU); mpfr_set_si(epsb, 1, GMP_RNDD); mpfr_div_2ui(epsb, epsb, 2*prec, GMP_RNDD); if (mpfr_cmp(epsb,b)>0) mpfr_set(epsb, b, GMP_RNDD); /* For the signs, we use the following convention: 0 is coded by 0 1 is coded by 1 -1 is coded by 2 NaN is coded by 3 */ r = evaluateFaithfulWithCutOffFast(fepsa, f, f_diff, epsa, cutoff, prec); if(r==0) mpfr_set_d(fepsa,0,GMP_RNDN); if (!mpfr_number_p(fepsa)) sgnfepsa = 3; else { sgnfepsa = mpfr_sgn(fepsa); if (sgnfepsa!=0) sgnfepsa = (sgnfepsa>0) ? 1 : 2; } r = evaluateFaithfulWithCutOffFast(f0, f, f_diff, zero_mpfr, cutoff, prec); if(r==0) mpfr_set_d(f0,0,GMP_RNDN); if (!mpfr_number_p(f0)) sgnf0 = 3; else { sgnf0 = mpfr_sgn(f0); if (sgnf0!=0) sgnf0 = (sgnf0>0) ? 1 : 2; } r = evaluateFaithfulWithCutOffFast(fepsb, f, f_diff, epsb, cutoff, prec); if(r==0) mpfr_set_d(fepsb,0,GMP_RNDN); if (!mpfr_number_p(fepsb)) sgnfepsb = 3; else { sgnfepsb = mpfr_sgn(fepsb); if (sgnfepsb!=0) sgnfepsb = (sgnfepsb>0) ? 1 : 2; } if (sgnfa>0) { codefa = 1; codeNegfa = 2; } else { codefa = 2; codeNegfa = 1; } if ( ((sgnfepsa==0) && (sgnf0==0) && (sgnfepsb==0)) || ((sgnfepsa==1) && (sgnf0==0) && (sgnfepsb==0)) || ((sgnfepsa==2) && (sgnf0==0) && (sgnfepsb==0)) || ((sgnfepsa==3) && (sgnf0==0) && (sgnfepsb==0)) || ((sgnfepsa==0) && (sgnf0==0) && (sgnfepsb==1)) || ((sgnfepsa==1) && (sgnf0==0) && (sgnfepsb==1)) || ((sgnfepsa==2) && (sgnf0==0) && (sgnfepsb==1)) || ((sgnfepsa==3) && (sgnf0==0) && (sgnfepsb==1)) || ((sgnfepsa==0) && (sgnf0==0) && (sgnfepsb==2)) || ((sgnfepsa==1) && (sgnf0==0) && (sgnfepsb==2)) || ((sgnfepsa==2) && (sgnf0==0) && (sgnfepsb==2)) || ((sgnfepsa==3) && (sgnf0==0) && (sgnfepsb==2)) || ((sgnfepsa==0) && (sgnf0==0) && (sgnfepsb==3)) || ((sgnfepsa==1) && (sgnf0==0) && (sgnfepsb==3)) || ((sgnfepsa==2) && (sgnf0==0) && (sgnfepsb==3)) || ((sgnfepsa==3) && (sgnf0==0) && (sgnfepsb==3)) ) { printMessage(5, SOLLYA_MSG_NEWTON_ZERO_IS_EXACT_ZERO, "Information (Newton's algorithm): 0 is an exact 0.\n"); mpfr_set(res, zero_mpfr, GMP_RNDN); stop_algo = 1; } if ( ((sgnfepsa==0) && (sgnf0==1) && (sgnfepsb==0)) || ((sgnfepsa==0) && (sgnf0==2) && (sgnfepsb==0)) || ((sgnfepsa==0) && (sgnf0==3) && (sgnfepsb==0)) || ((sgnfepsa==0) && (sgnf0==1) && (sgnfepsb==1)) || ((sgnfepsa==0) && (sgnf0==2) && (sgnfepsb==1)) || ((sgnfepsa==0) && (sgnf0==3) && (sgnfepsb==1)) || ((sgnfepsa==0) && (sgnf0==1) && (sgnfepsb==2)) || ((sgnfepsa==0) && (sgnf0==2) && (sgnfepsb==2)) || ((sgnfepsa==0) && (sgnf0==3) && (sgnfepsb==2)) || ((sgnfepsa==0) && (sgnf0==1) && (sgnfepsb==3)) || ((sgnfepsa==0) && (sgnf0==2) && (sgnfepsb==3)) || ((sgnfepsa==0) && (sgnf0==3) && (sgnfepsb==3)) ) { printMessage(5, SOLLYA_MSG_NEWTON_AN_EXACT_ZERO_HAS_BEEN_FOUND, "Information (Newton's algorithm): an exact 0 has been discovered.\n"); mpfr_set(res, epsa, GMP_RNDN); stop_algo = 1; } if ( ((sgnfepsa==1) && (sgnf0==1) && (sgnfepsb==0)) || ((sgnfepsa==2) && (sgnf0==1) && (sgnfepsb==0)) || ((sgnfepsa==3) && (sgnf0==1) && (sgnfepsb==0)) || ((sgnfepsa==1) && (sgnf0==2) && (sgnfepsb==0)) || ((sgnfepsa==2) && (sgnf0==2) && (sgnfepsb==0)) || ((sgnfepsa==3) && (sgnf0==2) && (sgnfepsb==0)) || ((sgnfepsa==1) && (sgnf0==3) && (sgnfepsb==0)) || ((sgnfepsa==2) && (sgnf0==3) && (sgnfepsb==0)) || ((sgnfepsa==3) && (sgnf0==3) && (sgnfepsb==0)) ) { printMessage(5, SOLLYA_MSG_NEWTON_AN_EXACT_ZERO_HAS_BEEN_FOUND, "Information (Newton's algorithm): an exact 0 has been discovered.\n"); mpfr_set(res, epsb, GMP_RNDN); stop_algo = 1; } /* The cases (-sngfa, * *) and (* * sgnfa) can be separated into subcases : */ if ((sgnfepsa==codeNegfa) && (sgnf0==3) && (sgnfepsb==codefa)) { printMessage(4, SOLLYA_MSG_NEWTON_FUNC_APPEARS_TO_HAVE_MORE_THAN_ONE_ZERO, "Warning (Newton's algorithm): the function has more than one zero in the interval.\n"); printMessage(4, SOLLYA_MSG_CONTINUATION, "Warning (Newton's algorithm): 0 seems to be one of them but wa cannot prove it.\n"); mpfr_set(res, zero_mpfr, GMP_RNDN); stop_algo = 1; } if ((sgnfepsa==codeNegfa) && (sgnf0==codefa) && (sgnfepsb==codefa)) { printMessage(4, SOLLYA_MSG_NEWTON_FUNC_APPEARS_TO_HAVE_MORE_THAN_ONE_ZERO, "Warning (Newton's algorithm): the function has more than one zero in the interval.\n"); printMessage(4, SOLLYA_MSG_CONTINUATION, "Warning (Newton's algorithm): one of them is too close to zero for being accurately determined.\n"); mpfr_set(res, epsa, GMP_RNDU); stop_algo = 1; } if ((sgnfepsa==codeNegfa) && (sgnf0==codeNegfa) && (sgnfepsb==codefa)) { printMessage(4, SOLLYA_MSG_NEWTON_FUNC_APPEARS_TO_HAVE_MORE_THAN_ONE_ZERO, "Warning (Newton's algorithm): the function has more than one zero in the interval.\n"); printMessage(4, SOLLYA_MSG_CONTINUATION, "Warning (Newton's algorithm): one of them is too close to zero for being accurately determined.\n"); mpfr_set(res, epsb, GMP_RNDD); stop_algo = 1; } if ( ((sgnfepsa==codeNegfa) && (sgnf0==1) && (sgnfepsb==codeNegfa)) || ((sgnfepsa==codeNegfa) && (sgnf0==2) && (sgnfepsb==codeNegfa)) || ((sgnfepsa==codeNegfa) && (sgnf0==3) && (sgnfepsb==codeNegfa)) || ((sgnfepsa==codeNegfa) && (sgnf0==1) && (sgnfepsb==3)) || ((sgnfepsa==codeNegfa) && (sgnf0==2) && (sgnfepsb==3)) || ((sgnfepsa==codeNegfa) && (sgnf0==3) && (sgnfepsb==3)) ) { mpfr_set(u, a, GMP_RNDD); mpfr_set(v, epsa, GMP_RNDU); } if ( ((sgnfepsa==codefa) && (sgnf0==1) && (sgnfepsb==codefa)) || ((sgnfepsa==codefa) && (sgnf0==2) && (sgnfepsb==codefa)) || ((sgnfepsa==codefa) && (sgnf0==3) && (sgnfepsb==codefa)) || ((sgnfepsa==3) && (sgnf0==1) && (sgnfepsb==codefa)) || ((sgnfepsa==3) && (sgnf0==2) && (sgnfepsb==codefa)) || ((sgnfepsa==3) && (sgnf0==3) && (sgnfepsb==codefa)) ) { mpfr_set(u, epsb, GMP_RNDD); mpfr_set(v, b, GMP_RNDU); } /* End of the subcases */ if ( ((sgnfepsa==codefa) && (sgnf0==codefa) && (sgnfepsb==codeNegfa)) || ((sgnfepsa==3) && (sgnf0==codefa) && (sgnfepsb==codeNegfa)) ) { printMessage(2, SOLLYA_MSG_NEWTON_ZERO_TOO_CLOSE_TO_ZERO_TO_BE_ACCURATE, "Warning (Newton's algorithm): the zero of f is too close to zero for being accurately determined.\n"); mpfr_set(res, epsb, GMP_RNDN); stop_algo = 1; } if ( ((sgnfepsa==codefa) && (sgnf0==codeNegfa) && (sgnfepsb==codeNegfa)) || ((sgnfepsa==codefa) && (sgnf0==codeNegfa) && (sgnfepsb==3)) ) { printMessage(2, SOLLYA_MSG_NEWTON_ZERO_TOO_CLOSE_TO_ZERO_TO_BE_ACCURATE, "Warning (Newton's algorithm): the zero of f is too close to zero for being accurately determined.\n"); mpfr_set(res, epsa, GMP_RNDN); stop_algo = 1; } if ((sgnfepsa==codefa) && (sgnf0==3) && (sgnfepsb==codeNegfa)) { printMessage(2, SOLLYA_MSG_NEWTON_ZERO_SEEMS_TO_BE_ZERO_NO_PROOF, "Warning (Newton's algorithm): 0 seems to be an exact zero but we cannot prove it.\n"); mpfr_set(res, zero_mpfr, GMP_RNDN); stop_algo = 1; } if ((sgnfepsa==codefa) && (sgnf0==3) && (sgnfepsb==3)) { if (mpfr_cmp_ui(b,0)==0) { printMessage(2, SOLLYA_MSG_NEWTON_ZERO_SEEMS_TO_BE_ZERO_NO_PROOF, "Warning (Newton's algorithm): 0 seems to be an exact zero but we cannot prove it.\n"); mpfr_set(res, zero_mpfr, GMP_RNDN); stop_algo = 1; } else { printMessage(0, SOLLYA_MSG_NEWTON_ALGORITHM_FAILS_DUE_TO_NUMERICAL_ISSUES, "Error (Newton's algorithm): numerical problems have been encountered. Failed.\n"); mpfr_set_nan(res); stop_algo = 1; } } if ((sgnfepsa==3) && (sgnf0==3) && (sgnfepsb==codeNegfa)) { if (mpfr_cmp_ui(a,0)==0) { printMessage(2, SOLLYA_MSG_NEWTON_ZERO_SEEMS_TO_BE_ZERO_NO_PROOF, "Warning (Newton's algorithm): 0 seems to be an exact zero but we cannot prove it.\n"); mpfr_set(res, zero_mpfr, GMP_RNDN); stop_algo = 1; } else { printMessage(0, SOLLYA_MSG_NEWTON_ALGORITHM_FAILS_DUE_TO_NUMERICAL_ISSUES, "Error (Newton's algorithm): numerical problems have been encountered. Failed.\n"); mpfr_set_nan(res); stop_algo = 1; } } if ((sgnfepsa==3) && (sgnf0==3) && (sgnfepsb==3)) { if ( (mpfr_cmp_ui(a,0)==0)&&(mpfr_cmp_ui(b,0)==0) ) { printMessage(2, SOLLYA_MSG_NEWTON_ZERO_SEEMS_TO_BE_ZERO_NO_PROOF, "Warning (Newton's algorithm): 0 seems to be an exact zero but we cannot prove it.\n"); mpfr_set(res, zero_mpfr, GMP_RNDN); stop_algo = 1; } else { printMessage(0, SOLLYA_MSG_NEWTON_ALGORITHM_FAILS_DUE_TO_NUMERICAL_ISSUES, "Error (Newton's algorithm): numerical problems have been encountered. Failed.\n"); mpfr_set_nan(res); stop_algo = 1; } } if ( ((sgnfepsa==codefa) && (sgnf0==codefa) && (sgnfepsb==3)) || ((sgnfepsa==3) && (sgnf0==codefa) && (sgnfepsb==3)) ) { printMessage(0, SOLLYA_MSG_NEWTON_ALGORITHM_FAILS_TO_LOCATE_ZERO, "Error (Newton's algorithm): failed to locate the zero\n"); mpfr_set_nan(res); stop_algo = 1; } if ( ((sgnfepsa==3) && (sgnf0==codeNegfa) && (sgnfepsb==codeNegfa)) || ((sgnfepsa==3) && (sgnf0==codeNegfa) && (sgnfepsb==3)) ) { printMessage(0, SOLLYA_MSG_NEWTON_ALGORITHM_FAILS_TO_LOCATE_ZERO, "Error (Newton's algorithm): failed to locate the zero\n"); mpfr_set_nan(res); stop_algo = 1; } mpfr_clear(epsa); mpfr_clear(epsb); mpfr_clear(fepsa); mpfr_clear(fepsb); mpfr_clear(f0); } /*************************************************************************/ /************** STEP 2 : iterating Newton's algorithm **************/ if (!stop_algo) { mpfr_init2(x, prec); mpfr_init2(xNew, prec); mpfr_init2(yNew, 12); mpfr_init2(tmp_mpfr, 53); if(x0!=NULL) mpfr_set(x,*x0,GMP_RNDN); else { mpfr_add(x, u, v, GMP_RNDU); mpfr_div_2ui(x, x, 1, GMP_RNDN); } iterator = safeMalloc(sizeof(node)); iterator->nodeType = SUB; temp = safeMalloc(sizeof(node)); temp->nodeType = VARIABLE; iterator->child1 = addMemRef(temp); temp = safeMalloc(sizeof(node)); temp->nodeType = DIV; temp->child1 = copyTree(f); temp->child2 = copyTree(f_diff); iterator->child2 = addMemRef(temp); iterator = addMemRef(iterator); temp = simplifyTreeErrorfree(iterator); free_memory(iterator); iterator = temp; /* Main loop */ nbr_iter = 0; while(!stop_algo) { /* TODO: here we might adapt the precision of xNew by doubling it at each step */ r = evaluateFaithfulWithCutOffFast(xNew, iterator, NULL, x, cutoff, prec); if(r==0) mpfr_set_d(xNew,0,GMP_RNDN); if ( ((mpfr_cmp(u, x)==0) && (mpfr_cmp(v, xNew)==0)) || ((mpfr_cmp(v, x)==0) && (mpfr_cmp(u, xNew)==0)) ) { printMessage(5, SOLLYA_MSG_NEWTON_PERFORMING_BISECTION_STEP, "Information (Newton's algorithm): performing a bisection step\n"); mpfr_add(xNew, u, v, GMP_RNDN); mpfr_div_2ui(xNew, xNew, 1, GMP_RNDN); } if( (mpfr_cmp(u,xNew)>0) || (mpfr_cmp(xNew,v)>0) || (!mpfr_number_p(xNew)) ) { printMessage(5, SOLLYA_MSG_NEWTON_PERFORMING_BISECTION_STEP, "Information (Newton's algorithm): performing a bisection step\n"); mpfr_add(xNew,u,v,GMP_RNDN); mpfr_div_2ui(xNew, xNew, 1, GMP_RNDN); if (mpfr_cmp(x, xNew)==0) { printMessage(5, SOLLYA_MSG_NEWTON_PERFORMING_TRISECTION_STEP, "Warning (Newton's algorithm): performing a trisection step.\n"); mpfr_sub(xNew,v,u,GMP_RNDN); mpfr_div_ui(xNew, xNew, 3, GMP_RNDN); mpfr_add(xNew, u, xNew, GMP_RNDN); } } r = evaluateFaithfulWithCutOffFast(yNew, f, f_diff, xNew, cutoff, prec); /* yNew=f[xNew] */ if(r==0) mpfr_set_d(yNew, 0, GMP_RNDN); if (mpfr_number_p(yNew)) { if (mpfr_cmp_ui(yNew, 0)==0) { printMessage(5, SOLLYA_MSG_NEWTON_AN_EXACT_ZERO_HAS_BEEN_FOUND, "Information (Newton's algorithm): an exact 0 has been discovered.\n"); mpfr_set(res, xNew, GMP_RNDN); stop_algo = 1; } else { if (mpfr_cmp_ui(yNew, 0)*sgnfa>0) mpfr_set(u, xNew, GMP_RNDN); else mpfr_set(v, xNew, GMP_RNDN); } } mpfr_sub(tmp_mpfr, xNew, x, GMP_RNDU); if (!mpfr_zero_p(tmp_mpfr)) estim_prec= 1 + mpfr_get_exp(xNew) - mpfr_get_exp(tmp_mpfr); mpfr_sub(tmp_mpfr,v,u,GMP_RNDN); if(mpfr_cmp_abs(v,u)>0) estim_prec2 = 1 + mpfr_get_exp(u) - mpfr_get_exp(tmp_mpfr); else estim_prec2 = 1 + mpfr_get_exp(v) - mpfr_get_exp(tmp_mpfr); if(estim_prec2 > estim_prec) estim_prec = estim_prec2; nbr_iter++; if ( ((n!=0) && (nbr_iter==n)) || mpfr_equal_p(x,xNew) || (estim_prec>(int)prec)) { mpfr_set(res, xNew, GMP_RNDN); stop_algo=1; } mpfr_set(x,xNew,GMP_RNDN); } free_memory(iterator); mpfr_clear(x); mpfr_clear(xNew); mpfr_clear(yNew); mpfr_clear(tmp_mpfr); } /*************************************************************************/ printMessage(7, SOLLYA_MSG_NEWTON_FINISHED_AFTER_NUMBER_OF_STEPS, "Information (Newton's algorithm): finished after %d steps.\n", nbr_iter); printMessage(8, SOLLYA_MSG_CONTINUATION, "Information (Newton's algorithm): x = %v\n",res); mpfr_clear(zero_mpfr); mpfr_clear(cutoff); mpfr_clear(u); mpfr_clear(v); return; } /* Just a wrapper */ void newton(mpfr_t res, node *f, node *f_diff, mpfr_t a, mpfr_t b, int sgnfa, mp_prec_t prec) { findZero(res, f, f_diff, a, b, sgnfa, NULL, 0, prec); return; } /* Finds the zeros of a function on an interval. */ chain *uncertifiedFindZeros(node *tree, mpfr_t a, mpfr_t b, unsigned long int points, mp_prec_t prec) { mpfr_t cutoff, h, x1, x2, y1, y2; mpfr_t *temp; node *diff_tree; chain *result=NULL; mpfr_init2(h,prec); mpfr_init2(y1,prec); mpfr_init2(y2,prec); mpfr_init2(x1,prec); mpfr_init2(x2,prec); mpfr_init2(cutoff,12); diff_tree = differentiate(tree); mpfr_set_si(cutoff, 0, GMP_RNDN); mpfr_sub(h,b,a,GMP_RNDD); mpfr_div_si(h,h,points,GMP_RNDD); mpfr_set(x1,b,GMP_RNDN); mpfr_sub(x2,b,h,GMP_RNDD); evaluateFaithfulWithCutOffFast(y1, tree, diff_tree, x1, cutoff, prec); evaluateFaithfulWithCutOffFast(y2, tree, diff_tree, x2, cutoff, prec); /* Little trick: if a=b, h=0, thus x1=x2=a=b */ /* By doing this, we avoid entering the loop */ if(mpfr_equal_p(a,b)) { mpfr_nextbelow(x2); } while(mpfr_greaterequal_p(x2,a)) { if((mpfr_sgn(y1)==0) || (mpfr_sgn(y2)==0) || (mpfr_sgn(y1) != mpfr_sgn(y2))) { if (mpfr_sgn(y1)==0) { temp = safeMalloc(sizeof(mpfr_t)); mpfr_init2(*temp, prec); mpfr_set(*temp, x1, GMP_RNDN); result = addElement(result, temp); } else { if (mpfr_sgn(y2)!=0) { temp = safeMalloc(sizeof(mpfr_t)); mpfr_init2(*temp, prec); newton(*temp, tree, diff_tree, x2, x1, mpfr_sgn(y2), prec); result = addElement(result, temp); } } } mpfr_set(x1,x2,GMP_RNDN); mpfr_sub(x2,x2,h,GMP_RNDD); mpfr_set(y1,y2,GMP_RNDN); evaluateFaithfulWithCutOffFast(y2, tree, diff_tree, x2, cutoff, prec); } if(! mpfr_equal_p(x1,a)) { mpfr_set(x2,a,GMP_RNDU); evaluateFaithfulWithCutOffFast(y2, tree, diff_tree, x2, cutoff, prec); if (mpfr_sgn(y1)==0) { temp = safeMalloc(sizeof(mpfr_t)); mpfr_init2(*temp, prec); mpfr_set(*temp, x1, GMP_RNDN); result = addElement(result, temp); } if (mpfr_sgn(y2)==0) { temp = safeMalloc(sizeof(mpfr_t)); mpfr_init2(*temp, prec); mpfr_set(*temp, x2, GMP_RNDN); result = addElement(result, temp); } if( (mpfr_sgn(y1)!=0) && (mpfr_sgn(y2)!=0) && (mpfr_sgn(y1) != mpfr_sgn(y2)) ) { temp = safeMalloc(sizeof(mpfr_t)); mpfr_init2(*temp, prec); newton(*temp, tree, diff_tree, x2, x1, mpfr_sgn(y2), prec); result = addElement(result, temp); } } else { /* x1=a */ if (mpfr_sgn(y1)==0) { temp = safeMalloc(sizeof(mpfr_t)); mpfr_init2(*temp, prec); mpfr_set(*temp, x1, GMP_RNDN); result = addElement(result, temp); } } mpfr_clear(h); mpfr_clear(y1); mpfr_clear(y2); mpfr_clear(x1); mpfr_clear(x2); mpfr_clear(cutoff); free_memory(diff_tree); return result; } /* Perform a step of exchange algorithm newx is the point to be inserted err_newx is the corresponding error lambdai_vect is the vector of lambda_i corresponding to vector x epsilon is the current radius of reference note that (p*w-f)(x_{n+1})= epsilon by definition and lambda_{n+1} = -1 by definition Thus the rule is * take the max of mu/lambda if sgn(err_newx)*sgn(epsilon)=-1 * take the min otherwise n is the number of elements in x */ void single_step_remez(mpfr_t newx, mpfr_t err_newx, mpfr_t *x, node **monomials_tree, node *w, mpfr_t *lambdai_vect, mpfr_t epsilon, int n, mp_prec_t prec) { int freeDegrees = n-1; int test,i,j,r, argmaxi, argmini; mpfr_t *N; mpfr_t *c; mpfr_t *mui_vect; node *temp_tree; node *temp_tree2; mpfr_t zero_mpfr, var1, var2, var3; mpfr_t maxi; mpfr_t mini; /* Initialisations and precomputations */ mpfr_init2(var1, prec); mpfr_init2(var2, prec); mpfr_init2(var3, prec); mpfr_init2(zero_mpfr, 53); mpfr_set_d(zero_mpfr, 0., GMP_RNDN); mpfr_init2(maxi, prec); mpfr_init2(mini, prec); N = safeMalloc(freeDegrees*freeDegrees*sizeof(mpfr_t)); c = safeMalloc(freeDegrees*sizeof(mpfr_t)); mui_vect = safeMalloc(freeDegrees*sizeof(mpfr_t)); /* Initialization of mui_vect */ for(j=1; j <= freeDegrees ; j++) { for(i=1; i<= freeDegrees; i++) { mpfr_init2(N[coeff(i,j,freeDegrees)],prec); } mpfr_init2(c[j-1], prec); mpfr_init2(mui_vect[j-1], prec); } /* Computation of the matrix */ for (i=1 ; i <= freeDegrees ; i++) { r = evaluateFaithfulWithCutOffFast(var1, w, NULL, x[i-1], zero_mpfr, prec); if(((r==1) || (r==4) || (r==5) || (r==6) || (r==7)) && (mpfr_number_p(var1))) test=1; else test=0; for (j=1 ; j <= freeDegrees ; j++) { if(test==1) { r = evaluateFaithfulWithCutOffFast(var2, monomials_tree[j-1], NULL, x[i-1], zero_mpfr, prec); if(((r==1) || (r==4) || (r==5) || (r==6) || (r==7)) && (mpfr_number_p(var2))) { mpfr_mul(var2, var1, var2, GMP_RNDN); mpfr_set(N[coeff(j,i,freeDegrees)],var2,GMP_RNDN); } } if((test==0) || (r==0) || (!mpfr_number_p(var2))) { temp_tree = safeMalloc(sizeof(node)); temp_tree->nodeType = MUL; temp_tree->child1 = copyTree(monomials_tree[j-1]); temp_tree->child2 = copyTree(w); temp_tree = addMemRef(temp_tree); temp_tree2 = simplifyTreeErrorfree(temp_tree); free_memory(temp_tree); temp_tree = temp_tree2; /* temp_tree = g_j(x)*w(x) */ r = evaluateFaithfulWithCutOffFast(var3, temp_tree, NULL, x[i-1], zero_mpfr, prec); if(r==0) mpfr_set_d(var3, 0., GMP_RNDN); mpfr_set(N[coeff(j,i,freeDegrees)],var3,GMP_RNDN); free_memory(temp_tree); } } } /* Computation of the vector corresponding to the new point */ r = evaluateFaithfulWithCutOffFast(var1, w, NULL, newx, zero_mpfr, prec); if(((r==1) || (r==4) || (r==5) || (r==6) || (r==7)) && (mpfr_number_p(var1))) test=1; else test=0; for (j=1 ; j <= freeDegrees ; j++) { if(test==1) { r = evaluateFaithfulWithCutOffFast(var2, monomials_tree[j-1], NULL, newx, zero_mpfr, prec); if(((r==1) || (r==4) || (r==5) || (r==6) || (r==7)) && (mpfr_number_p(var2))) { mpfr_mul(var2, var1, var2, GMP_RNDN); mpfr_set(c[j-1],var2,GMP_RNDN); } } if((test==0) || (r==0) || (!mpfr_number_p(var2))) { temp_tree = safeMalloc(sizeof(node)); temp_tree->nodeType = MUL; temp_tree->child1 = copyTree(monomials_tree[j-1]); temp_tree->child2 = copyTree(w); temp_tree = addMemRef(temp_tree); temp_tree2 = simplifyTreeErrorfree(temp_tree); free_memory(temp_tree); temp_tree = temp_tree2; /* temp_tree = g_j(x)*w(x) */ r = evaluateFaithfulWithCutOffFast(var3, temp_tree, NULL, newx, zero_mpfr, prec); if(r==0) mpfr_set_d(var3, 0., GMP_RNDN); mpfr_set(c[j-1], var3, GMP_RNDN); free_memory(temp_tree); } } /* Resolution of the system */ system_solve(mui_vect , N, c, freeDegrees, prec); /* Finding the maximum and minimum */ mpfr_set(maxi, zero_mpfr, GMP_RNDN); argmaxi=freeDegrees; mpfr_set(mini, zero_mpfr, GMP_RNDN); argmini=freeDegrees; for(i=freeDegrees-1;i>=0;i--) { mpfr_div(var1, mui_vect[i], lambdai_vect[i], GMP_RNDN); if (mpfr_cmp(var1, maxi)>0) { mpfr_set(maxi, var1, GMP_RNDN); argmaxi=i; } if (mpfr_cmp(var1, mini)<0) { mpfr_set(mini, var1, GMP_RNDN); argmini=i; } } /* Introduce newx */ if(mpfr_sgn(err_newx)*mpfr_sgn(epsilon)==1) { printMessage(4,SOLLYA_MSG_REMEZ_EXCHANGE_TAKE_A_CERTAIN_MINIMUM,"Remez: exchange algorithm takes the minimum (%.16v) at place %d\n",mini,argmini); mpfr_set(x[argmini], newx, GMP_RNDN); } else { printMessage(4,SOLLYA_MSG_REMEZ_EXCHANGE_TAKE_A_CERTAIN_MAXIMUM,"Remez: exchange algorithm takes the maximum (%.16v) at place %d\n",maxi,argmaxi); mpfr_set(x[argmaxi], newx, GMP_RNDN); } mpfr_sort(x, freeDegrees+1, prec); /* Freeing the memory */ for(j=1; j <= freeDegrees ; j++) { for(i=1; i<= freeDegrees; i++) { mpfr_clear(N[coeff(i,j,freeDegrees)]); } mpfr_clear(c[j-1]); mpfr_clear(mui_vect[j-1]); } safeFree(N); safeFree(c); safeFree(mui_vect); mpfr_clear(zero_mpfr); mpfr_clear(var1); mpfr_clear(var2); mpfr_clear(var3); mpfr_clear(maxi); mpfr_clear(mini); return; } /* Store in res the zeros of tree on [a;b] deg+1 indicates the number of zeros which we are expecting. error' = tree and tree' = diff_tree */ void quickFindZeros(mpfr_t *res, mpfr_t *curr_points, node *error, node *tree, node *diff_tree, node **monomials_tree, node *w, mpfr_t *lambdai_vect, mpfr_t epsilon, int HaarCompliant, int deg, mpfr_t a, mpfr_t b, mp_prec_t prec) { long int n = 50*(deg+2); long int i=0; int tooManyOscillations = 0; /* This variable is used to ensure that the message "the function oscillates too much" is displayed only once */ /* The variable test is used to check that the maximum (in absolute value) of the error will be inserted in the new list of points. If it is not the case, a step of the exchange algorithm is performed */ int test=0; mpfr_t h, x1, x2, x, y1, y2, zero_mpfr, maxi, argmaxi, z, alpha1, alpha2, alpha; mpfr_init2(h,prec); mpfr_init2(y1,prec); mpfr_init2(y2,prec); mpfr_init2(x1,prec); mpfr_init2(x2,prec); mpfr_init2(x, prec); mpfr_init2(zero_mpfr,prec); mpfr_init2(z, prec); mpfr_init2(maxi, prec); mpfr_init2(argmaxi, prec); mpfr_init2(alpha1, 24); mpfr_init2(alpha2, 24); mpfr_init2(alpha, 24); mpfr_set_d(zero_mpfr, 0., GMP_RNDN); evaluateFaithfulWithCutOffFast(z, error, tree, a, zero_mpfr, prec); mpfr_set(maxi,z,GMP_RNDN); mpfr_set(argmaxi,a,GMP_RNDN); evaluateFaithfulWithCutOffFast(z, error, tree, b, zero_mpfr, prec); if (mpfr_cmpabs(z,maxi)>0) { mpfr_set(maxi,z,GMP_RNDN); mpfr_set(argmaxi,b,GMP_RNDN); } mpfr_sub(h,b,a,GMP_RNDD); mpfr_div_si(h,h,n,GMP_RNDD); mpfr_set(x1,a,GMP_RNDN); mpfr_add(x2,a,h,GMP_RNDN); evaluateFaithfulWithCutOffFast(y1, tree, diff_tree, x1, zero_mpfr, prec); evaluateFaithfulWithCutOffFast(alpha1, diff_tree, NULL, x1, zero_mpfr, prec); while(mpfr_lessequal_p(x2,b)) { evaluateFaithfulWithCutOffFast(y2, tree, diff_tree, x2, zero_mpfr, prec); evaluateFaithfulWithCutOffFast(alpha2, diff_tree, NULL, x2, zero_mpfr, prec); if( (mpfr_sgn(y1)==0) || (mpfr_sgn(y2)==0) || (mpfr_sgn(y1) != mpfr_sgn(y2))) { if (mpfr_sgn(y1)==0) { evaluateFaithfulWithCutOffFast(z, error, tree, x1, zero_mpfr, prec); if (mpfr_sgn(z)*mpfr_sgn(alpha1)<0) { i++; if(i>deg+2) { if (!tooManyOscillations) printMessage(1,SOLLYA_MSG_REMEZ_FUNCTION_OSCILLATES_TOO_MUCH, "Warning: the function oscillates too much. Nevertheless, we try to continue.\n"); tooManyOscillations = 1; } else mpfr_set(res[i-1], x1, GMP_RNDN); } if (mpfr_cmpabs(z,maxi)>0) { if ( (i>deg+2)||(mpfr_sgn(z)*mpfr_sgn(alpha1)>=0) ) test=0; else test=1; mpfr_set(maxi,z,GMP_RNDN); mpfr_set(argmaxi,x1,GMP_RNDN); } /* Attention when decommenting this code sequence again: the printMessages in it have not (or partially) been converted to the new style */ /* if(mpfr_sgn(y2)==0) { evaluateFaithfulWithCutOffFast(z, error, tree, x2, zero_mpfr, prec); if (mpfr_sgn(z)*mpfr_sgn(alpha2)<0) { i++; if(i>deg+2) printMessage(1,"Warning: the function oscillates too much. Nevertheless, we try to continue.\n"); else mpfr_set(res[i-1], x2, GMP_RNDN); } if (mpfr_cmpabs(z,maxi)>0) { if ( (i>deg+2)||(mpfr_sgn(z)*mpfr_sgn(alpha2)>=0) ) test=0; else test=1; mpfr_set(maxi,z,GMP_RNDN); mpfr_set(argmaxi,x2,GMP_RNDN); } } */ } else { if (mpfr_sgn(y2)==0) { evaluateFaithfulWithCutOffFast(z, error, tree, x2, zero_mpfr, prec); if (mpfr_sgn(z)*mpfr_sgn(alpha2)<0) { i++; if(i>deg+2) { if (!tooManyOscillations) printMessage(1,SOLLYA_MSG_REMEZ_FUNCTION_OSCILLATES_TOO_MUCH, "Warning: the function oscillates too much. Nevertheless, we try to continue.\n"); tooManyOscillations = 1; } else mpfr_set(res[i-1], x2, GMP_RNDN); } if (mpfr_cmpabs(z,maxi)>0) { if ( (i>deg+2) || (mpfr_sgn(z)*mpfr_sgn(alpha2)>=0) ) test=0; else test=1; mpfr_set(maxi,z,GMP_RNDN); mpfr_set(argmaxi,x2,GMP_RNDN); } } else { newton(x, tree, diff_tree, x1, x2, mpfr_sgn(y1), prec); evaluateFaithfulWithCutOffFast(z, error, tree, x , zero_mpfr, prec); evaluateFaithfulWithCutOffFast(alpha, diff_tree, NULL, x , zero_mpfr, prec); if (mpfr_sgn(z)*mpfr_sgn(alpha)<0) { i++; if(i>deg+2) { if (!tooManyOscillations) printMessage(1,SOLLYA_MSG_REMEZ_FUNCTION_OSCILLATES_TOO_MUCH, "Warning: the function oscillates too much. Nevertheless, we try to continue.\n"); tooManyOscillations = 1; } else mpfr_set(res[i-1], x, GMP_RNDN); } if (mpfr_cmpabs(z,maxi)>0) { if ( (i>deg+2) || (mpfr_sgn(z)*mpfr_sgn(alpha)>=0) ) test=0; else test=1; mpfr_set(maxi,z,GMP_RNDN); mpfr_set(argmaxi,x,GMP_RNDN); } } } } mpfr_set(x1,x2,GMP_RNDN); mpfr_add(x2,x2,h,GMP_RNDN); mpfr_set(y1,y2,GMP_RNDN); } if ((ideg+2)||(!HaarCompliant)||(!test)) { /* printMessage(1,"Warning: the function fails to oscillate enough.\n"); printMessage(1,"Check Haar condition and/or increase precision.\n"); *crash_report = -1; */ test=0; printMessage(2, SOLLYA_MSG_REMEZ_PERFORMING_AN_EXCHANGE_STEP, "Performing an exchange step...\n"); printMessage(4,SOLLYA_MSG_REMEZ_COMPUTED_INFNORM_IS_A_CERTAIN_VALUE,"Computed infinity norm : %v\nReached at point %v\n",maxi,argmaxi); for(i=0;i0) mpfr_set(res[deg+1], a, GMP_RNDN); else mpfr_set(res[deg+1], b, GMP_RNDN); } } mpfr_sort(res, deg+2, prec); } } } /* We enter here if and only if we had (i=deg or i=deg+1) && HaarCompliant && test in the first place. */ if(test) { /* since we did not perform an exchange step, we have to check that the pseudo-alternating condition is fulfilled */ test=1; for(i=0; (i= 0 ) test=0; } if(!test) { printMessage(2, SOLLYA_MSG_REMEZ_FAILED_TO_FIND_PSEUDOALTERNATING_POINTS, "Failed to find pseudo-alternating points. Performing an exchange step...\n"); printMessage(4, SOLLYA_MSG_REMEZ_COMPUTED_INFNORM_IS_A_CERTAIN_VALUE, "Computed infinity norm : %v\nReached at point %v\n", maxi, argmaxi); for(i=0;inodeType = SUB; temp1 = safeMalloc(sizeof(node)); temp1->nodeType = MUL; temp1->child1 = copyTree(poly); temp1->child2 = copyTree(w); error->child1 = addMemRef(temp1); error->child2 = copyTree(f); error = addMemRef(error); temp1 = simplifyTreeErrorfree(error); free_memory(error); error = temp1; printMessage(8,SOLLYA_MSG_REMEZ_CONSTRUCTING_THE_ERROR_PRIME_TREE,"Constructing the error' tree...\n"); error_diff = differentiate(error); temp1 = simplifyTreeErrorfree(error_diff); free_memory(error_diff); error_diff = temp1; printMessage(8,SOLLYA_MSG_REMEZ_CONSTRUCTING_THE_ERROR_SECOND_TREE,"Constructing the error'' tree...\n"); error_diff2 = differentiate(error_diff); temp1 = simplifyTreeErrorfree(error_diff2); free_memory(error_diff2); error_diff2 = temp1; printMessage(6, SOLLYA_MSG_REMEZ_COMPUTING_THE_YI, "Computing the yi...\n"); /* If x = [x1 ... xn], we construct [y0 y1 ... yn] by y0 = (a+x1)/2, yn = (xn+b)/2 and yi = (xi + x(i+1))/2 */ y = (mpfr_t *)safeMalloc((n+1)*sizeof(mpfr_t)); mpfr_init2(y[0], prec); mpfr_add(y[0], x[0], a, GMP_RNDN); mpfr_div_2ui(y[0], y[0], 1, GMP_RNDN); for(i=1; ia and xn=b and *case 2bis* the symetrical case We call *case 3* the case where x1<>a and xn<>b */ if (mpfr_equal_p(y[0], a) && mpfr_equal_p(y[n],b)) { case1 = 1; case2 = 0; case2b = 0; case3 = 0; } else { if ((! mpfr_equal_p(y[0], a)) && mpfr_equal_p(y[n],b)) { case1 = 0; case2 = 1; case2b = 0; case3 = 0; } else { if (mpfr_equal_p(y[0], a) && (! mpfr_equal_p(y[n],b))) { case1 = 0; case2 = 0; case2b = 1; case3 = 0; } else { case1 = 0; case2 = 0; case2b = 0; case3 = 1; } } } printMessage(6, SOLLYA_MSG_REMEZ_ALGORITHM_IS_IN_A_CERTAIN_CASE, "We are in case %s\n", (case1 ? "1" : (case2 ? "2" : (case2b ? "2bis" : (case3 ? "3" : "unknown"))))); /* If one of error_diff(y0) .... error_diff(yn) is a real NaN (i.e. if evaluateFaithfulWithCutOffFast returns 1 and store a NaN) this leads to numerical problems -> we use quickFindZeros If sgn(error_diff(yi))*sgn(error_diff(y(i+1))) > 0 for some i=1..n-2 If we are in case 2 and sgn(error_diff(y0))*sgn(error_diff(y1)) > 0 If we are in case 2bis and sgn(error_diff(y(n-1)))*sgn(error_diff(yn)) > 0 If we are in case 3 and one of this two last condition is not fulfilled this means the hypothesis (xi ~ zeros of error_diff) is false -> quickFindZeros If we are in case 1 : if sgn(error_diff(y0))*sgn(error_diff(y1)) > 0 (the most probable) we have a problem if error(y0) is a real NaN or if sgn(error(y0))*sgn(error_diff(y0))>0 if sgn(error_diff(y(n-1)))*sgn(error_diff(yn)) > 0 (the most probable) we have a problem if error(yn) is a real NaN or if sgn(error(yn))*sgn(error_diff(yn))<0 If we are in case 2 if sgn(error_diff(y(n-1)))*sgn(error_diff(yn)) > 0 (the most probable) we have a problem if error(yn) is a real NaN or if sgn(error(yn))*sgn(error_diff(yn))<0 If we are in case 2bis, if sgn(error_diff(y0))*sgn(error_diff(y1)) > 0 (the most probable) we have a problem if error(y0) is a real NaN or if sgn(error(y0))*sgn(error_diff(y0))>0 */ s = (int *)safeMalloc((n+1)*sizeof(int)); test = 1; i = 0; while(test && (i<=n)) { r = evaluateFaithfulWithCutOffFast(dummy_mpfr, error_diff, error_diff2, y[i], zero_mpfr, prec); if((!mpfr_number_p(dummy_mpfr)) && ((r==1) || (r==4) || (r==5) || (r==6) || (r==7))) test=0; else { if(r==0) s[i]=0; else s[i] = mpfr_sgn(dummy_mpfr); } i++; } if (test) { printMessage(6,SOLLYA_MSG_REMEZ_THE_COMPUTED_SIGNS_ARE_CERTAIN_VALUES,"The computed signs are: "); for(i=0;i<=n;i++) printMessage(6,SOLLYA_MSG_CONTINUATION,"%d ",s[i]); printMessage(6,SOLLYA_MSG_CONTINUATION,"\n"); } else { printMessage(6,SOLLYA_MSG_REMEZ_SIGNS_COULD_NOT_BE_EVALUATED,"Test is false because signs could not be evaluated\n"); } if(test) { i = 1; while(test && (i<=n-2)) { if(s[i]*s[i+1] > 0) test=0; i++; } } if(test && case2 && (s[0]*s[1]>0)) test=0; if(test && case2b && (s[n-1]*s[n]>0)) test=0; if(test && case3 && ((s[0]*s[1]>0) || (s[n-1]*s[n]>0))) test=0; if(test && (case1 || case2b) && (s[0]*s[1]>0)) { r = evaluateFaithfulWithCutOffFast(dummy_mpfr, error, error_diff, y[0], zero_mpfr, prec); if((!mpfr_number_p(dummy_mpfr)) && ((r==1) || (r==4) || (r==5) || (r==6) || (r==7))) test=0; else { if((r!=0) && (mpfr_sgn(dummy_mpfr)*s[0] > 0)) test=0; } } if(test && (case1 || case2) && (s[n-1]*s[n]>0)) { r = evaluateFaithfulWithCutOffFast(dummy_mpfr, error, error_diff, y[n], zero_mpfr, prec); if((!mpfr_number_p(dummy_mpfr)) && ((r==1) || (r==4) || (r==5) || (r==6) || (r==7))) test=0; else { if((r!=0) && (mpfr_sgn(dummy_mpfr)*s[n] < 0)) test=0; } } if(test && HaarCompliant) { if((case1 || case2b) && (s[0]*s[1]<=0)) { if(s[0]==0) mpfr_set(z[0], a, GMP_RNDN); else { if(s[1]==0) mpfr_set(z[0], y[1], GMP_RNDN); else findZero(z[0], error_diff, error_diff2,y[0],y[1],s[0],NULL, NEWTON_STEPS,prec); } } if((case1 || case2b) && (s[0]*s[1]>0)) mpfr_set(z[0], a, GMP_RNDN); if(case2 || case3) findZero(z[0], error_diff, error_diff2, y[0], y[1], s[0], &x[0], NEWTON_STEPS, prec); for(i=1;i<=n-2;i++) findZero(z[i], error_diff, error_diff2, y[i], y[i+1], s[i], &x[i], NEWTON_STEPS, prec); if((case1 || case2) && (s[n-1]*s[n]<=0)) { if(s[n]==0) mpfr_set(z[n-1], b, GMP_RNDN); else { if(s[n-1]==0) mpfr_set(z[n-1], y[n-1], GMP_RNDN); else findZero(z[n-1], error_diff, error_diff2, y[n-1], y[n], s[n-1], NULL, NEWTON_STEPS, prec); } } if((case1 || case2) && (s[n-1]*s[n]>0)) mpfr_set(z[n-1],b,GMP_RNDN); if(case2b || case3) findZero(z[n-1], error_diff, error_diff2, y[n-1], y[n], s[n-1], &x[n-1], NEWTON_STEPS, prec); /* We expect error(z[i]) ~ - sgn(lambda[i])*epsilon We check the sign of error at these points and for z[i]<>a,b, we check the sign of error'' */ test=1; for(i=1; (i<=n) && test; i++) { r = evaluateFaithfulWithCutOffFast(var_mpfr, error, error_diff, z[i-1], zero_mpfr, prec); if(r==0) mpfr_set_d(var_mpfr, 0., GMP_RNDN); if ( mpfr_sgn(var_mpfr)*mpfr_sgn(lambdai_vect[i-1])*mpfr_sgn(epsilon) >= 0 ) test=0; if ( (!mpfr_equal_p(z[i-1],a)) && (!mpfr_equal_p(z[i-1],b)) ) { r = evaluateFaithfulWithCutOffFast(var_mpfr, error_diff2, NULL, z[i-1], zero_mpfr, prec); if(r==0) mpfr_set_d(var_mpfr, 0., GMP_RNDN); if(-mpfr_sgn(var_mpfr)*mpfr_sgn(epsilon)*mpfr_sgn(lambdai_vect[i-1]) >= 0) test=0; } } if (!test) { printMessage(1,SOLLYA_MSG_REMEZ_MAIN_HEURISTIC_FAILED_USING_SLOWER_ALGO,"Warning in Remez: main heuristic failed. A slower algorithm is used for this step.\n"); quickFindZeros(z, x, error, error_diff, error_diff2, monomials_tree, w, lambdai_vect, epsilon, HaarCompliant, freeDegrees-1, a, b, prec); if(crash_report==-1) { free_memory(error); free_memory(error_diff); free_memory(error_diff2); mpfr_clear(var_mpfr); mpfr_clear(zero_mpfr); mpfr_clear(dummy_mpfr); mpfr_clear(dummy_mpfr2); mpfr_clear(max_val); safeFree(s); for(i=0;i<=n;i++) mpfr_clear(y[i]); safeFree(y); for(i=1;i<=n;i++) { mpfr_clear(z[i-1]); } safeFree(z); return -1; } } } else { printMessage(1, SOLLYA_MSG_REMEZ_SLOWER_ALGORITHM_USED_FOR_A_STEP, "Warning in Remez: a slower algorithm is used for this step%s\n", ((!HaarCompliant) ? " (pseudo-alternation condition changed)" : "")); quickFindZeros(z, x, error, error_diff, error_diff2, monomials_tree, w, lambdai_vect, epsilon, HaarCompliant, freeDegrees-1, a, b, prec); if(crash_report==-1) { free_memory(error); free_memory(error_diff); free_memory(error_diff2); mpfr_clear(var_mpfr); mpfr_clear(zero_mpfr); mpfr_clear(dummy_mpfr); mpfr_clear(dummy_mpfr2); mpfr_clear(max_val); safeFree(s); for(i=0;i<=n;i++) mpfr_clear(y[i]); safeFree(y); for(i=1;i<=n;i++) { mpfr_clear(z[i-1]); } safeFree(z); return -1; } } printMessage(4,SOLLYA_MSG_REMEZ_THE_NEW_POINTS_ARE_CERTAIN_VALUES,"The new points are: "); for(i=1; i<=n; i++) printMessage(4,SOLLYA_MSG_CONTINUATION,"%v ",z[i-1]); printMessage(4,SOLLYA_MSG_CONTINUATION,"\n"); /* Test the quality of the current error */ mpfr_set_d(max_val, 0., GMP_RNDN); if((computedQuality!=NULL) || (infinityNorm != NULL)) { for(i=1;i<=n;i++) { r = evaluateFaithfulWithCutOffFast(var_mpfr, error, error_diff, z[i-1], zero_mpfr, prec); if(r==0) mpfr_set_d(var_mpfr, 0., GMP_RNDN); mpfr_abs(var_mpfr, var_mpfr, GMP_RNDN); if(mpfr_cmp(var_mpfr, max_val) > 0) mpfr_set(max_val, var_mpfr, GMP_RNDU); } mpfr_div(var_mpfr, max_val, epsilon, (mpfr_cmp_ui(epsilon,0)>0)?GMP_RNDU:GMP_RNDD); mpfr_abs(var_mpfr, var_mpfr, GMP_RNDU); mpfr_sub_ui(var_mpfr, var_mpfr, 1, GMP_RNDU); } if(computedQuality!=NULL) mpfr_set(computedQuality, var_mpfr, GMP_RNDU); if(infinityNorm!=NULL) mpfr_set(infinityNorm, max_val, GMP_RNDU); printMessage(2, SOLLYA_MSG_REMEZ_THE_CURRENT_NORM_TAKES_A_CERTAIN_VALUE, "Current norm: %v (1 +/- %.3v)\n",max_val,var_mpfr); free_memory(error); free_memory(error_diff); free_memory(error_diff2); mpfr_clear(var_mpfr); mpfr_clear(zero_mpfr); mpfr_clear(dummy_mpfr); mpfr_clear(dummy_mpfr2); mpfr_clear(max_val); safeFree(s); for(i=0;i<=n;i++) mpfr_clear(y[i]); safeFree(y); for(i=1;i<=n;i++) { mpfr_set(x[i-1], z[i-1], GMP_RNDN); mpfr_clear(z[i-1]); } safeFree(z); return 0; } /* Normally, we have satisfying_error < target_error. If we manage to prove that target_error is unreachable, we stop the algorithm, returning error. If we manage to reach satisfying_error, we stop the algorithm, returning the current polynomial. Otherwise, we run the algorithm until the required quality is obtained. -----------------------|----------------------------|--------------------------> satisfying target :-) :-( */ node *remezAux(node *f, node *w, chain *monomials, mpfr_t u, mpfr_t v, mp_prec_t prec, mpfr_t quality, mpfr_t satisfying_error, mpfr_t target_error) { int freeDegrees = lengthChain(monomials); int i, j, r, count, test, crash, HaarCompliant, forEverNotHaarCompliant; mpfr_t zero_mpfr, var1, var2, var3, computedQuality, infinityNorm; node *temp_tree; node *temp_tree2; node *temp_tree_simplified; node *poly; node *res; chain *curr; node **monomials_tree; mpfr_t *x; mpfr_t *M; mpfr_t *N; mpfr_t *b; mpfr_t *c; mpfr_t *ai_vect; mpfr_t *lambdai_vect; mpfr_t *previous_lambdai_vect; mpfr_t previous_epsilon; mpfr_t perturb; gmp_randstate_t random_state; int quality_prec; /* Make compiler happy */ res = NULL; /* End of compiler happiness */ forEverNotHaarCompliant = 0; quality_prec = (mpfr_regular_p(quality)?(10 - mpfr_get_exp(quality)):prec); gmp_randinit_default(random_state); gmp_randseed_ui(random_state, 65845285); HaarCompliant=1; printMessage(3, SOLLYA_MSG_ENTERING_REMEZ_FUNCTION, "Entering in Remez function...\nRequired quality : %v\n",quality); /* Initialisations and precomputations */ mpfr_init2(var1, prec); mpfr_init2(var2, prec); mpfr_init2(var3, prec); mpfr_init2(zero_mpfr, 53); mpfr_set_d(zero_mpfr, 0., GMP_RNDN); mpfr_init2(previous_epsilon, prec); mpfr_set(previous_epsilon, zero_mpfr, GMP_RNDN); if (mpfr_get_prec(quality)>prec) mpfr_init2(computedQuality, mpfr_get_prec(quality)); else mpfr_init2(computedQuality, prec); mpfr_set_inf(computedQuality, 1); mpfr_init2(infinityNorm, quality_prec); M = safeMalloc((freeDegrees+1)*(freeDegrees+1)*sizeof(mpfr_t)); N = safeMalloc(freeDegrees*freeDegrees*sizeof(mpfr_t)); b = safeMalloc((freeDegrees+1)*sizeof(mpfr_t)); c = safeMalloc(freeDegrees*sizeof(mpfr_t)); ai_vect = safeMalloc((freeDegrees+1)*sizeof(mpfr_t)); lambdai_vect = safeMalloc((freeDegrees+1)*sizeof(mpfr_t)); previous_lambdai_vect = safeMalloc((freeDegrees+1)*sizeof(mpfr_t)); x = safeMalloc((freeDegrees+1)*sizeof(mpfr_t)); for(j=1; j <= freeDegrees+1 ; j++) { for(i=1; i<= freeDegrees+1; i++) { mpfr_init2(M[coeff(i,j,freeDegrees+1)],prec); } mpfr_init2(b[j-1], prec); mpfr_init2(ai_vect[j-1], prec); mpfr_init2(x[j-1], prec); } for(j=1; j <= freeDegrees ; j++) { for(i=1; i<= freeDegrees; i++) { mpfr_init2(N[coeff(i,j,freeDegrees)],prec); } mpfr_init2(c[j-1], prec); mpfr_init2(lambdai_vect[j-1], prec); mpfr_init2(previous_lambdai_vect[j-1], prec); } mpfr_init2(lambdai_vect[freeDegrees], prec); mpfr_init2(previous_lambdai_vect[freeDegrees], prec); mpfr_set_si(lambdai_vect[freeDegrees],-1,GMP_RNDN); mpfr_set_si(previous_lambdai_vect[freeDegrees],-1,GMP_RNDN); poly = NULL; printMessage(8, SOLLYA_MSG_REMEZ_COMPUTING_MONOMIALS, "Computing monomials...\n"); pushTimeCounter(); monomials_tree = safeMalloc(freeDegrees*sizeof(node *)); curr = monomials; for(j=0;jvalue)); curr=curr->next; } popTimeCounter("Remez: computing monomials"); count = 0; /* Definition of the array x of the n+2 Chebychev points */ printMessage(8, SOLLYA_MSG_REMEZ_COMPUTING_INITIAL_POINT_SET, "Computing an initial points set...\n"); pushTimeCounter(); /*************************************************************/ mpfr_const_pi(var1, GMP_RNDN); mpfr_div_si(var1, var1, (long)freeDegrees, GMP_RNDN); /* var1 = Pi/freeDegrees */ mpfr_sub(var2, u, v, GMP_RNDN); mpfr_div_2ui(var2, var2, 1, GMP_RNDN); /* var2 = (u-v)/2 */ mpfr_add(var3, u, v, GMP_RNDN); mpfr_div_2ui(var3, var3, 1, GMP_RNDN); /* var3 = (u+v)/2 */ for (i=1 ; i <= freeDegrees+1 ; i++) { mpfr_mul_si(x[i-1], var1, i-1, GMP_RNDN); mpfr_cos(x[i-1], x[i-1], GMP_RNDN); mpfr_fma(x[i-1], x[i-1], var2, var3, GMP_RNDN); /* x_i = [cos((i-1)*Pi/freeDegrees)]*(u-v)/2 + (u+v)/2 */ } /* Random pertubration of the points... */ mpfr_init2(perturb, prec); for(i=2;i<=freeDegrees;i++) { mpfr_urandomb(perturb, random_state); mpfr_mul_2ui(perturb, perturb, 1, GMP_RNDN); mpfr_sub_ui(perturb, perturb, 1, GMP_RNDN); mpfr_div_2ui(perturb, perturb, 2, GMP_RNDN); /* perturb \in [-1/4; 1/4] */ /* If no perturbation is desired, set: mpfr_set_d(perturb,0.,GMP_RNDN); */ mpfr_sub(var1, x[i-1], x[i-2], GMP_RNDN); mpfr_sub(var2, x[i], x[i-1], GMP_RNDN); if (mpfr_cmpabs(var1,var2)>0) mpfr_mul(var3, var2, perturb, GMP_RNDN); else mpfr_mul(var3, var1, perturb, GMP_RNDN); mpfr_add(x[i-1], x[i-1], var3, GMP_RNDN); } mpfr_clear(perturb); /*************************************************************/ /*************************************************************/ /* Manually chosen points */ /*************************************************************/ /* assume the list of points to be stored in variable list: run: i=0; for t in list do {write("mpfr_set_str(x[",i,"],\"",t,"\", 10, GMP_RNDN);\n"); i=i+1;} ; */ /* mpfr_set_str(x[0],"-0.3125e-1", 10, GMP_RNDN); mpfr_set_str(x[1],"-0.270866924296709954921192919457109841628145246303031e-1", 10, GMP_RNDN); mpfr_set_str(x[2],"-0.156792125481182037300460865714390558114871681447265e-1", 10, GMP_RNDN); mpfr_set_str(x[3],"0.270866923865259682207709736846537325622398567463872667e-1", 10, GMP_RNDN); */ /*************************************************************/ /*************************************************************/ /* Evenly distributed points */ /*************************************************************/ /* mpfr_sub(var1, v, u, GMP_RNDN); mpfr_div_si(var1, var1, (long)(freeDegrees), GMP_RNDN); // var1 = (v-u)/freeDegrees for (i=1 ; i <= freeDegrees+1 ; i++) { mpfr_mul_si(x[i-1], var1, i-1, GMP_RNDN); mpfr_add(x[i-1], x[i-1], u, GMP_RNDN); } */ /*************************************************************/ /*************************************************************/ /* Alternative Cheb points */ /*************************************************************/ /* mpfr_const_pi(var1, GMP_RNDN); mpfr_div_si(var1, var1, 2*((long)freeDegrees+1), GMP_RNDN); // var1 = Pi/(2*freeDegrees+2) mpfr_sub(var2, u, v, GMP_RNDN); mpfr_div_2ui(var2, var2, 1, GMP_RNDN); // var2 = (u-v)/2 mpfr_add(var3, u, v, GMP_RNDN); mpfr_div_2ui(var3, var3, 1, GMP_RNDN); // var3 = (u+v)/2 for (i=1 ; i <= freeDegrees+1 ; i++) { mpfr_mul_si(x[i-1], var1, 2*i-1, GMP_RNDN); mpfr_cos(x[i-1], x[i-1], GMP_RNDN); mpfr_fma(x[i-1], x[i-1], var2, var3, GMP_RNDN); // x_i=[cos((2i-1)*Pi/(2freeDegrees+2))]*(u-v)/2 + (u+v)/2 } */ /*************************************************************/ popTimeCounter("Remez: computing initial points set"); printMessage(4,SOLLYA_MSG_REMEZ_THE_COMPUTED_POINT_SET_IS_CERTAIN_VALUES,"Computed points set:\n"); for(i=1;i<=freeDegrees+1;i++) printMessage(4,SOLLYA_MSG_CONTINUATION,"%v ",x[i-1]); printMessage(4,SOLLYA_MSG_CONTINUATION,"\n"); mpfr_set_inf(infinityNorm, 1); mpfr_set_ui(ai_vect[freeDegrees], 0, GMP_RNDN); /* The parameter epsilon is stored in ai_vect[freeDegrees] */ while( (mpfr_cmp(computedQuality, quality)>0) && (count<200) && (mpfr_cmpabs(ai_vect[freeDegrees],target_error)<=0) && (mpfr_cmp(infinityNorm,satisfying_error)>0) ) { while( (mpfr_cmp(computedQuality, quality)>0) && (count<200) && (mpfr_cmpabs(ai_vect[freeDegrees],target_error)<=0) && (mpfr_cmp(infinityNorm,satisfying_error)>0) ) { free_memory(poly); /* Definition of the matrices M and N of Remez algorithm N lets us determine the modified alternation property M lets us solve the interpolation problem */ printMessage(4, SOLLYA_MSG_REMEZ_COMPUTING_THE_MATRIX, "Step %d\nComputing the matrix...\n",count); pushTimeCounter(); for (i=1 ; i <= freeDegrees+1 ; i++) { r = evaluateFaithfulWithCutOffFast(var1, w, NULL, x[i-1], zero_mpfr, prec); if(((r==1) || (r==4) || (r==5) || (r==6) || (r==7)) && (mpfr_number_p(var1))) test=1; else test=0; for (j=1 ; j <= freeDegrees ; j++) { if(test==1) { r = evaluateFaithfulWithCutOffFast(var2, monomials_tree[j-1], NULL, x[i-1], zero_mpfr, prec); if(((r==1) || (r==4) || (r==5) || (r==6) || (r==7)) && (mpfr_number_p(var2))) { mpfr_mul(var2, var1, var2, GMP_RNDN); mpfr_set(M[coeff(i,j,freeDegrees+1)],var2,GMP_RNDN); if (i<=freeDegrees) mpfr_set(N[coeff(j,i,freeDegrees)],var2,GMP_RNDN); else mpfr_set(c[j-1],var2,GMP_RNDN); } } if((test==0) || (r==0) || (!mpfr_number_p(var2))) { printMessage(2,SOLLYA_MSG_REMEZ_COMPUTAT_OF_MATRIX_ENTRY_USES_SLOWER_ALGO,"Information: the construction of M[%d,%d] uses a slower algorithm\n",i,j); temp_tree = safeMalloc(sizeof(node)); temp_tree->nodeType = MUL; temp_tree->child1 = copyTree(monomials_tree[j-1]); temp_tree->child2 = copyTree(w); temp_tree = addMemRef(temp_tree); temp_tree2 = simplifyTreeErrorfree(temp_tree); free_memory(temp_tree); temp_tree = temp_tree2; /* temp_tree = x^(monomials[j])*w(x) */ r = evaluateFaithfulWithCutOffFast(var3, temp_tree, NULL, x[i-1], zero_mpfr, prec); if(r==0) mpfr_set_d(var3, 0., GMP_RNDN); mpfr_set(M[coeff(i,j,freeDegrees+1)],var3,GMP_RNDN); if (i<=freeDegrees) mpfr_set(N[coeff(j,i,freeDegrees)],var3,GMP_RNDN); else mpfr_set(c[j-1], var3, GMP_RNDN); free_memory(temp_tree); } } } system_solve( lambdai_vect , N, c, freeDegrees, prec); if(HaarCompliant==2) HaarCompliant=0; /* Too many oscillations: forcing exchange step */ else { HaarCompliant=1; for(i=1; i<=freeDegrees+1; i++) { if (mpfr_sgn(lambdai_vect[i-1])*mpfr_sgn(previous_lambdai_vect[i-1])<=0) HaarCompliant=0; } if(count==0) HaarCompliant=1; } if (forEverNotHaarCompliant) HaarCompliant = 0; for (i=1 ; i <= freeDegrees+1 ; i++) { if (mpfr_sgn(lambdai_vect[i-1])>0) mpfr_set_si(M[coeff(i, freeDegrees+1, freeDegrees+1)], 1 ,GMP_RNDN); else { if (mpfr_sgn(lambdai_vect[i-1])<0) mpfr_set_si(M[coeff(i, freeDegrees+1, freeDegrees+1)], -1 ,GMP_RNDN); else { printMessage(1,SOLLYA_MSG_REMEZ_DEGENERATED_SYSTEM_IN_NON_HAAR_CONTEXT,"Warning: degenerated system in a non Haar context. The algorithm may be incorrect.\n"); mpfr_set_si(M[coeff(i, freeDegrees+1, freeDegrees+1)], 1 ,GMP_RNDN); } } } printMessage(4,SOLLYA_MSG_REMEZ_SIGNS_FOR_PSEUDO_ALTERN_ARE_CERTAIN_VALS,"Signs for pseudo-alternating condition : ["); for (i=1 ; i <= freeDegrees ; i++) { printMessage(4,SOLLYA_MSG_CONTINUATION,"%.3v, ",M[coeff(i, freeDegrees+1, freeDegrees+1)]); } printMessage(4,SOLLYA_MSG_CONTINUATION,"-1]\n"); popTimeCounter("Remez: computing the matrix"); printMessage(7,SOLLYA_MSG_REMEZ_THE_COMPUTED_MATRIX_HAS_A_CERTAIN_VALUE,"The computed matrix is "); printMessageMatrix(7,M,freeDegrees+1); printMessage(7,SOLLYA_MSG_CONTINUATION,"\n"); /* Determination of the polynomial corresponding to M and x */ for (i=1 ; i <= freeDegrees+1 ; i++) { r = evaluateFaithfulWithCutOffFast(var1, f, NULL, x[i-1], zero_mpfr, prec); /* var1=f(x_i) */ if(r==0) mpfr_set_d(var1, 0., GMP_RNDN); mpfr_set(b[i-1],var1,GMP_RNDN); } printMessage(8, SOLLYA_MSG_REMEZ_SOLVING_THE_SYSTEM, "Resolving the system...\n"); pushTimeCounter(); system_solve(ai_vect, M, b, freeDegrees+1, prec); popTimeCounter("Remez: solving the system"); poly = constructPolynomialFromArray(ai_vect, monomials_tree, freeDegrees); printMessage(3, SOLLYA_MSG_REMEZ_THE_COMPUTED_POLY_HAS_A_CERTAIN_VALUE, "The computed polynomial is %b\n",poly); printMessage(2, SOLLYA_MSG_REMEZ_CURRENT_EPSILON_HAS_A_CERTAIN_VALUE, "Current value of epsilon : %.16v\n",ai_vect[freeDegrees]); /* Plotting the error curve */ /* node *plotTemp; */ /* chain *plotList=NULL; */ /* plotTemp = makeSub(makeMul(copyTree(poly),copyTree(w)),copyTree(f)); */ /* plotList=addElement(plotList, plotTemp); */ /* plotTree(plotList,u,v,defaultpoints,prec,NULL,0); */ /* free_memory(plotTemp); */ /* freeChain(plotList, nothing); */ /* Computing the useful derivatives of functions */ printMessage(8, SOLLYA_MSG_REMEZ_DIFFERENTIATING_THE_COMPUTED_POLYNOMIAL, "Differentiating the computed polynomial...\n"); pushTimeCounter(); /* Hornerization of the polynomial */ /* temp_tree = horner(poly); free_memory(poly); poly = temp_tree; */ printMessage(8, SOLLYA_MSG_REMEZ_SEARCHING_FOR_EXTREMA_OF_ERROR_FUNCTION, "Searching extrema of the error function...\n"); /* Find extremas and tests the quality of the current approximation */ pushTimeCounter(); crash = qualityOfError(computedQuality, infinityNorm, x, poly, f, w, monomials_tree, lambdai_vect, ai_vect[freeDegrees], HaarCompliant, freeDegrees, u, v, prec); popTimeCounter("Remez: computing the quality of approximation"); if(crash==-1) { /* temporary check until I patch the algorithm in order to handle correctly cases when the error oscillates too much */ temp_tree = addMemRef(makeSub(makeMul(copyTree(poly), copyTree(w)), copyTree(f))); uncertifiedInfnorm(infinityNorm, NULL, temp_tree, u, v, getToolPoints(), quality_prec); printMessage(1,SOLLYA_MSG_REMEZ_THE_BEST_POLY_GIVES_A_CERTAIN_ERROR,"The best polynomial obtained gives an error of %v\n",infinityNorm); free_memory(temp_tree); /* end of the temporary check */ for(j=0;j 0) { forEverNotHaarCompliant = 1; printMessage(2, SOLLYA_MSG_REMEZ_SWITCHING_DEFINITIVELY_TO_SLOW_ALGORITHM, "Remez: multipoint algorithm failed due to lack of Haar condition. Switching back to single point algorithm.\n"); } mpfr_set(previous_epsilon, ai_vect[freeDegrees], GMP_RNDN); } res = NULL; /* We check if exited the loop because we proved the target_error to be unreachable */ /* If so, we exit returning error */ if(mpfr_cmpabs(ai_vect[freeDegrees],target_error)>0) { printMessage(2, SOLLYA_MSG_REMEZ_FINISHES_AS_TARGET_ERROR_IS_NOT_REACHABLE, "Remez finished after %d steps\nThe target error (%.16v) has been proved unreachable.\n",count,target_error); printMessage(5, SOLLYA_MSG_CONTINUATION,"Last computed poly: %b\n",poly); res = copyTree(poly); /* Alternatively, we could do res = makeError(); */ } if (!res) { /* temporary check until I patch the algorithm in order to handle correctly cases when the error oscillates too much */ temp_tree = addMemRef(makeSub(addMemRef(makeMul(copyTree(poly), copyTree(w))), copyTree(f))); temp_tree_simplified = simplifyTreeErrorfree(temp_tree); free_memory(temp_tree); temp_tree = temp_tree_simplified; uncertifiedInfnorm(infinityNorm, &var1, temp_tree, u, v, getToolPoints(), quality_prec); /* var1 now contains a point where the max is reached */ evaluateFaithfulWithCutOffFast(var2, temp_tree, NULL, var1, zero_mpfr, prec); /* var2 is the value of the error at a point where the norm is reached */ free_memory(temp_tree); /* end of the temporary check */ /* We check if we exited the loop because we managed to find a satisfying error */ /* If so we exit returning the current polynomial */ if (mpfr_cmp(infinityNorm,satisfying_error)<=0) { printMessage(2, SOLLYA_MSG_REMEZ_FINISHES_AS_TARGET_ERROR_HAS_BEEN_REACHED, "Remez finished after %d steps\nThe following satisfying error (%.16v) has been reached.\nCurrent infinity norm: %v\n",count,satisfying_error,infinityNorm); res = copyTree(poly); } } if (!res) { mpfr_div(computedQuality, infinityNorm, ai_vect[freeDegrees], (mpfr_cmp_ui(ai_vect[freeDegrees], 0)>0)?GMP_RNDU:GMP_RNDD); mpfr_abs(computedQuality, computedQuality, GMP_RNDU); mpfr_sub_ui(computedQuality, computedQuality, 1, GMP_RNDU); if(mpfr_cmp(computedQuality, quality)<=0) { printMessage(2, SOLLYA_MSG_REMEZ_FINISHES_AS_QUALITY_HAS_BEEN_REACHED, "Remez finished after %d steps\nThe computed infnorm is %.16v\nThe polynomial is optimal within a factor 1 +/- %.3v\n",count,infinityNorm,computedQuality); printMessage(5, SOLLYA_MSG_CONTINUATION, "Computed poly: %b\n",poly); res = copyTree(poly); } } if(res==NULL) { printMessage(2, SOLLYA_MSG_REMEZ_FAILS_AND_LOOPS_AGAIN, "Warning: Remez algorithm failed (too many oscillations?)\nLooping again\n"); HaarCompliant=2; /* Attempt to (somehow) fix bug #8867: in case we forgot a point during the algorithm, we force its introduction now */ single_step_remez(var1, var2, x, monomials_tree, w, lambdai_vect, ai_vect[freeDegrees], freeDegrees+1, prec); } } free_memory(poly); for(j=0;j0) mpfr_mul(var3, var2, perturb, GMP_RNDN); else mpfr_mul(var3, var1, perturb, GMP_RNDN); mpfr_add(x[i], x[i], var3, GMP_RNDN); } gmp_randclear(random_state); mpfr_clear(perturb); mpfr_clear(var1); mpfr_clear(var2); mpfr_clear(var3); return; } mpfr_t *remezMatrix(node *w, mpfr_t *x, node **monomials_tree, int n, mp_prec_t *currentPrec) { mpfr_t var1, var2, var3, zero_mpfr; mpfr_t *M; int i,j,r, test; node *temp_tree, *temp_tree2; mp_prec_t prec= *currentPrec; M = (mpfr_t *)(safeMalloc((n+1)*(n+1)*sizeof(mpfr_t))); mpfr_init2(var1, prec); mpfr_init2(var2, prec); mpfr_init2(var3, prec); mpfr_init2(zero_mpfr, 53); mpfr_set_d(zero_mpfr, 0., GMP_RNDN); for (i=1 ; i <= n+1 ; i++) { mpfr_init2(M[coeff(i,n+1,n+1)], prec); if(i%2==0) mpfr_set_si(M[coeff(i,n+1,n+1)], 1, GMP_RNDN); else mpfr_set_si(M[coeff(i,n+1,n+1)], -1, GMP_RNDN); r = evaluateFaithfulWithCutOffFast(var1, w, NULL, x[i-1], zero_mpfr, prec); if(((r==1) || (r==4) || (r==5) || (r==6) || (r==7)) && (mpfr_number_p(var1))) test=1; else test=0; for (j=1 ; j <= n ; j++) { mpfr_init2(M[coeff(i,j,n+1)], prec); if(test==1) { r = evaluateFaithfulWithCutOffFast(var2, monomials_tree[j-1], NULL, x[i-1], zero_mpfr, prec); if(((r==1) || (r==4) || (r==5) || (r==6) || (r==7)) && (mpfr_number_p(var2))) { mpfr_mul(var2, var1, var2, GMP_RNDN); mpfr_set(M[coeff(i,j,n+1)],var2,GMP_RNDN); } } if((test==0) || (r==0) || (!mpfr_number_p(var2))) { printMessage(2,SOLLYA_MSG_REMEZ_COMPUTAT_OF_MATRIX_ENTRY_USES_SLOWER_ALGO,"Information: the construction of M[%d,%d] uses a slower algorithm\n",i,j); temp_tree = safeMalloc(sizeof(node)); temp_tree->nodeType = MUL; temp_tree->child1 = copyTree(monomials_tree[j-1]); temp_tree->child2 = copyTree(w); temp_tree = addMemRef(temp_tree); temp_tree2 = simplifyTreeErrorfree(temp_tree); free_memory(temp_tree); temp_tree = temp_tree2; /* temp_tree = x^(monomials[j])*w(x) */ r = evaluateFaithfulWithCutOffFast(var3, temp_tree, NULL, x[i-1], zero_mpfr, prec); if(r==0) mpfr_set_d(var3, 0., GMP_RNDN); mpfr_set(M[coeff(i,j,n+1)],var3,GMP_RNDN); free_memory(temp_tree); } } } mpfr_clear(zero_mpfr); mpfr_clear(var1); mpfr_clear(var2); mpfr_clear(var3); return M; } node *elementaryStepRemezAlgorithm(mpfr_t *h, node *func, node *weight, mpfr_t *x, node **monomials_tree, int n, mp_prec_t *currentPrec) { mpfr_t *M; mpfr_t *b, *ai_vect; int i,j; mpfr_t zero_mpfr; node *poly; int r; mpfr_init2(zero_mpfr, 53); mpfr_set_d(zero_mpfr, 0., GMP_RNDN); b = (mpfr_t *)(safeMalloc((n+1)*sizeof(mpfr_t))); ai_vect = (mpfr_t *)(safeMalloc((n+1)*sizeof(mpfr_t))); for(i=0;i<=n;i++) { mpfr_init2(b[i], *currentPrec); r=evaluateFaithfulWithCutOffFast(b[i], func, NULL, x[i], zero_mpfr, *currentPrec); if (r == 0) mpfr_set_d(b[i], 0., GMP_RNDN); } for(i=0;i<=n;i++) mpfr_init2(ai_vect[i], *currentPrec); M = remezMatrix(weight, x, monomials_tree, n, currentPrec); system_solve(ai_vect, M, b, n+1, *currentPrec); poly = constructPolynomialFromArray(ai_vect, monomials_tree, n); if (h!=NULL) mpfr_set(*h, ai_vect[n], GMP_RNDU); for(i=0;i<=n;i++) mpfr_clear(b[i]); safeFree(b); for(i=0;i<=n;i++) mpfr_clear(ai_vect[i]); safeFree(ai_vect); for(i=1;i<=n+1;i++) { for(j=1;j<=n+1;j++) mpfr_clear(M[coeff(i,j,n+1)]); } safeFree(M); mpfr_clear(zero_mpfr); return poly; } void radiusBasicMinimaxChebychevsPoints(mpfr_t *h, node *func, node *weight, mpfr_t a, mpfr_t b, int n, mp_prec_t *currentPrec) { mpfr_t *x; node **monomials_tree; int i; node *poly; monomials_tree = (node **)safeMalloc(n*sizeof(node *)); monomials_tree[0] = addMemRef(makeConstantDouble(1.)); for(i=1;impfr_get_prec(b))?(mpfr_get_prec(a)):(mpfr_get_prec(b)); sollya_mpfi_init2(tmp1, prec_tmp); sollya_mpfi_init2(tmp2, 12); sollya_mpfi_interv_fr(tmp1, a, b); evaluateInterval(tmp2, weight, NULL, tmp1); if (sollya_mpfi_has_infinity(tmp2)) { printMessage(1, SOLLYA_MSG_GUESSDEGREE_POSSIBLE_SINGULAR_WEIGHT, "Warning: guessdegree: the weight function might not be continuous over the given interval.\nThis is not allowed but it is the user's responsibility to check it.\nNo other test will be performed, but be aware that the command is allowed to return anything in this case.\n"); } sollya_mpfi_clear(tmp1); sollya_mpfi_clear(tmp2); } /* n reprensents the number of unknowns: n=1 corresponds to degree 0 */ /* bound represents the maximal value allowed for n. If we do not find a suitable n<=bound, we return an interval [*, +inf]. We assume bound>=1 */ /* We try n=1, 2, 4, 8, etc. until we find one for which the basic minimax problem achieve the required bound eps */ pushTimeCounter(); radiusBasicMinimaxChebychevsPoints(&h, func, weight, a, b, n, &prec); printMessage(4, SOLLYA_MSG_GUESSDEGREE_TRYING_A_CERTAIN_DEGREE, "Information: guessdegree: trying degree %d. Found radius: %v\n",n-1,h); /* If h= 0) { n *= 2; if (n=0) { /* Even n=bound does not achieve the discrete problem, a fortiori it does not achieve the continuous problem. Return [bound+1, +Inf] */ printMessage(1, SOLLYA_MSG_GUESSDEGREE_NONE_OF_LESSER_DEGS_SATISFIES_ERROR, "Warning: guessdegree: none of the degrees smaller than %d satisfies the required error.\n", bound-1); mpfr_clear(h); tempMpfr = (mpfr_t *)safeMalloc(sizeof(mpfr_t)); mpfr_init2(*tempMpfr,128); mpfr_set_ui(*tempMpfr, bound, GMP_RNDN); /* n=bound+1 converts to degree bound */ range.a = tempMpfr; tempMpfr = (mpfr_t *)safeMalloc(sizeof(mpfr_t)); mpfr_init2(*tempMpfr,128); mpfr_set_inf(*tempMpfr, 1); range.b = tempMpfr; return range; } /* Now, the basic minimax problem achieves eps for min(n,bound) but not for n/2. We use a bisection to obtain a thinner bound. Note that if n=1 achieves the bound eps, we have nothing to do */ if(n!=1) { n_min = n/2; n_max = (n<=bound)?n:bound; n = (n_min + n_max)/2; while(n != n_min) { radiusBasicMinimaxChebychevsPoints(&h, func, weight, a, b, n, &prec); printMessage(4, SOLLYA_MSG_GUESSDEGREE_TRYING_A_CERTAIN_DEG_WITHIN_BOUNDS, "Information: guessdegree: trying degree %d (current bounds: [%d, %d]). Found radius: %v\n",n-1,n_min-1,n_max-1,h); if(mpfr_cmp(h,eps) >= 0) n_min = n; else n_max = n; n = (n_min + n_max)/2; } } else n_max = 1; popTimeCounter("finding a lower bound for guessdegree"); /* Now n_min = n = n_max - 1 What we know for sure is: n_min is not sufficient to achieve the basic minimax problem. A fortiori, it is not sufficient for the continuous minimax problem. n_max is a possible candidate for the continuous minimax problem */ n = n_max; pushTimeCounter(); firstStepContinuousMinimaxChebychevsPoints(&h, func, weight, a, b, n, &prec); printMessage(4, SOLLYA_MSG_GUESSDEGREE_TRYING_A_CERTAIN_DEGREE, "Information: guessdegree: trying degree %d. Found infnorm: %v\n",n-1,h); while(mpfr_cmp(h,eps) > 0) { n++; if (n>bound) break; firstStepContinuousMinimaxChebychevsPoints(&h, func, weight, a, b, n, &prec); printMessage(4, SOLLYA_MSG_GUESSDEGREE_TRYING_A_CERTAIN_DEGREE, "Information: guessdegree: trying degree %d. Found infnorm: %v\n",n-1,h); } popTimeCounter("finding an upper bound for guessdegree"); /* if (n>bound), it is possible that n_max suffices, but we did not manage to prove that n suffices for any n_max<=n<=bound. So we return [n_max, +Inf]. Otherwise, we are sure that n is sufficient to achieve eps in the continuous problem. We return [n_max, n]; */ if (n>bound) printMessage(2, SOLLYA_MSG_GUESSDEG_NONE_OF_LESS_DEGS_SEEMS_TO_SATISFY_ERR, "Warning: guessdegree: we did not find a degree less than %d for which we can prove that the error is satisfied.\n", bound-1); mpfr_clear(h); tempMpfr = (mpfr_t *)safeMalloc(sizeof(mpfr_t)); mpfr_init2(*tempMpfr,128); mpfr_set_ui(*tempMpfr, n_max-1, GMP_RNDN); range.a = tempMpfr; tempMpfr = (mpfr_t *)safeMalloc(sizeof(mpfr_t)); mpfr_init2(*tempMpfr,128); if (n<=bound) mpfr_set_ui(*tempMpfr, n-1, GMP_RNDN); else mpfr_set_inf(*tempMpfr, 1); range.b = tempMpfr; return range; } sollya-6.0+ds/remez.h000066400000000000000000000062371300174114700145650ustar00rootroot00000000000000/* Copyright 2006-2014 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef REMEZ_H #define REMEZ_H #include #include "expression.h" #include "remez.h" #include "chain.h" #include "infnorm.h" chain *uncertifiedFindZeros(node *tree, mpfr_t a, mpfr_t b, unsigned long int points, mp_prec_t prec); node *remez(node *func, node *weight, chain *monomials, mpfr_t a, mpfr_t b, mpfr_t quality, mpfr_t satisfying_error, mpfr_t target_error, mp_prec_t prec); rangetype guessDegree(node *func, node *weight, mpfr_t a, mpfr_t b, mpfr_t eps, int bound); node *constructPolynomial(mpfr_t *coeff, chain *monomials, mp_prec_t prec); node *constructPolynomialFromArray(mpfr_t *coeff, node **monomials, int n); void findZero(mpfr_t res, node *f, node *f_diff, mpfr_t a, mpfr_t b, int sgnfa, mpfr_t *x0, int n, mp_prec_t prec); #endif /* ifdef REMEZ_H*/ sollya-6.0+ds/signalhandling.c000066400000000000000000000173471300174114700164240ustar00rootroot00000000000000/* Copyright 2013-2016 by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Contributors Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #define _POSIX_SOURCE #define _POSIX_C_SOURCE (200312L) #include #include #include #include #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "signalhandling.h" #define UNUSED_PARAM(_unused_param_x) ((void)(_unused_param_x)) extern jmp_buf recoverEnvironment; extern int handlingCtrlC; extern int lastHandledSignal; extern int recoverEnvironmentReady; extern int exitInsteadOfRecover; extern int libraryMode; int blockedSignalCounter = 0; int deferredMode = 0; int deferredSignal = 0; int deferredSignalIsDeferred = 0; int deferredCount = 0; int emulatedBlockedSignalCounter = 0; int sollyaFprintf(FILE *fd, const char *format, ...); void signalHandler(int i) { if (deferredMode) { if (deferredSignalIsDeferred) return; deferredSignal = i; deferredSignalIsDeferred = 1; return; } switch (i) { case SIGINT: handlingCtrlC = 1; lastHandledSignal = HANDLING_SIGINT; break; case SIGSEGV: lastHandledSignal = HANDLING_SIGSEGV; break; case SIGBUS: lastHandledSignal = HANDLING_SIGBUS; break; case SIGFPE: lastHandledSignal = HANDLING_SIGFPE; break; case SIGPIPE: lastHandledSignal = HANDLING_SIGPIPE; break; default: sollyaFprintf(stderr,"Error: must handle an unknown signal.\n"); exit(1); } if (recoverEnvironmentReady) { if (exitInsteadOfRecover) { sollyaFprintf(stderr,"Error: the recover environment has not been initialized. Exiting.\n"); exit(1); } longjmp(recoverEnvironment,1); } } RETSIGTYPE signalHandlerForSignal(int i) { if (!emulatedBlockedSignalCounter) { signalHandler(i); } return (RETSIGTYPE) 1; /* RETSIGTYPE is either int or void. When it is int, nothing happens. When it is void, C supports that cast and returns nothing. */ } static inline void deferSignalHandlingInner() { if (deferredMode) return; deferredMode = 1; deferredSignal = 0; deferredSignalIsDeferred = 0; } void deferSignalHandling() { deferredCount++; if (deferredCount > 0) deferSignalHandlingInner(); } static inline void resumeSignalHandlingInner() { if (!deferredMode) return; deferredMode = 0; if (!deferredSignalIsDeferred) return; deferredSignalIsDeferred = 0; signalHandler(deferredSignal); deferredSignal = 0; } void resumeSignalHandling() { deferredCount--; if (deferredCount <= 0) resumeSignalHandlingInner(); } void initSignalHandler(int nointeract) { #if (defined(HAVE_SIGACTION) && HAVE_SIGACTION) && (defined(HAVE_SIGADDSET) && HAVE_SIGADDSET) && (defined(HAVE_SIGEMPTYSET) && HAVE_SIGEMPTYSET) && (defined(HAVE_SIGPROCMASK) && HAVE_SIGPROCMASK) && (!defined(__CYGWIN__)) sigset_t mask; struct sigaction action; #endif blockedSignalCounter = 0; if (libraryMode) return; #if (defined(HAVE_SIGACTION) && HAVE_SIGACTION) && (defined(HAVE_SIGADDSET) && HAVE_SIGADDSET) && (defined(HAVE_SIGEMPTYSET) && HAVE_SIGEMPTYSET) && (defined(HAVE_SIGPROCMASK) && HAVE_SIGPROCMASK) && (!defined(__CYGWIN__)) action.sa_handler = signalHandler; action.sa_flags = 0; sigemptyset(&(action.sa_mask)); if (!nointeract) sigaddset(&(action.sa_mask),SIGINT); sigaddset(&(action.sa_mask),SIGSEGV); sigaddset(&(action.sa_mask),SIGBUS); sigaddset(&(action.sa_mask),SIGFPE); sigaddset(&(action.sa_mask),SIGPIPE); if (!nointeract) sigaction(SIGINT, &action, NULL); sigaction(SIGSEGV, &action, NULL); sigaction(SIGBUS, &action, NULL); sigaction(SIGFPE, &action, NULL); sigaction(SIGPIPE, &action, NULL); sigemptyset(&mask); if (!nointeract) sigaddset(&mask,SIGINT); sigaddset(&mask,SIGSEGV); sigaddset(&mask,SIGBUS); sigaddset(&mask,SIGFPE); sigaddset(&mask,SIGPIPE); sigprocmask(SIG_UNBLOCK, &mask, NULL); #else emulatedBlockedSignalCounter = 1; if (!nointeract) { if (signal(SIGINT, signalHandlerForSignal) == SIG_IGN) { signal(SIGINT, SIG_IGN); } } if (signal(SIGSEGV, signalHandlerForSignal) == SIG_IGN) { signal(SIGSEGV, SIG_IGN); } if (signal(SIGBUS, signalHandlerForSignal) == SIG_IGN) { signal(SIGBUS, SIG_IGN); } if (signal(SIGFPE, signalHandlerForSignal) == SIG_IGN) { signal(SIGFPE, SIG_IGN); } if (signal(SIGPIPE, signalHandlerForSignal) == SIG_IGN) { signal(SIGPIPE, SIG_IGN); } emulatedBlockedSignalCounter = 0; #endif } void blockSignals(int nointeract) { #if (defined(HAVE_SIGACTION) && HAVE_SIGACTION) && (defined(HAVE_SIGADDSET) && HAVE_SIGADDSET) && (defined(HAVE_SIGEMPTYSET) && HAVE_SIGEMPTYSET) && (defined(HAVE_SIGPROCMASK) && HAVE_SIGPROCMASK) && (!defined(__CYGWIN__)) sigset_t mask; #endif blockedSignalCounter = 0; if (libraryMode) return; #if (defined(HAVE_SIGACTION) && HAVE_SIGACTION) && (defined(HAVE_SIGADDSET) && HAVE_SIGADDSET) && (defined(HAVE_SIGEMPTYSET) && HAVE_SIGEMPTYSET) && (defined(HAVE_SIGPROCMASK) && HAVE_SIGPROCMASK) && (!defined(__CYGWIN__)) sigemptyset(&mask); if (!nointeract) sigaddset(&mask,SIGINT); sigaddset(&mask,SIGSEGV); sigaddset(&mask,SIGBUS); sigaddset(&mask,SIGFPE); sigaddset(&mask,SIGPIPE); sigprocmask(SIG_BLOCK, &mask, NULL); #else UNUSED_PARAM(nointeract); emulatedBlockedSignalCounter = 1; #endif } void initSignalHandlerCounted(int nointeract) { blockedSignalCounter--; if (blockedSignalCounter < 0) blockedSignalCounter = 0; if (blockedSignalCounter == 0) initSignalHandler(nointeract); } void blockSignalsCounted(int nointeract) { if (blockedSignalCounter < 0) blockedSignalCounter = 0; if (blockedSignalCounter == 0) blockSignals(nointeract); blockedSignalCounter++; } sollya-6.0+ds/signalhandling.h000066400000000000000000000051351300174114700164210ustar00rootroot00000000000000/* Copyright 2013-2015 by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, Contributors Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef SIGNALHANDLING_H #define SIGNALHANDLING_H /* Some internal signal numbers */ #define HANDLING_SIGINT 1 #define HANDLING_SIGSEGV 2 #define HANDLING_SIGBUS 3 #define HANDLING_SIGFPE 4 #define HANDLING_SIGPIPE 5 void initSignalHandler(int nointeract); void blockSignals(int nointeract); void initSignalHandlerCounted(int nointeract); void blockSignalsCounted(); void deferSignalHandling(); void resumeSignalHandling(); #endif /* ifdef SIGNALHANDLING_H*/ sollya-6.0+ds/sollya-library-wrappers.c000066400000000000000000006065241300174114700202510ustar00rootroot00000000000000/* Copyright 2011-2016 by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard and J. Benoit christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also herefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include #include #include #include #include #include #include #include "expression.h" #include "execute.h" #include "chain.h" #include "assignment.h" #include "mpfi-compat.h" #include "sollya-messaging.h" #include "sollya-library-wrappers.h" #include "printf.h" #include "infnorm.h" #include "double.h" #include "hash.h" /* Internal initialization state */ int __sollya_lib_initialized = 0; /* Some helper macros */ #define MAKE_THINGLIST_DECLS(__thinglist) \ va_list varlist; \ chain *__thinglist, *curr; \ node *elem #define MAKE_THINGLIST_DECLS_FROM_VA_LIST(__thinglist) \ chain *__thinglist, *curr; \ node *elem #define MAKE_THINGLIST_FROM_VARIADIC(__last) \ va_start(varlist,(__last)); \ thinglist = (chain *) safeMalloc(sizeof(chain)); \ thinglist->value = copyThing((__last)); \ thinglist->next = NULL; \ curr = thinglist; \ while ((elem = va_arg(varlist,node *)) != NULL) { \ curr->next = (chain *) safeMalloc(sizeof(chain)); \ curr = curr->next; \ curr->value = copyThing(elem); \ curr->next = NULL; \ } \ va_end(varlist) #define MAKE_THINGLIST_FROM_VA_LIST(__last, __varlist) \ thinglist = (chain *) safeMalloc(sizeof(chain)); \ thinglist->value = copyThing((__last)); \ thinglist->next = NULL; \ curr = thinglist; \ while ((elem = va_arg((__varlist),node *)) != NULL) { \ curr->next = (chain *) safeMalloc(sizeof(chain)); \ curr = curr->next; \ curr->value = copyThing(elem); \ curr->next = NULL; \ } \ (void) 1 /* MPFR and double precision zero normalizing functions The functions change a +/- 0 to +0 and do nothing with the rest of the inputs. */ static void __sollya_lib_internal_mpfr_zero_sign_normalize(mpfr_t op) { if (mpfr_zero_p(op)) { mpfr_mul(op,op,op,GMP_RNDN); /* (+/- 0)^2 = +0 */ } } static void __sollya_lib_internal_double_zero_sign_normalize(double *op) { if (*op == 0.0) { *op = *op * *op; /* (+/- 0)^2 = +0 */ } } /* Actual wrapper functions */ static int __sollya_lib_init_with_custom_memory_functions_with_arguments_with_custom_memory_function_modifiers(void *(*myMalloc)(size_t), void *(*myCalloc)(size_t, size_t), void *(*myRealloc)(void *, size_t), void (*myFree)(void*), void *(*myReallocWithSize)(void *, size_t, size_t), void (*myFreeWithSize)(void *, size_t), int argc, char **argv, void (*my_mp_set_func)(void *(*)(size_t), void *(*)(void *, size_t, size_t), void (*)(void *, size_t)), void (*my_mp_get_func)(void *(**)(size_t), void *(**)(void *, size_t, size_t), void (**)(void *, size_t))) { if (__sollya_lib_initialized < 0) __sollya_lib_initialized = 0; __sollya_lib_initialized++; if (__sollya_lib_initialized > 1) return 0; return initializeLibraryMode(myMalloc, myCalloc, myRealloc, myFree, myReallocWithSize, myFreeWithSize, argc, argv, my_mp_set_func, my_mp_get_func); } int sollya_lib_init_with_custom_memory_functions_with_custom_memory_function_modifiers(void *(*myMalloc)(size_t), void *(*myCalloc)(size_t, size_t), void *(*myRealloc)(void *, size_t), void (*myFree)(void*), void *(*myReallocWithSize)(void *, size_t, size_t), void (*myFreeWithSize)(void *, size_t), void (*my_mp_set_func)(void *(*)(size_t), void *(*)(void *, size_t, size_t), void (*)(void *, size_t)), void (*my_mp_get_func)(void *(**)(size_t), void *(**)(void *, size_t, size_t), void (**)(void *, size_t))) { return __sollya_lib_init_with_custom_memory_functions_with_arguments_with_custom_memory_function_modifiers(myMalloc, myCalloc, myRealloc, myFree, myReallocWithSize, myFreeWithSize, 0, NULL, my_mp_set_func, my_mp_get_func); } static int __sollya_lib_init_with_arguments_with_custom_memory_function_modifiers(int argc, char **argv, void (*my_mp_set_func)(void *(*)(size_t), void *(*)(void *, size_t, size_t), void (*)(void *, size_t)), void (*my_mp_get_func)(void *(**)(size_t), void *(**)(void *, size_t, size_t), void (**)(void *, size_t))) { return __sollya_lib_init_with_custom_memory_functions_with_arguments_with_custom_memory_function_modifiers(NULL, NULL, NULL, NULL, NULL, NULL, argc, argv, my_mp_set_func, my_mp_get_func); } int sollya_lib_init_with_custom_memory_function_modifiers(void (*my_mp_set_func)(void *(*)(size_t), void *(*)(void *, size_t, size_t), void (*)(void *, size_t)), void (*my_mp_get_func)(void *(**)(size_t), void *(**)(void *, size_t, size_t), void (**)(void *, size_t))) { return __sollya_lib_init_with_arguments_with_custom_memory_function_modifiers(0, NULL, my_mp_set_func, my_mp_get_func); } static int __sollya_lib_init_with_custom_memory_functions_with_arguments(void *(*myMalloc)(size_t), void *(*myCalloc)(size_t, size_t), void *(*myRealloc)(void *, size_t), void (*myFree)(void*), void *(*myReallocWithSize)(void *, size_t, size_t), void (*myFreeWithSize)(void *, size_t), int argc, char **argv) { return __sollya_lib_init_with_custom_memory_functions_with_arguments_with_custom_memory_function_modifiers(myMalloc, myCalloc, myRealloc, myFree, myReallocWithSize, myFreeWithSize, argc, argv, NULL, NULL); } int sollya_lib_init_with_custom_memory_functions(void *(*myMalloc)(size_t), void *(*myCalloc)(size_t, size_t), void *(*myRealloc)(void *, size_t), void (*myFree)(void*), void *(*myReallocWithSize)(void *, size_t, size_t), void (*myFreeWithSize)(void *, size_t)) { return __sollya_lib_init_with_custom_memory_functions_with_arguments(myMalloc, myCalloc, myRealloc, myFree, myReallocWithSize, myFreeWithSize, 0, NULL); } static int __sollya_lib_init_with_arguments(int argc, char **argv) { return __sollya_lib_init_with_arguments_with_custom_memory_function_modifiers(argc, argv, NULL, NULL); } int sollya_lib_init() { return __sollya_lib_init_with_arguments(0, NULL); } int sollya_lib_close() { __sollya_lib_initialized--; if (__sollya_lib_initialized < 0) __sollya_lib_initialized = 0; if (__sollya_lib_initialized > 0) return 0; return finalizeLibraryMode(); } int sollya_lib_install_msg_callback(int (*callback_func) (sollya_msg_t, void *), void *data) { return installMessageCallback(callback_func, data); } int sollya_lib_uninstall_msg_callback() { return uninstallMessageCallback(); } void sollya_lib_get_msg_callback(int (**fptr)(sollya_msg_t, void *), void **data) { int (*myfptr)(sollya_msg_t, void *); void *mydata; getMessageCallback(&myfptr, &mydata); if (fptr != NULL) *fptr = myfptr; if (data != NULL) *data = mydata; } int sollya_lib_get_msg_id(sollya_msg_t msg) { return getMessageId(msg); } char *sollya_lib_msg_to_text(sollya_msg_t msg) { return messageNumberToText(getMessageId(msg)); } int sollya_lib_printf(const char *format, ...) { va_list varlist; int res; va_start(varlist,format); res = sollyaVfprintf(stdout,format,varlist); va_end(varlist); return res; } int sollya_lib_v_printf(const char *format, va_list varlist) { int res; res = sollyaVfprintf(stdout,format,varlist); return res; } int sollya_lib_fprintf(FILE *fd, const char *format, ...) { va_list varlist; int res; va_start(varlist,format); res = sollyaVfprintf(fd,format,varlist); va_end(varlist); return res; } int sollya_lib_v_fprintf(FILE *fd, const char *format, va_list varlist) { int res; res = sollyaVfprintf(fd,format,varlist); return res; } int sollya_lib_sprintf(char *str, const char *format, ...) { va_list varlist; int res; va_start(varlist,format); res = sollyaInternalVsprintf(str, format, varlist); va_end(varlist); return res; } int sollya_lib_v_sprintf(char *str, const char *format, va_list varlist) { return sollyaInternalVsprintf(str, format, varlist); } int sollya_lib_snprintf(char *str, size_t size, const char *format, ...) { va_list varlist; int res; va_start(varlist,format); res = sollyaInternalVsnprintf(str, size, format, varlist); va_end(varlist); return res; } int sollya_lib_v_snprintf(char *str, size_t size, const char *format, va_list varlist) { return sollyaInternalVsnprintf(str, size, format, varlist); } void sollya_lib_printlibrarymessage(int verb, const char *str) { sollyaLibPrintmessage((verb < 0 ? 0 : verb), 0, "%s", str); } void sollya_lib_clear_obj(sollya_obj_t obj1) { freeThing(obj1); } void sollya_lib_free(void *ptr) { if (ptr == NULL) return; safeFree(ptr); } void *sollya_lib_malloc(size_t size) { return safeMalloc(size); } void *sollya_lib_calloc(size_t nmemb, size_t size) { return safeCalloc(nmemb, size); } void *sollya_lib_realloc(void *ptr, size_t size) { return safeRealloc(ptr, size); } sollya_obj_t sollya_lib_copy_obj(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return copyThing(obj1); } int sollya_lib_cmp_objs_structurally(sollya_obj_t obj1, sollya_obj_t obj2) { if (obj1 == NULL) return 0; if (obj2 == NULL) return 0; if (obj1 == obj2) return 1; return isEqualThingLibrary(obj1, obj2); } void sollya_lib_name_free_variable(const char *str) { if (str == NULL) return; if (variablename != NULL) { safeFree(variablename); variablename = NULL; } variablename = (char *) safeCalloc(strlen(str) + 1, sizeof(char)); strcpy(variablename, str); } char *sollya_lib_get_free_variable_name() { char unnamed[] = "_x_"; char *staticName, *res; staticName = unnamed; if (variablename != NULL) staticName = variablename; res = (char *) safeCalloc(strlen(staticName) + 1, sizeof(char)); strcpy(res,staticName); return res; } void sollya_lib_plot(sollya_obj_t obj1, sollya_obj_t obj2, ...) { node *thingToExecute; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return; if (obj2 == NULL) return; MAKE_THINGLIST_FROM_VARIADIC(obj2); thingToExecute = addMemRef(makePlot(addElement(thinglist, copyThing(obj1)))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_v_plot(sollya_obj_t obj1, sollya_obj_t obj2, va_list varlist) { node *thingToExecute; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return; if (obj2 == NULL) return; MAKE_THINGLIST_FROM_VA_LIST(obj2,varlist); thingToExecute = addMemRef(makePlot(addElement(thinglist, copyThing(obj1)))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_printdouble(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makePrintHexa(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_printsingle(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makePrintFloat(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_printexpansion(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makePrintExpansion(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_bashexecute(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeBashExecute(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_externalplot(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, sollya_obj_t obj4, sollya_obj_t obj5, ...) { node *thingToExecute; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return; if (obj2 == NULL) return; if (obj3 == NULL) return; if (obj4 == NULL) return; if (obj5 == NULL) return; MAKE_THINGLIST_FROM_VARIADIC(obj5); thingToExecute = addMemRef(makeExternalPlot(addElement(addElement(addElement(addElement(thinglist, copyThing(obj4)),copyThing(obj3)),copyThing(obj2)),copyThing(obj1)))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_v_externalplot(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, sollya_obj_t obj4, sollya_obj_t obj5, va_list varlist) { node *thingToExecute; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return; if (obj2 == NULL) return; if (obj3 == NULL) return; if (obj4 == NULL) return; if (obj5 == NULL) return; MAKE_THINGLIST_FROM_VA_LIST(obj5,varlist); thingToExecute = addMemRef(makeExternalPlot(addElement(addElement(addElement(addElement(thinglist, copyThing(obj4)),copyThing(obj3)),copyThing(obj2)),copyThing(obj1)))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_asciiplot(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToExecute; if (obj1 == NULL) return; if (obj2 == NULL) return; thingToExecute = addMemRef(makeAsciiPlot(copyThing(obj1),copyThing(obj2))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_execute(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeExecute(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_printxml(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makePrintXml(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_printxml_newfile(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToExecute; if (obj1 == NULL) return; if (obj2 == NULL) return; thingToExecute = addMemRef(makePrintXmlNewFile(copyThing(obj1),copyThing(obj2))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_printxml_appendfile(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToExecute; if (obj1 == NULL) return; if (obj2 == NULL) return; thingToExecute = addMemRef(makePrintXmlAppendFile(copyThing(obj1),copyThing(obj2))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_worstcase(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, sollya_obj_t obj4, sollya_obj_t obj5, ...) { node *thingToExecute; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return; if (obj2 == NULL) return; if (obj3 == NULL) return; if (obj4 == NULL) return; if (obj5 == NULL) return; MAKE_THINGLIST_FROM_VARIADIC(obj5); thingToExecute = addMemRef(makeWorstCase(addElement(addElement(addElement(addElement(thinglist, copyThing(obj4)),copyThing(obj3)),copyThing(obj2)),copyThing(obj1)))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_v_worstcase(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, sollya_obj_t obj4, sollya_obj_t obj5, va_list varlist) { node *thingToExecute; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return; if (obj2 == NULL) return; if (obj3 == NULL) return; if (obj4 == NULL) return; if (obj5 == NULL) return; MAKE_THINGLIST_FROM_VA_LIST(obj5,varlist); thingToExecute = addMemRef(makeWorstCase(addElement(addElement(addElement(addElement(thinglist, copyThing(obj4)),copyThing(obj3)),copyThing(obj2)),copyThing(obj1)))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_autoprint(sollya_obj_t obj1, ...) { node *thingToExecute; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return; MAKE_THINGLIST_FROM_VARIADIC(obj1); thingToExecute = addMemRef(makeAutoprint(thinglist)); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_suppressmessage(sollya_obj_t obj1, ...) { node *thingToExecute; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return; MAKE_THINGLIST_FROM_VARIADIC(obj1); thingToExecute = addMemRef(makeSuppressMessage(thinglist)); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_unsuppressmessage(sollya_obj_t obj1, ...) { node *thingToExecute; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return; MAKE_THINGLIST_FROM_VARIADIC(obj1); thingToExecute = addMemRef(makeUnsuppressMessage(thinglist)); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_implementconstant(sollya_obj_t obj1, ...) { node *thingToExecute; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return; MAKE_THINGLIST_FROM_VARIADIC(obj1); thingToExecute = addMemRef(makeImplementConst(thinglist)); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_v_implementconstant(sollya_obj_t obj1, va_list varlist) { node *thingToExecute; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return; MAKE_THINGLIST_FROM_VA_LIST(obj1,varlist); thingToExecute = addMemRef(makeImplementConst(thinglist)); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_v_autoprint(sollya_obj_t obj1, va_list varlist) { node *thingToExecute; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return; MAKE_THINGLIST_FROM_VA_LIST(obj1,varlist); thingToExecute = addMemRef(makeAutoprint(thinglist)); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_v_suppressmessage(sollya_obj_t obj1, va_list varlist) { node *thingToExecute; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return; MAKE_THINGLIST_FROM_VA_LIST(obj1,varlist); thingToExecute = addMemRef(makeSuppressMessage(thinglist)); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_v_unsuppressmessage(sollya_obj_t obj1, va_list varlist) { node *thingToExecute; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return; MAKE_THINGLIST_FROM_VA_LIST(obj1,varlist); thingToExecute = addMemRef(makeUnsuppressMessage(thinglist)); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_prec_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makePrecAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_points_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makePointsAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_diam_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeDiamAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_display_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeDisplayAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_verbosity_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeVerbosityAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_canonical_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeCanonicalAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_autosimplify_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeAutoSimplifyAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_fullparentheses_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeFullParenAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_showmessagenumbers_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeShowMessageNumbersAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_taylorrecursions_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeTaylorRecursAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_timing_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeTimingAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_midpointmode_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeMidpointAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_dieonerrormode_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeDieOnErrorAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_rationalmode_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeRationalModeAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_roundingwarnings_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeSuppressWarningsAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_hopitalrecursions_and_print(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeHopitalRecursAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_prec(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makePrecStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_points(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makePointsStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_diam(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeDiamStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_display(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeDisplayStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_verbosity(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeVerbosityStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_canonical(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeCanonicalStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_autosimplify(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeAutoSimplifyStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_fullparentheses(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeFullParenStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_showmessagenumbers(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeShowMessageNumbersStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_taylorrecursions(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeTaylorRecursStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_timing(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeTimingStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_midpointmode(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeMidpointStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_dieonerrormode(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeDieOnErrorStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_rationalmode(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeRationalModeStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_roundingwarnings(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeSuppressWarningsStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } void sollya_lib_set_hopitalrecursions(sollya_obj_t obj1) { node *thingToExecute; if (obj1 == NULL) return; thingToExecute = addMemRef(makeHopitalRecursStillAssign(copyThing(obj1))); executeCommand(thingToExecute); freeThing(thingToExecute); } sollya_obj_t sollya_lib_free_variable() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeVariable()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_and(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeAnd(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_or(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeOr(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_negate(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeNegation(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_cmp_equal(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeCompareEqual(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_cmp_in(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeCompareIn(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_cmp_less(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeCompareLess(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_cmp_greater(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeCompareGreater(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_cmp_less_equal(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeCompareLessEqual(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_cmp_greater_equal(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeCompareGreaterEqual(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_cmp_not_equal(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeCompareNotEqual(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_add(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeAdd(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_sub(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeSub(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_concat(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeConcat(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_append(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeAppend(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_prepend(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makePrepend(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_apply(sollya_obj_t obj1, ...) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return NULL; MAKE_THINGLIST_FROM_VARIADIC(obj1); if (thinglist->next == NULL) { thinglist->next = (chain *) safeMalloc(sizeof(chain)); thinglist->next->value = makeUnit(); thinglist->next->next = NULL; } thingToEvaluate = addMemRef(makeApply((node *) (thinglist->value), thinglist->next)); evaluatedThing = evaluateThing(thingToEvaluate); safeFree(thinglist); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_v_apply(sollya_obj_t obj1, va_list varlist) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return NULL; MAKE_THINGLIST_FROM_VA_LIST(obj1,varlist); if (thinglist->next == NULL) { thinglist->next = (chain *) safeMalloc(sizeof(chain)); thinglist->next->value = makeUnit(); thinglist->next->next = NULL; } thingToEvaluate = addMemRef(makeApply((node *) (thinglist->value), thinglist->next)); evaluatedThing = evaluateThing(thingToEvaluate); safeFree(thinglist); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_execute_procedure(sollya_obj_t obj1, ...) { node *thingToEvaluate, *evaluatedThing; va_list varlist; chain *thinglist, *curr; node *elem; if (obj1 == NULL) return NULL; va_start(varlist,obj1); elem = va_arg(varlist,node *); if (elem == NULL) { thinglist = addElement(NULL,makeUnit()); } else { thinglist = (chain *) safeMalloc(sizeof(chain)); thinglist->value = copyThing(elem); thinglist->next = NULL; curr = thinglist; while ((elem = va_arg(varlist,node *)) != NULL) { curr->next = (chain *) safeMalloc(sizeof(chain)); curr = curr->next; curr->value = copyThing(elem); curr->next = NULL; } } va_end(varlist); thingToEvaluate = addMemRef(makeApply(copyThing(obj1),thinglist)); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_v_execute_procedure(sollya_obj_t obj1, va_list varlist) { node *thingToEvaluate, *evaluatedThing; chain *thinglist, *curr; node *elem; if (obj1 == NULL) return NULL; elem = va_arg(varlist,node *); if (elem == NULL) { thinglist = addElement(NULL,makeUnit()); } else { thinglist = (chain *) safeMalloc(sizeof(chain)); thinglist->value = copyThing(elem); thinglist->next = NULL; curr = thinglist; while ((elem = va_arg(varlist,node *)) != NULL) { curr->next = (chain *) safeMalloc(sizeof(chain)); curr = curr->next; curr->value = copyThing(elem); curr->next = NULL; } } thingToEvaluate = addMemRef(makeApply(copyThing(obj1),thinglist)); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_approx(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeEvalConst(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_mul(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeMul(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_div(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeDiv(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_pow(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makePow(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_neg(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeNeg(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_sup(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeDeboundMax(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_mid(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeDeboundMid(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_inf(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeDeboundMin(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_diff(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeDiff(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_bashevaluate(sollya_obj_t obj1, ...) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return NULL; MAKE_THINGLIST_FROM_VARIADIC(obj1); thingToEvaluate = addMemRef(makeBashevaluate(thinglist)); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_v_bashevaluate(sollya_obj_t obj1, va_list varlist) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return NULL; MAKE_THINGLIST_FROM_VA_LIST(obj1,varlist); thingToEvaluate = addMemRef(makeBashevaluate(thinglist)); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_getsuppressedmessages() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeGetSuppressedMessages()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_getbacktrace() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeGetBacktrace()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_remez(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, ...) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; MAKE_THINGLIST_FROM_VARIADIC(obj3); thingToEvaluate = addMemRef(makeRemez(addElement(addElement(thinglist, copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_v_remez(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, va_list varlist) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; MAKE_THINGLIST_FROM_VA_LIST(obj3,varlist); thingToEvaluate = addMemRef(makeRemez(addElement(addElement(thinglist, copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_annotatefunction(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, sollya_obj_t obj4, ...) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; if (obj4 == NULL) return NULL; MAKE_THINGLIST_FROM_VARIADIC(obj4); thingToEvaluate = addMemRef(makeAnnotateFunction(addElement(addElement(addElement(thinglist, copyThing(obj3)), copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_v_annotatefunction(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, sollya_obj_t obj4, va_list varlist) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; if (obj4 == NULL) return NULL; MAKE_THINGLIST_FROM_VA_LIST(obj4,varlist); thingToEvaluate = addMemRef(makeAnnotateFunction(addElement(addElement(addElement(thinglist, copyThing(obj3)), copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_min(sollya_obj_t obj1, ...) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return NULL; MAKE_THINGLIST_FROM_VARIADIC(obj1); thingToEvaluate = addMemRef(makeMin(thinglist)); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_v_min(sollya_obj_t obj1, va_list varlist) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return NULL; MAKE_THINGLIST_FROM_VA_LIST(obj1,varlist); thingToEvaluate = addMemRef(makeMin(thinglist)); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_max(sollya_obj_t obj1, ...) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return NULL; MAKE_THINGLIST_FROM_VARIADIC(obj1); thingToEvaluate = addMemRef(makeMax(thinglist)); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_v_max(sollya_obj_t obj1, va_list varlist) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return NULL; MAKE_THINGLIST_FROM_VA_LIST(obj1,varlist); thingToEvaluate = addMemRef(makeMax(thinglist)); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_fpminimax(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, sollya_obj_t obj4, ...) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; if (obj4 == NULL) return NULL; MAKE_THINGLIST_FROM_VARIADIC(obj4); thingToEvaluate = addMemRef(makeFPminimax(addElement(addElement(addElement(thinglist, copyThing(obj3)), copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_v_fpminimax(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, sollya_obj_t obj4, va_list varlist) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; if (obj4 == NULL) return NULL; MAKE_THINGLIST_FROM_VA_LIST(obj4,varlist); thingToEvaluate = addMemRef(makeFPminimax(addElement(addElement(addElement(thinglist, copyThing(obj3)), copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_horner(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeHorner(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_canonical(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeCanonicalThing(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_expand(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeExpand(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_dirtysimplify(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeDirtysimplify(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_simplify(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeSimplifySafe(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_taylor(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; thingToEvaluate = addMemRef(makeTaylor(copyThing(obj1),copyThing(obj2),copyThing(obj3))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_taylorform(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, ...) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; MAKE_THINGLIST_FROM_VARIADIC(obj3); thingToEvaluate = addMemRef(makeTaylorform(addElement(addElement(thinglist, copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_v_taylorform(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, va_list varlist) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; MAKE_THINGLIST_FROM_VA_LIST(obj3,varlist); thingToEvaluate = addMemRef(makeTaylorform(addElement(addElement(thinglist, copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_chebyshevform(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; thingToEvaluate = addMemRef(makeChebyshevform(addElement(addElement(addElement(NULL,copyThing(obj3)),copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_autodiff(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; thingToEvaluate = addMemRef(makeAutodiff(addElement(addElement(addElement(NULL,copyThing(obj3)),copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_degree(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeDegree(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_numerator(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeNumerator(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_denominator(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeDenominator(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_substitute(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeSubstitute(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_composepolynomials(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeComposePolynomials(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_coeff(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeCoeff(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_subpoly(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeSubpoly(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_roundcoefficients(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeRoundcoefficients(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_rationalapprox(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeRationalapprox(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_round(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; thingToEvaluate = addMemRef(makeRoundToFormat(copyThing(obj1),copyThing(obj2),copyThing(obj3))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_evaluate(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeEvaluate(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_parse(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeParse(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_readxml(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeReadXml(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_infnorm(sollya_obj_t obj1, sollya_obj_t obj2, ...) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; MAKE_THINGLIST_FROM_VARIADIC(obj2); thingToEvaluate = addMemRef(makeInfnorm(addElement(thinglist, copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_v_infnorm(sollya_obj_t obj1, sollya_obj_t obj2, va_list varlist) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; MAKE_THINGLIST_FROM_VA_LIST(obj2,varlist); thingToEvaluate = addMemRef(makeInfnorm(addElement(thinglist, copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_supnorm(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, sollya_obj_t obj4, sollya_obj_t obj5) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; if (obj4 == NULL) return NULL; if (obj5 == NULL) return NULL; thingToEvaluate = addMemRef(makeSupnorm(addElement(addElement(addElement(addElement(addElement(NULL,copyThing(obj5)),copyThing(obj4)), copyThing(obj3)),copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_findzeros(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeFindZeros(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_dirtyinfnorm(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeDirtyInfnorm(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_numberroots(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeNumberRoots(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_integral(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeIntegral(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_dirtyintegral(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeDirtyIntegral(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_implementpoly(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, sollya_obj_t obj4, sollya_obj_t obj5, sollya_obj_t obj6, ...) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; if (obj4 == NULL) return NULL; if (obj5 == NULL) return NULL; if (obj6 == NULL) return NULL; MAKE_THINGLIST_FROM_VARIADIC(obj6); thingToEvaluate = addMemRef(makeImplementPoly(addElement(addElement(addElement(addElement(addElement(thinglist, copyThing(obj5)), copyThing(obj4)),copyThing(obj3)),copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_v_implementpoly(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, sollya_obj_t obj4, sollya_obj_t obj5, sollya_obj_t obj6, va_list varlist) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; if (obj4 == NULL) return NULL; if (obj5 == NULL) return NULL; if (obj6 == NULL) return NULL; MAKE_THINGLIST_FROM_VA_LIST(obj6,varlist); thingToEvaluate = addMemRef(makeImplementPoly(addElement(addElement(addElement(addElement(addElement(thinglist, copyThing(obj5)), copyThing(obj4)),copyThing(obj3)),copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_checkinfnorm(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; thingToEvaluate = addMemRef(makeCheckInfnorm(copyThing(obj1),copyThing(obj2),copyThing(obj3))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_searchgal(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, sollya_obj_t obj4, sollya_obj_t obj5, sollya_obj_t obj6) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; if (obj4 == NULL) return NULL; if (obj5 == NULL) return NULL; if (obj6 == NULL) return NULL; thingToEvaluate = addMemRef(makeSearchGal(addElement(addElement(addElement(addElement(addElement(addElement(NULL,copyThing(obj6)),copyThing(obj5)),copyThing(obj4)), copyThing(obj3)),copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_guessdegree(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, ...) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; MAKE_THINGLIST_FROM_VARIADIC(obj3); thingToEvaluate = addMemRef(makeGuessDegree(addElement(addElement(thinglist, copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_v_guessdegree(sollya_obj_t obj1, sollya_obj_t obj2, sollya_obj_t obj3, va_list varlist) { node *thingToEvaluate, *evaluatedThing; MAKE_THINGLIST_DECLS_FROM_VA_LIST(thinglist); if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; if (obj3 == NULL) return NULL; MAKE_THINGLIST_FROM_VA_LIST(obj3,varlist); thingToEvaluate = addMemRef(makeGuessDegree(addElement(addElement(thinglist, copyThing(obj2)),copyThing(obj1)))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_dirtyfindzeros(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = addMemRef(makeDirtyFindZeros(copyThing(obj1),copyThing(obj2))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_head(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeHead(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_roundcorrectly(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeRoundCorrectly(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_revert(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeRevert(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_sort(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeSort(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_mantissa(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeMantissa(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_precision(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makePrecision(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_exponent(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeExponent(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_tail(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeTail(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_range(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = makeRange(copyThing(obj1),copyThing(obj2)); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return addMemRef(evaluatedThing); } sollya_obj_t sollya_lib_sqrt(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeSqrt(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_exp(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeExp(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_log(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeLog(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_log2(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeLog2(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_log10(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeLog10(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_sin(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeSin(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_cos(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeCos(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_tan(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeTan(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_asin(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeAsin(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_acos(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeAcos(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_atan(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeAtan(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_sinh(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeSinh(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_cosh(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeCosh(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_tanh(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeTanh(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_asinh(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeAsinh(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_acosh(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeAcosh(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_atanh(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeAtanh(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_abs(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeAbs(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_erf(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeErf(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_erfc(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeErfc(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_log1p(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeLog1p(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_expm1(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeExpm1(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_double(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeDouble(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_single(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeSingle(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_quad(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeQuad(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_halfprecision(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeHalfPrecision(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_double_double(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeDoubledouble(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_triple_double(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeTripledouble(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_doubleextended(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeDoubleextended(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_ceil(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeCeil(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_floor(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeFloor(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_nearestint(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeNearestInt(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_libraryconstant(char *name, void (*func)(mpfr_t, mp_prec_t)) { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = sollya_lib_build_function_libraryconstant(name, func); if (thingToEvaluate == NULL) return NULL; thingToEvaluate = addMemRef(thingToEvaluate); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_libraryfunction(sollya_obj_t obj1, char *name, int (*func)(mpfi_t, mpfi_t, int)) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = sollya_lib_build_function_libraryfunction(copyThing(obj1),name,func); if (thingToEvaluate == NULL) return NULL; thingToEvaluate = addMemRef(thingToEvaluate); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_libraryconstant_with_data(char *name, void (*func)(mpfr_t, mp_prec_t, void *), void *data, void (*dealloc)(void *)) { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = sollya_lib_build_function_libraryconstant_with_data(name, func, data, dealloc); if (thingToEvaluate == NULL) return NULL; thingToEvaluate = addMemRef(thingToEvaluate); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_libraryfunction_with_data(sollya_obj_t obj1, char *name, int (*func)(mpfi_t, mpfi_t, int, void *), void *data, void (*dealloc)(void *)) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = sollya_lib_build_function_libraryfunction_with_data(copyThing(obj1),name,func,data,dealloc); if (thingToEvaluate == NULL) return NULL; thingToEvaluate = addMemRef(thingToEvaluate); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_procedurefunction(sollya_obj_t obj1, sollya_obj_t obj2) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; thingToEvaluate = sollya_lib_build_function_procedurefunction(copyThing(obj1), copyThing(obj2)); if (thingToEvaluate == NULL) return NULL; thingToEvaluate = addMemRef(thingToEvaluate); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_length(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeLength(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_objectname(sollya_obj_t obj1) { node *thingToEvaluate, *evaluatedThing; if (obj1 == NULL) return NULL; thingToEvaluate = addMemRef(makeObjectName(copyThing(obj1))); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_prec() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makePrecDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_points() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makePointsDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_diam() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeDiamDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_display() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeDisplayDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_verbosity() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeVerbosityDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_canonical() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeCanonicalDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_autosimplify() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeAutoSimplifyDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_fullparentheses() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeFullParenDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_showmessagenumbers() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeShowMessageNumbersDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_taylorrecursions() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeTaylorRecursDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_timing() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeTimingDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_midpointmode() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeMidpointDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_dieonerrormode() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeDieOnErrorDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_rationalmode() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeRationalModeDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_roundingwarnings() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeSuppressWarningsDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_get_hopitalrecursions() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeHopitalRecursDeref()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_on() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeOn()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_off() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeOff()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_dyadic() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeDyadic()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_powers() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makePowers()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_binary() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeBinaryThing()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_hexadecimal() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeHexadecimalThing()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_file() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeFile()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_postscript() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makePostscript()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_postscriptfile() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makePostscriptFile()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_perturb() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makePerturb()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_round_down() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeRoundDown()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_round_up() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeRoundUp()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_round_towards_zero() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeRoundToZero()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_round_to_nearest() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeRoundToNearest()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_honorcoeffprec() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeHonorCoeff()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_true() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeTrue()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_false() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeFalse()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_void() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeUnit()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_default() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeDefault()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_decimal() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeDecimal()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_absolute() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeAbsolute()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_relative() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeRelative()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_fixed() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeFixed()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_floating() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeFloating()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_error() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeError()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_double_obj() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeDoubleSymbol()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_single_obj() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeSingleSymbol()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_quad_obj() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeQuadSymbol()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_halfprecision_obj() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeHalfPrecisionSymbol()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_doubleextended_obj() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeDoubleextendedSymbol()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_double_double_obj() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeDoubleDoubleSymbol()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_triple_double_obj() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makeTripleDoubleSymbol()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_pi() { node *thingToEvaluate, *evaluatedThing; thingToEvaluate = addMemRef(makePi()); evaluatedThing = evaluateThing(thingToEvaluate); freeThing(thingToEvaluate); return evaluatedThing; } sollya_obj_t sollya_lib_parse_string(const char *str) { if (str == NULL) return addMemRef(parseString("")); return addMemRef(parseString((char *) str)); } sollya_obj_t sollya_lib_string(char *str) { char *mystr; int dealloc; sollya_obj_t res; dealloc = 0; if (str == NULL) { mystr = safeCalloc(2, sizeof(char)); mystr[0] = '\0'; dealloc = 1; } else { mystr = str; dealloc = 0; } res = addMemRef(makeString(str)); if (dealloc) safeFree(mystr); return res; } sollya_obj_t sollya_lib_range_from_interval(mpfi_t interval) { sollya_obj_t temp, res; mp_prec_t prec; mpfr_t left, right; sollya_mpfi_t myInterval; sollya_init_and_convert_interval(myInterval, interval); prec = sollya_mpfi_get_prec(myInterval); mpfr_init2(left,prec); mpfr_init2(right,prec); sollya_mpfi_get_left(left,myInterval); sollya_mpfi_get_right(right,myInterval); temp = makeRange(makeConstant(left),makeConstant(right)); res = evaluateThing(temp); freeThing(temp); mpfr_clear(left); mpfr_clear(right); sollya_mpfi_clear(myInterval); return addMemRef(res); } sollya_obj_t sollya_lib_range_from_bounds(mpfr_t left, mpfr_t right) { sollya_obj_t temp, res; temp = makeRange(makeConstant(left),makeConstant(right)); res = evaluateThing(temp); freeThing(temp); return addMemRef(res); } sollya_obj_t sollya_lib_constant(mpfr_t value) { return addMemRef(makeConstant(value)); } sollya_obj_t sollya_lib_constant_from_double(double value) { sollya_obj_t temp; mpfr_t valueAsMpfr; mpfr_init2(valueAsMpfr,64); /* On some systems, doubles actually are double-extended */ mpfr_set_d(valueAsMpfr, value, GMP_RNDN); temp = addMemRef(makeConstant(valueAsMpfr)); mpfr_clear(valueAsMpfr); return temp; } sollya_obj_t sollya_lib_constant_from_int(int value) { sollya_obj_t temp; mpfr_t valueAsMpfr; mpfr_init2(valueAsMpfr,8 * sizeof(int) + 5); mpfr_set_si(valueAsMpfr, value, GMP_RNDN); temp = addMemRef(makeConstant(valueAsMpfr)); mpfr_clear(valueAsMpfr); return temp; } static int __sollya_lib_helper_mpfr_from_int64(mpfr_t rop, int64_t value, mp_rnd_t rnd) { double valueDoubleHi, valueDoubleLo; int64_t valueHi, valueLo, tempInt64; mpfr_t valueMpfr, tempMpfr; int res; /* Cut the 64 bit signed value into two pieces such that value = valueHi * 2^32 + valueLo. Then convert both values to double, which will always hold. Adjust the high value. Finally convert to MPFR. */ valueHi = value; valueHi >>= 32; /* Performs floor, even signed */ tempInt64 = valueHi; tempInt64 <<= 32; /* Exact */ valueLo = value - tempInt64; valueDoubleHi = (double) valueHi; valueDoubleLo = (double) valueLo; valueDoubleHi *= 4294967296.0; /* Multiply by 2^32 */ mpfr_init2(valueMpfr, 64); mpfr_init2(tempMpfr, 64); mpfr_set_d(valueMpfr, valueDoubleHi, GMP_RNDN); mpfr_set_d(tempMpfr, valueDoubleLo, GMP_RNDN); mpfr_add(valueMpfr, valueMpfr, tempMpfr, GMP_RNDN); /* exact */ /* Set the result, this may round and sets the ternary value */ res = mpfr_set(rop, valueMpfr, rnd); mpfr_clear(tempMpfr); mpfr_clear(valueMpfr); return res; } static int __sollya_lib_helper_mpfr_from_uint64(mpfr_t rop, uint64_t value, mp_rnd_t rnd) { double valueDoubleHi, valueDoubleLo; uint64_t valueHi, valueLo, tempInt64; mpfr_t valueMpfr, tempMpfr; int res; /* Cut the 64 bit unsigned value into two pieces such that value = valueHi * 2^32 + valueLo. Then convert both values to double, which will always hold. Adjust the high value. Finally convert to MPFR. */ valueHi = value; valueHi >>= 32; /* Performs floor */ tempInt64 = valueHi; tempInt64 <<= 32; /* Exact */ valueLo = value - tempInt64; valueDoubleHi = (double) valueHi; valueDoubleLo = (double) valueLo; valueDoubleHi *= 4294967296.0; /* Multiply by 2^32 */ mpfr_init2(valueMpfr, 64); mpfr_init2(tempMpfr, 64); mpfr_set_d(valueMpfr, valueDoubleHi, GMP_RNDN); mpfr_set_d(tempMpfr, valueDoubleLo, GMP_RNDN); mpfr_add(valueMpfr, valueMpfr, tempMpfr, GMP_RNDN); /* exact */ /* Set the result, this may round and sets the ternary value */ res = mpfr_set(rop, valueMpfr, rnd); mpfr_clear(valueMpfr); mpfr_clear(tempMpfr); return res; } sollya_obj_t sollya_lib_constant_from_int64(int64_t value) { sollya_obj_t temp; mpfr_t valueMpfr; mpfr_init2(valueMpfr, 64); __sollya_lib_helper_mpfr_from_int64(valueMpfr, value, GMP_RNDN); /* exact as 64 are enough */ temp = addMemRef(makeConstant(valueMpfr)); mpfr_clear(valueMpfr); return temp; } sollya_obj_t sollya_lib_constant_from_uint64(uint64_t value) { sollya_obj_t temp; mpfr_t valueMpfr; mpfr_init2(valueMpfr, 64); __sollya_lib_helper_mpfr_from_uint64(valueMpfr, value, GMP_RNDN); /* exact as 64 are enough */ temp = addMemRef(makeConstant(valueMpfr)); mpfr_clear(valueMpfr); return temp; } sollya_obj_t sollya_lib_constant_from_mpz(mpz_t value) { mpfr_t temp; sollya_obj_t res; mpfr_init2(temp, getMpzPrecision(value)); mpfr_set_z(temp, value, GMP_RNDN); /* exact as precision determined to make it exact */ res = addMemRef(sollya_lib_constant(temp)); mpfr_clear(temp); return res; } sollya_obj_t sollya_lib_constant_from_mpq(mpq_t value) { mpz_t numerator, denominator; sollya_obj_t res, simplifiedRes; mpz_init(numerator); mpz_init(denominator); mpq_get_num(numerator, value); mpq_get_den(denominator, value); res = addMemRef(makeDiv(sollya_lib_constant_from_mpz(numerator), sollya_lib_constant_from_mpz(denominator))); simplifiedRes = addMemRef(simplifyTreeErrorfree(res)); mpz_clear(numerator); mpz_clear(denominator); freeThing(res); return simplifiedRes; } int sollya_lib_get_interval_from_range(mpfi_t interval, sollya_obj_t obj1) { mpfr_t a, b; if (obj1 == NULL) return 0; mpfr_init2(a,tools_precision); /* evaluateThingToRange will change the precision afterwards */ mpfr_init2(b,tools_precision); /* evaluateThingToRange will change the precision afterwards */ if (evaluateThingToRange(a, b, obj1)) { sollya_mpfi_interv_fr(interval, a, b); mpfr_clear(a); mpfr_clear(b); return 1; } mpfr_clear(a); mpfr_clear(b); return 0; } int sollya_lib_get_prec_of_range(mp_prec_t *pr, sollya_obj_t obj1) { mpfr_t a, b; mp_prec_t p, prec; if (obj1 == NULL) return 0; mpfr_init2(a,tools_precision); /* evaluateThingToRange will change the precision afterwards */ mpfr_init2(b,tools_precision); /* evaluateThingToRange will change the precision afterwards */ if (evaluateThingToRange(a, b, obj1)) { prec = mpfr_get_prec(a); p = mpfr_get_prec(b); if (p > prec) prec = p; if (pr != NULL) { *pr = prec; } return 1; } mpfr_clear(a); mpfr_clear(b); return 0; } int sollya_lib_get_bounds_from_range(mpfr_t left, mpfr_t right, sollya_obj_t obj1) { mpfr_t a, b; mp_prec_t p, pp; sollya_mpfi_t temp; if (obj1 == NULL) return 0; mpfr_init2(a,tools_precision); /* evaluateThingToRange will change the precision afterwards */ mpfr_init2(b,tools_precision); /* evaluateThingToRange will change the precision afterwards */ if (evaluateThingToRange(a, b, obj1)) { p = mpfr_get_prec(a); pp = mpfr_get_prec(b); if (pp > p) p = pp; sollya_mpfi_init2(temp,p); sollya_mpfi_interv_fr(temp, a, b); sollya_mpfi_get_left(left, temp); sollya_mpfi_get_right(right, temp); __sollya_lib_internal_mpfr_zero_sign_normalize(left); __sollya_lib_internal_mpfr_zero_sign_normalize(right); sollya_mpfi_clear(temp); mpfr_clear(a); mpfr_clear(b); return 1; } mpfr_clear(a); mpfr_clear(b); return 0; } int sollya_lib_get_string(char **str, sollya_obj_t obj1) { int res; char *mystr; if (obj1 == NULL) return 0; res = evaluateThingToString(&mystr, obj1); if (res) { if (str != NULL) { *str = mystr; } else { safeFree(mystr); } } return res; } static inline int __sollya_lib_get_constant_inner(mpfr_t value, sollya_obj_t obj1, sollya_obj_t roundOp, int *warning) { sollya_obj_t evaluatedObj, simplifiedObj, roundedObj, simplifiedRoundedObj; mp_prec_t prec; mpfr_t dummyX; sollya_fp_result_t evalRes; if (obj1 == NULL) return 0; evaluatedObj = evaluateThing(obj1); if (!isPureTree(evaluatedObj)) { freeThing(evaluatedObj); return 0; } simplifiedObj = simplifyTreeErrorfree(evaluatedObj); if (!isConstant(simplifiedObj)) { freeThing(evaluatedObj); freeThing(simplifiedObj); return 0; } if (accessThruMemRef(simplifiedObj)->nodeType == CONSTANT) { prec = mpfr_get_prec(*(accessThruMemRef(simplifiedObj)->value)); if (prec < 200) prec = 200; mpfr_set_prec(value, prec); if (roundOp == NULL) { mpfr_set(value, *(accessThruMemRef(simplifiedObj)->value), GMP_RNDN); /* exact */ freeThing(evaluatedObj); freeThing(simplifiedObj); return 1; } else { roundedObj = substitute(roundOp, simplifiedObj); simplifiedRoundedObj = simplifyTreeErrorfree(roundedObj); if (accessThruMemRef(simplifiedRoundedObj)->nodeType == CONSTANT) { prec = mpfr_get_prec(*(accessThruMemRef(simplifiedRoundedObj)->value)); if (prec < 200) prec = 200; mpfr_set_prec(value, prec); if ((mpfr_cmp(*(accessThruMemRef(simplifiedRoundedObj)->value), *(accessThruMemRef(simplifiedObj)->value)) != 0) && mpfr_number_p(*(accessThruMemRef(simplifiedObj)->value))) { if (!noRoundingWarnings) { if (*warning) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_CONSTANT_RETRIEVAL,"Warning: rounding occurred on retrieval of a constant.\n"); *warning = 0; } } } mpfr_set(value, *(accessThruMemRef(simplifiedRoundedObj)->value), GMP_RNDN); /* exact */ freeThing(roundedObj); freeThing(simplifiedRoundedObj); freeThing(evaluatedObj); freeThing(simplifiedObj); return 1; } freeThing(roundedObj); freeThing(simplifiedRoundedObj); } } if (roundOp == NULL) { mpfr_init2(dummyX, 12); mpfr_set_si(dummyX, 1, GMP_RNDN); evalRes = sollya_lib_evaluate_function_at_point(value, simplifiedObj, dummyX, NULL); mpfr_clear(dummyX); } else { mpfr_set_nan(value); evalRes = sollya_lib_evaluate_function_at_constant_expression(value, roundOp, simplifiedObj, NULL); if ((!mpfr_number_p(value)) || ((evalRes != SOLLYA_FP_FAITHFUL) && (evalRes != SOLLYA_FP_PROVEN_EXACT) && (evalRes != SOLLYA_FP_FAITHFUL_PROVEN_INEXACT) && (evalRes != SOLLYA_FP_CORRECTLY_ROUNDED) && (evalRes != SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT))) { mpfr_init2(dummyX, 12); mpfr_set_si(dummyX, 1, GMP_RNDN); evalRes = sollya_lib_evaluate_function_at_point(value, simplifiedObj, dummyX, NULL); mpfr_clear(dummyX); if (!mpfr_number_p(value)) { evalRes = sollya_lib_evaluate_function_at_constant_expression(value, roundOp, simplifiedObj, NULL); } } } switch (evalRes) { case SOLLYA_FP_FAITHFUL: case SOLLYA_FP_CORRECTLY_ROUNDED: case SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT: case SOLLYA_FP_PROVEN_EXACT: case SOLLYA_FP_FAITHFUL_PROVEN_INEXACT: if (!noRoundingWarnings) { if (*warning) { if (roundOp == NULL) { printMessage(1,SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST,"Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation to %d bits will be used.\n",mpfr_get_prec(value)); } else { printMessage(1,SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST,"Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used.\n"); } *warning = 0; } } freeThing(evaluatedObj); freeThing(simplifiedObj); return 1; break; case SOLLYA_FP_BELOW_CUTOFF: if ((!noRoundingWarnings) && (roundOp != NULL)) { if (*warning) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_CONSTANT_RETRIEVAL,"Warning: rounding occurred on retrieval of a constant.\n"); *warning = 0; } } freeThing(evaluatedObj); freeThing(simplifiedObj); return 1; break; case SOLLYA_FP_INFINITY: freeThing(evaluatedObj); freeThing(simplifiedObj); return 1; break; case SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD: case SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_NOT_BELOW_THRESHOLD: if (!noRoundingWarnings) { if (*warning) { printMessage(1,SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_IS_NOT_FAITHFUL,"Warning: the given expression is not a constant but an expression to evaluate\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"and a faithful evaluation is *NOT* possible.\n"); *warning = 0; } } freeThing(evaluatedObj); freeThing(simplifiedObj); return 1; break; case SOLLYA_FP_NOT_FAITHFUL_ZERO_NOT_CONTAINED: case SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED: if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_SOME_EVALUATION_IS_NOT_FAITHFUL,"Warning: the expression could *NOT* be faithfully evaluated.\n"); if (roundOp != NULL) { if (*warning) { *warning = 0; printMessage(1,SOLLYA_MSG_ROUNDING_ON_CONSTANT_RETRIEVAL,"Warning: rounding occurred on retrieval of a constant.\n"); } } } freeThing(evaluatedObj); freeThing(simplifiedObj); return 1; break; default: freeThing(evaluatedObj); freeThing(simplifiedObj); return 0; } freeThing(evaluatedObj); freeThing(simplifiedObj); return 0; } int sollya_lib_get_constant(mpfr_t value, sollya_obj_t obj1) { mpfr_t myValue; int res, warning = 1; if (obj1 == NULL) return 0; mpfr_init2(myValue, mpfr_get_prec(value)); res = __sollya_lib_get_constant_inner(myValue, obj1, NULL, &warning); if (res) { if (mpfr_set(value, myValue, GMP_RNDN) != 0) { if ((!noRoundingWarnings) && warning) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_CONSTANT_RETRIEVAL,"Warning: rounding occurred on retrieval of a constant.\n"); } } __sollya_lib_internal_mpfr_zero_sign_normalize(value); } mpfr_clear(myValue); return res; } int sollya_lib_get_prec_of_constant(mp_prec_t *pr, sollya_obj_t obj1) { sollya_obj_t evaluatedObj, simplifiedObj; mp_prec_t prec; if (obj1 == NULL) return 0; evaluatedObj = evaluateThing(obj1); if (!isPureTree(evaluatedObj)) { freeThing(evaluatedObj); return 0; } simplifiedObj = simplifyTreeErrorfree(evaluatedObj); if (!isConstant(simplifiedObj)) { freeThing(evaluatedObj); freeThing(simplifiedObj); return 0; } if (accessThruMemRef(simplifiedObj)->nodeType == CONSTANT) { prec = mpfr_get_prec(*(accessThruMemRef(simplifiedObj)->value)); if (pr != NULL) { *pr = prec; } freeThing(evaluatedObj); freeThing(simplifiedObj); return 1; } freeThing(evaluatedObj); freeThing(simplifiedObj); return 0; } int sollya_lib_get_constant_as_double(double *value, sollya_obj_t obj1) { mpfr_t temp, reconvert; sollya_obj_t roundOp; int warning = 1; double val; if (obj1 == NULL) return 0; roundOp = makeDouble(makeVariable()); mpfr_init2(temp,53); /* sollya_lib_get_constant_inner may change the precision afterwards */ if (__sollya_lib_get_constant_inner(temp, obj1, roundOp, &warning)) { val = sollya_mpfr_get_d(temp, GMP_RNDN); __sollya_lib_internal_double_zero_sign_normalize(&val); mpfr_init2(reconvert,64); mpfr_set_d(reconvert, val, GMP_RNDN); /* Exact as precision enough for a double */ if ((mpfr_cmp(temp, reconvert) != 0) && (mpfr_number_p(temp) || mpfr_inf_p(temp)) && (mpfr_number_p(reconvert) || mpfr_inf_p(reconvert))) { if ((!noRoundingWarnings) && warning) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_CONSTANT_RETRIEVAL,"Warning: rounding occurred on retrieval of a constant.\n"); } } mpfr_clear(reconvert); mpfr_clear(temp); freeThing(roundOp); if (value != NULL) { *value = val; } return 1; } mpfr_clear(temp); freeThing(roundOp); return 0; } int sollya_lib_get_constant_as_mpz(mpz_t value, sollya_obj_t obj1) { mpfr_t temp, reconvert; sollya_obj_t roundOp; int warning = 1; if (obj1 == NULL) return 0; roundOp = makeNearestInt(makeVariable()); mpfr_init2(temp,64); /* sollya_lib_get_constant_inner may change the precision afterwards */ if (__sollya_lib_get_constant_inner(temp, obj1, roundOp, &warning)) { if (mpfr_to_mpz(value, temp)) { mpfr_init2(reconvert, getMpzPrecision(value)); mpfr_set_z(reconvert, value, GMP_RNDN); /* exact as precision determined to make it exact */ if ((mpfr_cmp(temp, reconvert) != 0) && (mpfr_number_p(temp) || mpfr_inf_p(temp)) && (mpfr_number_p(reconvert) || mpfr_inf_p(reconvert))) { if ((!noRoundingWarnings) && warning) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_CONSTANT_RETRIEVAL,"Warning: rounding occurred on retrieval of a constant.\n"); } } mpfr_clear(reconvert); } else { if (mpfr_nan_p(temp)) { mpz_set_si(value, 0); printMessage(1, SOLLYA_MSG_NAN_CONVERTED_TO_NUMBER_ON_CONSTANT_RETRIEVAL,"Warning: a Not-A-Number value has been converted to a number upon retrieval of a constant.\n"); } else { if (mpfr_inf_p(temp)) { mpz_set_si(value, 0); printMessage(1, SOLLYA_MSG_INF_CONVERTED_TO_NUMBER_ON_CONSTANT_RETRIEVAL,"Warning: an infinity has been converted to a number upon retrieval of a constant.\n"); } else { mpfr_clear(temp); freeThing(roundOp); return 0; } } } mpfr_clear(temp); freeThing(roundOp); return 1; } mpfr_clear(temp); freeThing(roundOp); return 0; } int sollya_lib_get_constant_as_mpq(mpq_t value, sollya_obj_t obj1) { sollya_obj_t evaluatedObj, simplifiedObj, rationalSimplifiedObj; mpq_t numerator, denominator; if (obj1 == NULL) return 0; evaluatedObj = evaluateThing(obj1); if (!isPureTree(evaluatedObj)) { freeThing(evaluatedObj); return 0; } simplifiedObj = simplifyTreeErrorfree(evaluatedObj); if (!isConstant(simplifiedObj)) { freeThing(evaluatedObj); freeThing(simplifiedObj); return 0; } rationalSimplifiedObj = simplifyRationalErrorfree(simplifiedObj); freeThing(evaluatedObj); freeThing(simplifiedObj); if (accessThruMemRef(rationalSimplifiedObj)->nodeType == CONSTANT) { if (mpfr_to_mpq(value, *(accessThruMemRef(rationalSimplifiedObj)->value))) { freeThing(rationalSimplifiedObj); return 1; } } if ((accessThruMemRef(rationalSimplifiedObj)->nodeType == DIV) && (accessThruMemRef(accessThruMemRef(rationalSimplifiedObj)->child1)->nodeType == CONSTANT) && (accessThruMemRef(accessThruMemRef(rationalSimplifiedObj)->child2)->nodeType == CONSTANT)) { mpq_init(numerator); mpq_init(denominator); if (mpfr_to_mpq(numerator, *(accessThruMemRef(accessThruMemRef(rationalSimplifiedObj)->child1)->value)) && mpfr_to_mpq(denominator, *(accessThruMemRef(accessThruMemRef(rationalSimplifiedObj)->child2)->value))) { mpq_div(value, numerator, denominator); mpq_clear(numerator); mpq_clear(denominator); freeThing(rationalSimplifiedObj); return 1; } mpq_clear(numerator); mpq_clear(denominator); } freeThing(rationalSimplifiedObj); return 0; } /* In some versions of MPFR, mpfr_get_si seems to contain a couple of bugs. */ static inline int __mpfr_get_si_wrapper(mpfr_t op, mp_rnd_t rnd) { mpfr_t opAsInteger, intMaxAsMpfr, intMinAsMpfr; int res; if (mpfr_number_p(op)) { mpfr_init2(opAsInteger, mpfr_get_prec(op)); mpfr_init2(intMaxAsMpfr, 8 * sizeof(int) + 10); mpfr_init2(intMinAsMpfr, 8 * sizeof(int) + 10); mpfr_set_si(intMaxAsMpfr, INT_MAX, GMP_RNDN); /* exact, enough precision */ mpfr_set_si(intMinAsMpfr, INT_MIN, GMP_RNDN); /* exact, enough precision */ mpfr_rint(opAsInteger, op, rnd); /* no double rounding, same precision */ if (mpfr_cmp(opAsInteger, intMaxAsMpfr) > 0) { res = INT_MAX; } else { if (mpfr_cmp(opAsInteger, intMinAsMpfr) < 0) { res = INT_MIN; } else { res = mpfr_get_si(opAsInteger, rnd); } } mpfr_clear(opAsInteger); mpfr_clear(intMaxAsMpfr); mpfr_clear(intMinAsMpfr); return res; } else { /* op is NaN or Inf */ if (mpfr_nan_p(op)) { return 0; } /* op is +/- Inf */ if (mpfr_sgn(op) < 0) { /* op is -Inf */ return INT_MIN; } /* op is + Inf */ return INT_MAX; } return -1; /* Unreachable */ } int sollya_lib_get_constant_as_int(int *value, sollya_obj_t obj1) { mpfr_t temp, reconvert; sollya_obj_t roundOp; int warning = 1; int val; if (obj1 == NULL) return 0; roundOp = makeNearestInt(makeVariable()); mpfr_init2(temp,8 * sizeof(int)); /* sollya_lib_get_constant_inner may change the precision afterwards */ if (__sollya_lib_get_constant_inner(temp, obj1, roundOp, &warning)) { val = __mpfr_get_si_wrapper(temp, GMP_RNDN); mpfr_init2(reconvert,8 * sizeof(int) + 10); mpfr_set_si(reconvert, val, GMP_RNDN); /* Exact as precision enough for an int */ if ((mpfr_cmp(temp, reconvert) != 0) || mpfr_nan_p(temp) || mpfr_nan_p(reconvert)) { if (mpfr_number_p(temp) || mpfr_inf_p(temp)) { if ((!noRoundingWarnings) && warning) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_CONSTANT_RETRIEVAL,"Warning: rounding occurred on retrieval of a constant.\n"); } } else { printMessage(1, SOLLYA_MSG_NAN_CONVERTED_TO_NUMBER_ON_CONSTANT_RETRIEVAL,"Warning: a Not-A-Number value has been converted to a number upon retrieval of a constant.\n"); } } mpfr_clear(reconvert); mpfr_clear(temp); freeThing(roundOp); if (value != NULL) { *value = val; } return 1; } mpfr_clear(temp); freeThing(roundOp); return 0; } static inline uint64_t __sollya_lib_helper_mpfr_to_uint64(mpfr_t op) { uint64_t res; mp_prec_t p; mpfr_t op_int, temp, temp2; unsigned int bytes[8]; int i; if (mpfr_number_p(op)) { p = mpfr_get_prec(op); if (p < 64) p = 64; mpfr_init2(op_int,p); mpfr_init2(temp,p); mpfr_init2(temp2,p); sollya_mpfr_rint_nearestint(op_int,op,GMP_RNDN); if (mpfr_sgn(op_int) >= 0) { for (i=0;i<8;i++) { mpfr_div_2ui(temp, op_int, 8, GMP_RNDN); /* exact */ mpfr_floor(temp, temp); mpfr_mul_2ui(temp2, temp, 8, GMP_RNDN); /* exact */ mpfr_sub(temp2, op_int, temp2, GMP_RNDN); /* Sterbenz */ bytes[i] = mpfr_get_ui(temp2, GMP_RNDN); /* exact */ mpfr_set(op_int, temp, GMP_RNDN); /* exact */ } if (mpfr_zero_p(op_int)) { res = 0; for (i=7;i>=0;i--) { res = res * ((uint64_t) 256) + (uint64_t) (bytes[i]); } } else { /* The mpfr value overflows on uint64 */ res = UINT64_MAX; } } else { /* The mpfr value is negative */ res = 0; } mpfr_clear(op_int); mpfr_clear(temp); mpfr_clear(temp2); } else { /* The value is a NaN or an Inf */ if (mpfr_inf_p(op)) { if (mpfr_sgn(op) < 0) { /* -Infty becomes 0 */ res = (uint64_t) 0; } else { /* +Infty becomes the maximum uint64 */ res = UINT64_MAX; } } else { /* The value is a NaN. It becomes 0. */ res = (uint64_t) 0; } } return res; } static inline int64_t __sollya_lib_helper_mpfr_to_int64(mpfr_t op) { mpfr_t opAbs; uint64_t opAbsAsUint64; uint64_t int64MaxAsUint64, minusInt64MinAsUint64; int64_t res; if (mpfr_number_p(op)) { mpfr_init2(opAbs, mpfr_get_prec(op)); mpfr_abs(opAbs, op, GMP_RNDN); /* Exact, same precision */ opAbsAsUint64 = __sollya_lib_helper_mpfr_to_uint64(opAbs); int64MaxAsUint64 = (uint64_t) (INT64_MAX); minusInt64MinAsUint64 = ((uint64_t) (-(INT64_MIN + ((int64_t) 16)))) + ((uint64_t) 16); if (mpfr_sgn(op) >= 0) { if (opAbsAsUint64 <= int64MaxAsUint64) { res = (int64_t) opAbsAsUint64; } else { res = INT64_MAX; } } else { if (opAbsAsUint64 < minusInt64MinAsUint64) { res = -((int64_t) opAbsAsUint64); } else { res = INT64_MIN; } } mpfr_clear(opAbs); } else { /* The value is a NaN or an Inf */ if (mpfr_inf_p(op)) { if (mpfr_sgn(op) < 0) { /* -Infty becomes the minimum int64 */ res = INT64_MIN; } else { /* +Infty becomes the maximum int64 */ res = INT64_MAX; } } else { /* The value is a NaN. It becomes 0. */ res = (int64_t) 0; } } return res; } int sollya_lib_get_constant_as_int64(int64_t *value, sollya_obj_t obj1) { mpfr_t temp, reconvert; sollya_obj_t roundOp; int warning = 1; int64_t val; if (obj1 == NULL) return 0; roundOp = addMemRef(makeNearestInt(makeVariable())); mpfr_init2(temp,8 * sizeof(int64_t) + 10); /* sollya_lib_get_constant_inner may change the precision afterwards */ if (__sollya_lib_get_constant_inner(temp, obj1, roundOp, &warning)) { val = __sollya_lib_helper_mpfr_to_int64(temp); mpfr_init2(reconvert,8 * sizeof(int64_t) + 10); __sollya_lib_helper_mpfr_from_int64(reconvert, val, GMP_RNDN); /* Exact as precision enough for an int64 */ if ((mpfr_cmp(temp, reconvert) != 0) || mpfr_nan_p(temp) || mpfr_nan_p(reconvert)) { if (mpfr_number_p(temp) || mpfr_inf_p(temp)) { if ((!noRoundingWarnings) && warning) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_CONSTANT_RETRIEVAL,"Warning: rounding occurred on retrieval of a constant.\n"); } } else { printMessage(1, SOLLYA_MSG_NAN_CONVERTED_TO_NUMBER_ON_CONSTANT_RETRIEVAL,"Warning: a Not-A-Number value has been converted to a number upon retrieval of a constant.\n"); } } mpfr_clear(reconvert); mpfr_clear(temp); freeThing(roundOp); if (value != NULL) { *value = val; } return 1; } mpfr_clear(temp); freeThing(roundOp); return 0; } int sollya_lib_get_constant_as_uint64(uint64_t *value, sollya_obj_t obj1) { mpfr_t temp, reconvert; sollya_obj_t roundOp; int warning = 1; uint64_t val; if (obj1 == NULL) return 0; roundOp = addMemRef(makeNearestInt(makeVariable())); mpfr_init2(temp,8 * sizeof(uint64_t) + 10); /* sollya_lib_get_constant_inner may change the precision afterwards */ if (__sollya_lib_get_constant_inner(temp, obj1, roundOp, &warning)) { val = __sollya_lib_helper_mpfr_to_uint64(temp); mpfr_init2(reconvert,8 * sizeof(uint64_t) + 10); __sollya_lib_helper_mpfr_from_uint64(reconvert, val, GMP_RNDN); /* Exact as precision enough for an uint64 */ if ((mpfr_cmp(temp, reconvert) != 0) || mpfr_nan_p(temp) || mpfr_nan_p(reconvert)) { if (mpfr_number_p(temp) || mpfr_inf_p(temp)) { if ((!noRoundingWarnings) && warning) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_CONSTANT_RETRIEVAL,"Warning: rounding occurred on retrieval of a constant.\n"); } } else { printMessage(1, SOLLYA_MSG_NAN_CONVERTED_TO_NUMBER_ON_CONSTANT_RETRIEVAL,"Warning: a Not-A-Number value has been converted to a number upon retrieval of a constant.\n"); } } mpfr_clear(reconvert); mpfr_clear(temp); freeThing(roundOp); if (value != NULL) { *value = val; } return 1; } mpfr_clear(temp); freeThing(roundOp); return 0; } sollya_obj_t sollya_lib_list(sollya_obj_t objects[], int num) { int i; chain *tempChain; node *unevaluatedList; node *evaluatedList; if (num < 1) return addMemRef(makeEmptyList()); if (objects == NULL) return addMemRef(makeEmptyList()); tempChain = NULL; for (i=num-1;i>=0;i--) { if (objects[i] != NULL) { tempChain = addElement(tempChain, copyThing(objects[i])); } } if (tempChain == NULL) { return addMemRef(makeEmptyList()); } unevaluatedList = addMemRef(makeList(tempChain)); evaluatedList = evaluateThing(unevaluatedList); freeThing(unevaluatedList); return evaluatedList; } sollya_obj_t sollya_lib_end_elliptic_list(sollya_obj_t objects[], int num) { int i; chain *tempChain; node *unevaluatedList; node *evaluatedList; if (num < 1) return addMemRef(makeError()); if (objects == NULL) return addMemRef(makeError()); tempChain = NULL; for (i=num-1;i>=0;i--) { if (objects[i] != NULL) { tempChain = addElement(tempChain, copyThing(objects[i])); } } if (tempChain == NULL) { return addMemRef(makeError()); } unevaluatedList = addMemRef(makeFinalEllipticList(tempChain)); evaluatedList = evaluateThing(unevaluatedList); freeThing(unevaluatedList); return evaluatedList; } int sollya_lib_get_list_elements(sollya_obj_t **objects, int *num, int *end_elliptic, sollya_obj_t obj1) { sollya_obj_t evaluatedObj; int tempVal, i; chain *curr; int number; sollya_obj_t *objs; if (obj1 == NULL) return 0; evaluatedObj = evaluateThing(obj1); if (isEmptyList(evaluatedObj)) { if (num != NULL) { *num = 0; } if (end_elliptic != NULL) { *end_elliptic = 0; } freeThing(evaluatedObj); return 1; } tempVal = 0; if (isPureList(evaluatedObj) || (tempVal = isPureFinalEllipticList(evaluatedObj))) { number = lengthChain(accessThruMemRef(evaluatedObj)->arguments); objs = (sollya_obj_t *) safeCalloc(number,sizeof(sollya_obj_t)); for (curr=accessThruMemRef(evaluatedObj)->arguments,i=0;curr!=NULL;curr=curr->next,i++) { objs[i] = copyThing((node *) (curr->value)); } if (num != NULL) { *num = number; } if (objects != NULL) { *objects = objs; } else { for (i=0;iargArray != NULL) { num = accessThruMemRef(evaluatedObj)->argArraySize; } else { num = lengthChain(accessThruMemRef(evaluatedObj)->arguments); } if ((n < 0) || ((!tempVal) && (n >= num))) { freeThing(evaluatedObj); return 0; } mpfr_init2(nAsMpfr, 8 * sizeof(n) + 10); mpfr_set_si(nAsMpfr, n, GMP_RNDN); /* exact */ indexObj = addMemRef(makeConstant(nAsMpfr)); mpfr_clear(nAsMpfr); protoObj = addMemRef(makeIndex(evaluatedObj, indexObj)); result = evaluateThing(protoObj); if (res != NULL) { *res = result; } else { freeThing(result); } freeThing(protoObj); return 1; } freeThing(evaluatedObj); return 0; } int sollya_lib_obj_is_function(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return isPureTree(obj1); } int sollya_lib_obj_is_list(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (isEmptyList(obj1) || isPureList(obj1)); } int sollya_lib_obj_is_end_elliptic_list(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (isEmptyList(obj1) || isPureFinalEllipticList(obj1)); } int sollya_lib_obj_is_range(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return isRange(obj1); } int sollya_lib_obj_is_string(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return isString(obj1); } int sollya_lib_obj_is_error(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return isError(obj1); } int sollya_lib_get_function_arity(int *ari, sollya_obj_t obj1) { int ar; if (obj1 == NULL) return 0; if (!isPureTree(obj1)) return 0; ar = arity(obj1); if (ari != NULL) { *ari = ar; } return 1; } int sollya_lib_v_decompose_function(sollya_obj_t obj1, sollya_base_function_t *base_func, int *ari, va_list varlist) { sollya_obj_t *elem; int i, funcArity, gottaBreak; if (obj1 == NULL) return 0; if (obj1->nodeType == MEMREF) return sollya_lib_v_decompose_function(getMemRefChild(obj1), base_func, ari, varlist); if (!isPureTree(obj1)) return 0; if (base_func != NULL) { switch (obj1->nodeType) { case VARIABLE: *base_func = SOLLYA_BASE_FUNC_FREE_VARIABLE; break; case CONSTANT: *base_func = SOLLYA_BASE_FUNC_CONSTANT; break; case ADD: *base_func = SOLLYA_BASE_FUNC_ADD; break; case SUB: *base_func = SOLLYA_BASE_FUNC_SUB; break; case MUL: *base_func = SOLLYA_BASE_FUNC_MUL; break; case DIV: *base_func = SOLLYA_BASE_FUNC_DIV; break; case SQRT: *base_func = SOLLYA_BASE_FUNC_SQRT; break; case EXP: *base_func = SOLLYA_BASE_FUNC_EXP; break; case LOG: *base_func = SOLLYA_BASE_FUNC_LOG; break; case LOG_2: *base_func = SOLLYA_BASE_FUNC_LOG_2; break; case LOG_10: *base_func = SOLLYA_BASE_FUNC_LOG_10; break; case SIN: *base_func = SOLLYA_BASE_FUNC_SIN; break; case COS: *base_func = SOLLYA_BASE_FUNC_COS; break; case TAN: *base_func = SOLLYA_BASE_FUNC_TAN; break; case ASIN: *base_func = SOLLYA_BASE_FUNC_ASIN; break; case ACOS: *base_func = SOLLYA_BASE_FUNC_ACOS; break; case ATAN: *base_func = SOLLYA_BASE_FUNC_ATAN; break; case SINH: *base_func = SOLLYA_BASE_FUNC_SINH; break; case COSH: *base_func = SOLLYA_BASE_FUNC_COSH; break; case TANH: *base_func = SOLLYA_BASE_FUNC_TANH; break; case ASINH: *base_func = SOLLYA_BASE_FUNC_ASINH; break; case ACOSH: *base_func = SOLLYA_BASE_FUNC_ACOSH; break; case ATANH: *base_func = SOLLYA_BASE_FUNC_ATANH; break; case POW: *base_func = SOLLYA_BASE_FUNC_POW; break; case NEG: *base_func = SOLLYA_BASE_FUNC_NEG; break; case ABS: *base_func = SOLLYA_BASE_FUNC_ABS; break; case DOUBLE: *base_func = SOLLYA_BASE_FUNC_DOUBLE; break; case SINGLE: *base_func = SOLLYA_BASE_FUNC_SINGLE; break; case QUAD: *base_func = SOLLYA_BASE_FUNC_QUAD; break; case HALFPRECISION: *base_func = SOLLYA_BASE_FUNC_HALFPRECISION; break; case DOUBLEDOUBLE: *base_func = SOLLYA_BASE_FUNC_DOUBLEDOUBLE; break; case TRIPLEDOUBLE: *base_func = SOLLYA_BASE_FUNC_TRIPLEDOUBLE; break; case ERF: *base_func = SOLLYA_BASE_FUNC_ERF; break; case ERFC: *base_func = SOLLYA_BASE_FUNC_ERFC; break; case LOG_1P: *base_func = SOLLYA_BASE_FUNC_LOG_1P; break; case EXP_M1: *base_func = SOLLYA_BASE_FUNC_EXP_M1; break; case DOUBLEEXTENDED: *base_func = SOLLYA_BASE_FUNC_DOUBLEEXTENDED; break; case LIBRARYFUNCTION: *base_func = SOLLYA_BASE_FUNC_LIBRARYFUNCTION; break; case PROCEDUREFUNCTION: *base_func = SOLLYA_BASE_FUNC_PROCEDUREFUNCTION; break; case CEIL: *base_func = SOLLYA_BASE_FUNC_CEIL; break; case FLOOR: *base_func = SOLLYA_BASE_FUNC_FLOOR; break; case NEARESTINT: *base_func = SOLLYA_BASE_FUNC_NEARESTINT; break; case PI_CONST: *base_func = SOLLYA_BASE_FUNC_PI; break; case LIBRARYCONSTANT: *base_func = SOLLYA_BASE_FUNC_LIBRARYCONSTANT; break; default: return 0; } } funcArity = arity(obj1); if (ari != NULL) { *ari = funcArity; } switch (obj1->nodeType) { case CONSTANT: case LIBRARYCONSTANT: case PI_CONST: funcArity = 1; break; case LIBRARYFUNCTION: funcArity = 2; break; case PROCEDUREFUNCTION: funcArity = 2; break; } i = 1; while ((elem = va_arg(varlist,sollya_obj_t *)) != NULL) { if (i <= funcArity) { gottaBreak = 0; switch (i) { case 1: switch (obj1->nodeType) { case CONSTANT: case LIBRARYCONSTANT: case PI_CONST: case VARIABLE: *elem = copyThing(obj1); break; default: *elem = copyThing(obj1->child1); break; } break; case 2: switch (obj1->nodeType) { case LIBRARYFUNCTION: *elem = (node *) safeMalloc(sizeof(node)); (*elem)->nodeType = LIBRARYFUNCTION; (*elem)->libFun = obj1->libFun; (*elem)->libFunDeriv = obj1->libFunDeriv; (*elem)->child1 = addMemRef(makeVariable()); *elem = addMemRef(*elem); break; case PROCEDUREFUNCTION: *elem = (node *) safeMalloc(sizeof(node)); (*elem)->nodeType = PROCEDUREFUNCTION; (*elem)->libFunDeriv = obj1->libFunDeriv; (*elem)->child1 = addMemRef(makeVariable()); (*elem)->child2 = copyThing(obj1->child2); *elem = addMemRef(*elem); break; default: *elem = copyThing(obj1->child2); break; } break; default: gottaBreak = 1; break; } if (gottaBreak) break; } else { break; } i++; } return 1; } int sollya_lib_decompose_function(sollya_obj_t obj1, sollya_base_function_t *base_func, int *ari, ...) { va_list varlist; int res; if (obj1 == NULL) return 0; va_start(varlist,ari); res = sollya_lib_v_decompose_function(obj1, base_func, ari, varlist); va_end(varlist); return res; } static inline int __sollya_lib_v_construct_function_inner_get_expected_number_args(sollya_base_function_t base_func) { switch (base_func) { case SOLLYA_BASE_FUNC_PI: return 1; break; case SOLLYA_BASE_FUNC_FREE_VARIABLE: return 0; break; case SOLLYA_BASE_FUNC_CONSTANT: return 1; break; case SOLLYA_BASE_FUNC_LIBRARYCONSTANT: return 1; break; case SOLLYA_BASE_FUNC_LIBRARYFUNCTION: case SOLLYA_BASE_FUNC_PROCEDUREFUNCTION: return 2; break; case SOLLYA_BASE_FUNC_ADD: case SOLLYA_BASE_FUNC_SUB: case SOLLYA_BASE_FUNC_MUL: case SOLLYA_BASE_FUNC_DIV: case SOLLYA_BASE_FUNC_POW: return 2; break; case SOLLYA_BASE_FUNC_ABS: case SOLLYA_BASE_FUNC_ACOS: case SOLLYA_BASE_FUNC_ACOSH: case SOLLYA_BASE_FUNC_ASIN: case SOLLYA_BASE_FUNC_ASINH: case SOLLYA_BASE_FUNC_ATAN: case SOLLYA_BASE_FUNC_ATANH: case SOLLYA_BASE_FUNC_CEIL: case SOLLYA_BASE_FUNC_COS: case SOLLYA_BASE_FUNC_COSH: case SOLLYA_BASE_FUNC_DOUBLE: case SOLLYA_BASE_FUNC_DOUBLEDOUBLE: case SOLLYA_BASE_FUNC_DOUBLEEXTENDED: case SOLLYA_BASE_FUNC_ERF: case SOLLYA_BASE_FUNC_ERFC: case SOLLYA_BASE_FUNC_EXP: case SOLLYA_BASE_FUNC_EXP_M1: case SOLLYA_BASE_FUNC_FLOOR: case SOLLYA_BASE_FUNC_HALFPRECISION: case SOLLYA_BASE_FUNC_LOG: case SOLLYA_BASE_FUNC_LOG_10: case SOLLYA_BASE_FUNC_LOG_1P: case SOLLYA_BASE_FUNC_LOG_2: case SOLLYA_BASE_FUNC_NEARESTINT: case SOLLYA_BASE_FUNC_NEG: case SOLLYA_BASE_FUNC_QUAD: case SOLLYA_BASE_FUNC_SIN: case SOLLYA_BASE_FUNC_SINGLE: case SOLLYA_BASE_FUNC_SINH: case SOLLYA_BASE_FUNC_SQRT: case SOLLYA_BASE_FUNC_TAN: case SOLLYA_BASE_FUNC_TANH: case SOLLYA_BASE_FUNC_TRIPLEDOUBLE: return 1; break; default: return -1; break; } return -1; } static inline int __sollya_lib_v_construct_function_inner(sollya_obj_t *func, sollya_base_function_t base_func, va_list varlist) { sollya_obj_t arg1, arg2, myfunc; int num_args, expected_num_args; arg1 = arg2 = NULL; /* Compiler happiness */ expected_num_args = __sollya_lib_v_construct_function_inner_get_expected_number_args(base_func); if (expected_num_args < 0) return 0; num_args = 0; if (expected_num_args > 0) { arg1 = va_arg(varlist,sollya_obj_t); if (arg1 != NULL) { num_args++; if (expected_num_args > 1) { arg2 = va_arg(varlist,sollya_obj_t); if (arg2 != NULL) { num_args++; } } } } switch (base_func) { case SOLLYA_BASE_FUNC_PI: if (num_args > 0) { if (accessThruMemRef(arg1)->nodeType != PI_CONST) return 0; } myfunc = addMemRef(sollya_lib_pi()); break; case SOLLYA_BASE_FUNC_FREE_VARIABLE: myfunc = addMemRef(sollya_lib_free_variable()); break; case SOLLYA_BASE_FUNC_CONSTANT: if (num_args < 1) return 0; if (accessThruMemRef(arg1)->nodeType != CONSTANT) return 0; myfunc = addMemRef(sollya_lib_copy_obj(arg1)); break; case SOLLYA_BASE_FUNC_LIBRARYCONSTANT: if (num_args < 1) return 0; if (accessThruMemRef(arg1)->nodeType != LIBRARYCONSTANT) return 0; myfunc = addMemRef(sollya_lib_copy_obj(arg1)); break; case SOLLYA_BASE_FUNC_LIBRARYFUNCTION: if (num_args < 2) return 0; if (accessThruMemRef(arg2)->nodeType != LIBRARYFUNCTION) return 0; if (accessThruMemRef(accessThruMemRef(arg2)->child1)->nodeType != VARIABLE) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_apply(arg2, arg1, NULL)); break; case SOLLYA_BASE_FUNC_PROCEDUREFUNCTION: if (num_args < 2) return 0; if (accessThruMemRef(arg2)->nodeType != PROCEDUREFUNCTION) return 0; if (accessThruMemRef(accessThruMemRef(arg2)->child1)->nodeType != VARIABLE) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_apply(arg2, arg1, NULL)); break; case SOLLYA_BASE_FUNC_ADD: if (num_args < 2) return 0; if (!((isPureTree(arg1) && isPureTree(arg2)) || (isRange(arg1) && isRange(arg2)) || ((isPureTree(arg1) && isConstant(arg1)) && isRange(arg2)) || (isRange(arg1) && (isPureTree(arg2) && isConstant(arg2))))) return 0; myfunc = addMemRef(sollya_lib_add(arg1, arg2)); break; case SOLLYA_BASE_FUNC_SUB: if (num_args < 2) return 0; if (!((isPureTree(arg1) && isPureTree(arg2)) || (isRange(arg1) && isRange(arg2)) || ((isPureTree(arg1) && isConstant(arg1)) && isRange(arg2)) || (isRange(arg1) && (isPureTree(arg2) && isConstant(arg2))))) return 0; myfunc = addMemRef(sollya_lib_sub(arg1, arg2)); break; case SOLLYA_BASE_FUNC_MUL: if (num_args < 2) return 0; if (!((isPureTree(arg1) && isPureTree(arg2)) || (isRange(arg1) && isRange(arg2)) || ((isPureTree(arg1) && isConstant(arg1)) && isRange(arg2)) || (isRange(arg1) && (isPureTree(arg2) && isConstant(arg2))))) return 0; myfunc = addMemRef(sollya_lib_mul(arg1, arg2)); break; case SOLLYA_BASE_FUNC_DIV: if (num_args < 2) return 0; if (!((isPureTree(arg1) && isPureTree(arg2)) || (isRange(arg1) && isRange(arg2)) || ((isPureTree(arg1) && isConstant(arg1)) && isRange(arg2)) || (isRange(arg1) && (isPureTree(arg2) && isConstant(arg2))))) return 0; myfunc = addMemRef(sollya_lib_div(arg1, arg2)); break; case SOLLYA_BASE_FUNC_POW: if (num_args < 2) return 0; if (!((isPureTree(arg1) && isPureTree(arg2)) || (isRange(arg1) && isRange(arg2)) || ((isPureTree(arg1) && isConstant(arg1)) && isRange(arg2)) || (isRange(arg1) && (isPureTree(arg2) && isConstant(arg2))))) return 0; myfunc = addMemRef(sollya_lib_pow(arg1, arg2)); break; case SOLLYA_BASE_FUNC_ABS: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_abs(arg1)); break; case SOLLYA_BASE_FUNC_ACOS: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_acos(arg1)); break; case SOLLYA_BASE_FUNC_ACOSH: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_acosh(arg1)); break; case SOLLYA_BASE_FUNC_ASIN: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_asin(arg1)); break; case SOLLYA_BASE_FUNC_ASINH: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_asinh(arg1)); break; case SOLLYA_BASE_FUNC_ATAN: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_atan(arg1)); break; case SOLLYA_BASE_FUNC_ATANH: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_atanh(arg1)); break; case SOLLYA_BASE_FUNC_CEIL: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_ceil(arg1)); break; case SOLLYA_BASE_FUNC_COS: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_cos(arg1)); break; case SOLLYA_BASE_FUNC_COSH: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_cosh(arg1)); break; case SOLLYA_BASE_FUNC_DOUBLE: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_double(arg1)); break; case SOLLYA_BASE_FUNC_DOUBLEDOUBLE: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_double_double(arg1)); break; case SOLLYA_BASE_FUNC_DOUBLEEXTENDED: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_doubleextended(arg1)); break; case SOLLYA_BASE_FUNC_ERF: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_erf(arg1)); break; case SOLLYA_BASE_FUNC_ERFC: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_erfc(arg1)); break; case SOLLYA_BASE_FUNC_EXP: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_exp(arg1)); break; case SOLLYA_BASE_FUNC_EXP_M1: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_expm1(arg1)); break; case SOLLYA_BASE_FUNC_FLOOR: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_floor(arg1)); break; case SOLLYA_BASE_FUNC_HALFPRECISION: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_halfprecision(arg1)); break; case SOLLYA_BASE_FUNC_LOG: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_log(arg1)); break; case SOLLYA_BASE_FUNC_LOG_10: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_log10(arg1)); break; case SOLLYA_BASE_FUNC_LOG_1P: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_log1p(arg1)); break; case SOLLYA_BASE_FUNC_LOG_2: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_log2(arg1)); break; case SOLLYA_BASE_FUNC_NEARESTINT: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_nearestint(arg1)); break; case SOLLYA_BASE_FUNC_NEG: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_neg(arg1)); break; case SOLLYA_BASE_FUNC_QUAD: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_quad(arg1)); break; case SOLLYA_BASE_FUNC_SIN: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_sin(arg1)); break; case SOLLYA_BASE_FUNC_SINGLE: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_single(arg1)); break; case SOLLYA_BASE_FUNC_SINH: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_sinh(arg1)); break; case SOLLYA_BASE_FUNC_SQRT: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_sqrt(arg1)); break; case SOLLYA_BASE_FUNC_TAN: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_tan(arg1)); break; case SOLLYA_BASE_FUNC_TANH: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_tanh(arg1)); break; case SOLLYA_BASE_FUNC_TRIPLEDOUBLE: if (num_args < 1) return 0; if (!(isPureTree(arg1) || isRange(arg1))) return 0; myfunc = addMemRef(sollya_lib_triple_double(arg1)); break; default: return 0; break; } if (func != NULL) { *func = myfunc; } else { freeThing(myfunc); } return 1; } int sollya_lib_v_construct_function(sollya_obj_t *func, sollya_base_function_t base_func, va_list varlist) { int res; sollya_obj_t myfunc; res = __sollya_lib_v_construct_function_inner(&myfunc, base_func, varlist); if (!res) return 0; if (isError(myfunc)) { freeThing(myfunc); return 0; } if (func != NULL) { *func = myfunc; } else { freeThing(myfunc); } return 1; } int sollya_lib_construct_function(sollya_obj_t *func, sollya_base_function_t base_func, ...) { va_list varlist; int res; va_start(varlist,base_func); res = sollya_lib_v_construct_function(func, base_func, varlist); va_end(varlist); return res; } int sollya_lib_v_get_subfunctions(sollya_obj_t obj1, int *ari, va_list varlist) { if (obj1 == NULL) return 0; return sollya_lib_v_decompose_function(obj1, NULL, ari, varlist); } int sollya_lib_get_subfunctions(sollya_obj_t obj1, int *ari, ...) { va_list varlist; int res; if (obj1 == NULL) return 0; va_start(varlist,ari); res = sollya_lib_v_get_subfunctions(obj1, ari, varlist); va_end(varlist); return res; } int sollya_lib_get_nth_subfunction(sollya_obj_t *subfunc, sollya_obj_t obj, int nIndexOne) { int res, arity, myarity; sollya_obj_t c1, c2; int n; n = nIndexOne - 1; if (n < 0) return 0; if (n > 1) return 0; if (obj == NULL) return 0; c1 = NULL; c2 = NULL; res = sollya_lib_get_subfunctions(obj, &arity, &c1, &c2); if (!res) return 0; if (c1 == NULL) { myarity = 0; } else { if (c2 == NULL) { myarity = 1; } else { myarity = 2; } } if (n >= myarity) { if (c1 != NULL) freeThing(c1); if (c2 != NULL) freeThing(c2); return 0; } switch (n) { case 0: if (subfunc != NULL) { *subfunc = copyThing(c1); } break; case 1: if (subfunc != NULL) { *subfunc = copyThing(c2); } break; default: if (c1 != NULL) freeThing(c1); if (c2 != NULL) freeThing(c2); return 0; } if (c1 != NULL) freeThing(c1); if (c2 != NULL) freeThing(c2); return 1; } int sollya_lib_get_head_function(sollya_base_function_t *base_func, sollya_obj_t obj1) { if (obj1 == NULL) return 0; return sollya_lib_decompose_function(obj1, base_func, NULL, NULL); } int sollya_lib_decompose_libraryfunction(int (**func)(mpfi_t, mpfi_t, int), int *deriv, sollya_obj_t *sub_func, sollya_obj_t obj) { if (obj == NULL) return 0; if (obj->nodeType == MEMREF) return sollya_lib_decompose_libraryfunction(func, deriv, sub_func, getMemRefChild(obj)); if (obj->nodeType != LIBRARYFUNCTION) return 0; if (obj->libFun->hasData) return 0; if (func != NULL) { *func = (int (*)(mpfi_t, mpfi_t, int)) (obj->libFun->code); } if (deriv != NULL) { *deriv = obj->libFunDeriv; } if (sub_func != NULL) { *sub_func = copyThing(obj->child1); } return 1; } int sollya_lib_decompose_libraryfunction_with_data(int (**func)(mpfi_t, mpfi_t, int, void *), int *deriv, sollya_obj_t *sub_func, void **data, void (**dealloc)(void *), sollya_obj_t obj) { if (obj == NULL) return 0; if (obj->nodeType == MEMREF) return sollya_lib_decompose_libraryfunction_with_data(func, deriv, sub_func, data, dealloc, getMemRefChild(obj)); if (obj->nodeType != LIBRARYFUNCTION) return 0; if (!(obj->libFun->hasData)) return 0; if (func != NULL) { *func = (int (*)(mpfi_t, mpfi_t, int, void *)) (obj->libFun->code); } if (deriv != NULL) { *deriv = obj->libFunDeriv; } if (sub_func != NULL) { *sub_func = copyThing(obj->child1); } if (data != NULL) { *data = obj->libFun->data; } if (dealloc != NULL) { *dealloc = obj->libFun->dealloc; } return 1; } int sollya_lib_decompose_libraryconstant(void (**func)(mpfr_t, mp_prec_t), sollya_obj_t obj) { if (obj == NULL) return 0; if (obj->nodeType == MEMREF) return sollya_lib_decompose_libraryconstant(func, getMemRefChild(obj)); if (obj->nodeType != LIBRARYCONSTANT) return 0; if (obj->libFun->hasData) return 0; if (func != NULL) { *func = (void (*)(mpfr_t, mp_prec_t)) (obj->libFun->code); } return 1; } int sollya_lib_decompose_libraryconstant_with_data(void (**func)(mpfr_t, mp_prec_t, void *), void **data, void (**dealloc)(void *), sollya_obj_t obj) { if (obj == NULL) return 0; if (obj->nodeType == MEMREF) return sollya_lib_decompose_libraryconstant_with_data(func, data, dealloc, getMemRefChild(obj)); if (obj->nodeType != LIBRARYCONSTANT) return 0; if (!(obj->libFun->hasData)) return 0; if (func != NULL) { *func = (void (*)(mpfr_t, mp_prec_t, void *)) (obj->libFun->code); } if (data != NULL) { *data = obj->libFun->data; } if (dealloc != NULL) { *dealloc = obj->libFun->dealloc; } return 1; } int sollya_lib_decompose_externalprocedure(sollya_externalprocedure_type_t *resType, sollya_externalprocedure_type_t **argTypes, int *arity, void **func, sollya_obj_t obj) { sollya_externalprocedure_type_t myResType; sollya_externalprocedure_type_t *myArgTypes; sollya_externalprocedure_type_t t; chain *curr; int myArity; int i; if (obj == NULL) return 0; if (obj->nodeType == MEMREF) return sollya_lib_decompose_externalprocedure(resType, argTypes, arity, func, getMemRefChild(obj)); if (obj->nodeType != EXTERNALPROCEDUREUSAGE) return 0; if (obj->libProc->hasData) return 0; if (obj->libProc->signature == NULL) return 0; if (obj->libProc->signature->next == NULL) return 0; switch (*((int *) (obj->libProc->signature->value))) { case VOID_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_VOID; break; case CONSTANT_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_CONSTANT; break; case FUNCTION_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_FUNCTION; break; case OBJECT_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_OBJECT; break; case RANGE_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_RANGE; break; case INTEGER_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_INTEGER; break; case STRING_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_STRING; break; case BOOLEAN_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_BOOLEAN; break; case CONSTANT_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_CONSTANT_LIST; break; case FUNCTION_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_FUNCTION_LIST; break; case OBJECT_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_OBJECT_LIST; break; case RANGE_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_RANGE_LIST; break; case INTEGER_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_INTEGER_LIST; break; case STRING_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_STRING_LIST; break; case BOOLEAN_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_BOOLEAN_LIST; break; default: return 0; } if ((*((int *) (obj->libProc->signature->next->value))) == VOID_TYPE) { myArity = 0; myArgTypes = NULL; } else { myArity = lengthChain(obj->libProc->signature->next); myArgTypes = (sollya_externalprocedure_type_t *) safeCalloc(myArity, sizeof(sollya_externalprocedure_type_t)); for (curr=obj->libProc->signature->next,i=0;curr!=NULL;curr=curr->next,i++) { switch (*((int *) (curr->value))) { case VOID_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_VOID; break; case CONSTANT_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_CONSTANT; break; case FUNCTION_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_FUNCTION; break; case OBJECT_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_OBJECT; break; case RANGE_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_RANGE; break; case INTEGER_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_INTEGER; break; case STRING_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_STRING; break; case BOOLEAN_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_BOOLEAN; break; case CONSTANT_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_CONSTANT_LIST; break; case FUNCTION_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_FUNCTION_LIST; break; case OBJECT_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_OBJECT_LIST; break; case RANGE_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_RANGE_LIST; break; case INTEGER_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_INTEGER_LIST; break; case STRING_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_STRING_LIST; break; case BOOLEAN_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_BOOLEAN_LIST; break; default: safeFree(myArgTypes); return 0; } myArgTypes[i] = t; } } if (func != NULL) { *func = obj->libProc->code; } if (resType != NULL) { *resType = myResType; } if (arity != NULL) { *arity = myArity; } if (myArity != 0) { if (argTypes != NULL) { *argTypes = myArgTypes; } else { safeFree(myArgTypes); } } return 1; } int sollya_lib_decompose_externalprocedure_with_data(sollya_externalprocedure_type_t *resType, sollya_externalprocedure_type_t **argTypes, int *arity, void **func, void **data, void (**dealloc)(void *), sollya_obj_t obj) { sollya_externalprocedure_type_t myResType; sollya_externalprocedure_type_t *myArgTypes; sollya_externalprocedure_type_t t; chain *curr; int myArity; int i; if (obj == NULL) return 0; if (obj->nodeType == MEMREF) return sollya_lib_decompose_externalprocedure_with_data(resType, argTypes, arity, func, data, dealloc, getMemRefChild(obj)); if (obj->nodeType != EXTERNALPROCEDUREUSAGE) return 0; if (!(obj->libProc->hasData)) return 0; if (obj->libProc->signature == NULL) return 0; if (obj->libProc->signature->next == NULL) return 0; switch (*((int *) (obj->libProc->signature->value))) { case VOID_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_VOID; break; case CONSTANT_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_CONSTANT; break; case FUNCTION_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_FUNCTION; break; case OBJECT_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_OBJECT; break; case RANGE_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_RANGE; break; case INTEGER_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_INTEGER; break; case STRING_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_STRING; break; case BOOLEAN_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_BOOLEAN; break; case CONSTANT_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_CONSTANT_LIST; break; case FUNCTION_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_FUNCTION_LIST; break; case OBJECT_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_OBJECT_LIST; break; case RANGE_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_RANGE_LIST; break; case INTEGER_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_INTEGER_LIST; break; case STRING_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_STRING_LIST; break; case BOOLEAN_LIST_TYPE: myResType = SOLLYA_EXTERNALPROC_TYPE_BOOLEAN_LIST; break; default: return 0; } if ((*((int *) (obj->libProc->signature->next->value))) == VOID_TYPE) { myArity = 0; myArgTypes = NULL; } else { myArity = lengthChain(obj->libProc->signature->next); myArgTypes = (sollya_externalprocedure_type_t *) safeCalloc(myArity, sizeof(sollya_externalprocedure_type_t)); for (curr=obj->libProc->signature->next,i=0;curr!=NULL;curr=curr->next,i++) { switch (*((int *) (curr->value))) { case VOID_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_VOID; break; case CONSTANT_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_CONSTANT; break; case FUNCTION_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_FUNCTION; break; case OBJECT_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_OBJECT; break; case RANGE_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_RANGE; break; case INTEGER_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_INTEGER; break; case STRING_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_STRING; break; case BOOLEAN_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_BOOLEAN; break; case CONSTANT_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_CONSTANT_LIST; break; case FUNCTION_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_FUNCTION_LIST; break; case OBJECT_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_OBJECT_LIST; break; case RANGE_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_RANGE_LIST; break; case INTEGER_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_INTEGER_LIST; break; case STRING_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_STRING_LIST; break; case BOOLEAN_LIST_TYPE: t = SOLLYA_EXTERNALPROC_TYPE_BOOLEAN_LIST; break; default: safeFree(myArgTypes); return 0; } myArgTypes[i] = t; } } if (func != NULL) { *func = obj->libProc->code; } if (data != NULL) { *data = obj->libProc->data; } if (resType != NULL) { *resType = myResType; } if (arity != NULL) { *arity = myArity; } if (myArity != 0) { if (argTypes != NULL) { *argTypes = myArgTypes; } else { safeFree(myArgTypes); } } if (dealloc != NULL) { *dealloc = obj->libProc->dealloc; } return 1; } int sollya_lib_decompose_procedurefunction(sollya_obj_t *proc, int *deriv, sollya_obj_t *sub_func, sollya_obj_t obj) { if (obj == NULL) return 0; if (obj->nodeType == MEMREF) return sollya_lib_decompose_procedurefunction(proc, deriv, sub_func, getMemRefChild(obj)); if (obj->nodeType != PROCEDUREFUNCTION) return 0; if (proc != NULL) { *proc = copyThing(obj->child2); } if (deriv != NULL) { *deriv = obj->libFunDeriv; } if (sub_func != NULL) { *sub_func = copyThing(obj->child1); } return 1; } int sollya_lib_is_on(sollya_obj_t obj1){ if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == ON); } int sollya_lib_is_off(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == OFF); } int sollya_lib_is_dyadic(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == DYADIC); } int sollya_lib_is_powers(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == POWERS); } int sollya_lib_is_binary(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == BINARY); } int sollya_lib_is_hexadecimal(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == HEXADECIMAL); } int sollya_lib_is_file(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == FILESYM); } int sollya_lib_is_postscript(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == POSTSCRIPT); } int sollya_lib_is_postscriptfile(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == POSTSCRIPTFILE); } int sollya_lib_is_perturb(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == PERTURB); } int sollya_lib_is_round_down(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == ROUNDDOWN); } int sollya_lib_is_round_up(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == ROUNDUP); } int sollya_lib_is_round_towards_zero(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == ROUNDTOZERO); } int sollya_lib_is_round_to_nearest(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == ROUNDTONEAREST); } int sollya_lib_is_honorcoeffprec(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == HONORCOEFF); } int sollya_lib_is_true(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == TRUE); } int sollya_lib_is_false(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == FALSE); } int sollya_lib_is_void(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == UNIT); } int sollya_lib_is_default(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == DEFAULT); } int sollya_lib_is_decimal(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == DECIMAL); } int sollya_lib_is_absolute(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == ABSOLUTESYM); } int sollya_lib_is_relative(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == RELATIVESYM); } int sollya_lib_is_fixed(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == FIXED); } int sollya_lib_is_floating(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == FLOATING); } int sollya_lib_is_double_obj(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == DOUBLESYMBOL); } int sollya_lib_is_single_obj(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == SINGLESYMBOL); } int sollya_lib_is_quad_obj(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == QUADSYMBOL); } int sollya_lib_is_halfprecision_obj(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == HALFPRECISIONSYMBOL); } int sollya_lib_is_doubleextended_obj(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == DOUBLEEXTENDEDSYMBOL); } int sollya_lib_is_double_double_obj(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == DOUBLEDOUBLESYMBOL); } int sollya_lib_is_triple_double_obj(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == TRIPLEDOUBLESYMBOL); } int sollya_lib_is_pi(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return (accessThruMemRef(obj1)->nodeType == PI_CONST); } int sollya_lib_obj_is_structure(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return isStructure(obj1); } int sollya_lib_obj_is_procedure(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return isProcedure(obj1); } int sollya_lib_obj_is_externalprocedure(sollya_obj_t obj1) { if (obj1 == NULL) return 0; return isExternalProcedureUsage(obj1); } uint64_t sollya_lib_hash(sollya_obj_t obj1) { if (obj1 == NULL) return hashPointer(obj1); return hashThing(obj1); } static inline int __sollya_lib_get_structure_elements_inner(char ***identifiers, sollya_obj_t **objects, int *num, sollya_obj_t obj1) { chain *curr; int i; if (obj1 == NULL) return 0; if (obj1->nodeType == MEMREF) return sollya_lib_get_structure_elements(identifiers, objects, num, getMemRefChild(obj1)); if (!isStructure(obj1)) return 0; *num = lengthChain(obj1->arguments); *identifiers = (char **) safeCalloc(*num, sizeof(char *)); *objects = (sollya_obj_t *) safeCalloc(*num, sizeof(sollya_obj_t)); for (curr=obj1->arguments, i=0; curr != NULL; curr=curr->next, i++) { (*objects)[i] = copyThing((node *) (((entry *) (curr->value))->value)); (*identifiers)[i] = (char *) safeCalloc(strlen((char *) (((entry *) (curr->value))->name)) + 1, sizeof(char)); strcpy((*identifiers)[i],(char *) (((entry *) (curr->value))->name)); } return 1; } int sollya_lib_get_structure_elements(char ***identifiers, sollya_obj_t **objects, int *num, sollya_obj_t obj1) { char **myidentifiers; sollya_obj_t *myobjects; int mynum; int i; int res; if (obj1 == NULL) return 0; res = __sollya_lib_get_structure_elements_inner(&myidentifiers, &myobjects, &mynum, obj1); if (res) { if (identifiers != NULL) { *identifiers = myidentifiers; } else { for (i=0;inodeType == MEMREF) return sollya_lib_get_element_in_structure(object, identifier, getMemRefChild(obj1)); if (!isStructure(obj1)) return 0; for (curr=obj1->arguments; curr != NULL; curr=curr->next) { if (!strcmp(identifier, (char *) (((entry *) (curr->value))->name))) { myobj = copyThing((node *) (((entry *) (curr->value))->value)); if (object != NULL) { *object = myobj; } else { freeThing(myobj); } return 1; } } return 0; } int sollya_lib_create_structure(sollya_obj_t *object, sollya_obj_t obj1, char *identifier, sollya_obj_t obj2) { entry *tempEntry; int added; chain *curr; node *tempObj; sollya_obj_t myobject; if (obj2 == NULL) return 0; if (identifier == NULL) return 0; if (!isValidIdentifier(identifier)) return 0; if (obj1 == NULL) { tempEntry = (entry *) safeMalloc(sizeof(entry)); tempEntry->name = (char *) safeCalloc(strlen(identifier) + 1, sizeof(char)); strcpy(tempEntry->name, identifier); tempEntry->value = copyThing(obj2); myobject = addMemRef(makeStructure(addElement(NULL, tempEntry))); if (object != NULL) { *object = myobject; } else { freeThing(myobject); } return 1; } if (obj1->nodeType == MEMREF) return sollya_lib_create_structure(object, getMemRefChild(obj1), identifier, obj2); if (!isStructure(obj1)) return 0; tempObj = (node *) safeMalloc(sizeof(node)); tempObj->nodeType = STRUCTURE; tempObj->arguments = NULL; added = 0; for (curr = obj1->arguments; curr != NULL; curr=curr->next) { tempEntry = (entry *) safeMalloc(sizeof(entry)); tempEntry->name = (char *) safeCalloc(strlen((char *) (((entry *) (curr->value))->name)) + 1, sizeof(char)); strcpy(tempEntry->name, (char *) (((entry *) (curr->value))->name)); if (!strcmp(identifier, (char *) (((entry *) (curr->value))->name))) { tempEntry->value = copyThing(obj2); added = 1; } else { tempEntry->value = copyThing((node *) (((entry *) (curr->value))->value)); } tempObj->arguments = addElement(tempObj->arguments, tempEntry); } if (!added) { tempEntry = (entry *) safeMalloc(sizeof(entry)); tempEntry->name = (char *) safeCalloc(strlen(identifier) + 1, sizeof(char)); strcpy(tempEntry->name, identifier); tempEntry->value = copyThing(obj2); tempObj->arguments = addElement(tempObj->arguments, tempEntry); } myobject = addMemRef(tempObj); if (object != NULL) { *object = myobject; } else { freeThing(myobject); } return 1; } sollya_fp_result_t sollya_lib_evaluate_function_at_point(mpfr_t y, sollya_obj_t obj1, mpfr_t x, mpfr_t *cutoff) { int res; mpfr_t myCutOff; sollya_mpfi_t xInt, yInt; mpfr_t yLeft, yRight; mp_prec_t prec, p; mpfr_t threshold; /* Check for stupid input */ if (obj1 == NULL) { mpfr_set_nan(y); return SOLLYA_FP_OBJ_NO_FUNCTION; } /* Check if object is a function */ if (!isPureTree(obj1)) { mpfr_set_nan(y); return SOLLYA_FP_OBJ_NO_FUNCTION; } /* Determine start precision */ prec = mpfr_get_prec(y) + 10; /* Initialize our own cutoff variable */ if (cutoff == NULL) { mpfr_init2(myCutOff, 12); mpfr_set_ui(myCutOff, 0, GMP_RNDN); } else { if (mpfr_nan_p(*cutoff)) { mpfr_set_nan(y); return SOLLYA_FP_CUTOFF_IS_NAN; } mpfr_init2(myCutOff, mpfr_get_prec(*cutoff)); mpfr_abs(myCutOff, *cutoff, GMP_RNDN); } /* Try to perform faithful evaluation */ res = evaluateFaithfulWithCutOffFast(y, obj1, NULL, x, myCutOff, prec); __sollya_lib_internal_mpfr_zero_sign_normalize(y); /* Free cutoff */ mpfr_clear(myCutOff); /* Translate the evaluation result code */ switch (res) { case 1: /* Faithful rounding was possible */ return SOLLYA_FP_FAITHFUL; break; case 4: /* Faithful/ correct rounding was possible and the result was exact */ return SOLLYA_FP_PROVEN_EXACT; break; case 5: /* Faithful rounding was possible and the result was inexact */ return SOLLYA_FP_FAITHFUL_PROVEN_INEXACT; break; case 6: /* Correct rounding was possible */ return SOLLYA_FP_CORRECTLY_ROUNDED; break; case 7: /* Correct rounding was possible and the result was inexact */ return SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT; break; case 2: /* Result was shown to be smaller than cutoff */ mpfr_set_ui(y,0,GMP_RNDN); /* Set to zero because we are below the cutoff */ __sollya_lib_internal_mpfr_zero_sign_normalize(y); return SOLLYA_FP_BELOW_CUTOFF; break; default: break; } /* If we are here, we could not achieve faithful rounding nor get below the cutoff. We have to perform an additional interval evaluation and see if we get real numbers as bounds and if zero is in that interval or not. */ if (prec < tools_precision) prec = tools_precision; sollya_mpfi_init2(xInt, mpfr_get_prec(x)); sollya_mpfi_set_fr(xInt, x); p = 256 * prec + 10; sollya_mpfi_init2(yInt, p); /* Perform interval evaluation */ evaluateInterval(yInt, obj1, NULL, xInt); /* Extract bounds */ mpfr_init2(yLeft, sollya_mpfi_get_prec(yInt)); mpfr_init2(yRight, sollya_mpfi_get_prec(yInt)); sollya_mpfi_get_left(yLeft, yInt); sollya_mpfi_get_right(yRight, yInt); /* Clear intervals */ sollya_mpfi_clear(xInt); sollya_mpfi_clear(yInt); /* Check if we got a "point" infinity proof interval */ if (mpfr_inf_p(yLeft) && mpfr_inf_p(yRight) && (mpfr_sgn(yLeft) == mpfr_sgn(yRight))) { mpfr_set(y, yLeft, GMP_RNDN); /* Copying an infinity */ mpfr_clear(yLeft); mpfr_clear(yRight); return SOLLYA_FP_INFINITY; } /* Check if one of the bounds is a NaN */ if (mpfr_nan_p(yLeft) || mpfr_nan_p(yRight)) { mpfr_clear(yLeft); mpfr_clear(yRight); mpfr_set_nan(y); return SOLLYA_FP_FAILURE; } /* Check if we have an infinity left over */ if ((!mpfr_number_p(yLeft)) || (!mpfr_number_p(yRight))) { /* Here we have [-Inf;Inf] or [4;Inf] or [-Inf;4] We return the floating-point evaluation of (inf(I) + sup(I))/2. This means we will produce NaN for [-Inf;Inf]. */ mpfr_add(yLeft, yLeft, yRight, GMP_RNDN); mpfr_div_2ui(y, yLeft, 1, GMP_RNDN); __sollya_lib_internal_mpfr_zero_sign_normalize(y); mpfr_clear(yLeft); mpfr_clear(yRight); return SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED; } /* Here, both bounds of the proof interval are numbers. Check if zero is in the proof interval or not. */ if (mpfr_sgn(yLeft) * mpfr_sgn(yRight) < 0) { /* Zero is in the proof interval. Separate the case if max(abs(yLeft),abs(yRight)) is less than 2^(-p/2) or not. Here, p is the computing precision we used for the last interval evaluation. */ mpfr_init2(threshold, 12); /* Will store a power of 2 */ mpfr_set_ui(threshold,1,GMP_RNDN); mpfr_div_2ui(threshold,threshold,(p >> 1),GMP_RNDN); /* exact: power of 2 */ if ((mpfr_cmp_abs(yLeft, threshold) < 0) && (mpfr_cmp_abs(yRight, threshold) < 0)) { mpfr_clear(threshold); /* Here both bounds are in magnitude less than the threshold = 2^(-p/2) We return 0. */ mpfr_set_ui(y,0,GMP_RNDN); __sollya_lib_internal_mpfr_zero_sign_normalize(y); mpfr_clear(yLeft); mpfr_clear(yRight); return SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD; } mpfr_clear(threshold); /* Here, at least one of the bounds is not below the threshold. We return the floating-point midpoint of the proof interval. */ mpfr_add(yLeft, yLeft, yRight, GMP_RNDN); mpfr_div_2ui(y, yLeft, 1, GMP_RNDN); __sollya_lib_internal_mpfr_zero_sign_normalize(y); mpfr_clear(yLeft); mpfr_clear(yRight); return SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_NOT_BELOW_THRESHOLD; } /* Here, zero is not in the proof interval. Take the approximate midpoint of the proof interval as an approximation of the mathematical result value. */ mpfr_add(yLeft, yLeft, yRight, GMP_RNDN); mpfr_div_2ui(y, yLeft, 1, GMP_RNDN); __sollya_lib_internal_mpfr_zero_sign_normalize(y); mpfr_clear(yLeft); mpfr_clear(yRight); return SOLLYA_FP_NOT_FAITHFUL_ZERO_NOT_CONTAINED; } sollya_fp_result_t sollya_lib_evaluate_function_at_constant_expression(mpfr_t y, sollya_obj_t obj1, sollya_obj_t x, mpfr_t *cutoff) { int res; mpfr_t myCutOff; sollya_mpfi_t xInt, yInt; mpfr_t yLeft, yRight; mp_prec_t prec, p; mpfr_t threshold; /* Check for stupid input */ if ((obj1 == NULL) || (x == NULL)) { mpfr_set_nan(y); return SOLLYA_FP_OBJ_NO_FUNCTION; } /* Check if object is a function */ if ((!isPureTree(obj1)) || (!isPureTree(x))) { mpfr_set_nan(y); return SOLLYA_FP_OBJ_NO_FUNCTION; } /* Check if abscissa expression is constant */ if (!isConstant(x)) { mpfr_set_nan(y); return SOLLYA_FP_EXPRESSION_NOT_CONSTANT; } /* Determine start precision */ prec = mpfr_get_prec(y) + 10; /* Initialize our own cutoff variable */ if (cutoff == NULL) { mpfr_init2(myCutOff, 12); mpfr_set_ui(myCutOff, 0, GMP_RNDN); } else { if (mpfr_nan_p(*cutoff)) { mpfr_set_nan(y); return SOLLYA_FP_CUTOFF_IS_NAN; } mpfr_init2(myCutOff, mpfr_get_prec(*cutoff)); mpfr_abs(myCutOff, *cutoff, GMP_RNDN); } /* Try to perform faithful evaluation */ res = evaluateFaithfulAtConstantExpression(y, obj1, NULL, x, myCutOff, prec); __sollya_lib_internal_mpfr_zero_sign_normalize(y); /* Free cutoff */ mpfr_clear(myCutOff); /* Translate the evaluation result code */ switch (res) { case 1: /* Faithful rounding was possible */ return SOLLYA_FP_FAITHFUL; break; case 4: /* Faithful/ correct rounding was possible and the result was exact */ return SOLLYA_FP_PROVEN_EXACT; break; case 5: /* Faithful rounding was possible and the result was inexact */ return SOLLYA_FP_FAITHFUL_PROVEN_INEXACT; break; case 6: /* Correct rounding was possible */ return SOLLYA_FP_CORRECTLY_ROUNDED; break; case 7: /* Correct rounding was possible and the result was inexact */ return SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT; break; case 2: /* Result was shown to be smaller than cutoff */ mpfr_set_ui(y,0,GMP_RNDN); /* Set to zero because we are below the cutoff */ __sollya_lib_internal_mpfr_zero_sign_normalize(y); return SOLLYA_FP_BELOW_CUTOFF; break; default: break; } /* If we are here, we could not achieve faithful rounding nor get below the cutoff. We have to perform an additional interval evaluation and see if we get real numbers as bounds and if zero is in that interval or not. */ if (prec < tools_precision) prec = tools_precision; p = 256 * prec + 10; /* Evaluate x to an interval xInt */ sollya_mpfi_init2(xInt, p); evaluateConstantExpressionToInterval(xInt, x); /* Initialize the ordinate interval */ sollya_mpfi_init2(yInt, p); /* Perform interval evaluation */ evaluateInterval(yInt, obj1, NULL, xInt); /* Extract bounds */ mpfr_init2(yLeft, sollya_mpfi_get_prec(yInt)); mpfr_init2(yRight, sollya_mpfi_get_prec(yInt)); sollya_mpfi_get_left(yLeft, yInt); sollya_mpfi_get_right(yRight, yInt); /* Clear intervals */ sollya_mpfi_clear(xInt); sollya_mpfi_clear(yInt); /* Check if we got a "point" infinity proof interval */ if (mpfr_inf_p(yLeft) && mpfr_inf_p(yRight) && (mpfr_sgn(yLeft) == mpfr_sgn(yRight))) { mpfr_set(y, yLeft, GMP_RNDN); /* Copying an infinity */ mpfr_clear(yLeft); mpfr_clear(yRight); return SOLLYA_FP_INFINITY; } /* Check if one of the bounds is a NaN */ if (mpfr_nan_p(yLeft) || mpfr_nan_p(yRight)) { mpfr_clear(yLeft); mpfr_clear(yRight); mpfr_set_nan(y); return SOLLYA_FP_FAILURE; } /* Check if we have an infinity left over */ if ((!mpfr_number_p(yLeft)) || (!mpfr_number_p(yRight))) { /* Here we have [-Inf;Inf] or [4;Inf] or [-Inf;4] We return the floating-point evaluation of (inf(I) + sup(I))/2. This means we will produce NaN for [-Inf;Inf]. */ mpfr_add(yLeft, yLeft, yRight, GMP_RNDN); mpfr_div_2ui(y, yLeft, 1, GMP_RNDN); __sollya_lib_internal_mpfr_zero_sign_normalize(y); mpfr_clear(yLeft); mpfr_clear(yRight); return SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED; } /* Here, both bounds of the proof interval are numbers. Check if zero is in the proof interval or not. */ if (mpfr_sgn(yLeft) * mpfr_sgn(yRight) < 0) { /* Zero is in the proof interval. Separate the case if max(abs(yLeft),abs(yRight)) is less than 2^(-p/2) or not. Here, p is the computing precision we used for the last interval evaluation. */ mpfr_init2(threshold, 12); /* Will store a power of 2 */ mpfr_set_ui(threshold,1,GMP_RNDN); mpfr_div_2ui(threshold,threshold,(p >> 1),GMP_RNDN); /* exact: power of 2 */ if ((mpfr_cmp_abs(yLeft, threshold) < 0) && (mpfr_cmp_abs(yRight, threshold) < 0)) { mpfr_clear(threshold); /* Here both bounds are in magnitude less than the threshold = 2^(-p/2) We return 0. */ mpfr_set_ui(y,0,GMP_RNDN); __sollya_lib_internal_mpfr_zero_sign_normalize(y); mpfr_clear(yLeft); mpfr_clear(yRight); return SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD; } mpfr_clear(threshold); /* Here, at least one of the bounds is not below the threshold. We return the floating-point midpoint of the proof interval. */ mpfr_add(yLeft, yLeft, yRight, GMP_RNDN); mpfr_div_2ui(y, yLeft, 1, GMP_RNDN); __sollya_lib_internal_mpfr_zero_sign_normalize(y); mpfr_clear(yLeft); mpfr_clear(yRight); return SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_NOT_BELOW_THRESHOLD; } /* Here, zero is not in the proof interval. Take the approximate midpoint of the proof interval as an approximation of the mathematical result value. */ mpfr_add(yLeft, yLeft, yRight, GMP_RNDN); mpfr_div_2ui(y, yLeft, 1, GMP_RNDN); __sollya_lib_internal_mpfr_zero_sign_normalize(y); mpfr_clear(yLeft); mpfr_clear(yRight); return SOLLYA_FP_NOT_FAITHFUL_ZERO_NOT_CONTAINED; } int sollya_lib_evaluate_function_over_interval(mpfi_t y, sollya_obj_t obj1, mpfi_t op_x) { sollya_mpfi_t myY, myPointY, x; mpfr_t xLeft, xRight, yLeft, yRight, myCutOff; mp_prec_t prec, p; /* Check for stupid input */ if (obj1 == NULL) { sollya_mpfi_set_nan(y); return 0; } /* Check if object is a function */ if (!isPureTree(obj1)) { sollya_mpfi_set_nan(y); return 0; } /* Convert entering mpfi_t interval to sollya_mpfi_t */ sollya_init_and_convert_interval(x, op_x); /* Initialize our own versions of the final result */ prec = sollya_mpfi_get_prec(y); sollya_mpfi_init2(myY, prec + 5); sollya_mpfi_init2(myPointY, prec + 5); sollya_mpfi_set_full_range(myPointY); /* If x is a point interval, try to use faithful evaluation with precision adaptation to get a tighter result. */ p = sollya_mpfi_get_prec(x); mpfr_init2(xLeft, p); mpfr_init2(xRight, p); sollya_mpfi_get_left(xLeft, x); sollya_mpfi_get_right(xRight, x); if (mpfr_equal_p(xLeft,xRight)) { mpfr_init2(yLeft, prec + 10); mpfr_init2(yRight, prec + 10); mpfr_init2(myCutOff, 12); mpfr_set_ui(myCutOff, 0, GMP_RNDN); if (evaluateFaithfulWithCutOffFast(yLeft, obj1, NULL, xLeft, myCutOff, prec + 15) == 1) { mpfr_set(yRight, yLeft, GMP_RNDN); /* exact */ mpfr_nextbelow(yLeft); mpfr_nextbelow(yLeft); mpfr_nextabove(yRight); mpfr_nextabove(yRight); if (mpfr_number_p(yLeft) && mpfr_number_p(yRight)) { sollya_mpfi_interv_fr(myPointY, yLeft, yRight); } } mpfr_clear(myCutOff); mpfr_clear(yLeft); mpfr_clear(yRight); } mpfr_clear(xLeft); mpfr_clear(xRight); /* Perform an interval evaluation on the whole interval */ evaluateInterval(myY, obj1, NULL, x); /* Set final result as intersection of myY and myPointY */ sollya_mpfi_intersect(y, myY, myPointY); /* Clear the local variables */ sollya_mpfi_clear(myY); sollya_mpfi_clear(myPointY); /* Clear our sollya_mpfi_t copy of the entering interval */ sollya_mpfi_clear(x); /* Indicate success, independently if we produced NaN or an interval */ return 1; } sollya_obj_t sollya_lib_externalprocedure(sollya_externalprocedure_type_t res_type, sollya_externalprocedure_type_t *arg_types, int arity, char *name, void *func) { libraryProcedure *libProc; int resType; int *argTypes; int i, t; sollya_obj_t unevaluatedExternalProcedure, evaluatedExternalProcedure; if (arity < 0) return sollya_lib_error(); if (arity > 0) { if (arg_types == NULL) return sollya_lib_error(); } switch (res_type) { case SOLLYA_EXTERNALPROC_TYPE_VOID: resType = VOID_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_CONSTANT: resType = CONSTANT_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_FUNCTION: resType = FUNCTION_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_RANGE: resType = RANGE_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_INTEGER: resType = INTEGER_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_STRING: resType = STRING_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_BOOLEAN: resType = BOOLEAN_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_OBJECT: resType = OBJECT_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_CONSTANT_LIST: resType = CONSTANT_LIST_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_FUNCTION_LIST: resType = FUNCTION_LIST_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_RANGE_LIST: resType = RANGE_LIST_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_INTEGER_LIST: resType = INTEGER_LIST_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_STRING_LIST: resType = STRING_LIST_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_BOOLEAN_LIST: resType = BOOLEAN_LIST_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_OBJECT_LIST: resType = OBJECT_LIST_TYPE; break; default: return sollya_lib_error(); } argTypes = safeCalloc(((arity > 0) ? arity : 1), sizeof(int)); for (i=0;i 0) { if (arg_types == NULL) return sollya_lib_error(); } switch (res_type) { case SOLLYA_EXTERNALPROC_TYPE_VOID: resType = VOID_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_CONSTANT: resType = CONSTANT_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_FUNCTION: resType = FUNCTION_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_RANGE: resType = RANGE_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_INTEGER: resType = INTEGER_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_STRING: resType = STRING_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_BOOLEAN: resType = BOOLEAN_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_OBJECT: resType = OBJECT_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_CONSTANT_LIST: resType = CONSTANT_LIST_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_FUNCTION_LIST: resType = FUNCTION_LIST_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_RANGE_LIST: resType = RANGE_LIST_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_INTEGER_LIST: resType = INTEGER_LIST_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_STRING_LIST: resType = STRING_LIST_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_BOOLEAN_LIST: resType = BOOLEAN_LIST_TYPE; break; case SOLLYA_EXTERNALPROC_TYPE_OBJECT_LIST: resType = OBJECT_LIST_TYPE; break; default: return sollya_lib_error(); } argTypes = safeCalloc(((arity > 0) ? arity : 1), sizeof(int)); for (i=0;ivalue); } sollya_obj_list_t sollya_lib_get_object_list_tail(sollya_obj_list_t list) { if (list == NULL) return NULL; return (sollya_obj_list_t) (list->next); } sollya_obj_list_t sollya_lib_construct_object_list(sollya_obj_t obj1, sollya_obj_list_t list) { if (obj1 == NULL) return list; return (sollya_obj_list_t) addElement(list, obj1); } sollya_obj_list_t sollya_lib_copy_object_list(sollya_obj_list_t list) { if (list == NULL) return NULL; return (sollya_obj_list_t) (copyChainWithoutReversal(list, copyThingOnVoid)); } void sollya_lib_clear_object_list(sollya_obj_list_t list) { if (list == NULL) return; freeChain(list, freeThingOnVoid); } int sollya_lib_is_empty_object_list(sollya_obj_list_t list) { return (list == NULL); } mpfr_t *sollya_lib_get_constant_list_head(sollya_constant_list_t list) { if (list == NULL) return NULL; return (mpfr_t *) (list->value); } sollya_constant_list_t sollya_lib_get_constant_list_tail(sollya_constant_list_t list) { if (list == NULL) return NULL; return (sollya_constant_list_t) (list->next); } sollya_constant_list_t sollya_lib_construct_constant_list(mpfr_t *constant, sollya_constant_list_t list) { if (constant == NULL) return list; return (sollya_constant_list_t) addElement(list, constant); } sollya_constant_list_t sollya_lib_copy_constant_list(sollya_constant_list_t list) { if (list == NULL) return NULL; return (sollya_constant_list_t) (copyChainWithoutReversal(list, copyMpfrPtr)); } void sollya_lib_clear_constant_list(sollya_constant_list_t list) { if (list == NULL) return; freeChain(list, freeMpfrPtr); } int sollya_lib_is_empty_constant_list(sollya_constant_list_t list) { return (list == NULL); } mpfi_t *sollya_lib_get_interval_list_head(sollya_interval_list_t list) { if (list == NULL) return NULL; return (mpfi_t *) (list->value); } sollya_interval_list_t sollya_lib_get_interval_list_tail(sollya_interval_list_t list) { if (list == NULL) return NULL; return (sollya_interval_list_t) (list->next); } sollya_interval_list_t sollya_lib_construct_interval_list(mpfi_t *interval, sollya_interval_list_t list) { if (interval == NULL) return list; return (sollya_interval_list_t) addElement(list, interval); } sollya_interval_list_t sollya_lib_copy_interval_list(sollya_interval_list_t list) { if (list == NULL) return NULL; return (sollya_interval_list_t) (copyChainWithoutReversal(list, copyMpfiPtr)); } void sollya_lib_clear_interval_list(sollya_interval_list_t list) { if (list == NULL) return; freeChain(list, freeMpfiPtr); } int sollya_lib_is_empty_interval_list(sollya_interval_list_t list) { return (list == NULL); } int sollya_lib_get_int_list_head(sollya_int_list_t list) { if (list == NULL) return 0; return *((int *) (list->value)); } sollya_int_list_t sollya_lib_get_int_list_tail(sollya_int_list_t list) { if (list == NULL) return NULL; return (sollya_int_list_t) (list->next); } sollya_int_list_t sollya_lib_construct_int_list(int integer, sollya_int_list_t list) { int *intPtr; intPtr = (int *) safeMalloc(sizeof(int)); *intPtr = integer; return (sollya_int_list_t) addElement(list, intPtr); } sollya_int_list_t sollya_lib_copy_int_list(sollya_int_list_t list) { if (list == NULL) return NULL; return (sollya_int_list_t) (copyChainWithoutReversal(list, copyIntPtrOnVoid)); } void sollya_lib_clear_int_list(sollya_int_list_t list) { if (list == NULL) return; freeChain(list, freeIntPtr); } int sollya_lib_is_empty_int_list(sollya_int_list_t list) { return (list == NULL); } int sollya_lib_get_boolean_list_head(sollya_boolean_list_t list) { if (list == NULL) return 0; return *((int *) (list->value)); } sollya_boolean_list_t sollya_lib_get_boolean_list_tail(sollya_boolean_list_t list) { if (list == NULL) return NULL; return (sollya_boolean_list_t) (list->next); } sollya_boolean_list_t sollya_lib_construct_boolean_list(int boolVal, sollya_boolean_list_t list) { int *intPtr; intPtr = (int *) safeMalloc(sizeof(int)); *intPtr = boolVal; return (sollya_boolean_list_t) addElement(list, intPtr); } sollya_boolean_list_t sollya_lib_copy_boolean_list(sollya_boolean_list_t list) { if (list == NULL) return NULL; return (sollya_boolean_list_t) (copyChainWithoutReversal(list, copyIntPtrOnVoid)); } void sollya_lib_clear_boolean_list(sollya_boolean_list_t list) { if (list == NULL) return; freeChain(list, freeIntPtr); } int sollya_lib_is_empty_boolean_list(sollya_boolean_list_t list) { return (list == NULL); } char *sollya_lib_get_string_list_head(sollya_string_list_t list) { if (list == NULL) return NULL; return (char *) (list->value); } sollya_string_list_t sollya_lib_get_string_list_tail(sollya_string_list_t list) { if (list == NULL) return NULL; return (sollya_string_list_t) (list->next); } sollya_string_list_t sollya_lib_construct_string_list(char *str, sollya_string_list_t list) { if (str == NULL) return list; return (sollya_string_list_t) addElement(list, str); } sollya_string_list_t sollya_lib_copy_string_list(sollya_string_list_t list) { if (list == NULL) return NULL; return (sollya_string_list_t) (copyChainWithoutReversal(list, copyString)); } void sollya_lib_clear_string_list(sollya_string_list_t list) { if (list == NULL) return; freeChain(list, freeStringPtr); } int sollya_lib_is_empty_string_list(sollya_string_list_t list) { return (list == NULL); } sollya_obj_t sollya_lib_build_list(sollya_obj_t obj1, ...) { node *elem, *unevaluatedList, *evaluatedList; chain *thinglist, *curr; va_list varlist; if (obj1 == NULL) { return addMemRef(makeEmptyList()); } va_start(varlist,obj1); thinglist = (chain *) safeMalloc(sizeof(chain)); thinglist->value = obj1; thinglist->next = NULL; curr = thinglist; while ((elem = va_arg(varlist,node *)) != NULL) { curr->next = (chain *) safeMalloc(sizeof(chain)); curr = curr->next; curr->value = elem; curr->next = NULL; } va_end(varlist); unevaluatedList = addMemRef(makeList(thinglist)); evaluatedList = evaluateThing(unevaluatedList); freeThing(unevaluatedList); return evaluatedList; } sollya_obj_t sollya_lib_build_end_elliptic_list(sollya_obj_t obj1, ...) { node *elem, *unevaluatedList, *evaluatedList; chain *thinglist, *curr; va_list varlist; if (obj1 == NULL) { return addMemRef(makeError()); } va_start(varlist,obj1); thinglist = (chain *) safeMalloc(sizeof(chain)); thinglist->value = obj1; thinglist->next = NULL; curr = thinglist; while ((elem = va_arg(varlist,node *)) != NULL) { curr->next = (chain *) safeMalloc(sizeof(chain)); curr = curr->next; curr->value = elem; curr->next = NULL; } va_end(varlist); unevaluatedList = addMemRef(makeFinalEllipticList(thinglist)); evaluatedList = evaluateThing(unevaluatedList); freeThing(unevaluatedList); return evaluatedList; } sollya_obj_t sollya_lib_v_build_list(va_list varlist) { node *elem, *unevaluatedList, *evaluatedList; chain *thinglist, *curr; elem = va_arg(varlist,node *); if (elem == NULL) { return addMemRef(makeEmptyList()); } thinglist = (chain *) safeMalloc(sizeof(chain)); thinglist->value = elem; thinglist->next = NULL; curr = thinglist; while ((elem = va_arg(varlist,node *)) != NULL) { curr->next = (chain *) safeMalloc(sizeof(chain)); curr = curr->next; curr->value = elem; curr->next = NULL; } unevaluatedList = addMemRef(makeList(thinglist)); evaluatedList = evaluateThing(unevaluatedList); freeThing(unevaluatedList); return evaluatedList; } sollya_obj_t sollya_lib_v_build_end_elliptic_list(va_list varlist) { node *elem, *unevaluatedList, *evaluatedList; chain *thinglist, *curr; elem = va_arg(varlist,node *); if (elem == NULL) { return addMemRef(makeError()); } thinglist = (chain *) safeMalloc(sizeof(chain)); thinglist->value = elem; thinglist->next = NULL; curr = thinglist; while ((elem = va_arg(varlist,node *)) != NULL) { curr->next = (chain *) safeMalloc(sizeof(chain)); curr = curr->next; curr->value = elem; curr->next = NULL; } unevaluatedList = addMemRef(makeFinalEllipticList(thinglist)); evaluatedList = evaluateThing(unevaluatedList); freeThing(unevaluatedList); return evaluatedList; } sollya_obj_t sollya_lib_build_function_free_variable() { return addMemRef(makeVariable()); } sollya_obj_t sollya_lib_build_function_add(sollya_obj_t obj1, sollya_obj_t obj2) { if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; return addMemRef(makeAdd(obj1,obj2)); } sollya_obj_t sollya_lib_build_function_sub(sollya_obj_t obj1, sollya_obj_t obj2) { if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; return addMemRef(makeSub(obj1,obj2)); } sollya_obj_t sollya_lib_build_function_mul(sollya_obj_t obj1, sollya_obj_t obj2) { if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; return addMemRef(makeMul(obj1,obj2)); } sollya_obj_t sollya_lib_build_function_div(sollya_obj_t obj1, sollya_obj_t obj2) { if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; return addMemRef(makeDiv(obj1,obj2)); } sollya_obj_t sollya_lib_build_function_sqrt(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeSqrt(obj1)); } sollya_obj_t sollya_lib_build_function_exp(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeExp(obj1)); } sollya_obj_t sollya_lib_build_function_log(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeLog(obj1)); } sollya_obj_t sollya_lib_build_function_log2(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeLog2(obj1)); } sollya_obj_t sollya_lib_build_function_log10(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeLog10(obj1)); } sollya_obj_t sollya_lib_build_function_sin(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeSin(obj1)); } sollya_obj_t sollya_lib_build_function_cos(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeCos(obj1)); } sollya_obj_t sollya_lib_build_function_tan(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeTan(obj1)); } sollya_obj_t sollya_lib_build_function_asin(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeAsin(obj1)); } sollya_obj_t sollya_lib_build_function_acos(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeAcos(obj1)); } sollya_obj_t sollya_lib_build_function_atan(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeAtan(obj1)); } sollya_obj_t sollya_lib_build_function_pow(sollya_obj_t obj1, sollya_obj_t obj2) { if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; return addMemRef(makePow(obj1, obj2)); } sollya_obj_t sollya_lib_build_function_neg(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeNeg(obj1)); } sollya_obj_t sollya_lib_build_function_abs(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeAbs(obj1)); } sollya_obj_t sollya_lib_build_function_double(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeDouble(obj1)); } sollya_obj_t sollya_lib_build_function_single(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeSingle(obj1)); } sollya_obj_t sollya_lib_build_function_quad(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeQuad(obj1)); } sollya_obj_t sollya_lib_build_function_halfprecision(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeHalfPrecision(obj1)); } sollya_obj_t sollya_lib_build_function_double_double(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeDoubledouble(obj1)); } sollya_obj_t sollya_lib_build_function_triple_double(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeTripledouble(obj1)); } sollya_obj_t sollya_lib_build_function_erf(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeErf(obj1)); } sollya_obj_t sollya_lib_build_function_erfc(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeErfc(obj1)); } sollya_obj_t sollya_lib_build_function_log1p(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeLog1p(obj1)); } sollya_obj_t sollya_lib_build_function_expm1(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeExpm1(obj1)); } sollya_obj_t sollya_lib_build_function_doubleextended(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeDoubleextended(obj1)); } sollya_obj_t sollya_lib_build_function_ceil(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeCeil(obj1)); } sollya_obj_t sollya_lib_build_function_floor(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeFloor(obj1)); } sollya_obj_t sollya_lib_build_function_nearestint(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeNearestInt(obj1)); } sollya_obj_t sollya_lib_build_function_sinh(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeSinh(obj1)); } sollya_obj_t sollya_lib_build_function_cosh(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeCosh(obj1)); } sollya_obj_t sollya_lib_build_function_tanh(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeTanh(obj1)); } sollya_obj_t sollya_lib_build_function_asinh(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeAsinh(obj1)); } sollya_obj_t sollya_lib_build_function_acosh(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeAcosh(obj1)); } sollya_obj_t sollya_lib_build_function_atanh(sollya_obj_t obj1) { if (obj1 == NULL) return NULL; return addMemRef(makeAtanh(obj1)); } sollya_obj_t sollya_lib_build_function_pi() { return addMemRef(makePi()); } sollya_obj_t sollya_lib_build_function_libraryconstant(char *name, void (*func)(mpfr_t, mp_prec_t)) { libraryFunction *libFunc; node *res; libFunc = bindConstantFunctionByPtr(name, func); if (libFunc == NULL) return NULL; res = (node *) safeMalloc(sizeof(node)); res->nodeType = LIBRARYCONSTANT; res->libFun = libFunc; return addMemRef(res); } sollya_obj_t sollya_lib_build_function_libraryfunction(sollya_obj_t obj1, char *name, int (*func)(mpfi_t, mpfi_t, int)) { libraryFunction *libFunc; node *res; if (obj1 == NULL) return NULL; libFunc = bindFunctionByPtr(name, func); if (libFunc == NULL) return NULL; res = (node *) safeMalloc(sizeof(node)); res->nodeType = LIBRARYFUNCTION; res->libFun = libFunc; res->libFunDeriv = 0; res->child1 = obj1; return addMemRef(res); } sollya_obj_t sollya_lib_build_function_libraryconstant_with_data(char *name, void (*func)(mpfr_t, mp_prec_t, void *), void *data, void (*dealloc)(void *)) { libraryFunction *libFunc; node *res; libFunc = bindConstantFunctionByPtrWithData(name, func, data, dealloc); if (libFunc == NULL) return NULL; res = (node *) safeMalloc(sizeof(node)); res->nodeType = LIBRARYCONSTANT; res->libFun = libFunc; return addMemRef(res); } sollya_obj_t sollya_lib_build_function_libraryfunction_with_data(sollya_obj_t obj1, char *name, int (*func)(mpfi_t, mpfi_t, int, void *), void *data, void (*dealloc)(void *)) { libraryFunction *libFunc; node *res; if (obj1 == NULL) return NULL; libFunc = bindFunctionByPtrWithData(name, func, data, dealloc); if (libFunc == NULL) return NULL; res = (node *) safeMalloc(sizeof(node)); res->nodeType = LIBRARYFUNCTION; res->libFun = libFunc; res->libFunDeriv = 0; res->child1 = obj1; return addMemRef(res); } sollya_obj_t sollya_lib_build_function_procedurefunction(sollya_obj_t obj1, sollya_obj_t obj2) { sollya_obj_t res; if (obj1 == NULL) return NULL; if (obj2 == NULL) return NULL; res = (node *) safeMalloc(sizeof(node)); res->nodeType = PROCEDUREFUNCTION; res->libFunDeriv = 0; res->child1 = obj1; res->child2 = obj2; return addMemRef(res); } sollya-6.0+ds/sollya-library-wrappers.h000066400000000000000000000055551300174114700202530ustar00rootroot00000000000000/* Copyright 2011-2012 by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, Contributors Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef SOLLYA_LIBRARY_WRAPPERS_H #define SOLLYA_LIBRARY_WRAPPERS_H /* Attention: do not change order of includes neither remove the following #define. */ #define __SOLLYA_NODE_TYPE_ALREADY_DEFINED 1 #include #include #include #include #include #include "expression.h" #include "execute.h" #include "mpfi-compat.h" typedef node * sollya_obj_t; typedef chain * sollya_obj_list_t; typedef chain * sollya_constant_list_t; typedef chain * sollya_interval_list_t; typedef chain * sollya_int_list_t; typedef chain * sollya_string_list_t; typedef chain * sollya_boolean_list_t; /* Here is where things actually do happen */ #include "sollya.h" #endif /* ifdef SOLLYA_LIBRARY_WRAPPERS_H*/ sollya-6.0+ds/sollya-messages.h000066400000000000000000001061311300174114700165450ustar00rootroot00000000000000/* Copyright 2012-2016 by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef SOLLYA_MESSAGES_H #define SOLLYA_MESSAGES_H /* Symbolic constants for the different messages in Sollya SOLLYA DEVELOPPERS: WHEN YOU ADD A NEW MESSAGE NUMBER, DO NOT FORGET TO ADD A CORRESPONDING MESSAGE TEXT IN sollya-messaging.h ! */ #define SOLLYA_MSG_NO_MSG 0 /* Void error message, no error at all */ #define SOLLYA_MSG_CONTINUATION 1 #define SOLLYA_MSG_UNDEFINED_ERROR 2 #define SOLLYA_MSG_ABS_NOT_TWICE_DIFFERENTIABLE 3 #define SOLLYA_MSG_HALF_NOT_DIFFERENTIABLE 4 #define SOLLYA_MSG_SINGLE_NOT_DIFFERENTIABLE 5 #define SOLLYA_MSG_DOUBLE_NOT_DIFFERENTIABLE 6 #define SOLLYA_MSG_DOUBLEEXTENDED_NOT_DIFFERENTIABLE 7 #define SOLLYA_MSG_DOUBLE_DOUBLE_NOT_DIFFERENTIABLE 8 #define SOLLYA_MSG_TRIPLE_DOUBLE_NOT_DIFFERENTIABLE 9 #define SOLLYA_MSG_QUAD_NOT_DIFFERENTIABLE 10 #define SOLLYA_MSG_CEIL_NOT_DIFFERENTIABLE 11 #define SOLLYA_MSG_FLOOR_NOT_DIFFERENTIABLE 12 #define SOLLYA_MSG_NEARESTINT_NOT_DIFFERENTIABLE 13 #define SOLLYA_MSG_UNDESIRED_ROUNDING_IN_ROUND_TO_FORMAT 14 #define SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE 15 #define SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_PREC 16 #define SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_CONVERTING_FROM_DOUBLE 17 #define SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_SINGLE 18 #define SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE_DOUBLE 19 #define SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE 20 #define SOLLYA_MSG_ROUNDING_DOWN_BEFORE_PRINTING_DOUBLE 22 #define SOLLYA_MSG_ROUNDING_UP_BEFORE_PRINTING_DOUBLE 23 #define SOLLYA_MSG_COULD_NOT_FIGURE_OUT_ENDIANESS 24 #define SOLLYA_MSG_ROUNDING_DOWN_BEFORE_PRINTING_SINGLE 25 #define SOLLYA_MSG_ROUNDING_UP_BEFORE_PRINTING_SINGLE 26 #define SOLLYA_MSG_SNAN_MIGHT_HAVE_BECOME_QNAN 27 #define SOLLYA_MSG_UNABLE_TO_CONVERT_FROM_HEXADECIMAL_CONSTANT 28 #define SOLLYA_MSG_GIVEN_FUNCTION_IS_NO_POLYNOMIAL 29 #define SOLLYA_MSG_NUM_OF_FORMATS_DOES_NOT_CORRESPOND_TO_DEGREE 30 #define SOLLYA_MSG_ERROR_WHILE_EXTRACTING_COEFFICIENTS_OF_POLY 31 #define SOLLYA_MSG_ERROR_POLY_COEFF_GETS_ROUNDED 32 #define SOLLYA_MSG_ERROR_EVALUATION_OF_POLY_COEFF_NOT_FAITHFUL 33 #define SOLLYA_MSG_ERROR_UNKNOWN_EXPANSION_FORMAT 34 #define SOLLYA_MSG_DOUBLE_ROUNDING_ON_HANDLING_POLY_COEFF 35 #define SOLLYA_MSG_AT_LEAST_ONE_POLY_COEFF_HAS_BEEN_ROUNDED 36 #define SOLLYA_MSG_NONE_OF_THE_POLY_COEFFS_HAS_BEEN_ROUNDED 37 #define SOLLYA_MSG_NON_REAL_NUMBER_CANNOT_BE_DOUBLE_EXPANSION 38 #define SOLLYA_MSG_DOUBLE_ROUNDING_ON_CONVERSION 39 #define SOLLYA_MSG_DOUBLE_EXPANSION_INCOMPLETE 40 #define SOLLYA_MSG_ROUNDING_WHILE_SIMPLIFYING_TO_POLYNOMIAL 41 #define SOLLYA_MSG_POLY_COEFF_IS_NOT_CONSTANT 42 #define SOLLYA_MSG_SOME_EVALUATION_IS_NOT_FAITHFUL 43 #define SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_IEEE_754_2008_OPERATOR 44 #define SOLLYA_MSG_STRING_CANNOT_BE_PARSED_BY_MINIPARSER 45 #define SOLLYA_MSG_ERROR_ON_RUNNING_GUESSDEGREE 46 #define SOLLYA_MSG_FILE_EXECUTION_ASKED_FOR_QUIT_NOT_QUITTING 47 #define SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_SEEMS_CONSTANT 48 #define SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_IS_CONSTANT_ON_FP 49 #define SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_IS_NOT_FAITHFUL 50 #define SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_NO_FAITHFUL_PLAIN_FP 51 #define SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST 52 #define SOLLYA_MSG_CONSTANT_IS_NOT_MACHINE_INTEGER_WILL_ROUND 53 #define SOLLYA_MSG_PRECISION_OF_NUMBERS_MUST_BE_AT_LEAST_TWO_BITS 54 #define SOLLYA_MSG_IDENTIFIER_ALREADY_BOUND 55 #define SOLLYA_MSG_IDENTIFIER_REASSIGNMENT 56 #define SOLLYA_MSG_DISPLAYED_VALUE_IS_FAITHFULLY_ROUNDED 57 #define SOLLYA_MSG_EXPRESSION_UNDEFINED_OR_UNSTABLE 58 #define SOLLYA_MSG_ROUNDING_MAY_HAVE_HAPPENED_AND_NOT_FAITHFUL 59 #define SOLLYA_MSG_EVALUATION_WITH_PLAIN_FP_ARITHMETIC 60 #define SOLLYA_MSG_ROUNDING_MAY_HAVE_HAPPENED_SOMEWHERE 61 #define SOLLYA_MSG_EXPRESSION_TOO_BIG_FOR_HORNER_FORM 62 #define SOLLYA_MSG_EXPRESSION_TOO_BIG_FOR_CANONICAL_FORM 63 #define SOLLYA_MSG_DOUBLE_SIMPLIFICATION_NECESSARY 64 #define SOLLYA_MSG_COMMAND_NOT_EXECUTABLE 65 #define SOLLYA_MSG_TIMER_UNUSABLE 66 #define SOLLYA_MSG_CAN_MODIFY_ONLY_ELEMENTS_OF_STRUCTURES 67 #define SOLLYA_MSG_CONTROL_STRUCTURE_NOT_EXECUTABLE_EXPR_NO_BOOLEAN 68 #define SOLLYA_MSG_AT_END_OF_FOR_CNTRL_VAR_NO_LONGER_ASSIGNABLE 69 #define SOLLYA_MSG_AT_END_OF_FOR_CNTRL_VAR_NO_LONGER_CONSTANT 70 #define SOLLYA_MSG_TOOL_HAS_BEEN_RESTARTED_INSIDE_LOOP 71 #define SOLLYA_MSG_CNTRL_VAR_OF_LOOP_CANNOT_BE_ASSIGNED 72 #define SOLLYA_MSG_ARGS_OF_FOR_LOOP_NOT_CONSTANT 73 #define SOLLYA_MSG_FOR_IN_LOOP_OVER_EMPTY_LIST 74 #define SOLLYA_MSG_FOR_IN_LOOP_OVER_END_ELLIPTIC_LIST_NOT_ALLOWED 75 #define SOLLYA_MSG_AT_LEAST_ONE_OPERATION_MUST_BE_EXECUTED 76 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER 77 #define SOLLYA_MSG_RESTART_IN_FILE_READ_INTO_ANOTHER 78 #define SOLLYA_MSG_QUIT_IN_FILE_READ_INTO_ANOTHER 79 #define SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_LOCAL_VAR 80 #define SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_LOCAL_VAR 81 #define SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_LOCAL_VAR 82 #define SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_LOCAL_VAR 83 #define SOLLYA_MSG_FRAME_SYSTEM_CORRUPTED_LOCAL_VAR_NOT_DECLARED 84 #define SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING 85 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING 86 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_LIST_OF_FUNCTIONS 87 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_RANGE 88 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING_NOR_DEFAULT 89 #define SOLLYA_MSG_IMPLEMENTATION_HAS_NOT_SUCCEEDED 90 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_CONSTANT 91 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_AN_EXPRESSION 92 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_A_FUNCTION 93 #define SOLLYA_MSG_ROUNDING_WHILE_PRINTING 94 #define SOLLYA_MSG_BASH_RETURNS_A_CERTAIN_RETURN_VALUE 95 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ABS_NOR_REL 96 #define SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_APPENDING 97 #define SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_READING 98 #define SOLLYA_MSG_FREE_VARIABLE_HAS_BEEN_NAMED_SOMEHOW 99 #define SOLLYA_MSG_FREE_VARIABLE_HAS_BEEN_RENAMED 100 #define SOLLYA_MSG_CAN_RENAME_ONLY_FREE_VARIABLE 101 #define SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_EXTERNAL 102 #define SOLLYA_MSG_IDENTIFIER_IS_BOUND_TO_VAR_CANNOT_BE_EXTERNAL 103 #define SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_EXTERNAL 104 #define SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_EXTERNAL 105 #define SOLLYA_MSG_ERROR_OCCURRED_COMMAND_NOT_EXECUTED 106 #define SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT 107 #define SOLLYA_MSG_ASSIGNMENT_OF_INDEXED_ELEMENTS_NOT_IN_RANGE 108 #define SOLLYA_MSG_ASSIGNMENT_OF_INDEXED_EMPTY_LIST_ONLY_ON_ZERO 109 #define SOLLYA_MSG_STRING_NOT_OF_LENGTH_ONE 110 #define SOLLYA_MSG_IDENTIFIER_NOT_BOUND_TO_LIST_OR_STRING 111 #define SOLLYA_MSG_IDENTIFIER_NOT_ASSIGNED_TO 112 #define SOLLYA_MSG_FIRST_ELMENT_OF_LEFT_SIDE_NOT_IDENTIFIER 113 #define SOLLYA_MSG_LEFT_HAND_SIDE_NOT_ELEMENT_OF_STRUCTURED_TYPE 114 #define SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_LIBRARY 115 #define SOLLYA_MSG_IDENTIFIER_IS_BOUND_TO_VAR_CANNOT_BE_LIBRARY 116 #define SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_LIBRARY 117 #define SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_LIBRARY 118 #define SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_LIBRARY 119 #define SOLLYA_MSG_PREC_MUST_BE_AT_LEAST_TWELVE_BITS 120 #define SOLLYA_MSG_POINTS_MUST_BE_AT_LEAST_THREE_POINTS 121 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_DISPLAY_TYPE 122 #define SOLLYA_MSG_VERBOSITY_MUST_NOT_BE_NEGATIVE 123 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF 124 #define SOLLYA_MSG_TAYLOR_RECURSIONS_MUST_NOT_BE_NEGATIVE 125 #define SOLLYA_MSG_HOPITAL_RECURSIONS_MUST_NOT_BE_NEGATIVE 126 #define SOLLYA_MSG_EXPR_OR_COMMAND_COULD_NOT_BE_HANDLED 127 #define SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED 128 #define SOLLYA_MSG_EVALUATION_CREATES_ERROR_SPECIAL_SYMBOL 129 #define SOLLYA_MSG_EXPR_TOO_BIG_FOR_AUTOMATIC_SIMPLIFICATION 130 #define SOLLYA_MSG_FPMINIMAX_LESS_FORMATS_THAN_MONOMIALS 131 #define SOLLYA_MSG_FPMINIMAX_LESS_MONOMIALS_THAN_FORMATS 132 #define SOLLYA_MSG_FPMINIMAX_FORMAT_LIST_MALFORMED 133 #define SOLLYA_MSG_FPMINIMAX_FORMAT_NEGATIVE_FOR_FP_COEFFS 134 #define SOLLYA_MSG_QUIT_OR_RESTART_MUST_NOT_BE_IN_MATCH 135 #define SOLLYA_MSG_FRAME_SYSTEM_CORRUPTED_MATCH_NOT_EXECUTED 136 #define SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_MATCHED 137 #define SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_MATCHED 138 #define SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_MATCHED 139 #define SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_MATCHED 140 #define SOLLYA_MSG_NO_MATCHING_CASE_FOUND 141 #define SOLLYA_MSG_QUIT_OR_RESTART_MUST_NOT_BE_IN_PROC 142 #define SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_PARAMETER 143 #define SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_PARAMETER 144 #define SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_PARAMETER 145 #define SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_PARAMETER 146 #define SOLLYA_MSG_FRAME_SYSTEM_CORRUPTED_PROC_NOT_EXECUTED 147 #define SOLLYA_MSG_REMEZ_MONOMIAL_DEGREES_MUST_NOT_BE_NEGATIVE 148 #define SOLLYA_MSG_REMEZ_MONOMIAL_DEGREE_GIVEN_TWICE 149 #define SOLLYA_MSG_REMEZ_TOO_MANY_ARGUMENTS 151 #define SOLLYA_MSG_REMEZ_SECND_ARG_MUST_BE_NONNEGATIVE_INT_OR_LIST 152 #define SOLLYA_MSG_FPMINIMAX_TOO_MANY_ARGUMENTS 153 #define SOLLYA_MSG_INVALID_FIFTH_ARGUMENT 154 #define SOLLYA_MSG_FPMINIMAX_SECND_ARG_MUST_BE_NONNEG_INT_OR_LIST 155 #define SOLLYA_MSG_FPMINIMAX_THIRD_ARG_MUST_BE_FORMAT_INDICATIONS 156 #define SOLLYA_MSG_FPMINIMAX_FOURTH_ARG_INTERVAL_OR_LIST_OF_POINTS 157 #define SOLLYA_MSG_TEST_COMPARES_ERROR_TO_SOMETHING 158 #define SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL 159 #define SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT 160 #define SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED 161 #define SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL 162 #define SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL 163 #define SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT 164 #define SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED 165 #define SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL 166 #define SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT 167 #define SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED 168 #define SOLLYA_MSG_ERROR_WHILE_EXECUTING_A_PROCEDURE 169 #define SOLLYA_MSG_DIFFERENTIATING_FOR_EVAL_AS_START_PREC_LOW 170 #define SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION 171 #define SOLLYA_MSG_EXTERNAL_PROCEDURE_SIGNALED_FAILURE 172 #define SOLLYA_MSG_PRECISION_OF_NUMS_MUST_BE_AT_LEAST_TWELVE_BITS 173 #define SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT 174 #define SOLLYA_MSG_RANGE_BOUNDS_IN_INVERSE_ORDER 175 #define SOLLYA_MSG_LITERAL_STRUCTURE_CONTAINS_ENTRY_TWICE 176 #define SOLLYA_MSG_NOT_LEAST_POSSIBLE_INCLUSION_INTERVAL 177 #define SOLLYA_MSG_ONLY_ONE_ENDPOINT_OF_RANGE_IS_NAN 178 #define SOLLYA_MSG_TREE_IS_CONSTANT_BUT_CANNOT_DO_FAITHFUL_EVAL 179 #define SOLLYA_MSG_TIMED_COMMAND_HAS_QUIT_THE_TOOL 180 #define SOLLYA_MSG_PARAM_OF_PROCEDURE_DOES_NOT_EXIST 181 #define SOLLYA_MSG_AUTODIFF_DEGREE_MUST_NOT_BE_NEGATIVE 182 #define SOLLYA_MSG_EXPR_IS_NO_FRACTION 183 #define SOLLYA_MSG_NO_ROUNDING_HAS_HAPPENED 184 #define SOLLYA_MSG_ROUND_UP_HAS_HAPPENED 185 #define SOLLYA_MSG_ROUND_DOWN_HAS_HAPPENED 186 #define SOLLYA_MSG_XML_FILE_CANNOT_BE_READ 187 #define SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING_IGNORING 188 #define SOLLYA_MSG_SUPNORM_DID_NOT_WORK_OUT_WELL 189 #define SOLLYA_MSG_GUESSDEGREE_FIFTH_ARGUMENT_MUST_BE_NUMBER 190 #define SOLLYA_MSG_ROUND_TO_NEAREST_IMPOSSIBLE_WITH_BOUNDING 191 #define SOLLYA_MSG_OUT_OF_CURRENT_EXPONENT_RANGE 192 #define SOLLYA_MSG_INADVERTED_ROUNDING_WHILE_DISPLAYING 193 #define SOLLYA_MSG_EXPRESSION_HAS_BEEN_SIMPLIFIED 194 #define SOLLYA_MSG_EXPRESSION_HAS_BEEN_SIMPLIFIED_TO_ANOTHER_ONE 195 #define SOLLYA_MSG_FORMALLY_DIFFERENTIATING_AN_EXPRESSION 196 #define SOLLYA_MSG_FORMALLY_DIFFERENTIATING_A_PARTICULAR_EXPR 197 #define SOLLYA_MSG_EXPR_TOO_BIG_FOR_SIMPLIFICATION_BEFORE_DIFF 198 #define SOLLYA_MSG_DEGREE_OF_POLYNOMIAL_DOESNT_HOLD_ON_MACHINE_INT 199 #define SOLLYA_MSG_DEG_OF_MAX_POLY_DIV_DOESNT_HOLD_ON_MACHINE_INT 200 #define SOLLYA_MSG_ROUNDING_UPON_BINOMIAL_COEFFICIENT_COMPUTATION 201 #define SOLLYA_MSG_ROUNDING_UPON_POW_EXPONENT_COMPUTATION 202 #define SOLLYA_MSG_RECURSION_ON_POLY_COEFFICIENTS_EXTRACTION 203 #define SOLLYA_MSG_POLY_COEFF_EXTRACTION_SPECIAL_ALGO_FOR_HORNER 204 #define SOLLYA_MSG_POLY_COEFF_EXTRACT_SPECIAL_ALGO_FOR_CANONICAL 205 #define SOLLYA_MSG_TRIED_TO_EXTRACT_COEFFS_OF_STH_NOT_POLYNOMIAL 206 #define SOLLYA_MSG_EXPR_NOT_HORNERIZED_AS_ALREADY_HORNERIZED 207 #define SOLLYA_MSG_ROUNDING_UPON_DIFFERENTIATION_OF_HORNER_POLY 208 #define SOLLYA_MSG_DIFFERENTIATION_USES_SPECIAL_ALGO_FOR_HORNER 209 #define SOLLYA_MSG_DIFFERENTIATION_USES_SPECIAL_ALGO_FOR_CANONICAL 210 #define SOLLYA_MSG_ROUNDING_UPON_DIFFERENTIATION_OF_POLYNOMIAL 211 #define SOLLYA_MSG_EXPR_NOT_CANONICALIZED_AS_ALREADY_CANONICAL 212 #define SOLLYA_MSG_NO_COMMAND_PROVIDED 213 #define SOLLYA_MSG_ERROR_WHILE_CREATING_A_PIPE 214 #define SOLLYA_MSG_ERROR_WHILE_FORKING 215 #define SOLLYA_MSG_UNABLE_TO_WRITE_TO_BASH 216 #define SOLLYA_MSG_THE_EXIT_CODE_OF_CHILD_PROCESS_IS 216 #define SOLLYA_MSG_SAMPLING_PREC_MUST_BE_LOWER_THAN_CURR_PREC 217 #define SOLLYA_MSG_EXTERNALPLOT_COULD_NOT_OPEN_A_LIBRARY 218 #define SOLLYA_MSG_EXTERNALPLOT_DID_NOT_FIND_FUNCTION_F 219 #define SOLLYA_MSG_COULD_NOT_OPEN_PLOT_FILE 220 #define SOLLYA_MSG_A_FUNCTION_COULD_NOT_BE_PLOTTED_AT_A_POINT 221 #define SOLLYA_MSG_TOOL_DIES_ON_ERROR_AS_PER_DIE_ON_ERROR_MODE 222 #define SOLLYA_MSG_ERROR_ON_INITIAL_SETUP 223 #define SOLLYA_MSG_FRAME_STACK_HAS_BEEN_CORRUPTED 224 #define SOLLYA_MSG_TIMING_STACK_HAS_BEEN_CORRUPTED 225 #define SOLLYA_MSG_LAST_COMMAND_INTERRUPTED 226 #define SOLLYA_MSG_RELEASING_FRAME_STACK 227 #define SOLLYA_MSG_COEFF_NOT_TWICE_GREATER_THAN_SUBPOLY 228 #define SOLLYA_MSG_PREC_OF_HORNER_STEP_GREATER_THAN_FOR_PREV_ONE 229 #define SOLLYA_MSG_NO_AUTO_ROUND_FOR_COEFF_W_PREC_HIGHER_THAN_TD 230 #define SOLLYA_MSG_INFERED_COEFF_PREC_HIGHER_THAN_REQUIRED 231 #define SOLLYA_MSG_COEFF_HAS_BEEN_ROUNDED_TO_TRIPLE_DOUBLE 232 #define SOLLYA_MSG_COEFF_HAS_BEEN_ROUNDED_TO_DOUBLE_DOUBLE 233 #define SOLLYA_MSG_COEFF_HAS_BEEN_ROUNDED_TO_DOUBLE 234 #define SOLLYA_MSG_ERROR_ON_HANDLING_A_COEFFICIENT 235 #define SOLLYA_MSG_IMPLEMENTED_POLY_DIFFERS_FROM_ORIGINAL_ONE 236 #define SOLLYA_MSG_COEFF_DOES_NOT_EVEN_HOLD_ON_TRIPLE_DOUBLE 237 #define SOLLYA_MSG_ROUNDING_ON_INTERNAL_HANDLING_OF_A_COEFFICIENT 238 #define SOLLYA_MSG_A_COEFF_COULD_NOT_BE_STORED_IN_ANY_KNOWN_FORMAT 239 #define SOLLYA_MSG_IMPLEMENTPOLY_FREE_VAR_HAS_UNKNOWN_FORMAT 240 #define SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT 241 #define SOLLYA_MSG_CURRENT_PREC_INSUFFICIENT_FOR_TD_CODE 242 #define SOLLYA_MSG_TARGET_ACCURACY_GREATER_OR_EQUAL_THAN_ONE 243 #define SOLLYA_MSG_TARGET_ACCURACY_LESS_THAN_140_BITS 244 #define SOLLYA_MSG_INFERED_OUTPUT_PREC_LESS_THAN_VARIABLE_PREC 245 #define SOLLYA_MSG_COEFF_DOES_NOT_HOLD_ON_TD_USING_FAITHFUL_EVAL 246 #define SOLLYA_MSG_ERROR_ON_DETERMINING_THE_REQUIRED_PRECISIONS 247 #define SOLLYA_MSG_ERROR_ON_DETERMINING_THE_REQUIRED_POWERS 248 #define SOLLYA_MSG_THE_POLY_THAT_GETS_IMPLEMENTED_IS 249 #define SOLLYA_MSG_ERROR_ON_CODE_GENERATION_FOR_COEFFICIENTS 250 #define SOLLYA_MSG_COULD_NOT_WRITE_TO_THE_IMPLEMENTATION_FILE 251 #define SOLLYA_MSG_ERROR_ON_CODE_GENERATION_FOR_POWERS_OF_FREE_VAR 252 #define SOLLYA_MSG_ERROR_ON_CODE_GENERATION_FOR_HORNER_SCHEME 253 #define SOLLYA_MSG_EXPR_SEEMS_TO_BE_ZERO_INCREASE_PREC 254 #define SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST 255 #define SOLLYA_MSG_XML_PARSER_CHANGE 256 #define SOLLYA_MSG_XML_PARSER_INDEX_CHANGE 257 #define SOLLYA_MSG_XML_PARSER_STATE_INFORMATION 258 #define SOLLYA_MSG_ROUNDING_ON_READING_CONSTANT_IN_XML_FILE 259 #define SOLLYA_MSG_XML_PARSER_FAILURE 260 #define SOLLYA_MSG_XML_SYNCHRONIZATION_LOST_TRYING_TO_RESYNCH 261 #define SOLLYA_MSG_XML_PARSER_UNABLE_TO_OPEN_A_CERTAIN_FILE 262 #define SOLLYA_MSG_XML_PARSE_FUNCTIONALITY_NOT_COMPILED_IN 263 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_INTEGER 264 #define SOLLYA_MSG_ROUNDING_ON_CONVERTING_A_MACHINE_INTEGER 265 #define SOLLYA_MSG_HARMLESS_ERROR_OCCURRED_COMMAND_NOT_EXECUTED 266 #define SOLLYA_MSG_INPUT_AND_OUTPUT_PRECISION_MUST_BE_GREATER_TEN 267 #define SOLLYA_MSG_INTERNAL_PREC_LESS_THAN_IN_AND_OUT_PREC 268 #define SOLLYA_MSG_EPS_SPECIFIED_GREATER_THAN_HALFULP_OF_OUT_PREC 269 #define SOLLYA_MSG_GIVEN_EPS_MUST_BE_POSITIVE_TAKING_ABS 270 #define SOLLYA_MSG_CERTAIN_AMOUNT_OF_CASES_HANDLED 271 #define SOLLYA_MSG_FUNC_EVALUATED_TO_ZERO_TAKING_ABSOLUTE_ERROR 272 #define SOLLYA_MSG_CANNOT_PERFORM_MORE_THAN_63_STEPS 273 #define SOLLYA_MSG_SEARCH_PREC_HIGHER_THAN_TOOL_PREC 274 #define SOLLYA_MSG_NUMBERS_OF_FUNCS_AND_FORMATS_DIFFER 275 #define SOLLYA_MSG_START_POINT_TOO_PRECISE_FOR_GIVEN_INPUT_PREC 276 #define SOLLYA_MSG_DEGREE_OF_TAYLORFORM_MUST_BE_AT_LEAST_ZERO 271 #define SOLLYA_MSG_ERROR_IN_TAYLORFORM_MULTIPLYING_INCOMPAT_MODELS 272 #define SOLLYA_MSG_ERROR_IN_TAYLORFORM_UNKNOWN_FUNC_FOR_ZUMKELLER 273 #define SOLLYA_MSG_ERROR_IN_TAYLORFORM_TRYING_TO_INCREASE_DEGREE 274 #define SOLLYA_MSG_DEVELOPMENT_POINT_NOT_CONSTANT 275 #define SOLLYA_MSG_ROUNDING_ON_COMPUTATION_OF_TAYLOR_COEFFICIENT 276 #define SOLLYA_MSG_ROUNDING_ON_COMPUTATION_OF_TAYLOR_POWER 277 #define SOLLYA_MSG_A_CHARACTER_COULD_NOT_BE_RECOGNIZED 278 #define SOLLYA_MSG_A_FILE_COULD_NOT_BE_OPENED_FOR_READING 279 #define SOLLYA_MSG_SPACES_REMOVED_FROM_CONSTANT_IN_SCIENTIF_NOTAT 280 #define SOLLYA_MSG_SYNTAX_ERROR_ENCOUNTERED_WHILE_PARSING 281 #define SOLLYA_MSG_SUPNORM_NO_TAYLOR 282 #define SOLLYA_MSG_SUPNORM_NOT_ENOUGH_WORKING_PRECISION 283 #define SOLLYA_MSG_SUPNORM_SINGULARITY_NOT_REMOVED 284 #define SOLLYA_MSG_SUPNORM_COULD_NOT_SHOW_POSITIVITY 285 #define SOLLYA_MSG_SUPNORM_SINGULARITY_NOT_DETECTED 286 #define SOLLYA_MSG_SUPNORM_ANOTHER_SINGULARITY_IN_DOM 287 #define SOLLYA_MSG_SUPNORM_CANNOT_COMPUTE_LOWER_BOUND 288 #define SOLLYA_MSG_SUPNORM_CANNOT_COMPUTE_ABSOLUTE_INF 289 #define SOLLYA_MSG_SUPNORM_CANNOT_DETERMINE_SIGN_OF_T 290 #define SOLLYA_MSG_SUPNORM_CANNOT_DETERMINE_ORDER_OF_SINGU 291 #define SOLLYA_MSG_SUPNORM_GENERIC_ERROR 292 #define SOLLYA_MSG_SUPNORM_ACCURACY_TOO_HIGH 292 #define SOLLYA_MSG_SUPNORM_COULD_NOT_FAITHFULLY_EVAL_ERROR_FUNC 293 #define SOLLYA_MSG_DOMAIN_IS_NO_CLOSED_INTERVAL_ON_THE_REALS 294 #define SOLLYA_MSG_DOMAIN_IS_EMPTY 295 #define SOLLYA_MSG_DOMAIN_IS_REDUCED_TO_A_POINT_WILL_SIMPLY_EVAL 296 #define SOLLYA_MSG_SUPNORM_COULD_NOT_EVALUATE_ERROR_FUNC 297 #define SOLLYA_MSG_ACCUARCY_INDICATION_IS_NOT_A_REAL_NUMBER 298 #define SOLLYA_MSG_ACCUARCY_INDICATION_IS_ZERO 299 #define SOLLYA_MSG_POLYNOMIAL_HAS_NON_DYADIC_COEFFICIENTS 300 #define SOLLYA_MSG_SUPNORM_SAFE_ENCLOSURE_COULD_NOT_BE_COMPUTED 301 #define SOLLYA_MSG_STURM_INTERVAL_A_CERTAIN_PREC_HAS_BEEN_CHOSEN 302 #define SOLLYA_MSG_STURM_COEFF_EVALUATED_TO_RATIONAL_NUMBER 303 #define SOLLYA_MSG_STURM_COEFF_NOT_CONSTANT_NOR_RATIONAL_ROUNDING 304 #define SOLLYA_MSG_STURM_COEFF_ROUNDED_TO_ZERO 305 #define SOLLYA_MSG_STURM_USING_SLOWER_ALGORITHM_ON_RATIONALS 306 #define SOLLYA_MSG_STURM_POLY_IS_ZERO_POLY 307 #define SOLLYA_MSG_CONSTANT_EXPR_CANNOT_BE_EVALUATED_AT_ALL 308 #define SOLLYA_MSG_PLOT_OVERFLOW_OCCURRED_ON_CONVERSION_TO_DOUBLE 309 #define SOLLYA_MSG_PLOT_FUNC_PROVEN_LESS_THAN_2_TO_MINUS_PREC 310 #define SOLLYA_MSG_PLOT_FUNC_UNDEFINED_OR_UNSTABLE_AT_POINT 311 #define SOLLYA_MSG_PLOT_NOT_FAITHFULLY_EVALUATED_AT_SOME_POINT 312 #define SOLLYA_MSG_DOMAIN_IS_REDUCED_TO_A_POINT_TRIVIAL_RESULT 313 #define SOLLYA_MSG_EXTERNAL_FUNC_OR_PROC_ALREADY_BOUND 314 #define SOLLYA_MSG_COULD_NOT_OPEN_LIBRARY_WITH_EXTERN_FUNC_OR_PROC 315 #define SOLLYA_MSG_EXTERNAL_FUNC_OR_PROC_NOT_FOUND_IN_LIBRARY 316 #define SOLLYA_MSG_COULD_NOT_CLOSE_LIBRARY 317 #define SOLLYA_MSG_ENTERING_NEWTONS_ALGORITHM 318 #define SOLLYA_MSG_NEWTON_ZERO_IS_EXACT_ZERO 319 #define SOLLYA_MSG_NEWTON_AN_EXACT_ZERO_HAS_BEEN_FOUND 320 #define SOLLYA_MSG_ERROR_IN_TAYLORFORM_COPYING_INCOMPAT_MODELS 321 #define SOLLYA_MSG_PLOT_COULD_NOT_OPEN_FILE 322 #define SOLLYA_MSG_NEWTON_FUNC_APPEARS_TO_HAVE_MORE_THAN_ONE_ZERO 323 #define SOLLYA_MSG_NEWTON_ZERO_TOO_CLOSE_TO_ZERO_TO_BE_ACCURATE 324 #define SOLLYA_MSG_NEWTON_ZERO_SEEMS_TO_BE_ZERO_NO_PROOF 325 #define SOLLYA_MSG_NEWTON_ALGORITHM_FAILS_DUE_TO_NUMERICAL_ISSUES 326 #define SOLLYA_MSG_NEWTON_ALGORITHM_FAILS_TO_LOCATE_ZERO 327 #define SOLLYA_MSG_NEWTON_PERFORMING_BISECTION_STEP 328 #define SOLLYA_MSG_NEWTON_PERFORMING_TRISECTION_STEP 329 #define SOLLYA_MSG_NEWTON_FINISHED_AFTER_NUMBER_OF_STEPS 330 #define SOLLYA_MSG_REMEZ_EXCHANGE_TAKE_A_CERTAIN_MINIMUM 331 #define SOLLYA_MSG_REMEZ_EXCHANGE_TAKE_A_CERTAIN_MAXIMUM 332 #define SOLLYA_MSG_REMEZ_FUNCTION_OSCILLATES_TOO_MUCH 333 #define SOLLYA_MSG_REMEZ_PERFORMING_AN_EXCHANGE_STEP 334 #define SOLLYA_MSG_REMEZ_COMPUTED_INFNORM_IS_A_CERTAIN_VALUE 335 #define SOLLYA_MSG_REMEZ_FAILED_TO_FIND_PSEUDOALTERNATING_POINTS 336 #define SOLLYA_MSG_REMEZ_CONSTRUCTING_THE_ERROR_TREE 337 #define SOLLYA_MSG_REMEZ_CONSTRUCTING_THE_ERROR_PRIME_TREE 338 #define SOLLYA_MSG_REMEZ_CONSTRUCTING_THE_ERROR_SECOND_TREE 339 #define SOLLYA_MSG_REMEZ_COMPUTING_THE_YI 340 #define SOLLYA_MSG_REMEZ_THE_COMPUTED_YI_ARE_CERTAIN_VALUES 341 #define SOLLYA_MSG_REMEZ_ALGORITHM_IS_IN_A_CERTAIN_CASE 342 #define SOLLYA_MSG_REMEZ_THE_COMPUTED_SIGNS_ARE_CERTAIN_VALUES 343 #define SOLLYA_MSG_REMEZ_SIGNS_COULD_NOT_BE_EVALUATED 344 #define SOLLYA_MSG_REMEZ_MAIN_HEURISTIC_FAILED_USING_SLOWER_ALGO 345 #define SOLLYA_MSG_REMEZ_SLOWER_ALGORITHM_USED_FOR_A_STEP 346 #define SOLLYA_MSG_REMEZ_THE_NEW_POINTS_ARE_CERTAIN_VALUES 347 #define SOLLYA_MSG_REMEZ_THE_CURRENT_NORM_TAKES_A_CERTAIN_VALUE 348 #define SOLLYA_MSG_ENTERING_REMEZ_FUNCTION 349 #define SOLLYA_MSG_REMEZ_COMPUTING_MONOMIALS 350 #define SOLLYA_MSG_REMEZ_COMPUTING_INITIAL_POINT_SET 351 #define SOLLYA_MSG_REMEZ_THE_COMPUTED_POINT_SET_IS_CERTAIN_VALUES 352 #define SOLLYA_MSG_REMEZ_COMPUTING_THE_MATRIX 353 #define SOLLYA_MSG_REMEZ_COMPUTAT_OF_MATRIX_ENTRY_USES_SLOWER_ALGO 354 #define SOLLYA_MSG_REMEZ_DEGENERATED_SYSTEM_IN_NON_HAAR_CONTEXT 355 #define SOLLYA_MSG_REMEZ_SIGNS_FOR_PSEUDO_ALTERN_ARE_CERTAIN_VALS 356 #define SOLLYA_MSG_REMEZ_THE_COMPUTED_MATRIX_HAS_A_CERTAIN_VALUE 357 #define SOLLYA_MSG_REMEZ_SOLVING_THE_SYSTEM 358 #define SOLLYA_MSG_REMEZ_THE_COMPUTED_POLY_HAS_A_CERTAIN_VALUE 359 #define SOLLYA_MSG_REMEZ_CURRENT_EPSILON_HAS_A_CERTAIN_VALUE 360 #define SOLLYA_MSG_REMEZ_DIFFERENTIATING_THE_COMPUTED_POLYNOMIAL 361 #define SOLLYA_MSG_REMEZ_SEARCHING_FOR_EXTREMA_OF_ERROR_FUNCTION 362 #define SOLLYA_MSG_REMEZ_THE_BEST_POLY_GIVES_A_CERTAIN_ERROR 363 #define SOLLYA_MSG_REMEZ_CURRENT_QUALITY_HAS_A_CERTAIN_VALUE 364 #define SOLLYA_MSG_REMEZ_FINISHES_AS_TARGET_ERROR_IS_NOT_REACHABLE 365 #define SOLLYA_MSG_REMEZ_FINISHES_AS_TARGET_ERROR_HAS_BEEN_REACHED 366 #define SOLLYA_MSG_REMEZ_FINISHES_AS_QUALITY_HAS_BEEN_REACHED 367 #define SOLLYA_MSG_REMEZ_FAILS_AND_LOOPS_AGAIN 368 #define SOLLYA_MSG_REMEZ_DOES_NOT_CONVERGE 369 #define SOLLYA_MSG_REMEZ_MAY_HAPPEN_NOT_TO_CONVRG_AS_DOM_IS_POINT 370 #define SOLLYA_MSG_GUESSDEGREE_TRYING_A_CERTAIN_DEGREE 371 #define SOLLYA_MSG_GUESSDEGREE_NONE_OF_LESSER_DEGS_SATISFIES_ERROR 372 #define SOLLYA_MSG_GUESSDEGREE_TRYING_A_CERTAIN_DEG_WITHIN_BOUNDS 373 #define SOLLYA_MSG_GUESSDEG_NONE_OF_LESS_DEGS_SEEMS_TO_SATISFY_ERR 374 #define SOLLYA_MSG_FPMINIMAX_SINGULAR_MATRIX 375 #define SOLLYA_MSG_FPMINIMAX_A_CERTAIN_COEFF_IS_EXACT_ZERO 376 #define SOLLYA_MSG_FPMINIMAX_MINIMAX_DOES_NOT_GIVE_ENOUGH_POINTS 377 #define SOLLYA_MSG_FPMINIMAX_THE_POINTS_ARE_CERTAIN_VALUES 378 #define SOLLYA_MSG_FPMINIMAX_FAILED_TO_RECOVER_COEFFS_FROM_POLY 379 #define SOLLYA_MSG_FPMINIMAX_THE_EXPONENTS_ARE_CERTAIN_VALUES 380 #define SOLLYA_MSG_FPMINIMAX_DID_NOT_CONVERGE 381 #define SOLLYA_MSG_FPMINIMAX_NOT_ENOUGH_POINTS 382 #define SOLLYA_MSG_FPMINIMAX_NOT_ENOUGH_FORMATS 383 #define SOLLYA_MSG_FPMINIMAX_COMP_OF_MATRIX_ENTRY_USES_SLOWER_ALGO 384 #define SOLLYA_MSG_DIFFERENTIATING_FOR_DECORRELATION 385 #define SOLLYA_MSG_DECORRELATION_INTERVAL_ADDITION_OR_SUBTRACTION 386 #define SOLLYA_MSG_DIFFERENTIATING_FOR_HOPITALS_RULE 387 #define SOLLYA_MSG_USING_HOPITALS_RULE_ON_POINT_DIVISION 388 #define SOLLYA_MSG_SIMPLIFYING_INTERVAL_DIV_WITH_ZERO_POINT_NUMERA 389 #define SOLLYA_MSG_USING_HOPITALS_RULE_IN_GENERAL_CASE 390 #define SOLLYA_MSG_RECURSION_ON_USE_OF_HOPITALS_RULE 391 #define SOLLYA_MSG_AVOIDING_TAYLOR_EVALUATION_ON_POINT_INTERVAL 392 #define SOLLYA_MSG_NO_TAYLOR_EVALUATION_AS_NO_DERIVATIVE_GIVEN 393 #define SOLLYA_MSG_USING_TAYLOR_EVALUATION 394 #define SOLLYA_MSG_NO_TAYLOR_EVALUATION_AS_NO_DERIVATIVE_GETS_HUGE 395 #define SOLLYA_MSG_DERIVATIVE_DOES_NOT_CHANGE_SIGN_ON_TAYLOR_EVAL 396 #define SOLLYA_MSG_NAN_OR_INF_ON_DERIVATIVE 397 #define SOLLYA_MSG_INVOKING_RECURSIVE_INTERVAL_ZERO_SEARCH 398 #define SOLLYA_MSG_RECURSIVE_INTERVAL_ZERO_SEARCH_HAS_FINISHED 399 #define SOLLYA_MSG_CERTAIN_NUM_OF_INTVALS_ENCLOSING_ZEROS_OF_DERIV 400 #define SOLLYA_MSG_EXPRESSION_IS_CONSTANT 401 #define SOLLYA_MSG_EVALUATION_AT_POINT_GIVES_NAN_EXCLUDING_POINT 402 #define SOLLYA_MSG_THE_CURRENT_MAXIMUM_IS_A_CERTAIN_VALUE 403 #define SOLLYA_MSG_EVALUATION_OF_DERIVATIVE_GIVES_NAN_NO_NEWTON 404 #define SOLLYA_MSG_NO_PROOF_WILL_BE_GENERATED 405 #define SOLLYA_MSG_INFNORM_RESULT_IS_TRIVIAL 406 #define SOLLYA_MSG_DERIVATIVE_IS_QUOTIENT 407 #define SOLLYA_MSG_DERIVATIVE_SEEMS_TO_HAVE_SINGULARITY 408 #define SOLLYA_MSG_DERIVATIVE_SEEMS_TO_HAVE_EXTENSIBLE_SINGULARITY 409 #define SOLLYA_MSG_DERIVATIVE_SEEMS_NOT_TO_HAVE_ANY_POLE 410 #define SOLLYA_MSG_INVOKING_INFNORM_SUBFUNCTION 411 #define SOLLYA_MSG_INFNORM_SUBFUNCTION_HAS_FINISHED 412 #define SOLLYA_MSG_STARTING_TO_WRITE_THE_PROOF 413 #define SOLLYA_MSG_THE_PROOF_HAS_BEEN_WRITTEN 414 #define SOLLYA_MSG_THE_EXPRESSION_IS_NOT_CONSTANT 415 #define SOLLYA_MSG_COULD_NOT_CHECK_INFNORM_ON_A_CERTAIN_INTERVAL 416 #define SOLLYA_MSG_REMOVING_A_POSSIBLE_ZERO_AT_SOME_POINT 417 #define SOLLYA_MSG_ZERO_FILTER_HAS_REMOVED_AT_LEAST_ONE_ZERO 418 #define SOLLYA_MSG_FAITHFUL_EVALUATION_RETURNS_NAN 419 #define SOLLYA_MSG_INTERMEDIATE_PRECISION_HAS_BEEN_INCREASED 420 #define SOLLYA_MSG_TAYLOR_RECURSION_TEMPORARILY_SET_TO_A_VALUE 421 #define SOLLYA_MSG_ABS_DIAM_AND_PREC_SET_TO_CERTAIN_VALUES 422 #define SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_EXTERNAL 423 #define SOLLYA_MSG_HANDLED_SIGSEGV 424 #define SOLLYA_MSG_HANDLED_SIGBUS 425 #define SOLLYA_MSG_HANDLED_SIGFPE 426 #define SOLLYA_MSG_HANDLED_SIGPIPE 427 #define SOLLYA_MSG_CANNOT_SUPPRESS_OR_UNSUPPRESS_A_MESSAGE 428 #define SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_INT_OR_LIST_OF_INT 429 #define SOLLYA_MSG_SUPPRESSION_NUMBER_OMITTED 430 #define SOLLYA_MSG_ROUNDING_ON_CONSTANT_RETRIEVAL 431 #define SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL 432 #define SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL 433 #define SOLLYA_MSG_EXPRESSION_EVALUATES_TO_INFINITY 434 #define SOLLYA_MSG_DEG_OF_MAX_POLY_DIV_IS_NOT_CONSTANT 435 #define SOLLYA_MSG_DEG_OF_MAX_POLY_DIV_IS_NOT_INTEGER 436 #define SOLLYA_MSG_DEG_OF_MAX_POLY_DIV_IS_NEGATIVE 437 #define SOLLYA_MSG_RATIONALAPPROX_SECOND_ARG_MUST_BE_GREATER_THAN_ONE 438 #define SOLLYA_MSG_ROUND_PREC_MUST_BE_AT_LEAST_TWO_BITS 439 #define SOLLYA_MSG_NAN_CONVERTED_TO_NUMBER_ON_CONSTANT_RETRIEVAL 440 #define SOLLYA_MSG_CHEBYSHEVFORM_DEGREE_MUST_NOT_BE_NEGATIVE 441 #define SOLLYA_MSG_CHEBYSHEVFORM_DOMAIN_MUST_NOT_BE_POINT_INTERVAL 442 #define SOLLYA_MSG_CHEBYSHEVFORM_ERROR_IN_COMPUTATION 443 #define SOLLYA_MSG_ERROR_IN_CHEBYSHEVFORM_COPYING_INCOMPAT_MODELS 444 #define SOLLYA_MSG_ERROR_IN_CHEBYSHEVFORM_UNKNOWN_FUNC_FOR_ZUMKELLER 445 #define SOLLYA_MSG_ERROR_IN_CHEBYSHEVFORM_NOT_A_POLYNOMIAL 446 #define SOLLYA_MSG_SPECIAL_ALGORITHM_USED_FOR_COEFF 447 #define SOLLYA_MSG_NO_CORRECT_ROUNDING_FOR_ROUND_OPERATOR 448 #define SOLLYA_MSG_ROUNDING_OF_BOUNDARY_INSTEAD_OF_CORRECT_ROUNDING 449 #define SOLLYA_MSG_NO_CORRECT_TERNARY_VALUE_FOR_ROUND_BUT_CORRECT_ROUNDING 450 #define SOLLYA_MSG_NO_CORRECT_TERNARY_VALUE_FOR_ROUND 451 #define SOLLYA_MSG_LIBRARY_CLOSER_ERROR 452 #define SOLLYA_MSG_INF_CONVERTED_TO_NUMBER_ON_CONSTANT_RETRIEVAL 453 #define SOLLYA_MSG_ANNOTATION_COULD_NOT_BE_SET_UP 454 #define SOLLYA_MSG_GENERIC_SOLLYA_LIBRARY_MSG 455 #define SOLLYA_MSG_GUESSDEGREE_POSSIBLE_SINGULAR_WEIGHT 456 #define SOLLYA_MSG_SAFE_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST 457 #define SOLLYA_MSG_DEGREE_OF_POLYNOMIAL_LARGER_THAN_MULTIPRECISION_INT 458 #define SOLLYA_MSG_ANNOTATION_INCOHERENT 459 #define SOLLYA_MSG_REMEZ_SWITCHING_DEFINITIVELY_TO_SLOW_ALGORITHM 460 #endif /* ifdef SOLLYA_MESSAGES_H*/ sollya-6.0+ds/sollya-messaging.c000066400000000000000000000070561300174114700167140ustar00rootroot00000000000000/* Copyright 2012 by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, Contributors Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also herefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ /* Do not change the order of the includes up to general.h (included) */ #include #include #include #include /* The following #defined is needed to activate some features in the sollya-messaging header file that are only needed when used with this sollya-messaging implementation file. */ #define SOLLYA_MESSAGING_USE_TABLES 1 #include "sollya-messaging.h" #undef SOLLYA_MESSAGING_USE_TABLES #include "general.h" /* End of the #includes */ char *messageNumberToText(int msgNum) { char *res; char *temp; char defaultMessage[] = "Unknown message number %d"; int i; if (msgNum >= 1) { for (i=0; messageTextsTable[i].msgNum >= 0; i++) { if (messageTextsTable[i].msgNum == msgNum) { res = (char *) safeCalloc(strlen(messageTextsTable[i].msgText) + 1, sizeof(char)); strcpy(res, messageTextsTable[i].msgText); return res; } } } temp = (char *) safeCalloc(strlen(defaultMessage) + (8 * (int) sizeof(int)) + 2, sizeof(char)); sprintf(temp, defaultMessage, msgNum); res = (char *) safeCalloc(strlen(temp) + 1, sizeof(char)); strcpy(res, temp); safeFree(temp); return res; } int messageNumberExists(int msgNum) { int i; if (msgNum >= 1) { for (i=0; messageTextsTable[i].msgNum >= 0; i++) { if (messageTextsTable[i].msgNum == msgNum) { return 1; } } } return 0; } int getMessageId(sollya_msg_t msg) { return msg->msg_id; } sollya-6.0+ds/sollya-messaging.h000066400000000000000000002200131300174114700167070ustar00rootroot00000000000000/* Copyright 2011-2016 by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributor Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef SOLLYA_MESSAGING_H #define SOLLYA_MESSAGING_H /* Symbolic constants for the different messages THE ACTUAL #defines ARE FACTORED OUT IN sollya-messages.h IN ORDER TO ALLOW THE LIBRARY INCLUDE HEADER sollya.h TO USE THEM. TO ADD A MESSAGE, ADD A #define AT THE END OF THE LIST IN sollya-messages.h. THEN ADD A CORRESPONDING MESSAGE TEXT IN THE TABLE BELOW. ATTENTION: THE MESSAGE NUMBERS MUST NOT BE NEGATIVE! DO NOT CHANGE THE #include THAT FOLLOWS. */ #include "sollya-messages.h" /* A typedef for the Sollya message type */ struct __sollya_internal_type_msg_struct { int msg_id; }; typedef struct __sollya_internal_type_msg_struct * sollya_msg_t; typedef struct __sollya_internal_type_msg_struct sollya_msg_decl_t; /* A table with textual explanations of the messages ADD A MESSAGE TEXT HERE ONCE YOU ADD A MESSAGE NUMBER IN sollya-messages.h The table gets defined only when sollya-messaging is included from sollya-messaging.c The table entries do not have to be sorted in any way. Just the last entry must have a negative (inexisting) message number. All other message numbers (used through their symbolic constants) must be positive. */ #if (defined(SOLLYA_MESSAGING_USE_TABLES) && (SOLLYA_MESSAGING_USE_TABLES)) typedef struct messageEntryStruct messageEntry; struct messageEntryStruct { int msgNum; char *msgText; }; static const messageEntry messageTextsTable[] = { { SOLLYA_MSG_CONTINUATION , "Continuation of the last message that just has started" }, { SOLLYA_MSG_UNDEFINED_ERROR , "Some undefined error occurred. This is a place-holder" }, { SOLLYA_MSG_ABS_NOT_TWICE_DIFFERENTIABLE , "abs is not twice differentiable" }, { SOLLYA_MSG_HALF_NOT_DIFFERENTIABLE , "half-precision rounding operator not differentiable" }, { SOLLYA_MSG_SINGLE_NOT_DIFFERENTIABLE , "single rounding operator not differentiable" }, { SOLLYA_MSG_DOUBLE_NOT_DIFFERENTIABLE , "double rounding operator not differentiable" }, { SOLLYA_MSG_DOUBLEEXTENDED_NOT_DIFFERENTIABLE , "double-extended rounding operator not differentiable" }, { SOLLYA_MSG_DOUBLE_DOUBLE_NOT_DIFFERENTIABLE , "double-double rounding operator not differentiable" }, { SOLLYA_MSG_TRIPLE_DOUBLE_NOT_DIFFERENTIABLE , "triple-double rounding operator not differentiable" }, { SOLLYA_MSG_QUAD_NOT_DIFFERENTIABLE , "quad rounding operator not differentiable" }, { SOLLYA_MSG_CEIL_NOT_DIFFERENTIABLE , "ceil operator not differentiable" }, { SOLLYA_MSG_FLOOR_NOT_DIFFERENTIABLE , "floor operator not differentiable" }, { SOLLYA_MSG_NEARESTINT_NOT_DIFFERENTIABLE , "nearestint operator not differentiable" }, { SOLLYA_MSG_UNDESIRED_ROUNDING_IN_ROUND_TO_FORMAT , "An undesired rounding occurred in round to format" }, { SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE , "A double rounding occurred in round to double" }, { SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_PREC , "A double rounding occurred in round-to-prec" }, { SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_CONVERTING_FROM_DOUBLE , "Rounding occurred while converting from double" }, { SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_SINGLE , "A double rounding occurred in round to single" }, { SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_DOUBLE_DOUBLE , "A double rounding occurred in round to double-double" }, { SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_TO_TRIPLE_DOUBLE , "A double rounding occurred in round to triple-double" }, { SOLLYA_MSG_ROUNDING_DOWN_BEFORE_PRINTING_DOUBLE , "A round-down occurred before printing a double precision value" }, { SOLLYA_MSG_ROUNDING_UP_BEFORE_PRINTING_DOUBLE , "A round-up occurred before printing a double precision value" }, { SOLLYA_MSG_COULD_NOT_FIGURE_OUT_ENDIANESS , "Could not figure out the endianness of the system" }, { SOLLYA_MSG_ROUNDING_DOWN_BEFORE_PRINTING_SINGLE , "A round-down occurred before printing a single precision value" }, { SOLLYA_MSG_ROUNDING_UP_BEFORE_PRINTING_SINGLE , "A round-up occurred before printing a single precision value" }, { SOLLYA_MSG_SNAN_MIGHT_HAVE_BECOME_QNAN , "An sNaN might have become a qNaN" }, { SOLLYA_MSG_UNABLE_TO_CONVERT_FROM_HEXADECIMAL_CONSTANT , "Unable to convert from a hexadecimal constant" }, { SOLLYA_MSG_GIVEN_FUNCTION_IS_NO_POLYNOMIAL , "The given function is no polynomial" }, { SOLLYA_MSG_NUM_OF_FORMATS_DOES_NOT_CORRESPOND_TO_DEGREE , "The number of formats does not correspond to the degree of the polynomial" }, { SOLLYA_MSG_ERROR_WHILE_EXTRACTING_COEFFICIENTS_OF_POLY , "Error while extracting the coefficients of a polynomial" }, { SOLLYA_MSG_ERROR_POLY_COEFF_GETS_ROUNDED , "A coefficient of a polynomial is not constant and gets rounded" }, { SOLLYA_MSG_ERROR_EVALUATION_OF_POLY_COEFF_NOT_FAITHFUL , "The evaluation of a coefficient of a polynomial does not give a faithful rounding" }, { SOLLYA_MSG_ERROR_UNKNOWN_EXPANSION_FORMAT , "An unknown expansion format is given" }, { SOLLYA_MSG_DOUBLE_ROUNDING_ON_HANDLING_POLY_COEFF , "A double rounding occurred while handling the evaluation of a coefficient of a polynomial" }, { SOLLYA_MSG_AT_LEAST_ONE_POLY_COEFF_HAS_BEEN_ROUNDED , "At least one of the coefficients of a polynomial has been rounded" }, { SOLLYA_MSG_NONE_OF_THE_POLY_COEFFS_HAS_BEEN_ROUNDED , "None of the coefficients of a polynomial has been rounded" }, { SOLLYA_MSG_NON_REAL_NUMBER_CANNOT_BE_DOUBLE_EXPANSION , "A number that is not real cannot be displayed as a double expansion" }, { SOLLYA_MSG_DOUBLE_ROUNDING_ON_CONVERSION , "A double rounding occurred unexpectly on a conversion" }, { SOLLYA_MSG_DOUBLE_EXPANSION_INCOMPLETE , "A double expansion is incomplete because of the limited exponent range of double precision" }, { SOLLYA_MSG_ROUNDING_WHILE_SIMPLIFYING_TO_POLYNOMIAL , "A rounding occurred while simplifying an expression to a polynomial" }, { SOLLYA_MSG_POLY_COEFF_IS_NOT_CONSTANT , "A coefficient of a polynomial is not a constant expression" }, { SOLLYA_MSG_SOME_EVALUATION_IS_NOT_FAITHFUL , "Some evaluation of a constant expression fails to give a faithful rounding" }, { SOLLYA_MSG_DOUBLE_ROUNDING_IN_ROUND_IEEE_754_2008_OPERATOR , "A double rounding occurred during invocation of an IEEE 754-2008 rounding operator" }, { SOLLYA_MSG_STRING_CANNOT_BE_PARSED_BY_MINIPARSER , "A given string cannot be parsed by the mini-parser" }, { SOLLYA_MSG_ERROR_ON_RUNNING_GUESSDEGREE , "Some error occurred while executing guessdegree" }, { SOLLYA_MSG_FILE_EXECUTION_ASKED_FOR_QUIT_NOT_QUITTING , "The execution of a file read by execute demanded stopping the interpretation but it is not stopped" }, { SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_SEEMS_CONSTANT , "An expression should be constant in a context. It seems constant but this could not be proven" }, { SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_IS_CONSTANT_ON_FP , "An expression should be constant in a context. It seems constant when floating-point evaluation is used" }, { SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_IS_NOT_FAITHFUL , "An expression should be constant in a context and faithful evaluation is not possible. Taking zero" }, { SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_NO_FAITHFUL_PLAIN_FP , "An expression should be constant in a context and faithful evaluation is not possible. Performing plain FP evaluation" }, { SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST , "Taking a faithful rounding for an expression that should be a constant" }, { SOLLYA_MSG_CONSTANT_IS_NOT_MACHINE_INTEGER_WILL_ROUND , "A constant that should be an integer is not a machine integer. The nearest machine integer will be used instead" }, { SOLLYA_MSG_PRECISION_OF_NUMBERS_MUST_BE_AT_LEAST_TWO_BITS , "The precision of numbers must be at least 2 bits. Will use 2 bits of precision" }, { SOLLYA_MSG_IDENTIFIER_ALREADY_BOUND , "An identifier is already bound to the free variable, to a library function, library constant or to an external procedure" }, { SOLLYA_MSG_IDENTIFIER_REASSIGNMENT , "An identifier has already been assigned. This assignment is a reassignment" }, { SOLLYA_MSG_DISPLAYED_VALUE_IS_FAITHFULLY_ROUNDED , "A rounding has happened but the displayed value is a faithful rounding of the true result" }, { SOLLYA_MSG_EXPRESSION_UNDEFINED_OR_UNSTABLE , "The given expression is undefined or numerically unstable" }, { SOLLYA_MSG_ROUNDING_MAY_HAVE_HAPPENED_AND_NOT_FAITHFUL , "Rounding may have happened and if there is rounding, the displayed value is not guaranteed to be a faithful rounding of the true result" }, { SOLLYA_MSG_EVALUATION_WITH_PLAIN_FP_ARITHMETIC , "The displayed value has been computed using plain floating-point arithmetic and might be completely wrong" }, { SOLLYA_MSG_ROUNDING_MAY_HAVE_HAPPENED_SOMEWHERE , "Rounding may have happened" }, { SOLLYA_MSG_EXPRESSION_TOO_BIG_FOR_HORNER_FORM , "The expression is too big for being written in Horner form" }, { SOLLYA_MSG_EXPRESSION_TOO_BIG_FOR_CANONICAL_FORM , "The expression is too big for being written in canonical form" }, { SOLLYA_MSG_DOUBLE_SIMPLIFICATION_NECESSARY , "A double simplification is necessary" }, { SOLLYA_MSG_COMMAND_NOT_EXECUTABLE , "The last command could not be executed. May leak memory" }, { SOLLYA_MSG_TIMER_UNUSABLE , "Unable to use the timer. Measures may be untrustable" }, { SOLLYA_MSG_CAN_MODIFY_ONLY_ELEMENTS_OF_STRUCTURES , "Cannot modify an element of something that is not a structure" }, { SOLLYA_MSG_CONTROL_STRUCTURE_NOT_EXECUTABLE_EXPR_NO_BOOLEAN , "The given expression does not evaluate to a boolean" }, { SOLLYA_MSG_AT_END_OF_FOR_CNTRL_VAR_NO_LONGER_ASSIGNABLE , "At the end of a for loop, the loop variable cannot longer be assigned to" }, { SOLLYA_MSG_AT_END_OF_FOR_CNTRL_VAR_NO_LONGER_CONSTANT , "At the end of a for loop, the loop variable decreased by the loop step does no longer evaluate to a constant" }, { SOLLYA_MSG_TOOL_HAS_BEEN_RESTARTED_INSIDE_LOOP , "The tool has been restarted inside a loop" }, { SOLLYA_MSG_CNTRL_VAR_OF_LOOP_CANNOT_BE_ASSIGNED , "The control variable of a loop cannot be assigned to" }, { SOLLYA_MSG_ARGS_OF_FOR_LOOP_NOT_CONSTANT , "At least one of the arguments of a loop does not evaluate to a constant" }, { SOLLYA_MSG_FOR_IN_LOOP_OVER_EMPTY_LIST , "Executing a for in statement on an empty list" }, { SOLLYA_MSG_FOR_IN_LOOP_OVER_END_ELLIPTIC_LIST_NOT_ALLOWED , "The given expression does not evaluate to a non-elliptic list" }, { SOLLYA_MSG_AT_LEAST_ONE_OPERATION_MUST_BE_EXECUTED , "At least one operation must be executed" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER , "A given expression does not evaluate to a machine integer" }, { SOLLYA_MSG_RESTART_IN_FILE_READ_INTO_ANOTHER , "A quit command has been used in a file read into another" }, { SOLLYA_MSG_QUIT_IN_FILE_READ_INTO_ANOTHER , "A restart command has been used in a file read into another" }, { SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_LOCAL_VAR , "An identifier is already bound to the current free variable. It cannot be declared as a local variable" }, { SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_LOCAL_VAR , "An identifier is already bound to a library function. It cannot be declared as a local variable" }, { SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_LOCAL_VAR , "An identifier is already bound to a library constant. It cannot be declared as a local variable" }, { SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_LOCAL_VAR , "An identifier is already bound to an external procedure. It cannot be declared as a local variable" }, { SOLLYA_MSG_FRAME_SYSTEM_CORRUPTED_LOCAL_VAR_NOT_DECLARED , "Previous command interruptions have corrupted the frame system. Some local variable cannot be declared" }, { SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING , "A file could not be opened for writing" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING , "A given expression does not evaluate to a string" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_LIST_OF_FUNCTIONS , "A given expression does not evaluate to a list of pure functions" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_RANGE , "A given expression does not evaluate to a range" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_STRING_NOR_DEFAULT , "A given expression does not evaluate to a string nor to a default value" }, { SOLLYA_MSG_IMPLEMENTATION_HAS_NOT_SUCCEEDED , "The implementation has not succeeded" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_CONSTANT , "A given expression does not evaluate to a constant" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_AN_EXPRESSION , "A given expression does not evaluate to an expression" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_A_FUNCTION , "A given expression does not evaluate to a function" }, { SOLLYA_MSG_ROUNDING_WHILE_PRINTING , "A rounding occurred while printing" }, { SOLLYA_MSG_BASH_RETURNS_A_CERTAIN_RETURN_VALUE , "After executing a command, bash returns a certain return value" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ABS_NOR_REL , "A given expression does not evaluate to neither absolute nor relative" }, { SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_APPENDING , "A file could not be opened for appending" }, { SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_READING , "A file could not be opened for reading" }, { SOLLYA_MSG_FREE_VARIABLE_HAS_BEEN_NAMED_SOMEHOW , "A certain name has been given to the free variable" }, { SOLLYA_MSG_FREE_VARIABLE_HAS_BEEN_RENAMED , "The free variable has been renamed" }, { SOLLYA_MSG_CAN_RENAME_ONLY_FREE_VARIABLE , "Only the free variable can be renamed. A variable with a different name cannot be renamed" }, { SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_EXTERNAL , "An identifier is already bound to the current free variable. It cannot be bound to an external procedure" }, { SOLLYA_MSG_IDENTIFIER_IS_BOUND_TO_VAR_CANNOT_BE_EXTERNAL , "An identifier is already bound to some identifier. It cannot be bound to an external procedure" }, { SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_EXTERNAL , "An identifier is already bound to a library constant. It cannot be bound to an external procedure" }, { SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_EXTERNAL , "An identifier is already bound to an external procedure. It cannot be bound to an external procedure" }, { SOLLYA_MSG_ERROR_OCCURRED_COMMAND_NOT_EXECUTED , "An error occurred. The command could not be executed" }, { SOLLYA_MSG_ASSIGNMENT_WILL_HAVE_NO_EFFECT , "An assignment will have no effect" }, { SOLLYA_MSG_ASSIGNMENT_OF_INDEXED_ELEMENTS_NOT_IN_RANGE , "Assignments to indexed elements of lists are only allowed on indices in the existing range" }, { SOLLYA_MSG_ASSIGNMENT_OF_INDEXED_EMPTY_LIST_ONLY_ON_ZERO , "Assignments to indexed elements of empty lists are only allowed on index 0" }, { SOLLYA_MSG_STRING_NOT_OF_LENGTH_ONE , "The given string is not of length one" }, { SOLLYA_MSG_IDENTIFIER_NOT_BOUND_TO_LIST_OR_STRING , "A certain identifier is not bound to a list or to a string" }, { SOLLYA_MSG_IDENTIFIER_NOT_ASSIGNED_TO , "A certain identifier is not assigned to anything" }, { SOLLYA_MSG_FIRST_ELMENT_OF_LEFT_SIDE_NOT_IDENTIFIER , "The first element of a left-hand side is not an identifier" }, { SOLLYA_MSG_LEFT_HAND_SIDE_NOT_ELEMENT_OF_STRUCTURED_TYPE , "The left-hand side is not an access to an element of a structured type" }, { SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_LIBRARY , "An identifier is already bound to the current free variable. It cannot be bound to a library function or constant" }, { SOLLYA_MSG_IDENTIFIER_IS_BOUND_TO_VAR_CANNOT_BE_LIBRARY , "An identifier is already bound to some identifier. It cannot be bound to a library function or constant" }, { SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_LIBRARY , "An identifier is already bound to a library constant. It cannot be bound to a library function or constant" }, { SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_LIBRARY , "An identifier is already bound to a library constant. It cannot be bound to a library function or constant" }, { SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_LIBRARY , "An identifier is already bound to an external procedure. It cannot be bound to a library function or constant" }, { SOLLYA_MSG_PREC_MUST_BE_AT_LEAST_TWELVE_BITS , "The precision of the tool must be at least 12 bits" }, { SOLLYA_MSG_POINTS_MUST_BE_AT_LEAST_THREE_POINTS , "The number of points must be at least 3 points" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_DISPLAY_TYPE , "A given expression does not evaluate to either default, dyadic, powers, hexadecimal or binary" }, { SOLLYA_MSG_VERBOSITY_MUST_NOT_BE_NEGATIVE , "The verbosity of the tool must not be negative" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_ON_OR_OFF , "A given expression does not evaluate to either on or off" }, { SOLLYA_MSG_TAYLOR_RECURSIONS_MUST_NOT_BE_NEGATIVE , "The number of Taylor recursions must not be negative" }, { SOLLYA_MSG_HOPITAL_RECURSIONS_MUST_NOT_BE_NEGATIVE , "The number of Hopital recursions must not be negative" }, { SOLLYA_MSG_EXPR_OR_COMMAND_COULD_NOT_BE_HANDLED , "A given expression or command could not be handled" }, { SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED , "At least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect" }, { SOLLYA_MSG_EVALUATION_CREATES_ERROR_SPECIAL_SYMBOL , "Evaluation creates an error special symbol" }, { SOLLYA_MSG_EXPR_TOO_BIG_FOR_AUTOMATIC_SIMPLIFICATION , "A given expression is too big to be treated by the automatic simplification" }, { SOLLYA_MSG_FPMINIMAX_LESS_FORMATS_THAN_MONOMIALS , "fpminimax: there are less formats indications than monomials" }, { SOLLYA_MSG_FPMINIMAX_LESS_MONOMIALS_THAN_FORMATS , "fpminimax: there are less monomials indications than formats. The list of formats will be truncated" }, { SOLLYA_MSG_FPMINIMAX_FORMAT_LIST_MALFORMED , "fpminimax: the formats list must contain only integers or formats" }, { SOLLYA_MSG_FPMINIMAX_FORMAT_NEGATIVE_FOR_FP_COEFFS , "fpminimax: a format indication is non-positive while floating-point coefficients are desired" }, { SOLLYA_MSG_QUIT_OR_RESTART_MUST_NOT_BE_IN_MATCH , "A quit or restart command may not be part of the body of a match-with construct" }, { SOLLYA_MSG_FRAME_SYSTEM_CORRUPTED_MATCH_NOT_EXECUTED , "Previous command interruptions have corrupted the frame system. A match-with construct cannot be executed" }, { SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_MATCHED , "An identifier is already bound to the current free variable. It cannot be used as a match variable" }, { SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_MATCHED , "An identifier is already bound to an external procedure. It cannot be used as a match variable" }, { SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_MATCHED , "An identifier is already bound to a library constant. It cannot be used as a match variable" }, { SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_MATCHED , "An identifier is already bound to a library constant. It cannot be used as a match variable" }, { SOLLYA_MSG_NO_MATCHING_CASE_FOUND , "No matching expression found in a match-with construct and no default case given" }, { SOLLYA_MSG_QUIT_OR_RESTART_MUST_NOT_BE_IN_PROC , "A quit or restart command may not be part of a procedure body" }, { SOLLYA_MSG_IDENTIFIER_IS_FREE_VAR_CANNOT_BE_PARAMETER , "An identifier is already bound to the current free variable. It cannot be used as a formal parameter of a procedure" }, { SOLLYA_MSG_IDENTIFIER_IS_EXTERNAL_PROC_CANNOT_BE_PARAMETER , "An identifier is already bound to an external procedure. It cannot be used as a formal parameter of a procedure" }, { SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_CONST_CANNOT_BE_PARAMETER , "An identifier is already bound to a library constant. It cannot be used as a formal parameter of a procedure" }, { SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_PARAMETER , "An identifier is already bound to a library constant. It cannot be used as a formal parameter of a procedure" }, { SOLLYA_MSG_FRAME_SYSTEM_CORRUPTED_PROC_NOT_EXECUTED , "Previous command interruptions have corrupted the frame system. A procedure cannot be executed" }, { SOLLYA_MSG_REMEZ_MONOMIAL_DEGREES_MUST_NOT_BE_NEGATIVE , "Monomial degrees must be non-negative" }, { SOLLYA_MSG_REMEZ_MONOMIAL_DEGREE_GIVEN_TWICE , "A monomial degree is given twice in argument to Remez algorithm" }, { SOLLYA_MSG_REMEZ_TOO_MANY_ARGUMENTS , "Too many arguments given to remez command. The remaining arguments will be ignored" }, { SOLLYA_MSG_REMEZ_SECND_ARG_MUST_BE_NONNEGATIVE_INT_OR_LIST , "The second argument of remez must be a non-negative integer or a list" }, { SOLLYA_MSG_FPMINIMAX_TOO_MANY_ARGUMENTS , "Too many arguments given to fpminimax command. The remaining arguments will be ignored" }, { SOLLYA_MSG_INVALID_FIFTH_ARGUMENT , "fpminimax: invalid fifth argument" }, { SOLLYA_MSG_FPMINIMAX_SECND_ARG_MUST_BE_NONNEG_INT_OR_LIST , "The second argument of fpminimax must be a non-negative integer or a list" }, { SOLLYA_MSG_FPMINIMAX_THIRD_ARG_MUST_BE_FORMAT_INDICATIONS , "fpminimax: the third argument of fpminimax must be a list of formats indications" }, { SOLLYA_MSG_FPMINIMAX_FOURTH_ARG_INTERVAL_OR_LIST_OF_POINTS , "fpminimax: the fourth argument of fpminimax must be either an interval or a list of points" }, { SOLLYA_MSG_TEST_COMPARES_ERROR_TO_SOMETHING , "The evaluation of one of the sides of a test yields error due to a syntax error or an error on a side-effect. The other side either also yields error due to an syntax or side-effect error or does not evaluate to error. The boolean returned may be meaningless" }, { SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL , "A test relies on floating-point result that is not faithfully evaluated" }, { SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT , "A test relies on floating-point result that is faithfully rounded or not" }, { SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED , "The tool is unable to decide a test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal" }, { SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL , "A test relies on floating-point result that is faithfully evaluated and at least one of the sides is not a real number" }, { SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL , "A minimum computation relies on floating-point result that is not faithfully evaluated" }, { SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT , "A minimum computation relies on floating-point result that is faithfully rounded or not" }, { SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED , "The tool is unable to decide a minimum computation by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal" }, { SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL , "A maximum computation relies on floating-point result that is not faithfully evaluated" }, { SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT , "A maximum computation relies on floating-point result that is faithfully rounded or not" }, { SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED , "The tool is unable to decide a maximum computation by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal" }, { SOLLYA_MSG_ERROR_WHILE_EXECUTING_A_PROCEDURE , "Some error occurred while executing a procedure" }, { SOLLYA_MSG_DIFFERENTIATING_FOR_EVAL_AS_START_PREC_LOW , "Formal differentiation is performed during evaluation because the start precision is low" }, { SOLLYA_MSG_FREE_VAR_INTERPRETED_AS_IDENTITY_FUNCTION , "The identifier for the free variable is used in a functional context. It will be interpreted as the identity function" }, { SOLLYA_MSG_EXTERNAL_PROCEDURE_SIGNALED_FAILURE , "An external procedure has signaled failure" }, { SOLLYA_MSG_PRECISION_OF_NUMS_MUST_BE_AT_LEAST_TWELVE_BITS , "The precision of numbers in the tool must be at least 12 bits" }, { SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT , "A rounding occurred while reading a constant" }, { SOLLYA_MSG_RANGE_BOUNDS_IN_INVERSE_ORDER , "Range bounds are given in inverse order. They will get reverted" }, { SOLLYA_MSG_LITERAL_STRUCTURE_CONTAINS_ENTRY_TWICE , "A literal structure contains at least one entry twice. This is not allowed" }, { SOLLYA_MSG_NOT_LEAST_POSSIBLE_INCLUSION_INTERVAL , "Upon some evaluation, inclusion property is satisfied but the diameter may be greater than the least possible" }, { SOLLYA_MSG_ONLY_ONE_ENDPOINT_OF_RANGE_IS_NAN , "One bound of a range is NaN while the other is not. Will normalize the range to have two NaN endpoints" }, { SOLLYA_MSG_TREE_IS_CONSTANT_BUT_CANNOT_DO_FAITHFUL_EVAL , "A given tree is constant but cannot be faithfully evaluated" }, { SOLLYA_MSG_TIMED_COMMAND_HAS_QUIT_THE_TOOL , "A command executed in a timed environment required quitting the tool. This is not possible. The quit command has been discarded" }, { SOLLYA_MSG_PARAM_OF_PROCEDURE_DOES_NOT_EXIST , "A given procedure has no argument named as indicated. The procedure is returned unchanged" }, { SOLLYA_MSG_AUTODIFF_DEGREE_MUST_NOT_BE_NEGATIVE , "The degree of differentiation for automatic differentiation must not be negative" }, { SOLLYA_MSG_EXPR_IS_NO_FRACTION , "A given expression is not a fraction. Will consider it as a fraction with denominator 1" }, { SOLLYA_MSG_NO_ROUNDING_HAS_HAPPENED , "No rounding has happened" }, { SOLLYA_MSG_ROUND_UP_HAS_HAPPENED , "Round-up has happened" }, { SOLLYA_MSG_ROUND_DOWN_HAS_HAPPENED , "Round-down has happened" }, { SOLLYA_MSG_XML_FILE_CANNOT_BE_READ , "A file could not be read in XML format" }, { SOLLYA_MSG_FILE_COULD_NOT_BE_OPENED_FOR_WRITING_IGNORING , "A file could not be opened for writing. Ignoring a proof argument" }, { SOLLYA_MSG_SUPNORM_DID_NOT_WORK_OUT_WELL , "The supremum norm on the error function between the given polynomial and the given function could not be computed" }, { SOLLYA_MSG_GUESSDEGREE_FIFTH_ARGUMENT_MUST_BE_NUMBER , "guessdegree: the optional fifth argument must be a positive number" }, { SOLLYA_MSG_ROUND_TO_NEAREST_IMPOSSIBLE_WITH_BOUNDING , "A correct rounding to nearest is impossible with the given enclosure" }, { SOLLYA_MSG_OUT_OF_CURRENT_EXPONENT_RANGE , "A certain value is out of the current exponent range. Displayed values may be wrong" }, { SOLLYA_MSG_INADVERTED_ROUNDING_WHILE_DISPLAYING , "An inadverted rounding happened while displaying a value. The displayed value may be wrong" }, { SOLLYA_MSG_EXPRESSION_HAS_BEEN_SIMPLIFIED , "An expression has been simplified" }, { SOLLYA_MSG_EXPRESSION_HAS_BEEN_SIMPLIFIED_TO_ANOTHER_ONE , "An expression has been simplified to another expression" }, { SOLLYA_MSG_FORMALLY_DIFFERENTIATING_AN_EXPRESSION , "An expression gets formally differentiated" }, { SOLLYA_MSG_FORMALLY_DIFFERENTIATING_A_PARTICULAR_EXPR , "A particular expression gets formally differentiated" }, { SOLLYA_MSG_EXPR_TOO_BIG_FOR_SIMPLIFICATION_BEFORE_DIFF , "An expression is too big to be simplified before it gets formally differentiated" }, { SOLLYA_MSG_DEGREE_OF_POLYNOMIAL_DOESNT_HOLD_ON_MACHINE_INT , "The degree of a certain polynomial does not hold on a machine integer" }, { SOLLYA_MSG_DEG_OF_MAX_POLY_DIV_DOESNT_HOLD_ON_MACHINE_INT , "The degree of a the maximal polynomial divider a certain expression does not hold on a machine integer" }, { SOLLYA_MSG_ROUNDING_UPON_BINOMIAL_COEFFICIENT_COMPUTATION , "A rounding occurred while computing a binomial coefficient" }, { SOLLYA_MSG_ROUNDING_UPON_POW_EXPONENT_COMPUTATION , "A rounding occurred while computing the exponent of an expanded power operator" }, { SOLLYA_MSG_RECURSION_ON_POLY_COEFFICIENTS_EXTRACTION , "Recursion has been necessary while extracting the coefficients of a polynomial" }, { SOLLYA_MSG_POLY_COEFF_EXTRACTION_SPECIAL_ALGO_FOR_HORNER , "A special algorithm for Horner forms is used when extracting the coefficients of a polynomial" }, { SOLLYA_MSG_POLY_COEFF_EXTRACT_SPECIAL_ALGO_FOR_CANONICAL , "A special algorithm for canonical forms is used when extracting the coefficients of a polynomial" }, { SOLLYA_MSG_TRIED_TO_EXTRACT_COEFFS_OF_STH_NOT_POLYNOMIAL , "A try was made to extract the coefficients of an expression that is not a polynomial" }, { SOLLYA_MSG_EXPR_NOT_HORNERIZED_AS_ALREADY_HORNERIZED , "A certain expression is not hornerized as it is already in Horner form" }, { SOLLYA_MSG_ROUNDING_UPON_DIFFERENTIATION_OF_HORNER_POLY , "Rounding has inadvertedly happened upon differentiation of an expression that was written in Horner form" }, { SOLLYA_MSG_DIFFERENTIATION_USES_SPECIAL_ALGO_FOR_HORNER , "A special algorithm for Horner forms is used when differentiating a Horner polynomial" }, { SOLLYA_MSG_DIFFERENTIATION_USES_SPECIAL_ALGO_FOR_CANONICAL , "A special algorithm for canonical forms is used when differentiating a canonically written polynomial" }, { SOLLYA_MSG_ROUNDING_UPON_DIFFERENTIATION_OF_POLYNOMIAL , "Rounding has inadvertedly happened upon differentiation of a polynomial" }, { SOLLYA_MSG_EXPR_NOT_CANONICALIZED_AS_ALREADY_CANONICAL , "A certain expression is not canonicalized as it is already in canonical form" }, { SOLLYA_MSG_NO_COMMAND_PROVIDED , "No command has been provided" }, { SOLLYA_MSG_ERROR_WHILE_CREATING_A_PIPE , "Error while creating a pipe" }, { SOLLYA_MSG_ERROR_WHILE_FORKING , "Error while forking" }, { SOLLYA_MSG_UNABLE_TO_WRITE_TO_BASH , "Unable to write to a bash command that has been forked" }, { SOLLYA_MSG_THE_EXIT_CODE_OF_CHILD_PROCESS_IS , "A child process has exited with a certain exit code" }, { SOLLYA_MSG_SAMPLING_PREC_MUST_BE_LOWER_THAN_CURR_PREC , "The sampling precision must be lower than the current precision of the tool" }, { SOLLYA_MSG_EXTERNALPLOT_COULD_NOT_OPEN_A_LIBRARY , "Externalplot could not open a library for some reason" }, { SOLLYA_MSG_EXTERNALPLOT_DID_NOT_FIND_FUNCTION_F , "Externalplot did not find function f in the library" }, { SOLLYA_MSG_COULD_NOT_OPEN_PLOT_FILE , "A certain plot file could not be opened" }, { SOLLYA_MSG_A_FUNCTION_COULD_NOT_BE_PLOTTED_AT_A_POINT , "A function could not be plotted at a certain point" }, { SOLLYA_MSG_TOOL_DIES_ON_ERROR_AS_PER_DIE_ON_ERROR_MODE , "The tool is going to die on an error as die-on-error mode is activated" }, { SOLLYA_MSG_ERROR_ON_INITIAL_SETUP , "An error occurred on initial setup of the tool" }, { SOLLYA_MSG_FRAME_STACK_HAS_BEEN_CORRUPTED , "The frame stack has been corrupted" }, { SOLLYA_MSG_TIMING_STACK_HAS_BEEN_CORRUPTED , "The timing stack has been corrupted" }, { SOLLYA_MSG_LAST_COMMAND_INTERRUPTED , "The last command has been interrupted. May leak memory" }, { SOLLYA_MSG_RELEASING_FRAME_STACK , "The variable frame stack has been released" }, { SOLLYA_MSG_COEFF_NOT_TWICE_GREATER_THAN_SUBPOLY , "A coefficient is not at least 2 times greater than a already evaluated sub-polynomial" }, { SOLLYA_MSG_PREC_OF_HORNER_STEP_GREATER_THAN_FOR_PREV_ONE , "The precision of a previous Horner step is greater than the one of the next" }, { SOLLYA_MSG_NO_AUTO_ROUND_FOR_COEFF_W_PREC_HIGHER_THAN_TD , "A coefficient's precision is higher than triple-double but no automatic rounding will be performed" }, { SOLLYA_MSG_INFERED_COEFF_PREC_HIGHER_THAN_REQUIRED , "The inferred precision of a certain coefficient of the polynomial is greater than the necessary precision computed for this step" }, { SOLLYA_MSG_COEFF_HAS_BEEN_ROUNDED_TO_TRIPLE_DOUBLE , "A coefficient of the polynomial has automatically been rounded to a triple-double" }, { SOLLYA_MSG_COEFF_HAS_BEEN_ROUNDED_TO_DOUBLE_DOUBLE , "A coefficient of the polynomial has automatically been rounded to a double-double" }, { SOLLYA_MSG_COEFF_HAS_BEEN_ROUNDED_TO_DOUBLE , "A coefficient of the polynomial has automatically been rounded to a double" }, { SOLLYA_MSG_ERROR_ON_HANDLING_A_COEFFICIENT , "There was an error during the internal handling of a coefficient" }, { SOLLYA_MSG_IMPLEMENTED_POLY_DIFFERS_FROM_ORIGINAL_ONE , "During implementation, at least one coefficient of a given polynomial has been rounded so that the implemented polynomial differs from the original one" }, { SOLLYA_MSG_COEFF_DOES_NOT_EVEN_HOLD_ON_TRIPLE_DOUBLE , "Tried to implement a coefficient that cannot even be written on a triple-double" }, { SOLLYA_MSG_ROUNDING_ON_INTERNAL_HANDLING_OF_A_COEFFICIENT , "A rounding occurred on the internal handling of a coefficient" }, { SOLLYA_MSG_A_COEFF_COULD_NOT_BE_STORED_IN_ANY_KNOWN_FORMAT , "At least one of the coefficients of the given polynomial could not be stored in any known format" }, { SOLLYA_MSG_IMPLEMENTPOLY_FREE_VAR_HAS_UNKNOWN_FORMAT , "The free variable is not associated to any known format in implementpoly" }, { SOLLYA_MSG_ERROR_IN_PRECISION_MANAGEMENT , "An error occurred in the internal management of precisions" }, { SOLLYA_MSG_CURRENT_PREC_INSUFFICIENT_FOR_TD_CODE , "The current tool's precision is not sufficient for implementing triple-double code" }, { SOLLYA_MSG_TARGET_ACCURACY_GREATER_OR_EQUAL_THAN_ONE , "The target accuracy is greater than or equal to 1. This make no sense" }, { SOLLYA_MSG_TARGET_ACCURACY_LESS_THAN_140_BITS , "The target accuracy is less than 2^(-140). Implementation is restricted to maximally triple-double" }, { SOLLYA_MSG_INFERED_OUTPUT_PREC_LESS_THAN_VARIABLE_PREC , "The inferred output expansion type is less from the given variable type" }, { SOLLYA_MSG_COEFF_DOES_NOT_HOLD_ON_TD_USING_FAITHFUL_EVAL , "A coefficient of the given polynomial cannot exactly be represented on a triple-double. It will be evaluated first, using faithful rounding" }, { SOLLYA_MSG_ERROR_ON_DETERMINING_THE_REQUIRED_PRECISIONS , "An error occurred upon determination of the required precisions" }, { SOLLYA_MSG_ERROR_ON_DETERMINING_THE_REQUIRED_POWERS , "An error occurred upon determination of the required powers" }, { SOLLYA_MSG_THE_POLY_THAT_GETS_IMPLEMENTED_IS , "A certain polynomial is obtained after rounding. This is the one that will get implemented" }, { SOLLYA_MSG_ERROR_ON_CODE_GENERATION_FOR_COEFFICIENTS , "An error occurred upon code generation for the polynomial's coefficients" }, { SOLLYA_MSG_COULD_NOT_WRITE_TO_THE_IMPLEMENTATION_FILE , "The implementation file could not be written to" }, { SOLLYA_MSG_ERROR_ON_CODE_GENERATION_FOR_POWERS_OF_FREE_VAR , "An error occurred upon code generation for the powers of the free variable" }, { SOLLYA_MSG_ERROR_ON_CODE_GENERATION_FOR_HORNER_SCHEME , "An error occurred upon code generation for the Horner scheme" }, { SOLLYA_MSG_EXPR_SEEMS_TO_BE_ZERO_INCREASE_PREC , "An expression seems to be exactly zero. If it is not, try to increase the tool precision" }, { SOLLYA_MSG_A_BASE_FUNC_IS_NOT_SUPPORTED_BY_IMPLEMENTCONST , "A certain base function is not supported by implementconst" }, { SOLLYA_MSG_XML_PARSER_CHANGE , "There is a change of the current XML parser" }, { SOLLYA_MSG_XML_PARSER_INDEX_CHANGE , "There is a change in the index of the current XML parser" }, { SOLLYA_MSG_XML_PARSER_STATE_INFORMATION , "The XML parser prints some information of its current state" }, { SOLLYA_MSG_ROUNDING_ON_READING_CONSTANT_IN_XML_FILE , "Rounding has happened on reading a constant in an XML file" }, { SOLLYA_MSG_XML_PARSER_FAILURE , "Failed to parse a certain XML file" }, { SOLLYA_MSG_XML_SYNCHRONIZATION_LOST_TRYING_TO_RESYNCH , "The XML parser has lost synchronization and is trying to resynchronize" }, { SOLLYA_MSG_XML_PARSER_UNABLE_TO_OPEN_A_CERTAIN_FILE , "The XML parser cannot open a certain file" }, { SOLLYA_MSG_XML_PARSE_FUNCTIONALITY_NOT_COMPILED_IN , "A certain XML file cannot be read because XInclude functionality has not been compiled in" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_INTEGER , "A given expression does not evaluate to an integer" }, { SOLLYA_MSG_ROUNDING_ON_CONVERTING_A_MACHINE_INTEGER , "A rounding has occurred during the conversion of a machine integer" }, { SOLLYA_MSG_HARMLESS_ERROR_OCCURRED_COMMAND_NOT_EXECUTED , "An error occurred. The last command will not succeed. This is harmless" }, { SOLLYA_MSG_INPUT_AND_OUTPUT_PRECISION_MUST_BE_GREATER_TEN , "The input and output precisions must be greater than 10" }, { SOLLYA_MSG_INTERNAL_PREC_LESS_THAN_IN_AND_OUT_PREC , "The internal precision must not be less than the input and output precisions" }, { SOLLYA_MSG_EPS_SPECIFIED_GREATER_THAN_HALFULP_OF_OUT_PREC , "The specified epsilon is greater than half an ulp of the specified output format" }, { SOLLYA_MSG_GIVEN_EPS_MUST_BE_POSITIVE_TAKING_ABS , "The specified epsilon value must be positive. Taking its absolute value" }, { SOLLYA_MSG_CERTAIN_AMOUNT_OF_CASES_HANDLED , "A certain amount of cases has been handled" }, { SOLLYA_MSG_FUNC_EVALUATED_TO_ZERO_TAKING_ABSOLUTE_ERROR , "The given function evaluates to zero at a certain point. Considering an absolute error instead of a relative error at this point" }, { SOLLYA_MSG_CANNOT_PERFORM_MORE_THAN_63_STEPS , "A certain command cannot perform more than 63 steps. Will decrease the number of steps to 63" }, { SOLLYA_MSG_SEARCH_PREC_HIGHER_THAN_TOOL_PREC , "The required search precision is higher that the current tool precision. No search is possible" }, { SOLLYA_MSG_NUMBERS_OF_FUNCS_AND_FORMATS_DIFFER , "The numbers of the given functions, formats and accuracies differ. No search is possible" }, { SOLLYA_MSG_START_POINT_TOO_PRECISE_FOR_GIVEN_INPUT_PREC , "The given start point is too precise for the given search precision. It gets rounded beforehand" }, { SOLLYA_MSG_DEGREE_OF_TAYLORFORM_MUST_BE_AT_LEAST_ZERO , "The degree of a Taylor form must be at least zero" }, { SOLLYA_MSG_ERROR_IN_TAYLORFORM_MULTIPLYING_INCOMPAT_MODELS , "Error in Taylor form computation: multiplication of incompatible models" }, { SOLLYA_MSG_ERROR_IN_TAYLORFORM_UNKNOWN_FUNC_FOR_ZUMKELLER , "Error in Taylor form computation: unknown type of function used with Zumkeller's technique" }, { SOLLYA_MSG_ERROR_IN_TAYLORFORM_TRYING_TO_INCREASE_DEGREE , "Error in Taylor form computation: trying to increase the degree of a model" }, { SOLLYA_MSG_DEVELOPMENT_POINT_NOT_CONSTANT , "The expression given as a development point is not constant" }, { SOLLYA_MSG_ROUNDING_ON_COMPUTATION_OF_TAYLOR_COEFFICIENT , "A rounding occurred while computing the constant factor of a Taylor coefficient" }, { SOLLYA_MSG_ROUNDING_ON_COMPUTATION_OF_TAYLOR_POWER , "A rounding occurred while computing the exponent of a power in a Taylor development" }, { SOLLYA_MSG_A_CHARACTER_COULD_NOT_BE_RECOGNIZED , "A certain character could not be recognized while lexing" }, { SOLLYA_MSG_A_FILE_COULD_NOT_BE_OPENED_FOR_READING , "A certain file could not be opened for reading" }, { SOLLYA_MSG_SPACES_REMOVED_FROM_CONSTANT_IN_SCIENTIF_NOTAT , "Spaces have been removed from a constant written in scientific notation" }, { SOLLYA_MSG_SYNTAX_ERROR_ENCOUNTERED_WHILE_PARSING , "Syntax error encountered while parsing" }, { SOLLYA_MSG_SUPNORM_NO_TAYLOR , "During supnorm computation, no suitable Taylor form could be found" }, { SOLLYA_MSG_SUPNORM_NOT_ENOUGH_WORKING_PRECISION , "During supnorm computation, no result could be found as the working precision seems to be too low" }, { SOLLYA_MSG_SUPNORM_SINGULARITY_NOT_REMOVED , "During supnorm computation, a singularity in the expression tree could not be removed" }, { SOLLYA_MSG_SUPNORM_COULD_NOT_SHOW_POSITIVITY , "During supnorm computation, the positivity of a polynomial could not be established" }, { SOLLYA_MSG_SUPNORM_SINGULARITY_NOT_DETECTED , "During supnorm computation, a false singularity could not be detected" }, { SOLLYA_MSG_SUPNORM_ANOTHER_SINGULARITY_IN_DOM , "During supnorm computation, there appeared to be at least two singularities in the domain. More bisection is needed" }, { SOLLYA_MSG_SUPNORM_CANNOT_COMPUTE_LOWER_BOUND , "During supnorm computation, it was not possible to determine a valid lower bound for the error function" }, { SOLLYA_MSG_SUPNORM_CANNOT_COMPUTE_ABSOLUTE_INF , "During supnorm computation, it was not possible to determine a valid lower bound for the absolute value of the function" }, { SOLLYA_MSG_SUPNORM_CANNOT_DETERMINE_SIGN_OF_T , "During supnorm computation, it was not possible to safely determine the sign of the Taylor polynomial" }, { SOLLYA_MSG_SUPNORM_CANNOT_DETERMINE_ORDER_OF_SINGU , "During supnorm computation, it was not possible to safely determine the order of a presume zero of the given function" }, { SOLLYA_MSG_SUPNORM_GENERIC_ERROR , "During supnorm computation, some generic error occurred. No further description is available" }, { SOLLYA_MSG_SUPNORM_ACCURACY_TOO_HIGH , "For supnorm, the given accuracy depasses the current maximum precision. Try to increase the precision of the tool" }, { SOLLYA_MSG_SUPNORM_COULD_NOT_FAITHFULLY_EVAL_ERROR_FUNC , "During supnorm computation, the error function between the function and the polynomial could not faithfully be evaluated at some point" }, { SOLLYA_MSG_DOMAIN_IS_NO_CLOSED_INTERVAL_ON_THE_REALS , "The given domain is not a closed interval on the reals" }, { SOLLYA_MSG_DOMAIN_IS_EMPTY , "The given domain is empty" }, { SOLLYA_MSG_DOMAIN_IS_REDUCED_TO_A_POINT_WILL_SIMPLY_EVAL , "The given domain is reduced to a point. Will simply evaluate at this point" }, { SOLLYA_MSG_SUPNORM_COULD_NOT_EVALUATE_ERROR_FUNC , "During supnorm computation, the error function between the function and the polynomial could not be evaluated at some point" }, { SOLLYA_MSG_ACCUARCY_INDICATION_IS_NOT_A_REAL_NUMBER , "The given accuracy indication is not a real number" }, { SOLLYA_MSG_ACCUARCY_INDICATION_IS_ZERO , "The given accuracy indication is zero" }, { SOLLYA_MSG_POLYNOMIAL_HAS_NON_DYADIC_COEFFICIENTS , "The given polynomials contains coefficients that are no dyadic numbers" }, { SOLLYA_MSG_SUPNORM_SAFE_ENCLOSURE_COULD_NOT_BE_COMPUTED , "An error occurred during supremum norm computation. A safe enclosure of the supremum norm could not be computed" }, { SOLLYA_MSG_STURM_INTERVAL_A_CERTAIN_PREC_HAS_BEEN_CHOSEN , "During execution of Sturm's algorithm in interval arithmetic, a certain precision has been chosen" }, { SOLLYA_MSG_STURM_COEFF_EVALUATED_TO_RATIONAL_NUMBER , "A coefficient of the given polynomial has been evaluated to a certain rational number" }, { SOLLYA_MSG_STURM_COEFF_NOT_CONSTANT_NOR_RATIONAL_ROUNDING , "A coefficient of the given polynomial is neither a floating point or rational constant nor can be evaluated without rounding to a floating point constant" }, { SOLLYA_MSG_STURM_COEFF_ROUNDED_TO_ZERO , "A coefficient of the given polynomial has been rounded to zero" }, { SOLLYA_MSG_STURM_USING_SLOWER_ALGORITHM_ON_RATIONALS , "Sturm's algorithm gets executed on rational numbers instead of being executed on intervals" }, { SOLLYA_MSG_STURM_POLY_IS_ZERO_POLY , "The given polynomial is the zero polynomial. It has an infinite number of zeros in the interval" }, { SOLLYA_MSG_CONSTANT_EXPR_CANNOT_BE_EVALUATED_AT_ALL , "A certain constant expression cannot be evaluated at all" }, { SOLLYA_MSG_PLOT_OVERFLOW_OCCURRED_ON_CONVERSION_TO_DOUBLE , "An overflow occurred in a conversion mpfr to double while plotting" }, { SOLLYA_MSG_PLOT_FUNC_PROVEN_LESS_THAN_2_TO_MINUS_PREC , "While plotting a function, it was proven to be less than 2^(-prec) at some point, where prec is the current tool precision. It gets plotted with an ordinate inside the proof interval" }, { SOLLYA_MSG_PLOT_FUNC_UNDEFINED_OR_UNSTABLE_AT_POINT , "A function to be plotted is undefined or numerically unstable at some point" }, { SOLLYA_MSG_PLOT_NOT_FAITHFULLY_EVALUATED_AT_SOME_POINT , "A function to be plotted has not been faithfully evaluated at at least one point" }, { SOLLYA_MSG_DOMAIN_IS_REDUCED_TO_A_POINT_TRIVIAL_RESULT , "The given domain is reduced to a point. The result is trivial" }, { SOLLYA_MSG_EXTERNAL_FUNC_OR_PROC_ALREADY_BOUND , "An external function or external procedure with the same name has already been bound to the tool" }, { SOLLYA_MSG_COULD_NOT_OPEN_LIBRARY_WITH_EXTERN_FUNC_OR_PROC , "A library with an external function or procedure could not be opened" }, { SOLLYA_MSG_EXTERNAL_FUNC_OR_PROC_NOT_FOUND_IN_LIBRARY , "No external function or external procedure with the given name could be found in the given library" }, { SOLLYA_MSG_COULD_NOT_CLOSE_LIBRARY , "A library could not be closed" }, { SOLLYA_MSG_ENTERING_NEWTONS_ALGORITHM , "Entering Newton's algorithm. Certain parameters are given" }, { SOLLYA_MSG_NEWTON_ZERO_IS_EXACT_ZERO , "Newton's algorithm: zero is an exact zero" }, { SOLLYA_MSG_NEWTON_AN_EXACT_ZERO_HAS_BEEN_FOUND , "Newton's algorithm: an exact zero has been found" }, { SOLLYA_MSG_ERROR_IN_TAYLORFORM_COPYING_INCOMPAT_MODELS , "Error in Taylor form computation: copy of incompatible models" }, { SOLLYA_MSG_PLOT_COULD_NOT_OPEN_FILE , "A certain file could not be opened for writing while attempting to plot" }, { SOLLYA_MSG_NEWTON_FUNC_APPEARS_TO_HAVE_MORE_THAN_ONE_ZERO , "Newton's algorithm: the function has more than one zero in the interval" }, { SOLLYA_MSG_NEWTON_ZERO_TOO_CLOSE_TO_ZERO_TO_BE_ACCURATE , "Newton's algorithm: the zero of the function is too close to zero for being accurately determined" }, { SOLLYA_MSG_NEWTON_ZERO_SEEMS_TO_BE_ZERO_NO_PROOF , "Newton's algorithm: zero seems to be a zero of function, which cannot be proved" }, { SOLLYA_MSG_NEWTON_ALGORITHM_FAILS_DUE_TO_NUMERICAL_ISSUES , "Newton's algorithm fails due to numerical issues" }, { SOLLYA_MSG_NEWTON_ALGORITHM_FAILS_TO_LOCATE_ZERO , "Newton's algorithm fails to locate the zero" }, { SOLLYA_MSG_NEWTON_PERFORMING_BISECTION_STEP , "Newton's algorithm: performing a bisection step" }, { SOLLYA_MSG_NEWTON_PERFORMING_TRISECTION_STEP , "Newton's algorithm: performing a trisection step" }, { SOLLYA_MSG_NEWTON_FINISHED_AFTER_NUMBER_OF_STEPS , "Newton's algorithm has finished after a certain number of steps" }, { SOLLYA_MSG_REMEZ_EXCHANGE_TAKE_A_CERTAIN_MINIMUM , "Remez: an exchange step takes a certain minimum to perform the exchange" }, { SOLLYA_MSG_REMEZ_EXCHANGE_TAKE_A_CERTAIN_MAXIMUM , "Remez: an exchange step takes a certain maximum to perform the exchange" }, { SOLLYA_MSG_REMEZ_FUNCTION_OSCILLATES_TOO_MUCH , "Remez: the error function oscillates too much" }, { SOLLYA_MSG_REMEZ_PERFORMING_AN_EXCHANGE_STEP , "Remez: performing an exchange step" }, { SOLLYA_MSG_REMEZ_COMPUTED_INFNORM_IS_A_CERTAIN_VALUE , "Remez: the computed infinity norm of the current error function takes a certain value" }, { SOLLYA_MSG_REMEZ_FAILED_TO_FIND_PSEUDOALTERNATING_POINTS , "Remez: failed to find pseudo-alternating points" }, { SOLLYA_MSG_REMEZ_CONSTRUCTING_THE_ERROR_TREE , "Remez: constructing the error tree" }, { SOLLYA_MSG_REMEZ_CONSTRUCTING_THE_ERROR_PRIME_TREE , "Remez: constructing the error' tree" }, { SOLLYA_MSG_REMEZ_CONSTRUCTING_THE_ERROR_SECOND_TREE , "Remez: constructing the error'' tree" }, { SOLLYA_MSG_REMEZ_COMPUTING_THE_YI , "Remez: computing the yi" }, { SOLLYA_MSG_REMEZ_THE_COMPUTED_YI_ARE_CERTAIN_VALUES , "Remez: the computed yi are certain values" }, { SOLLYA_MSG_REMEZ_ALGORITHM_IS_IN_A_CERTAIN_CASE , "Remez: the algorithm is in a certain case" }, { SOLLYA_MSG_REMEZ_THE_COMPUTED_SIGNS_ARE_CERTAIN_VALUES , "Remez: the computed signs take certain values" }, { SOLLYA_MSG_REMEZ_SIGNS_COULD_NOT_BE_EVALUATED , "Remez: the signs could not be evaluated" }, { SOLLYA_MSG_REMEZ_MAIN_HEURISTIC_FAILED_USING_SLOWER_ALGO , "Remez: the main heuristic failed; using a slower algorithm" }, { SOLLYA_MSG_REMEZ_SLOWER_ALGORITHM_USED_FOR_A_STEP , "Remez: a slower algorithm is used for a certain step" }, { SOLLYA_MSG_REMEZ_THE_NEW_POINTS_ARE_CERTAIN_VALUES , "Remez: the new points take certain values" }, { SOLLYA_MSG_REMEZ_THE_CURRENT_NORM_TAKES_A_CERTAIN_VALUE , "Remez: the current norm takes a certain value" }, { SOLLYA_MSG_ENTERING_REMEZ_FUNCTION , "Entering the Remez function. Certain parameters are given" }, { SOLLYA_MSG_REMEZ_COMPUTING_MONOMIALS , "Remez: computing the monomials" }, { SOLLYA_MSG_REMEZ_COMPUTING_INITIAL_POINT_SET , "Remez: computing an initial point set" }, { SOLLYA_MSG_REMEZ_THE_COMPUTED_POINT_SET_IS_CERTAIN_VALUES , "Remez: the computed point set contains certain values" }, { SOLLYA_MSG_REMEZ_COMPUTING_THE_MATRIX , "Remez: computing the matrix" }, { SOLLYA_MSG_REMEZ_COMPUTAT_OF_MATRIX_ENTRY_USES_SLOWER_ALGO , "Remez: the computation of a certain matrix entry uses a slower algorithm" }, { SOLLYA_MSG_REMEZ_DEGENERATED_SYSTEM_IN_NON_HAAR_CONTEXT , "Remez: the system is degenerated in a non-Haar context" }, { SOLLYA_MSG_REMEZ_SIGNS_FOR_PSEUDO_ALTERN_ARE_CERTAIN_VALS , "Remez: the signs for the pseudo-alternation condition are certain values" }, { SOLLYA_MSG_REMEZ_THE_COMPUTED_MATRIX_HAS_A_CERTAIN_VALUE , "Remez: the computed matrix has a certain value" }, { SOLLYA_MSG_REMEZ_SOLVING_THE_SYSTEM , "Remez: solving the system" }, { SOLLYA_MSG_REMEZ_THE_COMPUTED_POLY_HAS_A_CERTAIN_VALUE , "Remez: the computed polynomial has a certain value" }, { SOLLYA_MSG_REMEZ_CURRENT_EPSILON_HAS_A_CERTAIN_VALUE , "Remez: the current epsilon has a certain value" }, { SOLLYA_MSG_REMEZ_DIFFERENTIATING_THE_COMPUTED_POLYNOMIAL , "Remez: differentiating the computed polynomial" }, { SOLLYA_MSG_REMEZ_SEARCHING_FOR_EXTREMA_OF_ERROR_FUNCTION , "Remez: searching for the extrema of the error function" }, { SOLLYA_MSG_REMEZ_THE_BEST_POLY_GIVES_A_CERTAIN_ERROR , "Remez: the best polynomial that has been computed yields to a certain error" }, { SOLLYA_MSG_REMEZ_CURRENT_QUALITY_HAS_A_CERTAIN_VALUE , "Remez: the current quality has a certain value" }, { SOLLYA_MSG_REMEZ_FINISHES_AS_TARGET_ERROR_IS_NOT_REACHABLE , "The Remez algorithm finishes as the given target error is provably not reachable" }, { SOLLYA_MSG_REMEZ_FINISHES_AS_TARGET_ERROR_HAS_BEEN_REACHED , "The Remez algorithm finishes as the given target error has been reached" }, { SOLLYA_MSG_REMEZ_FINISHES_AS_QUALITY_HAS_BEEN_REACHED , "The Remez algorithm finishes as the specified quality has been reached" }, { SOLLYA_MSG_REMEZ_FAILS_AND_LOOPS_AGAIN , "The Remez algorithm has failed (possible because of too many oscillations) and it loops again" }, { SOLLYA_MSG_REMEZ_DOES_NOT_CONVERGE , "The Remez algorithm does not converge" }, { SOLLYA_MSG_REMEZ_MAY_HAPPEN_NOT_TO_CONVRG_AS_DOM_IS_POINT , "The Remez algorithm may happen not to converge because the given domain is reduced to a point" }, { SOLLYA_MSG_GUESSDEGREE_TRYING_A_CERTAIN_DEGREE , "Guessdegree is about to try a certain degree" }, { SOLLYA_MSG_GUESSDEGREE_NONE_OF_LESSER_DEGS_SATISFIES_ERROR , "Guessdegree: none of the degrees less than a certain degree satisfies the target error" }, { SOLLYA_MSG_GUESSDEGREE_TRYING_A_CERTAIN_DEG_WITHIN_BOUNDS , "Guessdegree is about to try a certain degree within certain bounds" }, { SOLLYA_MSG_GUESSDEG_NONE_OF_LESS_DEGS_SEEMS_TO_SATISFY_ERR , "Guessdegree: none of the degrees less than a certain degree provably satisfy the target error" }, { SOLLYA_MSG_FPMINIMAX_SINGULAR_MATRIX , "Fpminimax: the matrix is singular" }, { SOLLYA_MSG_FPMINIMAX_A_CERTAIN_COEFF_IS_EXACT_ZERO , "Fpminimax: a certain coefficient is an exact zero" }, { SOLLYA_MSG_FPMINIMAX_MINIMAX_DOES_NOT_GIVE_ENOUGH_POINTS , "Fpminimax: the minimax does not give enough points, switching to Chebyshev points" }, { SOLLYA_MSG_FPMINIMAX_THE_POINTS_ARE_CERTAIN_VALUES , "Fpminimax: the points are certain values" }, { SOLLYA_MSG_FPMINIMAX_FAILED_TO_RECOVER_COEFFS_FROM_POLY , "Fpminimax failed to recover the coefficients from the given pseudo-polynomial" }, { SOLLYA_MSG_FPMINIMAX_THE_EXPONENTS_ARE_CERTAIN_VALUES , "Fpminimax: the exponents are certain values" }, { SOLLYA_MSG_FPMINIMAX_DID_NOT_CONVERGE , "Fpminimax did not converge" }, { SOLLYA_MSG_FPMINIMAX_NOT_ENOUGH_POINTS , "Fpminimax has been called with no sufficient number of points" }, { SOLLYA_MSG_FPMINIMAX_NOT_ENOUGH_FORMATS , "Fpminimax has been called with no sufficient number of formats" }, { SOLLYA_MSG_FPMINIMAX_COMP_OF_MATRIX_ENTRY_USES_SLOWER_ALGO , "Fpminimax: the computation of a certain matrix entry uses a slower algorithm" }, { SOLLYA_MSG_DIFFERENTIATING_FOR_DECORRELATION , "Interval evaluation performs a formal differentiation in order to try to decorrelate expressions" }, { SOLLYA_MSG_DECORRELATION_INTERVAL_ADDITION_OR_SUBTRACTION , "Decorrelation is performed on an interval addition or subtraction" }, { SOLLYA_MSG_DIFFERENTIATING_FOR_HOPITALS_RULE , "Interval evaluation performs a formal differentiation in order to use Hopital's rule" }, { SOLLYA_MSG_USING_HOPITALS_RULE_ON_POINT_DIVISION , "Using Hopital's rule on point division" }, { SOLLYA_MSG_SIMPLIFYING_INTERVAL_DIV_WITH_ZERO_POINT_NUMERA , "Simplifying an interval division with a zero point interval as a numerator" }, { SOLLYA_MSG_USING_HOPITALS_RULE_IN_GENERAL_CASE , "Using Hopital's rule in the general case" }, { SOLLYA_MSG_RECURSION_ON_USE_OF_HOPITALS_RULE , "Recursion is needed on the use of Hopital's rule" }, { SOLLYA_MSG_AVOIDING_TAYLOR_EVALUATION_ON_POINT_INTERVAL , "Avoiding Taylor evaluation on a point interval" }, { SOLLYA_MSG_NO_TAYLOR_EVALUATION_AS_NO_DERIVATIVE_GIVEN , "No Taylor evaluation is possible because no derivative has been given" }, { SOLLYA_MSG_USING_TAYLOR_EVALUATION , "Taylor evaluation gets used" }, { SOLLYA_MSG_NO_TAYLOR_EVALUATION_AS_NO_DERIVATIVE_GETS_HUGE , "No Taylor evaluation is possible because with all recursions, the tree of the derivative has become huge" }, { SOLLYA_MSG_DERIVATIVE_DOES_NOT_CHANGE_SIGN_ON_TAYLOR_EVAL , "The derivative of a function does not change sign on an interval during Taylor evaluation. The convex hull algorithm gets used" }, { SOLLYA_MSG_NAN_OR_INF_ON_DERIVATIVE , "The tree for the derivative of a function evaluates to NaN or Inf on an interval. The function might not be differentiable" }, { SOLLYA_MSG_INVOKING_RECURSIVE_INTERVAL_ZERO_SEARCH , "Invoking recursive interval zero search" }, { SOLLYA_MSG_RECURSIVE_INTERVAL_ZERO_SEARCH_HAS_FINISHED , "Recursive interval zero search has finished" }, { SOLLYA_MSG_CERTAIN_NUM_OF_INTVALS_ENCLOSING_ZEROS_OF_DERIV , "A certain number of interval enclosing the zeros of the derivative of a function has been found" }, { SOLLYA_MSG_EXPRESSION_IS_CONSTANT , "The given expression is constant" }, { SOLLYA_MSG_EVALUATION_AT_POINT_GIVES_NAN_EXCLUDING_POINT , "The evaluation of a certain function at a certain point becomes NaN. The point gets excluded from the list of points yielding to the result" }, { SOLLYA_MSG_THE_CURRENT_MAXIMUM_IS_A_CERTAIN_VALUE , "The current maximum is a certain value" }, { SOLLYA_MSG_EVALUATION_OF_DERIVATIVE_GIVES_NAN_NO_NEWTON , "The evaluation of the derivative of the function gives NaN. Newton's algorithm will not be used on this sub-interval" }, { SOLLYA_MSG_NO_PROOF_WILL_BE_GENERATED , "No proof will be generated" }, { SOLLYA_MSG_INFNORM_RESULT_IS_TRIVIAL , "The infnorm result of the given function on the given domain is trivially computable" }, { SOLLYA_MSG_DERIVATIVE_IS_QUOTIENT , "The derivative of the given function is a quotient" }, { SOLLYA_MSG_DERIVATIVE_SEEMS_TO_HAVE_SINGULARITY , "The derivative of the given function seems to have a singularity in the domain" }, { SOLLYA_MSG_DERIVATIVE_SEEMS_TO_HAVE_EXTENSIBLE_SINGULARITY , "The derivative of the given function seems to have an extensible singularity in the domain" }, { SOLLYA_MSG_DERIVATIVE_SEEMS_NOT_TO_HAVE_ANY_POLE , "The derivative of the given function seems not to have any pole in the domain" }, { SOLLYA_MSG_INVOKING_INFNORM_SUBFUNCTION , "Invoking the infnorm subfunction" }, { SOLLYA_MSG_INFNORM_SUBFUNCTION_HAS_FINISHED , "The infnorm subfunction has finished" }, { SOLLYA_MSG_STARTING_TO_WRITE_THE_PROOF , "Starting to write the proof" }, { SOLLYA_MSG_THE_PROOF_HAS_BEEN_WRITTEN , "The proof has been written" }, { SOLLYA_MSG_THE_EXPRESSION_IS_NOT_CONSTANT , "The given expression is not constant. It will be evaluated at 1" }, { SOLLYA_MSG_COULD_NOT_CHECK_INFNORM_ON_A_CERTAIN_INTERVAL , "The given infinity norm result could not be checked on a certain (sub-)interval" }, { SOLLYA_MSG_REMOVING_A_POSSIBLE_ZERO_AT_SOME_POINT , "A possible zero at some point is removed" }, { SOLLYA_MSG_ZERO_FILTER_HAS_REMOVED_AT_LEAST_ONE_ZERO , "The actual zero filter has removed at least one possible zero" }, { SOLLYA_MSG_FAITHFUL_EVALUATION_RETURNS_NAN , "Faithful evaluation returns NaN" }, { SOLLYA_MSG_INTERMEDIATE_PRECISION_HAS_BEEN_INCREASED , "The intermediate precision has been increased to a certain value" }, { SOLLYA_MSG_TAYLOR_RECURSION_TEMPORARILY_SET_TO_A_VALUE , "The number of Taylor recursions has been temporarily set to a certain value" }, { SOLLYA_MSG_ABS_DIAM_AND_PREC_SET_TO_CERTAIN_VALUES , "The absolute diameter and the intermediate precision have been temporarily set to certain values" }, { SOLLYA_MSG_IDENTIFIER_IS_LIBRARY_FUNC_CANNOT_BE_EXTERNAL , "An identifier is already bound to a library function. It cannot be bound to an external procedure" }, { SOLLYA_MSG_HANDLED_SIGSEGV , "A SIGSEGV signal has been handled" }, { SOLLYA_MSG_HANDLED_SIGBUS , "A SIGBUS signal has been handled" }, { SOLLYA_MSG_HANDLED_SIGFPE , "A SIGFPE signal has been handled" }, { SOLLYA_MSG_HANDLED_SIGPIPE , "A SIGPIPE signal has been handled" }, { SOLLYA_MSG_CANNOT_SUPPRESS_OR_UNSUPPRESS_A_MESSAGE , "A message with a certain message number cannot be suppressed nor unsuppressed" }, { SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_INT_OR_LIST_OF_INT , "A certain expression does not evaluate to a machine integer nor to a list of machine integers" }, { SOLLYA_MSG_SUPPRESSION_NUMBER_OMITTED , "A certain message suppression or unsuppression command will have had no effect for a certain message number" }, { SOLLYA_MSG_ROUNDING_ON_CONSTANT_RETRIEVAL , "A rounding occurred on retrieval of a constant" }, { SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL , "A minimum computation relies on floating-point result that is faithfully evaluated and at least one of the terms is not a real number" }, { SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL , "A maximum computation relies on floating-point result that is faithfully evaluated and at least one of the terms is not a real number" }, { SOLLYA_MSG_EXPRESSION_EVALUATES_TO_INFINITY , "An expression evaluates to infinity" }, { SOLLYA_MSG_DEG_OF_MAX_POLY_DIV_IS_NOT_CONSTANT , "An attempt was made to compute the degree of the maximal polynomial divider of a polynomial in an expression using a power operator with an exponent which is not a constant but a constant expression" }, { SOLLYA_MSG_DEG_OF_MAX_POLY_DIV_IS_NOT_INTEGER , "An attempt was made to compute the degree of the maximal polynomial divider of a polynomial in an expression using a power operator with an exponent which is not an integer" }, { SOLLYA_MSG_DEG_OF_MAX_POLY_DIV_IS_NEGATIVE , "An attempt was made to compute the degree of the maximal polynomial divider of a polynomial in an expression using a power operator with an exponent which is negative" }, { SOLLYA_MSG_RATIONALAPPROX_SECOND_ARG_MUST_BE_GREATER_THAN_ONE , "Error in rationalapprox: the second argument of rationalapprox must be greater or equal to 2" }, { SOLLYA_MSG_ROUND_PREC_MUST_BE_AT_LEAST_TWO_BITS , "The precision specified when rounding to a particular format must be at least 2 bits" }, { SOLLYA_MSG_NAN_CONVERTED_TO_NUMBER_ON_CONSTANT_RETRIEVAL , "A Not-A-Number value has been converted to a number upon retrieval of a constant." }, { SOLLYA_MSG_CHEBYSHEVFORM_DEGREE_MUST_NOT_BE_NEGATIVE , "The degree of a Chebyshev form must be at least zero."}, { SOLLYA_MSG_CHEBYSHEVFORM_DOMAIN_MUST_NOT_BE_POINT_INTERVAL , "The domain of a Chebyshev Model can not be a point interval"}, { SOLLYA_MSG_CHEBYSHEVFORM_ERROR_IN_COMPUTATION , "An error occurred during computation of a Chebyshev form."}, { SOLLYA_MSG_ERROR_IN_CHEBYSHEVFORM_COPYING_INCOMPAT_MODELS , "Error in Chebyshev form computation: copy of incompatible models."}, { SOLLYA_MSG_ERROR_IN_CHEBYSHEVFORM_UNKNOWN_FUNC_FOR_ZUMKELLER , "Error in Chebyshev form computation: unknown type of function used with Zumkeller's technique."}, { SOLLYA_MSG_ERROR_IN_CHEBYSHEVFORM_NOT_A_POLYNOMIAL , "Error in Chebyshev form computation: the given function is not a polynomial, no modification is made." }, { SOLLYA_MSG_SPECIAL_ALGORITHM_USED_FOR_COEFF , "A special algorithm is used to extract the i-th coefficient of an expression that is a polynomial." }, { SOLLYA_MSG_NO_CORRECT_ROUNDING_FOR_ROUND_OPERATOR , "No correctly rounded result could be obtained upon evaluation of a rounding operator." }, { SOLLYA_MSG_ROUNDING_OF_BOUNDARY_INSTEAD_OF_CORRECT_ROUNDING , "The returned rounding is the rounding of the rounding boundary because correct rounding has not been possible." }, { SOLLYA_MSG_NO_CORRECT_TERNARY_VALUE_FOR_ROUND_BUT_CORRECT_ROUNDING, "A correct rounding was possible but the actual rounding direction could not be determined." }, { SOLLYA_MSG_NO_CORRECT_TERNARY_VALUE_FOR_ROUND , "The actual rounding direction during a round operation could not be determined." }, { SOLLYA_MSG_LIBRARY_CLOSER_ERROR , "While closing a library, the function \"sollya_external_lib_close\" was found and called but it signaled an error." }, { SOLLYA_MSG_INF_CONVERTED_TO_NUMBER_ON_CONSTANT_RETRIEVAL , "An infinity has been converted to a number upon retrieval of a constant." }, { SOLLYA_MSG_ANNOTATION_COULD_NOT_BE_SET_UP , "The annotation could not be set up. The function is returned as-is." }, { SOLLYA_MSG_GENERIC_SOLLYA_LIBRARY_MSG , "An external program using the Sollya library has displayed a message." }, { SOLLYA_MSG_GUESSDEGREE_POSSIBLE_SINGULAR_WEIGHT , "The weight function in guessdegree might not be continuous over the given interval." }, { SOLLYA_MSG_SAFE_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST , "At least one of the given expressions is not a constant but requires evaluation. Evaluation is guaranteed to ensure the inclusion property." }, { SOLLYA_MSG_DEGREE_OF_POLYNOMIAL_LARGER_THAN_MULTIPRECISION_INT , "The degree of the given polynomial is larger than the largest multiprecision integer that can be held in memory. The polynomial's degree will be returned as -1." }, { SOLLYA_MSG_ANNOTATION_INCOHERENT , "An inconsistency has been detected between the results obtained with the evaluation of two distinct annotations of the same function." }, { SOLLYA_MSG_REMEZ_SWITCHING_DEFINITIVELY_TO_SLOW_ALGORITHM , "Remez: multipoint algorithm failed due to lack of Haar condition. Switching back to single point algorithm." }, /* Add your new warning message texts above here. */ { -1, "Unknown message number -1" } /* Do not ever change the text in this default entry, which must be the last entry in the list */ }; #endif /* Declaration of the function translating message numbers to texts */ char *messageNumberToText(int); int messageNumberExists(int); int getMessageId(sollya_msg_t); #endif /* ifdef SOLLYA_MESSAGING_H*/ sollya-6.0+ds/sollya.h000066400000000000000000001337341300174114700147510ustar00rootroot00000000000000/* Copyright 2007-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2) Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by CNRS, LIP6, UPMC Sorbonne Universités, UPMC Univ Paris 06, CNRS, LIP6 UMR 7606, 4 place Jussieu 75005 Paris Contributors Ch. Lauter, S. Chevillard, M. Joldes, M. Mezzarobba christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org joldes@laas.fr marc@mezzarobba.net This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef SOLLYA_H #define SOLLYA_H /* The following #include should be first ! IT MUST BE PROTECTED BY THE #if THAT IS USED! This is because this header file is used both internally when compiling the Sollya library and when using the library. */ #if (!(defined(__SOLLYA_NODE_TYPE_ALREADY_DEFINED) && (__SOLLYA_NODE_TYPE_ALREADY_DEFINED))) #include #endif /* Now some other #includes we need to get the different types defined. For some reason we can't really understand, some systems need the inclusions to be done in the order they are given. */ #include #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif /* Define a type for all Sollya objects and for lists of Sollya objects, constants, intervals, integers, strings and booleans. This header file is used both internally when compiling the Sollya library and when using the library. This is why the typedef logic below is pretty ackward. Please be very careful when messing with it. If you are a Sollya library user, the only thing you have to know that in the end of the following #if block, a type sollya_obj_t, types sollya_obj_list_t (list of Sollya objects) sollya_constant_list_t (list of MPFRs) sollya_interval_list_t (list of MPFIs) sollya_int_list_t (list of ints) sollya_string_list_t (list of char *s) sollya_boolean_list_t (list of ints as booleans) and the type sollya_msg_t are defined. These types represent the different objects the Sollya library is able to handle and objects that can be chained together. */ #if (!(defined(__SOLLYA_NODE_TYPE_ALREADY_DEFINED) && (__SOLLYA_NODE_TYPE_ALREADY_DEFINED))) typedef struct __sollya_internal_type_chain_struct __sollya_internal_type_chain; typedef __sollya_internal_type_chain * sollya_obj_list_t; typedef __sollya_internal_type_chain * sollya_constant_list_t; typedef __sollya_internal_type_chain * sollya_interval_list_t; typedef __sollya_internal_type_chain * sollya_int_list_t; typedef __sollya_internal_type_chain * sollya_string_list_t; typedef __sollya_internal_type_chain * sollya_boolean_list_t; typedef struct __sollya_internal_type_object_base_struct __sollya_internal_type_object_base; typedef __sollya_internal_type_object_base * sollya_obj_t; typedef struct __sollya_internal_type_msg_struct * sollya_msg_t; #endif /* Define an enumeration type for the status of floating-point evaluation */ enum sollya_fp_result_flag_enum_t { SOLLYA_FP_FLAG_CORRECTLY_ROUNDED = (1 << 0), SOLLYA_FP_FLAG_FAITHFUL = (1 << 1), SOLLYA_FP_FLAG_PROVEN_EXACT = (1 << 2), SOLLYA_FP_FLAG_PROVEN_INEXACT = (1 << 3), SOLLYA_FP_FLAG_NOT_FAITHFUL = (1 << 4), SOLLYA_FP_FLAG_BELOW_CUTOFF = (1 << 5), SOLLYA_FP_FLAG_BELOW_THRESHOLD = (1 << 6), SOLLYA_FP_FLAG_ZERO_CONTAINED = (1 << 7), SOLLYA_FP_FLAG_INFINITY_CONTAINED = (1 << 8), SOLLYA_FP_FLAG_FAILURE = (1 << 9), SOLLYA_FP_FLAG_CUTOFF_IS_NAN = (1 << 10), SOLLYA_FP_FLAG_EXPRESSION_NOT_CONSTANT = (1 << 11) }; typedef enum sollya_fp_result_flag_enum_t sollya_fp_result_flag_t; enum sollya_fp_result_enum_t { SOLLYA_FP_OBJ_NO_FUNCTION = 0, SOLLYA_FP_PROVEN_EXACT = SOLLYA_FP_FLAG_PROVEN_EXACT, SOLLYA_FP_FAITHFUL = SOLLYA_FP_FLAG_FAITHFUL, SOLLYA_FP_FAITHFUL_PROVEN_INEXACT = (SOLLYA_FP_FLAG_FAITHFUL | SOLLYA_FP_FLAG_PROVEN_INEXACT), SOLLYA_FP_CORRECTLY_ROUNDED = SOLLYA_FP_FLAG_CORRECTLY_ROUNDED, SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT = (SOLLYA_FP_FLAG_CORRECTLY_ROUNDED | SOLLYA_FP_FLAG_PROVEN_INEXACT), SOLLYA_FP_BELOW_CUTOFF = SOLLYA_FP_FLAG_BELOW_CUTOFF, SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD = (SOLLYA_FP_FLAG_NOT_FAITHFUL | SOLLYA_FP_FLAG_ZERO_CONTAINED | SOLLYA_FP_FLAG_BELOW_THRESHOLD), SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_NOT_BELOW_THRESHOLD = (SOLLYA_FP_FLAG_NOT_FAITHFUL | SOLLYA_FP_FLAG_ZERO_CONTAINED), SOLLYA_FP_NOT_FAITHFUL_ZERO_NOT_CONTAINED = SOLLYA_FP_FLAG_NOT_FAITHFUL, SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED = (SOLLYA_FP_FLAG_NOT_FAITHFUL | SOLLYA_FP_FLAG_INFINITY_CONTAINED), SOLLYA_FP_INFINITY = (SOLLYA_FP_FLAG_INFINITY_CONTAINED | SOLLYA_FP_FLAG_PROVEN_EXACT), SOLLYA_FP_FAILURE = SOLLYA_FP_FLAG_FAILURE, SOLLYA_FP_CUTOFF_IS_NAN = SOLLYA_FP_FLAG_CUTOFF_IS_NAN, SOLLYA_FP_EXPRESSION_NOT_CONSTANT = SOLLYA_FP_FLAG_EXPRESSION_NOT_CONSTANT }; typedef enum sollya_fp_result_enum_t sollya_fp_result_t; /* Define an enumeration type for the mathematical base functions */ enum sollya_base_function_enum_t { SOLLYA_BASE_FUNC_ABS, SOLLYA_BASE_FUNC_ACOS, SOLLYA_BASE_FUNC_ACOSH, SOLLYA_BASE_FUNC_ADD, SOLLYA_BASE_FUNC_ASIN, SOLLYA_BASE_FUNC_ASINH, SOLLYA_BASE_FUNC_ATAN, SOLLYA_BASE_FUNC_ATANH, SOLLYA_BASE_FUNC_CEIL, SOLLYA_BASE_FUNC_CONSTANT, SOLLYA_BASE_FUNC_COS, SOLLYA_BASE_FUNC_COSH, SOLLYA_BASE_FUNC_DIV, SOLLYA_BASE_FUNC_DOUBLE, SOLLYA_BASE_FUNC_DOUBLEDOUBLE, SOLLYA_BASE_FUNC_DOUBLEEXTENDED, SOLLYA_BASE_FUNC_ERF, SOLLYA_BASE_FUNC_ERFC, SOLLYA_BASE_FUNC_EXP, SOLLYA_BASE_FUNC_EXP_M1, SOLLYA_BASE_FUNC_FLOOR, SOLLYA_BASE_FUNC_FREE_VARIABLE, SOLLYA_BASE_FUNC_HALFPRECISION, SOLLYA_BASE_FUNC_LIBRARYCONSTANT, SOLLYA_BASE_FUNC_LIBRARYFUNCTION, SOLLYA_BASE_FUNC_LOG, SOLLYA_BASE_FUNC_LOG_10, SOLLYA_BASE_FUNC_LOG_1P, SOLLYA_BASE_FUNC_LOG_2, SOLLYA_BASE_FUNC_MUL, SOLLYA_BASE_FUNC_NEARESTINT, SOLLYA_BASE_FUNC_NEG, SOLLYA_BASE_FUNC_PI, SOLLYA_BASE_FUNC_POW, SOLLYA_BASE_FUNC_PROCEDUREFUNCTION, SOLLYA_BASE_FUNC_QUAD, SOLLYA_BASE_FUNC_SIN, SOLLYA_BASE_FUNC_SINGLE, SOLLYA_BASE_FUNC_SINH, SOLLYA_BASE_FUNC_SQRT, SOLLYA_BASE_FUNC_SUB, SOLLYA_BASE_FUNC_TAN, SOLLYA_BASE_FUNC_TANH, SOLLYA_BASE_FUNC_TRIPLEDOUBLE }; typedef enum sollya_base_function_enum_t sollya_base_function_t; /* Define an enumeration type for the types supported with sollya_lib_externalprocedure */ enum sollya_externalprocedure_type_enum_t { SOLLYA_EXTERNALPROC_TYPE_VOID, SOLLYA_EXTERNALPROC_TYPE_CONSTANT, SOLLYA_EXTERNALPROC_TYPE_FUNCTION, SOLLYA_EXTERNALPROC_TYPE_RANGE, SOLLYA_EXTERNALPROC_TYPE_INTEGER, SOLLYA_EXTERNALPROC_TYPE_STRING, SOLLYA_EXTERNALPROC_TYPE_BOOLEAN, SOLLYA_EXTERNALPROC_TYPE_OBJECT, SOLLYA_EXTERNALPROC_TYPE_CONSTANT_LIST, SOLLYA_EXTERNALPROC_TYPE_FUNCTION_LIST, SOLLYA_EXTERNALPROC_TYPE_RANGE_LIST, SOLLYA_EXTERNALPROC_TYPE_INTEGER_LIST, SOLLYA_EXTERNALPROC_TYPE_STRING_LIST, SOLLYA_EXTERNALPROC_TYPE_BOOLEAN_LIST, SOLLYA_EXTERNALPROC_TYPE_OBJECT_LIST }; typedef enum sollya_externalprocedure_type_enum_t sollya_externalprocedure_type_t; /* Initialization and finalization functions */ int sollya_lib_init(void); int sollya_lib_init_with_custom_memory_functions(void *(*)(size_t), void *(*)(size_t, size_t), void *(*)(void *, size_t), void (*)(void *), void *(*)(void *, size_t, size_t), void (*)(void *, size_t)); int sollya_lib_init_with_custom_memory_function_modifiers(void (*)(void *(*)(size_t), void *(*)(void *, size_t, size_t), void (*)(void *, size_t)), void (*)(void *(**)(size_t), void *(**)(void *, size_t, size_t), void (**)(void *, size_t))); int sollya_lib_init_with_custom_memory_functions_with_custom_memory_function_modifiers(void *(*)(size_t), void *(*)(size_t, size_t), void *(*)(void *, size_t), void (*)(void *), void *(*)(void *, size_t, size_t), void (*)(void *, size_t), void (*)(void *(*)(size_t), void *(*)(void *, size_t, size_t), void (*)(void *, size_t)), void (*)(void *(**)(size_t), void *(**)(void *, size_t, size_t), void (**)(void *, size_t))); int sollya_lib_close(void); /* Functions to install and uninstall a call-back for the messages emitted by the Sollya core. */ int sollya_lib_install_msg_callback(int (*) (sollya_msg_t, void *), void *); int sollya_lib_uninstall_msg_callback(void); void sollya_lib_get_msg_callback(int (**)(sollya_msg_t, void *), void **); /* A function to get a numerical message id out of the opaque sollya_msg_t object */ int sollya_lib_get_msg_id(sollya_msg_t); /* A function to translate a message (as received by the message call-back function) to text. Attention: the function malloc's the returned character string, which must therefore be freed by the user. */ char *sollya_lib_msg_to_text(sollya_msg_t); /* Functions to print anything, including Sollya objects */ int sollya_lib_printf(const char *, ...); int sollya_lib_v_printf(const char *, va_list); int sollya_lib_fprintf(FILE *, const char *, ...); int sollya_lib_v_fprintf(FILE *, const char *, va_list); int sollya_lib_sprintf(char *, const char *, ...); int sollya_lib_v_sprintf(char *, const char *, va_list); int sollya_lib_snprintf(char *, size_t, const char *, ...); int sollya_lib_v_snprintf(char *, size_t, const char *, va_list); /* A function to display Sollya message out of library code */ void sollya_lib_printlibrarymessage(int, const char *); /* A function to clear Sollya_objects */ void sollya_lib_clear_obj(sollya_obj_t); /* Some Sollya library functions allocate memory when returning arrays or character strings. This memory must be freed by the user. However, the freeing must not be done using the traditional system free() but the following Sollya free. The Sollya free function will call back the memory deallocation function that might have been registered with the Sollya library upon library initialization. */ void sollya_lib_free(void *); /* The same way, the user might want to allocate memory through Sollya library's memory function call chain */ void *sollya_lib_malloc(size_t); void *sollya_lib_calloc(size_t, size_t); void *sollya_lib_realloc(void *, size_t); /* A function to structurally compare two Sollya objects */ int sollya_lib_cmp_objs_structurally(sollya_obj_t, sollya_obj_t); /* A function to copy Sollya objects */ sollya_obj_t sollya_lib_copy_obj(sollya_obj_t); /* A function to name the free mathematical variable and one to get its name. - If the variable has already been named when the naming function is called, the variable gets renamed. - If the variable has not been named yet, "_x_" is returned as its name. This corresponds to the name displayed by other functions. - The pointer returned for the name *must* be freed by the user. - The pointer given to the naming function is not "used up" by the function. */ void sollya_lib_name_free_variable(const char *); char *sollya_lib_get_free_variable_name(void); /* Functions corresponding to Sollya commands */ void sollya_lib_plot(sollya_obj_t, sollya_obj_t, ...); void sollya_lib_v_plot(sollya_obj_t, sollya_obj_t, va_list); void sollya_lib_printdouble(sollya_obj_t); void sollya_lib_printsingle(sollya_obj_t); void sollya_lib_printexpansion(sollya_obj_t); void sollya_lib_bashexecute(sollya_obj_t); void sollya_lib_externalplot(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, ...); void sollya_lib_v_externalplot(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, va_list); void sollya_lib_asciiplot(sollya_obj_t, sollya_obj_t); void sollya_lib_execute(sollya_obj_t); void sollya_lib_printxml(sollya_obj_t); void sollya_lib_printxml_newfile(sollya_obj_t, sollya_obj_t); void sollya_lib_printxml_appendfile(sollya_obj_t, sollya_obj_t); void sollya_lib_worstcase(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, ...); void sollya_lib_v_worstcase(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, va_list); void sollya_lib_autoprint(sollya_obj_t, ...); void sollya_lib_v_autoprint(sollya_obj_t, va_list); void sollya_lib_suppressmessage(sollya_obj_t, ...); void sollya_lib_v_suppressmessage(sollya_obj_t, va_list); void sollya_lib_unsuppressmessage(sollya_obj_t, ...); void sollya_lib_v_unsuppressmessage(sollya_obj_t, va_list); void sollya_lib_implementconstant(sollya_obj_t, ...); void sollya_lib_v_implementconstant(sollya_obj_t, va_list); void sollya_lib_set_prec_and_print(sollya_obj_t); void sollya_lib_set_points_and_print(sollya_obj_t); void sollya_lib_set_diam_and_print(sollya_obj_t); void sollya_lib_set_display_and_print(sollya_obj_t); void sollya_lib_set_verbosity_and_print(sollya_obj_t); void sollya_lib_set_canonical_and_print(sollya_obj_t); void sollya_lib_set_autosimplify_and_print(sollya_obj_t); void sollya_lib_set_fullparentheses_and_print(sollya_obj_t); void sollya_lib_set_showmessagenumbers_and_print(sollya_obj_t); void sollya_lib_set_taylorrecursions_and_print(sollya_obj_t); void sollya_lib_set_timing_and_print(sollya_obj_t); void sollya_lib_set_midpointmode_and_print(sollya_obj_t); void sollya_lib_set_dieonerrormode_and_print(sollya_obj_t); void sollya_lib_set_rationalmode_and_print(sollya_obj_t); void sollya_lib_set_roundingwarnings_and_print(sollya_obj_t); void sollya_lib_set_hopitalrecursions_and_print(sollya_obj_t); void sollya_lib_set_prec(sollya_obj_t); void sollya_lib_set_points(sollya_obj_t); void sollya_lib_set_diam(sollya_obj_t); void sollya_lib_set_display(sollya_obj_t); void sollya_lib_set_verbosity(sollya_obj_t); void sollya_lib_set_canonical(sollya_obj_t); void sollya_lib_set_autosimplify(sollya_obj_t); void sollya_lib_set_fullparentheses(sollya_obj_t); void sollya_lib_set_showmessagenumbers(sollya_obj_t); void sollya_lib_set_taylorrecursions(sollya_obj_t); void sollya_lib_set_timing(sollya_obj_t); void sollya_lib_set_midpointmode(sollya_obj_t); void sollya_lib_set_dieonerrormode(sollya_obj_t); void sollya_lib_set_rationalmode(sollya_obj_t); void sollya_lib_set_roundingwarnings(sollya_obj_t); void sollya_lib_set_hopitalrecursions(sollya_obj_t); /* Functions corresponding to Sollya built-in procedures */ sollya_obj_t sollya_lib_free_variable(void); sollya_obj_t sollya_lib_and(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_or(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_negate(sollya_obj_t); sollya_obj_t sollya_lib_cmp_equal(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_cmp_in(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_cmp_less(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_cmp_greater(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_cmp_less_equal(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_cmp_greater_equal(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_cmp_not_equal(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_add(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_sub(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_concat(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_append(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_prepend(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_apply(sollya_obj_t, ...); sollya_obj_t sollya_lib_v_apply(sollya_obj_t, va_list); sollya_obj_t sollya_lib_approx(sollya_obj_t); sollya_obj_t sollya_lib_mul(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_div(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_pow(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_neg(sollya_obj_t); sollya_obj_t sollya_lib_sup(sollya_obj_t); sollya_obj_t sollya_lib_mid(sollya_obj_t); sollya_obj_t sollya_lib_inf(sollya_obj_t); sollya_obj_t sollya_lib_diff(sollya_obj_t); sollya_obj_t sollya_lib_bashevaluate(sollya_obj_t, ...); sollya_obj_t sollya_lib_v_bashevaluate(sollya_obj_t, va_list); sollya_obj_t sollya_lib_getsuppressedmessages(void); sollya_obj_t sollya_lib_getbacktrace(void); sollya_obj_t sollya_lib_remez(sollya_obj_t, sollya_obj_t, sollya_obj_t, ...); sollya_obj_t sollya_lib_v_remez(sollya_obj_t, sollya_obj_t, sollya_obj_t, va_list); sollya_obj_t sollya_lib_annotatefunction(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, ...); sollya_obj_t sollya_lib_v_annotatefunction(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, va_list); sollya_obj_t sollya_lib_min(sollya_obj_t, ...); sollya_obj_t sollya_lib_v_min(sollya_obj_t, va_list); sollya_obj_t sollya_lib_max(sollya_obj_t, ...); sollya_obj_t sollya_lib_v_max(sollya_obj_t, va_list); sollya_obj_t sollya_lib_fpminimax(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, ...); sollya_obj_t sollya_lib_v_fpminimax(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, va_list); sollya_obj_t sollya_lib_horner(sollya_obj_t); sollya_obj_t sollya_lib_canonical(sollya_obj_t); sollya_obj_t sollya_lib_expand(sollya_obj_t); sollya_obj_t sollya_lib_dirtysimplify(sollya_obj_t); sollya_obj_t sollya_lib_simplify(sollya_obj_t); sollya_obj_t sollya_lib_taylor(sollya_obj_t, sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_taylorform(sollya_obj_t, sollya_obj_t, sollya_obj_t, ...); sollya_obj_t sollya_lib_v_taylorform(sollya_obj_t, sollya_obj_t, sollya_obj_t, va_list); sollya_obj_t sollya_lib_chebyshevform(sollya_obj_t, sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_autodiff(sollya_obj_t, sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_degree(sollya_obj_t); sollya_obj_t sollya_lib_numerator(sollya_obj_t); sollya_obj_t sollya_lib_denominator(sollya_obj_t); sollya_obj_t sollya_lib_substitute(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_composepolynomials(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_coeff(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_subpoly(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_roundcoefficients(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_rationalapprox(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_round(sollya_obj_t, sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_evaluate(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_parse(sollya_obj_t); sollya_obj_t sollya_lib_readxml(sollya_obj_t); sollya_obj_t sollya_lib_infnorm(sollya_obj_t, sollya_obj_t, ...); sollya_obj_t sollya_lib_v_infnorm(sollya_obj_t, sollya_obj_t, va_list); sollya_obj_t sollya_lib_supnorm(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_findzeros(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_dirtyinfnorm(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_numberroots(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_integral(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_dirtyintegral(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_implementpoly(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, ...); sollya_obj_t sollya_lib_v_implementpoly(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, va_list); sollya_obj_t sollya_lib_checkinfnorm(sollya_obj_t, sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_searchgal(sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_guessdegree(sollya_obj_t, sollya_obj_t, sollya_obj_t, ...); sollya_obj_t sollya_lib_v_guessdegree(sollya_obj_t, sollya_obj_t, sollya_obj_t, va_list); sollya_obj_t sollya_lib_dirtyfindzeros(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_head(sollya_obj_t); sollya_obj_t sollya_lib_roundcorrectly(sollya_obj_t); sollya_obj_t sollya_lib_revert(sollya_obj_t); sollya_obj_t sollya_lib_sort(sollya_obj_t); sollya_obj_t sollya_lib_mantissa(sollya_obj_t); sollya_obj_t sollya_lib_exponent(sollya_obj_t); sollya_obj_t sollya_lib_precision(sollya_obj_t); sollya_obj_t sollya_lib_tail(sollya_obj_t); sollya_obj_t sollya_lib_range(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_sqrt(sollya_obj_t); sollya_obj_t sollya_lib_exp(sollya_obj_t); sollya_obj_t sollya_lib_log(sollya_obj_t); sollya_obj_t sollya_lib_log2(sollya_obj_t); sollya_obj_t sollya_lib_log10(sollya_obj_t); sollya_obj_t sollya_lib_sin(sollya_obj_t); sollya_obj_t sollya_lib_cos(sollya_obj_t); sollya_obj_t sollya_lib_tan(sollya_obj_t); sollya_obj_t sollya_lib_asin(sollya_obj_t); sollya_obj_t sollya_lib_acos(sollya_obj_t); sollya_obj_t sollya_lib_atan(sollya_obj_t); sollya_obj_t sollya_lib_sinh(sollya_obj_t); sollya_obj_t sollya_lib_cosh(sollya_obj_t); sollya_obj_t sollya_lib_tanh(sollya_obj_t); sollya_obj_t sollya_lib_asinh(sollya_obj_t); sollya_obj_t sollya_lib_acosh(sollya_obj_t); sollya_obj_t sollya_lib_atanh(sollya_obj_t); sollya_obj_t sollya_lib_abs(sollya_obj_t); sollya_obj_t sollya_lib_erf(sollya_obj_t); sollya_obj_t sollya_lib_erfc(sollya_obj_t); sollya_obj_t sollya_lib_log1p(sollya_obj_t); sollya_obj_t sollya_lib_expm1(sollya_obj_t); sollya_obj_t sollya_lib_double(sollya_obj_t); sollya_obj_t sollya_lib_single(sollya_obj_t); sollya_obj_t sollya_lib_quad(sollya_obj_t); sollya_obj_t sollya_lib_halfprecision(sollya_obj_t); sollya_obj_t sollya_lib_double_double(sollya_obj_t); sollya_obj_t sollya_lib_triple_double(sollya_obj_t); sollya_obj_t sollya_lib_doubleextended(sollya_obj_t); sollya_obj_t sollya_lib_ceil(sollya_obj_t); sollya_obj_t sollya_lib_floor(sollya_obj_t); sollya_obj_t sollya_lib_nearestint(sollya_obj_t); sollya_obj_t sollya_lib_length(sollya_obj_t); sollya_obj_t sollya_lib_objectname(sollya_obj_t); sollya_obj_t sollya_lib_get_prec(void); sollya_obj_t sollya_lib_get_points(void); sollya_obj_t sollya_lib_get_diam(void); sollya_obj_t sollya_lib_get_display(void); sollya_obj_t sollya_lib_get_verbosity(void); sollya_obj_t sollya_lib_get_canonical(void); sollya_obj_t sollya_lib_get_autosimplify(void); sollya_obj_t sollya_lib_get_fullparentheses(void); sollya_obj_t sollya_lib_get_showmessagenumbers(void); sollya_obj_t sollya_lib_get_taylorrecursions(void); sollya_obj_t sollya_lib_get_timing(void); sollya_obj_t sollya_lib_get_midpointmode(void); sollya_obj_t sollya_lib_get_dieonerrormode(void); sollya_obj_t sollya_lib_get_rationalmode(void); sollya_obj_t sollya_lib_get_roundingwarnings(void); sollya_obj_t sollya_lib_get_hopitalrecursions(void); /* Functions creating Sollya objects */ sollya_obj_t sollya_lib_on(void); sollya_obj_t sollya_lib_off(void); sollya_obj_t sollya_lib_dyadic(void); sollya_obj_t sollya_lib_powers(void); sollya_obj_t sollya_lib_binary(void); sollya_obj_t sollya_lib_hexadecimal(void); sollya_obj_t sollya_lib_file(void); sollya_obj_t sollya_lib_postscript(void); sollya_obj_t sollya_lib_postscriptfile(void); sollya_obj_t sollya_lib_perturb(void); sollya_obj_t sollya_lib_round_down(void); sollya_obj_t sollya_lib_round_up(void); sollya_obj_t sollya_lib_round_towards_zero(void); sollya_obj_t sollya_lib_round_to_nearest(void); sollya_obj_t sollya_lib_honorcoeffprec(void); sollya_obj_t sollya_lib_true(void); sollya_obj_t sollya_lib_false(void); sollya_obj_t sollya_lib_void(void); sollya_obj_t sollya_lib_default(void); sollya_obj_t sollya_lib_decimal(void); sollya_obj_t sollya_lib_absolute(void); sollya_obj_t sollya_lib_relative(void); sollya_obj_t sollya_lib_fixed(void); sollya_obj_t sollya_lib_floating(void); sollya_obj_t sollya_lib_error(void); sollya_obj_t sollya_lib_double_obj(void); sollya_obj_t sollya_lib_single_obj(void); sollya_obj_t sollya_lib_quad_obj(void); sollya_obj_t sollya_lib_halfprecision_obj(void); sollya_obj_t sollya_lib_doubleextended_obj(void); sollya_obj_t sollya_lib_double_double_obj(void); sollya_obj_t sollya_lib_triple_double_obj(void); sollya_obj_t sollya_lib_pi(void); sollya_obj_t sollya_lib_libraryconstant(char *, void (*)(mpfr_t, mp_prec_t)); sollya_obj_t sollya_lib_libraryfunction(sollya_obj_t, char *, int (*)(mpfi_t, mpfi_t, int)); sollya_obj_t sollya_lib_externalprocedure(sollya_externalprocedure_type_t, sollya_externalprocedure_type_t *, int, char *, void *); sollya_obj_t sollya_lib_libraryconstant_with_data(char *, void (*)(mpfr_t, mp_prec_t, void *), void *, void (*)(void *)); sollya_obj_t sollya_lib_libraryfunction_with_data(sollya_obj_t, char *, int (*)(mpfi_t, mpfi_t, int, void *), void *, void (*)(void *)); sollya_obj_t sollya_lib_externalprocedure_with_data(sollya_externalprocedure_type_t, sollya_externalprocedure_type_t *, int, char *, void *, void *, void (*)(void *)); sollya_obj_t sollya_lib_procedurefunction(sollya_obj_t, sollya_obj_t); /* A function to parse expressions and evaluate them */ sollya_obj_t sollya_lib_parse_string(const char *); /* Functions to execute Sollya procedures with library calls */ sollya_obj_t sollya_lib_execute_procedure(sollya_obj_t, ...); sollya_obj_t sollya_lib_v_execute_procedure(sollya_obj_t, va_list); /* Functions to convert from constants to Sollya objects */ /* There is no specific constructor for NaN and +/-Inf: they can be created through a call to sollya_lib_constant_from_double */ sollya_obj_t sollya_lib_string(char *); sollya_obj_t sollya_lib_range_from_interval(mpfi_t); sollya_obj_t sollya_lib_range_from_bounds(mpfr_t, mpfr_t); sollya_obj_t sollya_lib_constant(mpfr_t); sollya_obj_t sollya_lib_constant_from_double(double); sollya_obj_t sollya_lib_constant_from_int(int); sollya_obj_t sollya_lib_constant_from_int64(int64_t); sollya_obj_t sollya_lib_constant_from_uint64(uint64_t); sollya_obj_t sollya_lib_constant_from_mpz(mpz_t); sollya_obj_t sollya_lib_constant_from_mpq(mpq_t); /* Functions to get values contained in Sollya objects */ int sollya_lib_get_interval_from_range(mpfi_t, sollya_obj_t); int sollya_lib_get_bounds_from_range(mpfr_t, mpfr_t, sollya_obj_t); int sollya_lib_get_string(char **, sollya_obj_t); int sollya_lib_get_constant_as_double(double *, sollya_obj_t); int sollya_lib_get_constant_as_int(int *, sollya_obj_t); int sollya_lib_get_constant_as_int64(int64_t *, sollya_obj_t); int sollya_lib_get_constant_as_uint64(uint64_t *, sollya_obj_t); int sollya_lib_get_constant(mpfr_t, sollya_obj_t); int sollya_lib_get_prec_of_constant(mp_prec_t *, sollya_obj_t); int sollya_lib_get_prec_of_range(mp_prec_t *, sollya_obj_t); int sollya_lib_get_constant_as_mpz(mpz_t, sollya_obj_t); int sollya_lib_get_constant_as_mpq(mpq_t, sollya_obj_t); /* Functions to build up Sollya lists from arrays of objects and to get arrays of Sollya objects out of Sollya lists */ /* Please notice that the list is created from copies of the elements given in the argument array. There exist sollya_lib_build_*list to create a list with references to the elements of the argument array */ /* The empty list is created with sollya_lib_list(NULL, 0) The end-elliptic list has no meaning. Hence sollya_lib_end_elliptic_list(NULL, 0) leads to an error */ sollya_obj_t sollya_lib_list(sollya_obj_t[], int); sollya_obj_t sollya_lib_end_elliptic_list(sollya_obj_t[], int); int sollya_lib_get_list_elements(sollya_obj_t **, int *, int *, sollya_obj_t); int sollya_lib_get_element_in_list(sollya_obj_t *, sollya_obj_t, int); /* Functions to check if a Sollya object represents a mathematical function, a list, an end-elliptic list, a range, a string, a structure or error. */ /* Constants and 0-ary functions as pi are considered as functions The empty list is considered both as a regular and an end-elliptic list. */ int sollya_lib_obj_is_function(sollya_obj_t); int sollya_lib_obj_is_list(sollya_obj_t); int sollya_lib_obj_is_end_elliptic_list(sollya_obj_t); int sollya_lib_obj_is_range(sollya_obj_t); int sollya_lib_obj_is_string(sollya_obj_t); int sollya_lib_obj_is_error(sollya_obj_t); int sollya_lib_obj_is_structure(sollya_obj_t); int sollya_lib_obj_is_procedure(sollya_obj_t); int sollya_lib_obj_is_externalprocedure(sollya_obj_t); /* Functions to decompose Sollya objects that represent mathematical functions. All these functions return a zero value if the Sollya object they are given is something else but a mathematical function and a non-zero value otherwise (i.e. if it is a function with an arity). */ int sollya_lib_get_function_arity(int *, sollya_obj_t); int sollya_lib_get_head_function(sollya_base_function_t *, sollya_obj_t); /* The first object is the function to get the subfunctions from. The second object is a pointer to an integer to store the number of subfunctions stored. The variadic objects are pointers to Sollya objects in which the subfunctions will be stored (if they exist). If less pointers are given than the function has subfunctions (i.e. less than the function's arity), the last pointer must be NULL. */ int sollya_lib_get_subfunctions(sollya_obj_t, int *, ...); int sollya_lib_v_get_subfunctions(sollya_obj_t, int *, va_list); int sollya_lib_get_nth_subfunction(sollya_obj_t *, sollya_obj_t, int); /* A one-does-it-all function */ int sollya_lib_decompose_function(sollya_obj_t, sollya_base_function_t *, int *, ...); int sollya_lib_v_decompose_function(sollya_obj_t, sollya_base_function_t *, int *, va_list); /* A construction function that inverts the action of the decomposition function. */ int sollya_lib_construct_function(sollya_obj_t *, sollya_base_function_t, ...); int sollya_lib_v_construct_function(sollya_obj_t *, sollya_base_function_t, va_list); /* Some particular functions to decompose library function objects, library constant objects and procedure function objects */ int sollya_lib_decompose_libraryfunction(int (**)(mpfi_t, mpfi_t, int), int *, sollya_obj_t *, sollya_obj_t); int sollya_lib_decompose_libraryconstant(void (**)(mpfr_t, mp_prec_t), sollya_obj_t); int sollya_lib_decompose_externalprocedure(sollya_externalprocedure_type_t *, sollya_externalprocedure_type_t **, int *, void **, sollya_obj_t); int sollya_lib_decompose_libraryfunction_with_data(int (**)(mpfi_t, mpfi_t, int, void *), int *, sollya_obj_t *, void **, void (**)(void *), sollya_obj_t); int sollya_lib_decompose_libraryconstant_with_data(void (**)(mpfr_t, mp_prec_t, void *), void **, void (**)(void *), sollya_obj_t); int sollya_lib_decompose_externalprocedure_with_data(sollya_externalprocedure_type_t *, sollya_externalprocedure_type_t **, int *, void **, void **, void (**)(void *), sollya_obj_t); int sollya_lib_decompose_procedurefunction(sollya_obj_t *, int *, sollya_obj_t *, sollya_obj_t); /* A function to compute a hash value on Sollya objects The function guarantees that if two objects compare equal, then they have the same hash. This function is actually pretty expensive in cases when Sollya needs to compute a unique representation before computing the hash. The hash value gets cached in most cases; so recomputing should essentially be free. */ uint64_t sollya_lib_hash(sollya_obj_t); /* Functions that work on Sollya objects that are structures The int return value indicates success (zero -> failure, non-zero -> success). Attention: Upon success, memory is allocated by the functions for the returned objects. This includes sollya_lib_create_structure which "returns" a new Sollya object representing a structure that contains all elements contained in the structure given in parameter plus, if applicable, a new element "identifier -> object". In the case when the identifier was already present in the given structure, a new (copied) structure is "returned" in which the existing correspondence "identifier -> ..." is replaced by the new one. In order to create a structure "from scratch", give NULL as an existing Sollya structure object to sollya_lib_create_structure. */ int sollya_lib_get_structure_elements(char ***, sollya_obj_t **, int *, sollya_obj_t); int sollya_lib_get_element_in_structure(sollya_obj_t *, char *, sollya_obj_t); int sollya_lib_create_structure(sollya_obj_t *, sollya_obj_t, char *, sollya_obj_t); /* Functions that check if a Sollya object is some particular constant */ int sollya_lib_is_on(sollya_obj_t); int sollya_lib_is_off(sollya_obj_t); int sollya_lib_is_dyadic(sollya_obj_t); int sollya_lib_is_powers(sollya_obj_t); int sollya_lib_is_binary(sollya_obj_t); int sollya_lib_is_hexadecimal(sollya_obj_t); int sollya_lib_is_file(sollya_obj_t); int sollya_lib_is_postscript(sollya_obj_t); int sollya_lib_is_postscriptfile(sollya_obj_t); int sollya_lib_is_perturb(sollya_obj_t); int sollya_lib_is_round_down(sollya_obj_t); int sollya_lib_is_round_up(sollya_obj_t); int sollya_lib_is_round_towards_zero(sollya_obj_t); int sollya_lib_is_round_to_nearest(sollya_obj_t); int sollya_lib_is_honorcoeffprec(sollya_obj_t); int sollya_lib_is_true(sollya_obj_t); int sollya_lib_is_false(sollya_obj_t); int sollya_lib_is_void(sollya_obj_t); int sollya_lib_is_default(sollya_obj_t); int sollya_lib_is_decimal(sollya_obj_t); int sollya_lib_is_absolute(sollya_obj_t); int sollya_lib_is_relative(sollya_obj_t); int sollya_lib_is_fixed(sollya_obj_t); int sollya_lib_is_floating(sollya_obj_t); int sollya_lib_is_double_obj(sollya_obj_t); int sollya_lib_is_single_obj(sollya_obj_t); int sollya_lib_is_quad_obj(sollya_obj_t); int sollya_lib_is_halfprecision_obj(sollya_obj_t); int sollya_lib_is_doubleextended_obj(sollya_obj_t); int sollya_lib_is_double_double_obj(sollya_obj_t); int sollya_lib_is_triple_double_obj(sollya_obj_t); int sollya_lib_is_pi(sollya_obj_t); /* Functions to evaluate Sollya objects that are mathematical functions at points, over intervals or at points given by constant expressions */ sollya_fp_result_t sollya_lib_evaluate_function_at_point(mpfr_t, sollya_obj_t, mpfr_t, mpfr_t *); sollya_fp_result_t sollya_lib_evaluate_function_at_constant_expression(mpfr_t, sollya_obj_t, sollya_obj_t, mpfr_t *); int sollya_lib_evaluate_function_over_interval(mpfi_t, sollya_obj_t, mpfi_t); /* Functions to manipulate lists These functions are not necessarily needed when using the Sollya library in free-standing applications. They are needed when the Sollya library is used in external procedures that are to be dynamically loaded into interactive Sollya sessions. Attention: these functions - take and return NULL as a placeholder for empty lists - only return references for Sollya objects, constants, intervals and strings (for the head functions) - only return references for the tail lists (for the tail functions) - "eat up" the references given when constructing lists from elements (construct functions) - return NULL (resp. 0 for integers and booleans) if the head of an empty list is queried - return an empty list for empty tails, in particular tails of empty lists. The copy functions structurally (deeply) copy both the lists and all elements. The clear functions clear both the lists and the elements. */ sollya_obj_t sollya_lib_get_object_list_head(sollya_obj_list_t); sollya_obj_list_t sollya_lib_get_object_list_tail(sollya_obj_list_t); sollya_obj_list_t sollya_lib_construct_object_list(sollya_obj_t, sollya_obj_list_t); sollya_obj_list_t sollya_lib_copy_object_list(sollya_obj_list_t); void sollya_lib_clear_object_list(sollya_obj_list_t); int sollya_lib_is_empty_object_list(sollya_obj_list_t); mpfr_t *sollya_lib_get_constant_list_head(sollya_constant_list_t); sollya_constant_list_t sollya_lib_get_constant_list_tail(sollya_constant_list_t); sollya_constant_list_t sollya_lib_construct_constant_list(mpfr_t *, sollya_constant_list_t); sollya_constant_list_t sollya_lib_copy_constant_list(sollya_constant_list_t); void sollya_lib_clear_constant_list(sollya_constant_list_t); int sollya_lib_is_empty_constant_list(sollya_obj_list_t); mpfi_t *sollya_lib_get_interval_list_head(sollya_interval_list_t); sollya_interval_list_t sollya_lib_get_interval_list_tail(sollya_interval_list_t); sollya_interval_list_t sollya_lib_construct_interval_list(mpfi_t *, sollya_interval_list_t); sollya_interval_list_t sollya_lib_copy_interval_list(sollya_interval_list_t); void sollya_lib_clear_interval_list(sollya_interval_list_t); int sollya_lib_is_empty_interval_list(sollya_obj_list_t); int sollya_lib_get_int_list_head(sollya_int_list_t); sollya_int_list_t sollya_lib_get_int_list_tail(sollya_int_list_t); sollya_int_list_t sollya_lib_construct_int_list(int, sollya_int_list_t); sollya_int_list_t sollya_lib_copy_int_list(sollya_int_list_t); void sollya_lib_clear_int_list(sollya_int_list_t); int sollya_lib_is_empty_int_list(sollya_obj_list_t); int sollya_lib_get_boolean_list_head(sollya_boolean_list_t); sollya_boolean_list_t sollya_lib_get_boolean_list_tail(sollya_boolean_list_t); sollya_boolean_list_t sollya_lib_construct_boolean_list(int, sollya_boolean_list_t); sollya_boolean_list_t sollya_lib_copy_boolean_list(sollya_boolean_list_t); void sollya_lib_clear_boolean_list(sollya_boolean_list_t); int sollya_lib_is_empty_boolean_list(sollya_obj_list_t); char *sollya_lib_get_string_list_head(sollya_string_list_t); sollya_string_list_t sollya_lib_get_string_list_tail(sollya_string_list_t); sollya_string_list_t sollya_lib_construct_string_list(char *, sollya_string_list_t); sollya_string_list_t sollya_lib_copy_string_list(sollya_string_list_t); void sollya_lib_clear_string_list(sollya_string_list_t); int sollya_lib_is_empty_string_list(sollya_obj_list_t); /* Functions for building Sollya objects representing mathematical functions or Sollya objects representing lists. Attention: in contrast to all other functions in the Sollya library, these functions "use up" the objects they take as an argument. */ sollya_obj_t sollya_lib_build_list(sollya_obj_t, ...); sollya_obj_t sollya_lib_build_end_elliptic_list(sollya_obj_t, ...); sollya_obj_t sollya_lib_v_build_list(va_list); sollya_obj_t sollya_lib_v_build_end_elliptic_list(va_list); sollya_obj_t sollya_lib_build_function_free_variable(void); sollya_obj_t sollya_lib_build_function_add(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_build_function_sub(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_build_function_mul(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_build_function_div(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_build_function_sqrt(sollya_obj_t); sollya_obj_t sollya_lib_build_function_exp(sollya_obj_t); sollya_obj_t sollya_lib_build_function_log(sollya_obj_t); sollya_obj_t sollya_lib_build_function_log2(sollya_obj_t); sollya_obj_t sollya_lib_build_function_log10(sollya_obj_t); sollya_obj_t sollya_lib_build_function_sin(sollya_obj_t); sollya_obj_t sollya_lib_build_function_cos(sollya_obj_t); sollya_obj_t sollya_lib_build_function_tan(sollya_obj_t); sollya_obj_t sollya_lib_build_function_asin(sollya_obj_t); sollya_obj_t sollya_lib_build_function_acos(sollya_obj_t); sollya_obj_t sollya_lib_build_function_atan(sollya_obj_t); sollya_obj_t sollya_lib_build_function_pow(sollya_obj_t, sollya_obj_t); sollya_obj_t sollya_lib_build_function_neg(sollya_obj_t); sollya_obj_t sollya_lib_build_function_abs(sollya_obj_t); sollya_obj_t sollya_lib_build_function_double(sollya_obj_t); sollya_obj_t sollya_lib_build_function_single(sollya_obj_t); sollya_obj_t sollya_lib_build_function_quad(sollya_obj_t); sollya_obj_t sollya_lib_build_function_halfprecision(sollya_obj_t); sollya_obj_t sollya_lib_build_function_double_double(sollya_obj_t); sollya_obj_t sollya_lib_build_function_triple_double(sollya_obj_t); sollya_obj_t sollya_lib_build_function_erf(sollya_obj_t); sollya_obj_t sollya_lib_build_function_erfc(sollya_obj_t); sollya_obj_t sollya_lib_build_function_log1p(sollya_obj_t); sollya_obj_t sollya_lib_build_function_expm1(sollya_obj_t); sollya_obj_t sollya_lib_build_function_doubleextended(sollya_obj_t); sollya_obj_t sollya_lib_build_function_ceil(sollya_obj_t); sollya_obj_t sollya_lib_build_function_floor(sollya_obj_t); sollya_obj_t sollya_lib_build_function_nearestint(sollya_obj_t); sollya_obj_t sollya_lib_build_function_sinh(sollya_obj_t); sollya_obj_t sollya_lib_build_function_cosh(sollya_obj_t); sollya_obj_t sollya_lib_build_function_tanh(sollya_obj_t); sollya_obj_t sollya_lib_build_function_asinh(sollya_obj_t); sollya_obj_t sollya_lib_build_function_acosh(sollya_obj_t); sollya_obj_t sollya_lib_build_function_atanh(sollya_obj_t); sollya_obj_t sollya_lib_build_function_pi(void); sollya_obj_t sollya_lib_build_function_libraryconstant(char *, void (*)(mpfr_t, mp_prec_t)); sollya_obj_t sollya_lib_build_function_libraryfunction(sollya_obj_t, char *, int (*)(mpfi_t, mpfi_t, int)); sollya_obj_t sollya_lib_build_function_libraryconstant_with_data(char *, void (*)(mpfr_t, mp_prec_t, void *), void *, void (*)(void *)); sollya_obj_t sollya_lib_build_function_libraryfunction_with_data(sollya_obj_t, char *, int (*)(mpfi_t, mpfi_t, int, void *), void *, void (*)(void *)); sollya_obj_t sollya_lib_build_function_procedurefunction(sollya_obj_t, sollya_obj_t); /* Macros provided as shortcuts to functions sollya_lib_build_function_* */ #define SOLLYA_X_ sollya_lib_build_function_free_variable() #define SOLLYA_ADD(x,y) sollya_lib_build_function_add((x), (y)) #define SOLLYA_SUB(x,y) sollya_lib_build_function_sub((x), (y)) #define SOLLYA_MUL(x,y) sollya_lib_build_function_mul((x), (y)) #define SOLLYA_DIV(x,y) sollya_lib_build_function_div((x), (y)) #define SOLLYA_SQRT(x) sollya_lib_build_function_sqrt(x) #define SOLLYA_EXP(x) sollya_lib_build_function_exp(x) #define SOLLYA_LOG(x) sollya_lib_build_function_log(x) #define SOLLYA_LOG2(x) sollya_lib_build_function_log2(x) #define SOLLYA_LOG10(x) sollya_lib_build_function_log10(x) #define SOLLYA_SIN(x) sollya_lib_build_function_sin(x) #define SOLLYA_COS(x) sollya_lib_build_function_cos(x) #define SOLLYA_TAN(x) sollya_lib_build_function_tan(x) #define SOLLYA_ASIN(x) sollya_lib_build_function_asin(x) #define SOLLYA_ACOS(x) sollya_lib_build_function_acos(x) #define SOLLYA_ATAN(x) sollya_lib_build_function_atan(x) #define SOLLYA_POW(x,y) sollya_lib_build_function_pow((x), (y)) #define SOLLYA_NEG(x) sollya_lib_build_function_neg(x) #define SOLLYA_ABS(x) sollya_lib_build_function_abs(x) #define SOLLYA_D(x) sollya_lib_build_function_double(x) #define SOLLYA_SG(x) sollya_lib_build_function_single(x) #define SOLLYA_QD(x) sollya_lib_build_function_quad(x) #define SOLLYA_HP(x) sollya_lib_build_function_halfprecision(x) #define SOLLYA_DD(x) sollya_lib_build_function_double_double(x) #define SOLLYA_TD(x) sollya_lib_build_function_triple_double(x) #define SOLLYA_ERF(x) sollya_lib_build_function_erf(x) #define SOLLYA_ERFC(x) sollya_lib_build_function_erfc(x) #define SOLLYA_LOG1P(x) sollya_lib_build_function_log1p(x) #define SOLLYA_EXPM1(x) sollya_lib_build_function_expm1(x) #define SOLLYA_DE(x) sollya_lib_build_function_doubleextended(x) #define SOLLYA_CEIL(x) sollya_lib_build_function_ceil(x) #define SOLLYA_FLOOR(x) sollya_lib_build_function_floor(x) #define SOLLYA_NEARESTINT(x) sollya_lib_build_function_nearestint(x) #define SOLLYA_SINH(x) sollya_lib_build_function_sinh(x) #define SOLLYA_COSH(x) sollya_lib_build_function_cosh(x) #define SOLLYA_TANH(x) sollya_lib_build_function_tanh(x) #define SOLLYA_ASINH(x) sollya_lib_build_function_asinh(x) #define SOLLYA_ACOSH(x) sollya_lib_build_function_acosh(x) #define SOLLYA_ATANH(x) sollya_lib_build_function_atanh(x) #define SOLLYA_PI (sollya_lib_build_function_pi()) #define SOLLYA_CONST(x) sollya_lib_constant_from_double(x) #define SOLLYA_CONST_UI64(x) sollya_lib_constant_from_uint64(x) #define SOLLYA_CONST_SI64(x) sollya_lib_constant_from_int64(x) #ifdef __cplusplus } #endif #endif sollya-6.0+ds/sollya.h2m000066400000000000000000000006021300174114700151730ustar00rootroot00000000000000help2man include file for sollya man page [DESCRIPTION] .B sollya is both a tool environment and a library for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity (supremum) norm and a fast Remez algorithm. [SEE ALSO] .BR rlwrap (1) sollya-6.0+ds/sollya.map000066400000000000000000000002321300174114700152610ustar00rootroot00000000000000LIBSOLLYA_6.0.0 { global: sollya_lib_*; ## ## symbol added by hand: here to allow the interactive tool to use the library sollya_tool_main; local: *; }; sollya-6.0+ds/sturm.c000066400000000000000000000555671300174114700146220ustar00rootroot00000000000000/* Copyright 2008-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors M. Joldes, Ch. Lauter, S. Chevillard joldes@laas.fr christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also herefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include #include "chain.h" #include "general.h" #include "infnorm.h" #include "execute.h" #include "expression.h" #include /* fprintf, fopen, fclose, */ #include /* exit, free, mktemp */ #include /*these are the functions that work on mpq_t*/ int sturm_mpq(int *n, mpq_t *p, int p_degree, sollya_mpfi_t x, mp_prec_t precision); int polynomialDivide_mpq(mpq_t *quotient, int *quotient_degree, mpq_t *rest, int *rest_degree, mpq_t *p, int p_degree, mpq_t *q, int q_degree) ; int polynomialDeriv_mpq(mpq_t **derivCoeff, int *deriv_degree, mpq_t *p, int p_degree); int polynomialEval_mpq( mpq_t *res, mpq_t x, mpq_t *p, int p_degree, mp_prec_t precision); int sturm_mpfi(int *n, mpq_t *p, int p_degree, sollya_mpfi_t x, mp_prec_t precision); int polynomialDivide_mpfi(sollya_mpfi_t *quotient, int *quotient_degree, sollya_mpfi_t *rest, int *rest_degree, sollya_mpfi_t *p, int p_degree, sollya_mpfi_t *q, int q_degree, mp_prec_t prec) ; int polynomialDeriv_mpfi(sollya_mpfi_t **derivCoeff, int *deriv_degree, sollya_mpfi_t *p, int p_degree, mp_prec_t prec); int polynomialEval_mpfi( sollya_mpfi_t *res, sollya_mpfi_t x, sollya_mpfi_t *p, int p_degree); void printMpq(mpq_t x) { mpz_t num; mpz_t denom; mpfr_t numMpfr; mpfr_t denomMpfr; mp_prec_t prec; int p; unsigned int dyadicValue; mpz_init(num); mpz_init(denom); mpq_get_num(num,x); mpq_get_den(denom,x); prec = mpz_sizeinbase(num, 2); dyadicValue = mpz_scan1(num, 0); p = prec - dyadicValue; if (p < 12) prec = 12; else prec = p; mpfr_init2(numMpfr,prec); mpfr_set_z(numMpfr,num,GMP_RNDN); prec = mpz_sizeinbase(denom, 2); dyadicValue = mpz_scan1(denom, 0); p = prec - dyadicValue; if (p < 12) prec = 12; else prec = p; mpfr_init2(denomMpfr,prec); mpfr_set_z(denomMpfr,denom,GMP_RNDN); printValue(&numMpfr); sollyaPrintf(" / "); printValue(&denomMpfr); mpfr_clear(numMpfr); mpfr_clear(denomMpfr); mpz_clear(num); mpz_clear(denom); } char *sprintMpz(mpz_t z) { mpfr_t zMpfr; mp_prec_t prec; int p; unsigned int dyadicValue; char *res; if ((dyadic == 0) && (mpz_sgn(z) != 0)) { res = safeCalloc(mpz_sizeinbase(z, 10) + 2,sizeof(char)); mpz_get_str(res, 10, z); } else { prec = mpz_sizeinbase(z, 2); dyadicValue = mpz_scan1(z, 0); p = prec - dyadicValue; if (p < 12) prec = 12; else prec = p; mpfr_init2(zMpfr,prec); mpfr_set_z(zMpfr,z,GMP_RNDN); res = sprintValue(&zMpfr); mpfr_clear(zMpfr); } return res; } char *sprintMpq(mpq_t x) { mpz_t num; mpz_t denom; char *numStr, *denomStr, *res; mpz_init(num); mpz_init(denom); mpq_get_num(num,x); mpq_get_den(denom,x); numStr = sprintMpz(num); denomStr = sprintMpz(denom); res = (char *) safeCalloc(strlen(numStr) + strlen(denomStr) + 3 + 1, sizeof(char)); sprintf(res,"%s / %s",numStr,denomStr); safeFree(numStr); safeFree(denomStr); mpz_clear(num); mpz_clear(denom); return res; } int polynomialDeriv_mpq(mpq_t **derivCoeff, int *deriv_degree, mpq_t *p, int p_degree){ int i; mpq_t aux; if ((mpq_cmp_ui(p[p_degree],0,1))==0) return 0; if (p_degree>=1) *deriv_degree=p_degree-1; else if (p_degree==0) *deriv_degree=0; else return 0; *derivCoeff= (mpq_t *)safeMalloc((*deriv_degree+1)*sizeof(mpq_t)); mpq_init((*derivCoeff)[0]);/*is set to 0*/ mpq_init(aux); for (i=1; i<=p_degree;i++){ if (i-1!=0) mpq_init((*derivCoeff)[i-1]); mpq_set_ui(aux,i,1); mpq_mul((*derivCoeff)[i-1],p[i],aux); } mpq_clear(aux); return 1; } int __polynomialEval_mpq_sign_lazy(mpq_t res, mpq_t x, mpq_t *p, int n, mp_prec_t prec) { sollya_mpfi_t X, Y, C; int i, okay; okay = 0; sollya_mpfi_init2(X, prec); sollya_mpfi_init2(Y, prec); sollya_mpfi_init2(C, prec); sollya_mpfi_set_q(X, x); sollya_mpfi_set_ui(Y, 0u); for (i=n;i>=0;i--) { sollya_mpfi_set_q(C, p[i]); sollya_mpfi_mul(Y, X, Y); sollya_mpfi_add(Y, C, Y); } if (!(sollya_mpfi_has_nan(Y) || sollya_mpfi_has_infinity(Y))) { if (sollya_mpfi_is_zero(Y)) { mpq_set_ui(res,0u,1u); okay = 1; } else { if (!sollya_mpfi_has_zero(Y)) { if (sollya_mpfi_has_positive_numbers(Y)) { mpq_set_ui(res,1u,1u); } else { mpq_set_si(res,-1,1u); } okay = 1; } } } sollya_mpfi_clear(C); sollya_mpfi_clear(Y); sollya_mpfi_clear(X); return okay; } int polynomialEval_mpq( mpq_t *res, mpq_t x, mpq_t *p, int p_degree, mp_prec_t precision){ int i; mpq_t pow, aux; if (__polynomialEval_mpq_sign_lazy(*res, x, p, p_degree, 2 * tools_precision)) { return 1; } if (precision > 2 * tools_precision) { if (__polynomialEval_mpq_sign_lazy(*res, x, p, p_degree, precision)) { return 1; } } mpq_init(pow); mpq_set_ui(pow,1,1); mpq_init(aux); mpq_set_ui(aux,1,1); mpq_set_ui(*res,0,1);/*is set to 0/1*/ for (i=0; i<=p_degree; i++) { mpq_mul(aux,p[i],pow); mpq_add(*res, aux, *res); mpq_mul(pow, pow, x); } mpq_clear(aux); mpq_clear(pow); return 1; } int polynomialDivide_mpq(mpq_t *quotient, int *quotient_degree, mpq_t *rest, int *rest_degree, mpq_t *p, int p_degree, mpq_t *q, int q_degree) { int i,step,k; mpq_t aux; *quotient_degree=p_degree-q_degree; if (((mpq_cmp_ui(q[q_degree],0,1))==0) || ((mpq_cmp_ui(p[p_degree],0,1))==0)) return 0; mpq_init(aux); step=0; for (k=*quotient_degree; k>=0;k--) { mpq_set(quotient[k],p[p_degree-step]); mpq_div(quotient[k],quotient[k],q[q_degree]); for (i=q_degree; i>=0;i--){ mpq_mul(aux,quotient[k],q[i]); mpq_sub(p[p_degree-step-(q_degree-i)],p[p_degree-step-(q_degree-i)],aux); } step++; } *rest_degree=0; for (i=q_degree-1; i>=0; i--) { if ((mpq_cmp_ui(p[i],0,1))!=0){ *rest_degree=i; break; } } for (i=*rest_degree; i>=0; i--){ mpq_set(rest[i],p[i]); } mpq_clear(aux); return 1; } int sturm_mpq(int *n, mpq_t *p, int p_degree, sollya_mpfi_t x, mp_prec_t precision){ mpq_t *quotient, *rest, *dp; int quotient_degree, rest_degree, dp_degree; mpq_t *evalResA; mpq_t *evalResB; mpq_t *s0, *s1; mpq_t evalRes; int s0_degree, s1_degree; mpfr_t a,b; mpq_t aq,bq; int i,na,nb,prec,nrRoots; int varSignB,varSignA; prec=sollya_mpfi_get_prec(x); na=0; nb=0; nrRoots=0; mpfr_init2(a,prec); mpfr_init2(b,prec); sollya_mpfi_get_left(a,x); sollya_mpfi_get_right(b,x); mpq_init(aq); mpq_init(bq); mpfr_to_mpq(aq,a); mpfr_to_mpq(bq,b); evalResA = (mpq_t *)safeMalloc((p_degree+1)*sizeof(mpq_t)); evalResB = (mpq_t *)safeMalloc((p_degree+1)*sizeof(mpq_t)); for (i=0; i<=p_degree; i++){ mpq_init(evalResA[i]); mpq_init(evalResB[i]); } s0=(mpq_t *)safeMalloc((p_degree+1)*sizeof(mpq_t)); quotient=(mpq_t *)safeMalloc((p_degree+1)*sizeof(mpq_t)); rest=(mpq_t *)safeMalloc((p_degree+1)*sizeof(mpq_t)); for (i=0; i<=p_degree; i++){ mpq_init(quotient[i]); mpq_init(rest[i]); } s0_degree=p_degree; for (i=0; i<=p_degree; i++){ mpq_init(s0[i]); mpq_set(s0[i],p[i]); } polynomialDeriv_mpq(&dp, &dp_degree, p, p_degree); mpq_init(evalRes); polynomialEval_mpq( &evalRes, aq, s0, s0_degree, precision); if (mpq_cmp_ui(evalRes,0,1)!=0){ mpq_set(evalResA[na],evalRes); na++; } else nrRoots++; /*if the left extremity is a root we count it here since the number of sign changes gives the nr of distinct roots between a and b, a0){ polynomialEval_mpq( &evalRes, aq, dp, dp_degree, precision); if (mpq_cmp_ui(evalRes,0,1)!=0){ mpq_set(evalResA[na],evalRes); na++; } polynomialEval_mpq( &evalRes, bq, dp, dp_degree, precision); if (mpq_cmp_ui(evalRes,0,1)!=0){ mpq_set(evalResB[nb],evalRes); nb++; } } while (s1_degree!=0){ polynomialDivide_mpq(quotient, "ient_degree, rest, &rest_degree, s0, s0_degree, s1, s1_degree) ; s0_degree=s1_degree; for(i=0;i<=s0_degree;i++) mpq_set(s0[i],s1[i]); s1_degree=rest_degree; for(i=0;i<=s1_degree;i++){ mpq_set(s1[i],rest[i]); } for (i=0; i<=s1_degree; i++) mpq_neg(s1[i],s1[i]); polynomialEval_mpq( &evalRes, aq, s1, s1_degree, precision); if (mpq_cmp_ui(evalRes,0,1)!=0){ mpq_set(evalResA[na],evalRes); na++; } polynomialEval_mpq( &evalRes, bq, s1, s1_degree, precision); if (mpq_cmp_ui(evalRes,0,1)!=0){ mpq_set(evalResB[nb],evalRes); nb++; } } varSignA=0; for (i=1; i0)?(varSignA-varSignB+nrRoots):(varSignB-varSignA+nrRoots) ); for (i=0; i<=p_degree; i++){ mpq_clear(s0[i]); mpq_clear(quotient[i]); mpq_clear(rest[i]); mpq_clear(evalResA[i]); mpq_clear(evalResB[i]); } for (i=0; i<=dp_degree; i++){ mpq_clear(dp[i]); } safeFree(dp); safeFree(s0); safeFree(evalResA); safeFree(evalResB); safeFree(quotient); safeFree(rest); mpfr_clear(a); mpfr_clear(b); mpq_clear(aq); mpq_clear(bq); mpq_clear(evalRes); return 1; } int polynomialDeriv_mpfi(sollya_mpfi_t **derivCoeff, int *deriv_degree, sollya_mpfi_t *p, int p_degree, mp_prec_t prec){ int i; sollya_mpfi_t aux; if (sollya_mpfi_is_zero(p[p_degree])) return 0; if (p_degree>=1) *deriv_degree=p_degree-1; else if (p_degree==0) *deriv_degree=0; else return 0; *derivCoeff= (sollya_mpfi_t *)safeMalloc((*deriv_degree+1)*sizeof(sollya_mpfi_t)); sollya_mpfi_init2((*derivCoeff)[0],prec); sollya_mpfi_set_ui((*derivCoeff)[0],0); sollya_mpfi_init2(aux,prec); for (i=1; i<=p_degree;i++){ if (i-1!=0) sollya_mpfi_init2((*derivCoeff)[i-1],prec); sollya_mpfi_set_ui(aux,i); sollya_mpfi_mul((*derivCoeff)[i-1],p[i],aux); } sollya_mpfi_clear(aux); return 1; } int polynomialEval_mpfi( sollya_mpfi_t *res, sollya_mpfi_t x, sollya_mpfi_t *p, int p_degree){ int i; sollya_mpfi_set_ui(*res,0); sollya_mpfi_set(*res,p[p_degree]); for (i=p_degree-1;i>=0;i--) { sollya_mpfi_mul(*res,*res,x); sollya_mpfi_add(*res,*res,p[i]); } return 1; } int polynomialDivide_mpfi(sollya_mpfi_t *quotient, int *quotient_degree, sollya_mpfi_t *rest, int *rest_degree, sollya_mpfi_t *p, int p_degree, sollya_mpfi_t *q, int q_degree, mp_prec_t prec) { int i,step,k; sollya_mpfi_t aux; int okay; okay = 1; *quotient_degree=p_degree-q_degree; if (sollya_mpfi_is_zero(q[q_degree]) || sollya_mpfi_is_zero(p[p_degree])) return 0; sollya_mpfi_init2(aux,prec); step=0; for (k=*quotient_degree; (k>=0) && okay;k--) { sollya_mpfi_set(quotient[k],p[p_degree-step]); if (!sollya_mpfi_has_zero(q[q_degree])) sollya_mpfi_div(quotient[k],quotient[k],q[q_degree]); else { okay = 0; } if (okay) { for (i=q_degree; i>=0;i--){ sollya_mpfi_mul(aux,quotient[k],q[i]); sollya_mpfi_sub(p[p_degree-step-(q_degree-i)],p[p_degree-step-(q_degree-i)],aux); } step++; } } *rest_degree=0; for (i=q_degree-1; i>=0; i--) { if (!sollya_mpfi_is_zero(p[i])){ *rest_degree=i; break; } } for (i=*rest_degree; i>=0; i--){ sollya_mpfi_set(rest[i],p[i]); } sollya_mpfi_clear(aux); return okay; } int sturm_mpfi(int *n, mpq_t *pMpq, int p_degree, sollya_mpfi_t x, mp_prec_t precision){ sollya_mpfi_t *quotient, *rest, *dp; int quotient_degree, rest_degree, dp_degree; sollya_mpfi_t *evalResA; sollya_mpfi_t *evalResB; sollya_mpfi_t *s0, *s1; sollya_mpfi_t evalRes; int s0_degree, s1_degree; mpfr_t a,b; sollya_mpfi_t aq,bq; int i,na,nb,nrRoots; int varSignB,varSignA; sollya_mpfi_t *p; int resultat; int resDiv; mp_prec_t prec, tempprec, prec2; resultat = 1; prec = precision; for (i=0;i<=p_degree;i++) { tempprec = getMpzPrecision(mpq_numref(pMpq[i])) + 10; if (tempprec > prec) prec = tempprec; tempprec = getMpzPrecision(mpq_denref(pMpq[i])) + 10; if (tempprec > prec) prec = tempprec; } prec = 2 * prec; printMessage(2,SOLLYA_MSG_STURM_INTERVAL_A_CERTAIN_PREC_HAS_BEEN_CHOSEN,"Information: in sturm_mpfi: chosen working precision is %d\n",(int) prec); p = (sollya_mpfi_t *) safeCalloc(p_degree+1,sizeof(sollya_mpfi_t)); for (i=0;i<=p_degree;i++) { sollya_mpfi_init2(p[i],prec); sollya_mpfi_set_q(p[i],pMpq[i]); } prec2=sollya_mpfi_get_prec(x); if (prec > prec2) prec2 = prec; na=0; nb=0; nrRoots=0; mpfr_init2(a,prec2); mpfr_init2(b,prec2); sollya_mpfi_get_left(a,x); sollya_mpfi_get_right(b,x); sollya_mpfi_init2(aq,prec2); sollya_mpfi_init2(bq,prec2); sollya_mpfi_set_fr(aq,a); sollya_mpfi_set_fr(bq,b); sollya_mpfi_init2(evalRes,prec); evalResA = (sollya_mpfi_t *)safeMalloc((p_degree+1)*sizeof(sollya_mpfi_t)); evalResB = (sollya_mpfi_t *)safeMalloc((p_degree+1)*sizeof(sollya_mpfi_t)); s0=(sollya_mpfi_t *)safeMalloc((p_degree+1)*sizeof(sollya_mpfi_t)); quotient=(sollya_mpfi_t *)safeMalloc((p_degree+1)*sizeof(sollya_mpfi_t)); rest=(sollya_mpfi_t *)safeMalloc((p_degree+1)*sizeof(sollya_mpfi_t)); for (i=0; i<=p_degree; i++){ sollya_mpfi_init2(evalResA[i],prec); sollya_mpfi_init2(evalResB[i],prec); sollya_mpfi_init2(quotient[i],prec); sollya_mpfi_init2(rest[i],prec); } s0_degree=p_degree; for (i=0; i<=p_degree; i++){ sollya_mpfi_init2(s0[i],prec); sollya_mpfi_set(s0[i],p[i]); } polynomialDeriv_mpfi(&dp, &dp_degree, p, p_degree, prec); polynomialEval_mpfi( &evalRes, aq, s0, s0_degree); if (!sollya_mpfi_has_zero(evalRes)){ sollya_mpfi_set(evalResA[na],evalRes); na++; } else { if (sollya_mpfi_is_zero(evalRes)) nrRoots++; /*if the left extremity is a root we count it here since the number of sign changes gives the nr of distinct roots between a and b, a0){ polynomialEval_mpfi( &evalRes, aq, dp, dp_degree); if (!sollya_mpfi_has_zero(evalRes)){ sollya_mpfi_set(evalResA[na],evalRes); na++; } else { if (!sollya_mpfi_is_zero(evalRes)) resultat = 0; } polynomialEval_mpfi( &evalRes, bq, dp, dp_degree); if (!sollya_mpfi_has_zero(evalRes)){ sollya_mpfi_set(evalResB[nb],evalRes); nb++; } else { if (!sollya_mpfi_is_zero(evalRes)) resultat = 0; } } while ((s1_degree!=0) && resultat) { resDiv = polynomialDivide_mpfi(quotient, "ient_degree, rest, &rest_degree, s0, s0_degree, s1, s1_degree, prec); if (!resDiv) resultat = 0; else { s0_degree=s1_degree; for(i=0;i<=s0_degree;i++) { sollya_mpfi_set(s0[i],s1[i]); } s1_degree=rest_degree; for(i=0;i<=s1_degree;i++){ sollya_mpfi_set(s1[i],rest[i]); } for (i=0; i<=s1_degree; i++) sollya_mpfi_neg(s1[i],s1[i]); polynomialEval_mpfi( &evalRes, aq, s1, s1_degree); if (!sollya_mpfi_has_zero(evalRes)){ sollya_mpfi_set(evalResA[na],evalRes); na++; } else { if (!sollya_mpfi_is_zero(evalRes)) resultat = 0; } polynomialEval_mpfi( &evalRes, bq, s1, s1_degree); if (!sollya_mpfi_has_zero(evalRes)){ sollya_mpfi_set(evalResB[nb],evalRes); nb++; } else { if (!sollya_mpfi_is_zero(evalRes)) resultat = 0; } } } varSignA=0; for (i=1; i0)?(varSignA-varSignB+nrRoots):(varSignB-varSignA+nrRoots) ); for (i=0; i<=p_degree; i++){ sollya_mpfi_clear(evalResA[i]); sollya_mpfi_clear(evalResB[i]); sollya_mpfi_clear(s0[i]); sollya_mpfi_clear(quotient[i]); sollya_mpfi_clear(rest[i]); } for (i=0; i<=dp_degree; i++){ sollya_mpfi_clear(dp[i]); } safeFree(dp); safeFree(evalResA); safeFree(evalResB); safeFree(s0); safeFree(quotient); safeFree(rest); sollya_mpfi_clear(evalRes); mpfr_clear(a); mpfr_clear(b); sollya_mpfi_clear(aq); sollya_mpfi_clear(bq); for (i=0;i<=p_degree;i++) { sollya_mpfi_clear(p[i]); } safeFree(p); return resultat; } int getNrRoots(mpfr_t res, node *f, sollya_mpfi_t range, mp_prec_t precision, int silent) { sollya_mpfi_t x; int degree,i,nr; node **coefficients; mpq_t *qCoefficients; int r; mpfr_t tempValue, tempValue2; node *tempTree; int deg; int resMpfi; mp_prec_t prec; if (!isPolynomial(f)) { printMessage(1,SOLLYA_MSG_GIVEN_FUNCTION_IS_NO_POLYNOMIAL,"Warning: the given function must be a polynomial in this context.\n"); return 0; } if (!sollya_mpfi_bounded_p(range)) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_NO_CLOSED_INTERVAL_ON_THE_REALS,"Warning: the given interval must have finite bounds.\n"); return 0; } prec=precision; sollya_mpfi_init2(x, sollya_mpfi_get_prec(range)); sollya_mpfi_set(x, range); getCoefficients(°ree,&coefficients,f); if (degree < 0) { printMessage(1,SOLLYA_MSG_GIVEN_FUNCTION_IS_NO_POLYNOMIAL,"Warning: the given function is not a polynomial.\n"); sollya_mpfi_clear(x); return 0; } qCoefficients = (mpq_t *) safeCalloc(degree+1,sizeof(mpq_t)); for (i=0;i<=degree;i++) { mpq_init(qCoefficients[i]); } mpfr_init2(tempValue,prec); mpfr_set_d(tempValue,1.0,GMP_RNDN); mpfr_init2(tempValue2,prec); for (i=0;i<=degree;i++) { if (coefficients[i] != NULL) { tempTree = simplifyTreeErrorfree(coefficients[i]); free_memory(coefficients[i]); if (!isConstant(tempTree)) { sollyaFprintf(stderr,"Error: getNrRoots: an error occurred. A polynomial coefficient is not constant.\n"); exit(1); } if (accessThruMemRef(tempTree)->nodeType != CONSTANT) { if (tryEvaluateConstantTermToMpq(qCoefficients[i], tempTree)) { printMessage(3,SOLLYA_MSG_STURM_COEFF_EVALUATED_TO_RATIONAL_NUMBER,"Information: in getNrRoots: evaluated the %dth coefficient to %r\n",i,qCoefficients[i]); } else { r=evaluateFaithful(tempValue2, tempTree, tempValue, prec); if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_STURM_COEFF_NOT_CONSTANT_NOR_RATIONAL_ROUNDING,"Warning: the %dth coefficient of the polynomial is neither a floating point\n",i); printMessage(1,SOLLYA_MSG_CONTINUATION,"constant nor can be evaluated without rounding to a floating point constant.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Will faithfully evaluate it with the current precision (%d bits) \n",((mpfr_get_prec(tempValue2) > prec) ? mpfr_get_prec(tempValue2) : prec)); } if (!r){ mpfr_set_ui(tempValue2,0,GMP_RNDN); if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_STURM_COEFF_ROUNDED_TO_ZERO,"Warning: Rounded the coefficient %d to 0.\n",i); } } mpfr_to_mpq(qCoefficients[i], tempValue2); printMessage(3,SOLLYA_MSG_STURM_COEFF_EVALUATED_TO_RATIONAL_NUMBER,"Information: evaluated the %dth coefficient to %r\n",i,qCoefficients[i]); } } else { mpfr_to_mpq(qCoefficients[i], *(accessThruMemRef(tempTree)->value)); } free_memory(tempTree); } else { mpq_set_ui(qCoefficients[i],0,1); } } safeFree(coefficients); mpfr_clear(tempValue); mpfr_clear(tempValue2); for(deg = degree; deg >= 0 && (mpq_sgn(qCoefficients[deg]) == 0); deg--); if (deg >= 0) { resMpfi = sturm_mpfi(&nr, qCoefficients, deg,x,precision); if (!resMpfi) { if (!silent) { printMessage(2,SOLLYA_MSG_STURM_USING_SLOWER_ALGORITHM_ON_RATIONALS,"Information: using slower GMP MPQ version\n"); } sturm_mpq(&nr, qCoefficients, deg,x,precision); } mpfr_set_si(res,nr,GMP_RNDN); } else { if (!silent) { printMessage(1,SOLLYA_MSG_STURM_POLY_IS_ZERO_POLY,"Warning: the given polynomial is the zero polynomial. Its number of zeros is infinite.\n"); } mpfr_set_inf(res,1); } sollya_mpfi_clear(x); for (i=0;i<=degree;i++) { mpq_clear(qCoefficients[i]); } safeFree(qCoefficients); return 1; } sollya-6.0+ds/sturm.h000066400000000000000000000051331300174114700146070ustar00rootroot00000000000000/* Copyright 2008-2014 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors Ch. Lauter, S. Chevillard, N. Jourdan christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org nicolas.jourdan@ens-lyon.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef STURM_H #define STURM_H #include #include "mpfi-compat.h" #include "expression.h" int getNrRoots(mpfr_t res, node *f, sollya_mpfi_t range, mp_prec_t prec, int silent); char *sprintMpq(mpq_t x); char *sprintMpz(mpz_t z); #endif /* ifdef STURM_H*/ sollya-6.0+ds/supnorm.c000066400000000000000000002523631300174114700151440ustar00rootroot00000000000000/* Copyright 2010-2016 by Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, M. Joldes, S. Chevillard christoph.lauter@ens-lyon.org joldes@laas.fr sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "supnorm.h" #include #include "mpfi-compat.h" #include "execute.h" #include #include #include "expression.h" #include "infnorm.h" #include "autodiff.h" #include "taylorform.h" #include "chain.h" #include "sturm.h" #include "general.h" #include "infnorm.h" #include "remez.h" #include "external.h" /* Add error codes here as needed. When adding error codes, add warning messages below (in supremumNormBisect()). In case of an error, return SUPNORM_SOME_ERROR unless a precise understanding which phase failed is available. */ #define SUPNORM_NO_ERROR 0 /* No error */ #define SUPNORM_SOME_ERROR -1 /* Some default error, don't know what caused it */ #define SUPNORM_NO_TAYLOR 1 /* Couldn't compute a Taylor */ #define SUPNORM_NOT_ENOUGH_WORKING_PRECISION 2 /* Got the impression the precision was not enough */ #define SUPNORM_SINGULARITY_NOT_REMOVED 3 /* Couldn't divide poly by (x-x0)^k */ #define SUPNORM_COULD_NOT_SHOW_POSITIVITY 4 /* Could not validate everything by showing positivity */ #define SUPNORM_SINGULARITY_NOT_DETECTED 5 /* Failed to compute an approximate value to a singularity */ #define SUPNORM_ANOTHER_SINGULARITY_IN_DOM 6 /* There's at least two singularities, more bisection needed */ #define SUPNORM_CANNOT_COMPUTE_LOWER_BOUND 7 /* For some reason, we cannot compute a valid lower bound */ #define SUPNORM_CANNOT_COMPUTE_ABSOLUTE_INF 8 /* For some reason, we cannot compute a valid lower bound on the absolute value of func */ #define SUPNORM_CANNOT_DETERMINE_SIGN_OF_T 9 /* For some reason, we cannot determine the sign of the Taylor polynomial at a point */ #define SUPNORM_CANNOT_DETERMINE_ORDER_OF_SINGU 10 /* Could not correctly determine the order of the pole (error intervals not [0]) */ /* Exactly add two polynomials For each monomial degree do: In the case when both monomials are floating-point numbers, return a monomial that is a floating-point number. In the case when one of the monomials is a ratio of two floating-point numbers and the other is a floating-point number or a ratio of floating-point numbers, return a ratio of floating-point numbers. Otherwise, return a monomial representing the sum of the two expressions. This version is a first, crude version. We can do better if need be. */ node *addPolynomialsExactly(node *p1, node *p2) { node *temp, *res, *temp2; if (!(isPolynomial(p1) && isPolynomial(p2))) { temp = makeAdd(copyTree(p1),copyTree(p2)); res = simplifyTreeErrorfree(temp); free_memory(temp); return res; } /* Here, we know that we have polynomials */ temp = makeAdd(copyTree(p1),copyTree(p2)); temp2 = horner(temp); res = simplifyRationalErrorfree(temp2); free_memory(temp); free_memory(temp2); return res; } /* Exactly subtract two polynomials For each monomial degree do: In the case when both monomials are floating-point numbers, return a monomial that is a floating-point number. In the case when one of the monomials is a ratio of two floating-point numbers and the other is a floating-point number or a ratio of floating-point numbers, return a ratio of floating-point numbers. Otherwise, return a monomial representing the sum of the two expressions. This version is a first, crude version. We can do better if need be. */ node *subPolynomialsExactly(node *p1, node *p2) { node *temp, *res, *temp2; if (!(isPolynomial(p1) && isPolynomial(p2))) { temp = makeSub(copyTree(p1),copyTree(p2)); res = simplifyTreeErrorfree(temp); free_memory(temp); return res; } /* Here, we know that we have polynomials */ temp = makeSub(copyTree(p1),copyTree(p2)); temp2 = horner(temp); res = simplifyRationalErrorfree(temp2); free_memory(temp); free_memory(temp2); return res; } /* Exactly scale a polynomial Return sum (s * c_i) * x^i for s and p(x) = sum c_i * x^i Wherever possible (even when more precision is needed), simplify the expressions s * c_i in the monomials. This version is a first, crude version. We can do better if need be. */ node *scalePolynomialExactly(node *poly, mpfr_t scale) { node *temp, *res, *temp2; if (!(isPolynomial(poly))) { temp = makeMul(copyTree(poly),makeConstant(scale)); res = simplifyTreeErrorfree(temp); free_memory(temp); return res; } /* Here, we know that we have a polynomial */ temp = makeMul(copyTree(poly),makeConstant(scale)); temp2 = horner(temp); res = simplifyRationalErrorfree(temp2); free_memory(temp); free_memory(temp2); return res; } /* Divide a polynomial by (x - x0)^k and check if rest is zero The function tries to divide the polynomial poly by (x - x0)^k through long division. If the division rest is zero, i.e. if poly/(x - x0)^k is a polynomial, the function returns a non-zero value and sets pTilde to poly/(x - x0)^k. Otherwise, if poly is not a polynomial or if poly/(x - x0)^k is not a polynomial because the division leaves a rest, the function returns zero and does not touch pTilde. */ int dividePolyByXMinusX0ToTheK(node **pTilde, node *poly, mpfr_t x0, int k, mp_prec_t prec) { int okay, degPoly, degQuotient; node *myPTilde; node *shifterForth, *shifterBack, *pShifted, *xToK, *pShiftedHorner, *quotient; node *quotientSimplified, *quotientShifted, *quotientShiftedHorner; mpfr_t kAsMpfr; UNUSED_PARAM(prec); /* Determine the degree of poly and, at the same time, if it really is a polynomial */ degPoly = getDegree(poly); /* We can't do anything if poly isn't a polynomial */ if (degPoly < 0) return 0; /* The division will fail if k is greater than the degree of poly */ if (k > degPoly) return 0; /* Cannot divide if (x-x0)^k is not a polynomial */ if (k < 0) return 0; /* Division by (x-x0)^0 = 1 is trivial */ if (k == 0) { *pTilde = copyTree(poly); return 1; } /* Here we know that degPoly >= k >= 1 */ okay = 0; myPTilde = NULL; /* We shift poly: pShifted(x) = poly(x + x0) */ shifterForth = makeAdd(makeVariable(),makeConstant(x0)); pShifted = substitute(poly,shifterForth); pShiftedHorner = horner(pShifted); /* Now build x^k */ mpfr_init2(kAsMpfr,5 + 8 * sizeof(k)); mpfr_set_si(kAsMpfr,k,GMP_RNDN); /* exact as per what precedes */ xToK = makePow(makeVariable(),makeConstant(kAsMpfr)); /* Now build quotient = pShifted/xToK */ quotient = makeDiv(pShiftedHorner,xToK); /* Now simplify quotient */ quotientSimplified = simplifyRationalErrorfree(quotient); /* Now shift the quotient back: quotientShifted(x) = quotientSimplified(x - x0) */ shifterBack = makeSub(makeVariable(),makeConstant(x0)); quotientShifted = substitute(quotientSimplified,shifterBack); quotientShiftedHorner = horner(quotientShifted); /* Try to get the degree of quotientShiftedHorner If it is non-negative, quotientShiftedHorner is a polynomial If it is equal to degPoly - k, the division worked */ degQuotient = getDegree(quotientShiftedHorner); if ((degQuotient >= 0) && (degQuotient == (degPoly - k))) { okay = 1; myPTilde = copyTree(quotientShiftedHorner); } /* Free all locally used memory */ free_memory(shifterForth); free_memory(pShifted); /* pSHiftedHorner gets freed by freeing quotient */ /* xToK gets freed by freeing quotient */ free_memory(quotient); free_memory(quotientSimplified); free_memory(shifterBack); free_memory(quotientShifted); free_memory(quotientShiftedHorner); mpfr_clear(kAsMpfr); /* Set result if appropriate and return */ if (myPTilde == NULL) okay = 0; if (okay) *pTilde = myPTilde; return okay; } /* Show positivity of a polynomial using the Sturm algorithm For a polynomial poly and a domain dom, return zero if there is a point in dom at which poly is non-positive, return a non-zero value otherwise. Return zero for expressions that are no polynomial. Return zero for domains that are not bounded by finite numbers. Return zero if something goes wrong in the Sturm routine. Generally, return zero in case of a doubt (not enough precision etc.) */ int showPositivity(node * poly, sollya_mpfi_t dom, mp_prec_t prec) { int res, positive, nbRoots; mpfr_t a, b, c, y, nbRootsMpfr; mp_prec_t pp; if (!isPolynomial(poly)) return 0; if (!sollya_mpfi_bounded_p(dom)) return 0; mpfr_init2(nbRootsMpfr,8 * sizeof(int)); res = getNrRoots(nbRootsMpfr, poly, dom, prec, 0); if (!mpfr_number_p(nbRootsMpfr)) { nbRoots = 1; } else { nbRoots = mpfr_get_si(nbRootsMpfr,GMP_RNDU); } mpfr_clear(nbRootsMpfr); if (!res) return 0; if (nbRoots != 0) return 0; /* Here, we know that we do not cross the abscissa We still have to establish that at some point (in the middle of the interval), we have a positive value. */ pp = sollya_mpfi_get_prec(dom); mpfr_init2(a,pp); mpfr_init2(b,pp); mpfr_init2(c,pp+1); sollya_mpfi_get_left(a,dom); sollya_mpfi_get_right(b,dom); mpfr_add(c,a,b,GMP_RNDN); mpfr_div_2ui(c,c,1,GMP_RNDN); mpfr_init2(y,16); res = evaluateFaithful(y, poly, c, prec); positive = 1; if (!res) positive = 0; if (!mpfr_number_p(y)) positive = 0; if (mpfr_sgn(y) <= 0) positive = 0; mpfr_clear(a); mpfr_clear(b); mpfr_clear(c); mpfr_clear(y); return positive; } /* Compute a value result such that forall x in dom abs(func(x)) > result If such a minimum cannot easily be computed, set result to 0 and return 0. Otherwise return a non-zero value. */ int computeAbsoluteMinimum(mpfr_t result, node *func, sollya_mpfi_t dom, mp_prec_t prec) { sollya_mpfi_t y; mpfr_t reslt; mpfr_t yl, yr; int res; node *deriv; mpfr_init2(reslt,mpfr_get_prec(result)); res = 0; mpfr_set_si(result,0,GMP_RNDN); sollya_mpfi_init2(y,prec); mpfr_init2(yl,prec); mpfr_init2(yr,prec); evaluateInterval(y, func, NULL, dom); sollya_mpfi_get_left(yl,y); sollya_mpfi_get_right(yr,y); if (mpfr_number_p(yl) && mpfr_number_p(yr)) { if (mpfr_sgn(yl) * mpfr_sgn(yr) > 0) { /* The interval does not cross the y-axis, we can take the absolute minimum */ sollya_mpfi_abs(y,y); sollya_mpfi_get_left(reslt,y); res = 1; } else { /* The interval does cross the y-axis, we give it another try with a derivative */ deriv = differentiate(func); evaluateInterval(y, func, deriv, dom); sollya_mpfi_get_left(yl,y); sollya_mpfi_get_right(yr,y); if ((mpfr_number_p(yl) && mpfr_number_p(yr)) && (mpfr_sgn(yl) * mpfr_sgn(yr) > 0)) { /* Here, we have a result that does not cross the y-axis */ sollya_mpfi_abs(y,y); sollya_mpfi_get_left(reslt,y); res = 1; } free_memory(deriv); } } sollya_mpfi_clear(y); mpfr_clear(yr); mpfr_clear(yl); mpfr_set(result,reslt,GMP_RNDN); /* exact */ mpfr_clear(reslt); return res; } /* Determine the sign of func at x Set sign to 1 if it can be shown that func(x) > 0, set sign to -1 if it can be shown that func(x) < 0. Return a non-zero value in both cases. Otherwise, if the sign cannot be safely determined, return zero and set sign to zero. */ int determineSignAtPoint(int *sign, node *func, mpfr_t x, mp_prec_t prec) { int okay, mySign; sollya_mpfi_t yAsInterv, xAsInterv; mpfr_t yLeft, yRight; okay = 1; mySign = 0; sollya_mpfi_init2(xAsInterv,mpfr_get_prec(x)); sollya_mpfi_init2(yAsInterv,prec); sollya_mpfi_set_fr(xAsInterv,x); mpfr_init2(yLeft,prec); mpfr_init2(yRight,prec); evaluateInterval(yAsInterv, func, NULL, xAsInterv); sollya_mpfi_get_left(yLeft,yAsInterv); sollya_mpfi_get_right(yRight,yAsInterv); if ((!mpfr_number_p(yLeft)) || (!mpfr_number_p(yRight)) || (mpfr_zero_p(yLeft)) || (mpfr_zero_p(yRight))) { okay = 0; } else { if (mpfr_sgn(yLeft) * mpfr_sgn(yRight) < 0) okay = 0; else mySign = (mpfr_sgn(yLeft) < 0) ? (-1) : 1; } sollya_mpfi_clear(xAsInterv); sollya_mpfi_clear(yAsInterv); mpfr_clear(yLeft); mpfr_clear(yRight); /* Return the result */ if (mySign == 0) okay = 0; if (okay) *sign = mySign; else *sign = 0; return okay; } /* Compute a certified lower bound ell to the supremum norm of eps = poly - func resp. eps = poly / func - 1 If mode is zero, let eps = poly - func else let eps = poly / func - 1. Compute a value ell such that for all x in dom, abs(eps(x)) >= ell. Additionally, if things are pretty, make sure that || eps || <= ell * (1 + abs(gamma)). If everything works fine, set ell to the computed value, ADAPTING THE PRECISION OF THE mpfr_t VARIABLE ell IF NECESSARY and return a non-zero value. Otherwise, set ell to zero and return zero. This case happens when gamma is not a non-zero number. The function assumes that poly is a polynomial but will work even if poly is not a polynomial. However, it will not try to ensure that ell approximates ||eps|| up to a relative error of abs(gamma). The procedure determines its working precision itself where possible. It hence disregards the prec parameter unless the determination of the working precision fails. */ int computeSupnormLowerBound(mpfr_t ell, node *poly, node *func, sollya_mpfi_t dom, mpfr_t gamma, int mode, mp_prec_t prec) { node *eps; node *epsPrime; int res; mpfr_t l, y; mpfr_t temp, absGamma; mp_prec_t pp, pr; int deg; chain *possibleExtrema; mpfr_t a, b, lMinusUlp; unsigned long int samplePoints; mpfr_t *aBound, *bBound; chain *curr; int resEval; if (mpfr_zero_p(gamma) || (!mpfr_number_p(gamma))) { mpfr_set_si(ell,0,GMP_RNDN); return 0; } pr = sollya_mpfi_get_prec(dom); mpfr_init2(a,pr); mpfr_init2(b,pr); sollya_mpfi_get_left(a,dom); sollya_mpfi_get_right(b,dom); if (!(mpfr_number_p(a) && mpfr_number_p(b))) { mpfr_clear(a); mpfr_clear(b); mpfr_set_si(ell,0,GMP_RNDN); return 0; } if (mode == ABSOLUTE) { eps = makeSub(copyTree(poly),copyTree(func)); epsPrime = makeSub(differentiate(poly),differentiate(func)); } else { eps = makeSub(makeDiv(copyTree(poly),copyTree(func)),makeConstantDouble(1.0)); epsPrime = makeSub(makeMul(differentiate(poly),copyTree(func)),makeMul(copyTree(poly),differentiate(func))); } mpfr_init2(temp,10 + 8 * ((sizeof(unsigned int) > sizeof(mp_prec_t)) ? sizeof(unsigned int) : sizeof(mp_prec_t))); mpfr_init2(absGamma,mpfr_get_prec(gamma)); mpfr_abs(absGamma,gamma,GMP_RNDN); mpfr_log2(temp,absGamma,GMP_RNDD); mpfr_neg(temp,temp,GMP_RNDU); mpfr_ceil(temp,temp); if (mpfr_sgn(temp) > 0) { pp = 10 + mpfr_get_ui(temp,GMP_RNDU); if (pp < 12) pp = 12; } else { pp = prec; if (pp < 12) pp = 12; } deg = getDegree(poly); if (deg >= 0) { samplePoints = 4 * deg + 1; } else { samplePoints = getToolPoints(); } possibleExtrema = uncertifiedFindZeros(epsPrime, a, b, samplePoints, 6 + (pp / 2)); /* We now really define epsPrime as the derivative of eps (for further use with evaluateFaithful) */ if (mode != ABSOLUTE) { epsPrime = makeDiv(epsPrime, makePow(copyTree(func), makeConstantDouble(2.0))); } aBound = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); bBound = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*aBound,pr); mpfr_set(*aBound,a,GMP_RNDD); /* exact */ mpfr_init2(*bBound,pr); mpfr_set(*bBound,b,GMP_RNDU); /* exact */ possibleExtrema = addElement(addElement(possibleExtrema,aBound),bBound); mpfr_init2(l,pp + 5); mpfr_init2(lMinusUlp,pp); mpfr_init2(y,pp + 10); mpfr_set_si(l,0,GMP_RNDN); res = 1; for (curr=possibleExtrema;curr!=NULL;curr=curr->next) { mpfr_set(lMinusUlp,l,GMP_RNDD); /* Take latest maximum minus a couple ulps as a cut off for evaluation */ if (!mpfr_zero_p(lMinusUlp)) mpfr_nextbelow(lMinusUlp); resEval = evaluateFaithfulWithCutOffFast(y, eps, epsPrime, *((mpfr_t *) (curr->value)), lMinusUlp, pp + 10); if ((resEval != 0) && (resEval != 3) && (mpfr_number_p(y))) { /* Evaluation okay ? */ mpfr_abs(y,y,GMP_RNDN); /* exact */ if (mpfr_sgn(y) > 0) { mpfr_nextbelow(y); /* Compensate for faithful rounding */ mpfr_nextbelow(y); } if (mpfr_cmp(y,l) > 0) { /* New absolute maximum */ mpfr_set(l,y,GMP_RNDD); /* Round down because we produce a lower bound */ } } else { /* Here, something went wrong with the evaluation */ res = 0; break; } } if (res) { if (mpfr_get_prec(ell) < mpfr_get_prec(l)) { mpfr_set_prec(ell,mpfr_get_prec(l)); } mpfr_set(ell,l,GMP_RNDN); /* exact */ } else { mpfr_set_si(ell,0,GMP_RNDN); } freeChain(possibleExtrema, freeMpfrPtr); mpfr_clear(l); mpfr_clear(lMinusUlp); mpfr_clear(y); mpfr_clear(a); mpfr_clear(b); mpfr_clear(absGamma); mpfr_clear(temp); free_memory(eps); free_memory(epsPrime); return res; } /* A small wrapper around taylorform Compute a polynomial poly and a bounding interval delta such that ( func - poly ) in delta. In the case when singu is NULL, use the absolute technique for taylorform, developing func at x0 = mid(dom), otherwise use the relative technique at x0 = singu. In any case, return delta in absolute terms. Account for all errors in the coefficients (as returned by taylorform). Check if the final interval delta is bounded, i.e. has finite real bounds (no NaNs, no Infs). No check is performed to know if the coefficients of the returned polynomial are finite real numbers. In the case when this happens whilst the bound delta is finite, the function returns success. Return a non-zero value on success, and a zero value otherwise. If a zero value is returned, the pointer assigned to *poly is invalid and delta is left untouched. This means, on failure, the function frees all memory allocated. Use prec as the working precision. HACK ALERT: currently, taylorform does not take any prec argument. This means we have to modify the global precision of the tool. We reset it correctly in the usual case but if a Ctrl-C pops in in the middle, it will not be reset. This should be changed in the future. IMPORTANT REMARK: as does the taylorform command, the computed polynomial here must be translated in order to get the right polynomial (i.e. T = poly(x-x0) is the true Taylor polynomial). */ int computeTaylorModel(node **poly, sollya_mpfi_t delta, node *func, sollya_mpfi_t dom, int n, mpfr_t *singu, mp_prec_t prec) { mp_prec_t oldToolPrec, ppp; int res; mpfr_t x0; int mode; sollya_mpfi_t *myDelta; sollya_mpfi_t myDom, temp, x0AsInterval, nAsInterval, lagrangeDelta, shiftedDom; chain *errors; chain *revertedErrors; chain *curr; node *myPoly; if (!sollya_mpfi_bounded_p(dom)) return 0; oldToolPrec = getToolPrecision(); setToolPrecision(prec); if (singu == NULL) { mpfr_init2(x0,sollya_mpfi_get_prec(dom) + 1); sollya_mpfi_mid(x0,dom); mode = ABSOLUTE; } else { mpfr_init2(x0,mpfr_get_prec(*singu)); mpfr_set(x0,*singu,GMP_RNDN); /* exact */ mode = RELATIVE; } sollya_mpfi_init2(x0AsInterval,mpfr_get_prec(x0)); sollya_mpfi_set_fr(x0AsInterval,x0); /* exact */ sollya_mpfi_init2(myDom, sollya_mpfi_get_prec(dom)); sollya_mpfi_set(myDom, dom); myDelta = NULL; errors = NULL; taylorform(&myPoly, &errors, &myDelta, func, n, &x0AsInterval, &myDom, mode); res = 1; if ( (myDelta == NULL) || (errors == NULL) || (!sollya_mpfi_bounded_p(*myDelta)) ) res = 0; else { if (mode == ABSOLUTE) { /* Set lagrangeDelta = myDelta */ sollya_mpfi_init2(lagrangeDelta,sollya_mpfi_get_prec(*myDelta)); sollya_mpfi_set(lagrangeDelta,*myDelta); } else { /* Compute lagrangeDelta = myDelta * (dom - x0)^n */ ppp = sollya_mpfi_get_prec(dom); sollya_mpfi_init2(temp,ppp); sollya_mpfi_init2(lagrangeDelta,ppp); sollya_mpfi_sub(temp,dom,x0AsInterval); sollya_mpfi_init2(nAsInterval,5 + 8 * sizeof(int)); sollya_mpfi_set_si(nAsInterval,n); /* exact */ sollya_mpfi_pow(temp, temp, nAsInterval); sollya_mpfi_mul(temp,temp,*myDelta); if (!sollya_mpfi_bounded_p(temp)) res = 0; else sollya_mpfi_set(lagrangeDelta,temp); sollya_mpfi_clear(temp); sollya_mpfi_clear(nAsInterval); } if (res) { /* Here, we have lagrangeDelta such that (func - (poly(x-x0) + sum errors[i] * (x-x0)^i)) in lagrangeDelta We now add (sum errors[i] * x^i)(dom-x0) to lagrangeDelta. We use a simple Horner to perform that evalutation/ bounding. The error list starts with c0, so we have to revert it before the Horner. HACK ALERT: We will allocate only the containers to the reverted list but we just copy over the pointers to the MPFIs. So when free'ing the reverted list, we must not free the MPFIs, as they will be free'd when free'ing the orginal list. */ sollya_mpfi_init2(temp,sollya_mpfi_get_prec(delta)); sollya_mpfi_init2(shiftedDom,sollya_mpfi_get_prec(dom)); sollya_mpfi_sub(shiftedDom,dom,x0AsInterval); revertedErrors = NULL; for (curr=errors;curr!=NULL;curr=curr->next) revertedErrors = addElement(revertedErrors,curr->value); /* Horner */ curr = revertedErrors; sollya_mpfi_set(temp,*((sollya_mpfi_t *) (curr->value))); for (curr=curr->next; curr != NULL; curr = curr->next) { sollya_mpfi_mul(temp,temp,shiftedDom); sollya_mpfi_add(temp,temp,*((sollya_mpfi_t *) (curr->value))); } freeChain(revertedErrors,freeNoPointer); sollya_mpfi_add(lagrangeDelta,lagrangeDelta,temp); if (!sollya_mpfi_bounded_p(lagrangeDelta)) res = 0; else sollya_mpfi_set(delta,lagrangeDelta); sollya_mpfi_clear(temp); sollya_mpfi_clear(shiftedDom); } sollya_mpfi_clear(lagrangeDelta); sollya_mpfi_clear(*myDelta); safeFree(myDelta); } if (!res) free_memory(myPoly); else *poly=myPoly; freeChain(errors,freeMpfiPtr); sollya_mpfi_clear(myDom); sollya_mpfi_clear(x0AsInterval); mpfr_clear(x0); setToolPrecision(oldToolPrec); return res; } /* Tries to compute a Taylor expansion poly of func with degree n such that || poly(x-x0) - func || <= delta. If such an expansion can be computed using computeTaylorForm, assign that expansion to *poly and return a non-zero value. Otherwise, do not touch the pointer *poly and return zero. This means, when the computation fails, all memory allocated for the computation has been freed. Be aware that poly is not checked to have finite, real coefficients. It is just ensured that the Lagrange and coefficient approximation error of the Taylor form is finite and contained in [-delta, delta]. The parameters singu and prec are passed directly to computeTaylorForm. IMPORTANT REMARK: this is an untranslated polynomial (see computeTaylorModel). */ int checkDegreeTaylorModel(node **poly, node *func, sollya_mpfi_t dom, mpfr_t delta, int n, mpfr_t *singu, mp_prec_t prec) { node *myPoly; int res, resCompute; sollya_mpfi_t computedDelta; mpfr_t supAbsComputedDelta; res = 0; sollya_mpfi_init2(computedDelta,prec); resCompute = computeTaylorModel(&myPoly, computedDelta, func, dom, n, singu, prec); if (resCompute) { /* Here, we have to check if sup(abs(computedDelta)) <= delta */ sollya_mpfi_abs(computedDelta,computedDelta); mpfr_init2(supAbsComputedDelta,prec); sollya_mpfi_get_right(supAbsComputedDelta,computedDelta); if (mpfr_number_p(supAbsComputedDelta) && mpfr_number_p(delta) && (mpfr_cmp(supAbsComputedDelta,delta) <= 0)) { /* Here, we have a polynomial that satisfies the bound */ *poly = myPoly; res = 1; } else { /* Here, we got a polynomial and a computedDelta, but the error is too large. So we have to free the polynomial */ free_memory(myPoly); res = 0; } mpfr_clear(supAbsComputedDelta); } else { /* Here, we could not compute a Taylor Model We simply return zero, without touching at poly. The computeTaylorModel function ensures that myPoly has not been assigned a newly allocated polynomial. */ res = 0; } sollya_mpfi_clear(computedDelta); return res; } /* Checks if poly is a polynomial with coefficients that are all fully evaluated MPFR constants each of which is finite and real (not NaN, not Inf). Returns a non-zero value if poly fullfills the constraints and zero otherwise. I believe that this code is useless. It is here to cover the case where checkDegreeTaylorModel would successfully return, but the returned polynomial would contain non-dyadic coefficients. I think that this cannot happen. */ int isPolynomialWithConstantDyadicFiniteRealCoefficients(node *poly) { node **coefficients; int degree, i, res; if (!isPolynomial(poly)) return 0; getCoefficients(°ree, &coefficients, poly); if (degree < 0) return 0; res = 1; for (i=0;i<=degree;i++) { if (coefficients[i] != NULL) { if ((!(accessThruMemRef(coefficients[i])->nodeType == CONSTANT)) || (!mpfr_number_p(*(accessThruMemRef(coefficients[i])->value)))) { res = 0; break; } } } for (i=0;i<=degree;i++) { if (coefficients[i] != NULL) free_memory(coefficients[i]); } safeFree(coefficients); return res; } /* Compute a Taylor Model poly for func such that - for all x in dom, abs(func(x) - poly(x)) <= delta, - the degree of poly is the least possible of the polynomials computable with the tool that satisfy the bound, - the degree of poly is less than or equal to maximumAllowedN, - the polynomial has finite, real coefficients that are MPFR constants. If such a polynomial is found, assign it to *poly and return a non-zero value. Otherwise, do not touch *poly and return zero. If singu is NULL, develop func at the midpoint of dom, using the absolute error mode of the Taylor Model code suite. Otherwise, develop func at singu, using the relative error mode of the Taylor Model code. Perform the computations with a working precision prec. */ int computeTaylorModelOfLeastDegree(node **poly, node *func, sollya_mpfi_t dom, mpfr_t delta, int maximumAllowedN, mpfr_t *singu, mp_prec_t prec) { node *myPoly; node *bestPoly; node *shifterBack; node *pShifted; mpfr_t x0; int n, okay, resCompute, nMin, nMax; nMax = 1; nMin = 0; okay = 0; bestPoly = NULL; while (nMax < 2*maximumAllowedN) { if (nMax > maximumAllowedN) nMax = maximumAllowedN; resCompute = checkDegreeTaylorModel(&myPoly, func, dom, delta, nMax, singu, prec); if (resCompute) { free_memory(bestPoly); /* does nothing if bestPoly == NULL */ bestPoly = myPoly; okay = 1; break; } nMin = nMax; nMax <<= 1; } if (!okay) return 0; /* We cannot find a suitable polynomial of degree <= maximumAllowedN */ /* Here we know that with nMin, we cannot reach the bound but with nMax we can. So we refine by bisecting the interval [nMin,nMax] Also, we know that bestPoly contains the poly associated with nMax. */ while (nMax - nMin > 1) { n = (nMin + nMax) / 2; resCompute = checkDegreeTaylorModel(&myPoly, func, dom, delta, n, singu, prec); if (resCompute) { /* OK with n, so the new interval is [nMin,n] */ nMax = n; free_memory(bestPoly); bestPoly = myPoly; } else nMin = n; /* Not OK with n, so the new interval is [n,nMax] */ } /* Now we know that bestPoly is the polynomial that we want, but we need to translate it */ if (singu == NULL) { mpfr_init2(x0,sollya_mpfi_get_prec(dom) + 1); sollya_mpfi_mid(x0,dom); } else { mpfr_init2(x0,mpfr_get_prec(*singu)); mpfr_set(x0,*singu,GMP_RNDN); /* exact */ } shifterBack = makeSub(makeVariable(),makeConstant(x0)); pShifted = substitute(bestPoly,shifterBack); free_memory(shifterBack); free_memory(bestPoly); bestPoly = horner(pShifted); free_memory(pShifted); mpfr_clear(x0); *poly = bestPoly; return 1; } /* Determines if func has a zero in dom. If, using a safe, validated algorithm, it can be shown that func does not vanish on dom, the function returns 0 and does not touch zero and bisect. Otherwise, the function tries to determine the least zero of func in dom and assigns that value to zero. If func appears to have no other zeros in dom, the function returns 1 and does not touch bisect. Otherwise, the function assigns the midpoint of the least and one-but-least zero of func in dom to bisect and returns 2. In the case when the function is not able to establish the fact that func does not vanish on dom but is not able to find an approximation to a zero of func in dom, it does not touch zero and bisect and returns -1. This means: if the return value is - 0: the calling function can safely assume that func does not have a zero in dom, - 1: the calling function can assume that zero is a good approximation to the least zero of func in dom and that it is probably the only zero of func in dom. Hence by overcoming the problems due to this zero of func, the supnorm is likely to be computable in one step, - 2: the calling function can assume that, for supnorm computation, it is a good idea to bisect in the indicated bisection point if the computation tackling only the first zero fails, - -1: the calling function is not provided with a zero that might need to be overcome in supnorm computation but is likely to see the supnorm computation on the whole domain dom fail. The argument expectedZeros is an indication how many zeros of func are maximally expected in the given range. */ int determinePossibleZeroAndBisectPoint(mpfr_t zero, mpfr_t bisect, node *func, sollya_mpfi_t dom, int expectedZeros, mp_prec_t prec) { int res; sollya_mpfi_t y; mpfr_t yl, yr; unsigned long int points; mpfr_t a, b; mp_prec_t pp, ppp; chain *possibleZeros; chain *curr; mpfr_t *least, *second; mpfr_t myBisect; sollya_mpfi_init2(y,prec); mpfr_init2(yl,prec); mpfr_init2(yr,prec); evaluateInterval(y, func, NULL, dom); sollya_mpfi_get_left(yl,y); sollya_mpfi_get_right(yr,y); if (mpfr_number_p(yl) && mpfr_number_p(yr) && (mpfr_sgn(yl) * mpfr_sgn(yr) > 0)) { /* Here, we know by interval evaluation of func over dom that there is no zero of func in the interval. We can return zero. */ res = 0; } else { /* Here, we have to compute a list of approximations to the zeros of func in dom. */ points = 4 * expectedZeros + 1; pp = sollya_mpfi_get_prec(dom); mpfr_init2(a,pp); mpfr_init2(b,pp); sollya_mpfi_get_left(a,dom); sollya_mpfi_get_right(b,dom); if ( (!mpfr_number_p(a)) || (!mpfr_number_p(b)) ) res=-1; /* an unbounded range, return -1. */ else { /* Try to compute a list of zeros */ pp = mpfr_get_prec(zero); if (prec > pp) pp = prec; possibleZeros = uncertifiedFindZeros(func, a, b, points, pp + 5); /* Remark: uncertifiedFindZeros always returns ordered values. Hence, the following code is uselessly complicated. */ if (possibleZeros != NULL) { /* We found at least one zero */ if (possibleZeros->next == NULL) { /* Here, we have exactly one zero. */ res = 1; mpfr_set(zero,*((mpfr_t *) (possibleZeros->value)),GMP_RNDN); /* It's an approx. anyway */ } else { /* Here, we have at least two zeros Start by exhibiting the least zero. */ least = (mpfr_t *) (possibleZeros->value); for (curr=possibleZeros;curr!=NULL;curr=curr->next) { if (mpfr_cmp(*((mpfr_t *) (curr->value)),*least) < 0) { least = (mpfr_t *) (curr->value); } } /* Now find the second least zero */ second = least; for (curr=possibleZeros;curr!=NULL;curr=curr->next) { if (mpfr_cmp(*((mpfr_t *) (curr->value)),*second) > 0) { second = (mpfr_t *) (curr->value); } } /* Now second is the greatest zero. In the next stanza we will go down on second with all zeros in the list greater than the least zero. Anyway, we first check if the greatest zero is greater then the least zero. If it is not, we cannot find a second least zero. */ if (mpfr_cmp(*least,*second) == 0) { /* Here, we couldn't find any zero larger than the least This case should not happen but anyway, we found one zero. */ res = 1; mpfr_set(zero,*least,GMP_RNDN); /* It's an approx. anyway */ } else { /* Here, we really found that there at least two different zeros We now go down on second with all zeros in the list greater than the least zero. */ for (curr=possibleZeros;curr!=NULL;curr=curr->next) { if ((mpfr_cmp(*((mpfr_t *) (curr->value)),*least) > 0) && (mpfr_cmp(*((mpfr_t *) (curr->value)),*second) < 0)) { second = (mpfr_t *) (curr->value); } } /* Now, second is really the second least zero in the list */ res = 2; mpfr_set(zero,*least,GMP_RNDN); /* It's an approx. anyway */ /* Compute midpoint between least and second least zero */ pp = mpfr_get_prec(*least); ppp = mpfr_get_prec(*second); if (ppp > pp) pp = ppp; mpfr_init2(myBisect,pp + 1); mpfr_add(myBisect, *least, *second, GMP_RNDN); mpfr_div_2ui(myBisect,myBisect,1,GMP_RNDN); /* Set bisection point to midpoint of the two least zeros */ mpfr_set(bisect,myBisect,GMP_RNDN); /* It's all an approx. anyway */ mpfr_clear(myBisect); } } freeChain(possibleZeros,freeMpfrPtr); } else { /* We did not find any zero, return -1. */ res = -1; } } mpfr_clear(a); mpfr_clear(b); } mpfr_clear(yr); mpfr_clear(yl); sollya_mpfi_clear(y); return res; } /* Determines the order of a zero of func at x0. The function computes an upper bound k for the order of a zero of func at x0, provided that the zero is of order less than n. In the case when an upper bound has been correctly determined, the function assigns the order to k and returns a non-zero value. Otherwise, if n is too low to correctly determine an upper bound, the function does not touch k and returns zero. In the context of supremum norm computation, initialize n to the degree of the polynomial p in p/f - 1, as f might not reasonably have a zero of a higher degree than that of p. HACK ALERT: currently, taylorform does not take any prec argument. This means we have to modify the global precision of the tool. We reset it correctly in the usual case but if a Ctrl-C pops in in the middle, it will not be reset. This should be changed in the future. */ int determineOrderOfZero(int *k, node *func, mpfr_t x0, int n, mp_prec_t prec) { int myK, res; mp_prec_t oldToolPrec; node *poly; chain *errors; sollya_mpfi_t x0AsInterval; node **coefficients; int degree, i, len; chain *curr; sollya_mpfi_t **errorsAsArray; res = 0; /* Make compiler happy: */ myK = -1; /* End of compiler happiness */ sollya_mpfi_init2(x0AsInterval,mpfr_get_prec(x0)); sollya_mpfi_set_fr(x0AsInterval,x0); oldToolPrec = getToolPrecision(); setToolPrecision(prec); poly = NULL; errors = NULL; taylorform(&poly, &errors, NULL, func, n, &x0AsInterval, NULL, RELATIVE); setToolPrecision(oldToolPrec); if ((poly != NULL) && (errors != NULL)) { len = lengthChain(errors); /* Normally, len == n+1 */ /* HACK ALERT: We will allocate only the containers to the array of errors but we just copy over the pointers to the MPFIs. So when free'ing the array, we must not free the MPFIs, as they will be free'd when free'ing the orginal list. */ errorsAsArray = (sollya_mpfi_t **) safeCalloc(len,sizeof(sollya_mpfi_t *)); i = 0; for (curr=errors;curr!=NULL;curr=curr->next) { errorsAsArray[i] = (sollya_mpfi_t *) (curr->value); i++; } coefficients = NULL; getCoefficients(°ree,&coefficients,poly); if ( (degree >= 0) && (coefficients != NULL) ) { if (len == degree + 1) { /* Should always be true */ myK = 0; while ((myK <= degree) && (myK <= n-1) && (!res)) { /* Normally n==degree */ if ( ( (coefficients[myK] == NULL) || ( (accessThruMemRef(coefficients[myK])->nodeType == CONSTANT) && (mpfr_zero_p(*(accessThruMemRef(coefficients[myK])->value))) ) ) && (sollya_mpfi_is_zero(*(errorsAsArray[myK]))) ) { myK++; } else { res = 1; } } } for (i=0;i<=degree;i++) { if (coefficients[i] != NULL) free_memory(coefficients[i]); } } if (coefficients != NULL) safeFree(coefficients); safeFree(errorsAsArray); freeChain(errors,freeMpfiPtr); free_memory(poly); } sollya_mpfi_clear(x0AsInterval); if (res) *k = myK; return res; } /* Compute the supremum norm on eps = p - f over dom The supremum norm is computed with an enclosure error less than accuracy, i.e. the obtained interval [l,u] satisfies in the end: abs(u-l/l) <= accuracy If everything works fine, result is affected with an interval safely enclosing the supremum norm. The return value is then *zero* (i.e. SUPNORM_NO_ERROR). Otherwise, if an error occurs, the return value is non-zero. The number of the return value then corresponds to a special error message meaning (see #defines above). No warning message is ever displayed by this function. The computing precision is prec. We are ensured that this function is called only if * poly is a polynomial * dom is a closed non-empty interval containing only numbers that is not reduced to a point, * accuracy is a positive number. In the case when the computation fails but there is hope in obtaining a result by bisection, the algorithm may assign a point in the interior of dom to bisectPoint. The global bisection code will then try to bisect at that point. If no value is assigned, the global bisection will be performed at the midpoint of dom. This means: if you just want default behavior for the bisection (in the midpoint), then do not touch bisectPoint. To begin with, we do not care about removable singularities in the expression of func. In such a case, the absolute supnorm may simply fail for now. */ int supnormAbsolute(sollya_mpfi_t result, node *poly, node *func, sollya_mpfi_t dom, mpfr_t accuracy, mp_prec_t prec, mpfr_t bisectPoint) { mpfr_t ell, gamma, fifthteenThirtySecond, errMax, bound, u, thirtyoneThirtySecond; mp_prec_t pr; node *T; int maximumAllowedN; node *boundAsNode, *s1, *s2, *pMinusT, *TMinusp; UNUSED_PARAM(bisectPoint); /* Compute ell such that ell <= || p - f || with an accuracy gamma = accuracy/32 */ mpfr_init2(ell,prec); mpfr_init2(gamma,mpfr_get_prec(accuracy)); mpfr_div_ui(gamma,accuracy,32,GMP_RNDN); /* exact, but it doesn't matter anyway */ if (!computeSupnormLowerBound(ell, poly, func, dom, gamma, ABSOLUTE, prec)) { /*we compute a lower bound with expected accuracy gamma=accuracy/32*/ /* Before returning, we do a quick heuristical check if we had a chance with this level of working precision */ mpfr_abs(ell,accuracy,GMP_RNDD); /* heuristic anyway */ mpfr_log2(ell,ell,GMP_RNDD); /* heuristic anyway */ mpfr_floor(ell,ell); mpfr_neg(ell,ell,GMP_RNDU); pr = mpfr_get_ui(ell,GMP_RNDD); mpfr_clear(ell); mpfr_clear(gamma); if (pr > prec) { return SUPNORM_NOT_ENOUGH_WORKING_PRECISION; } return SUPNORM_CANNOT_COMPUTE_LOWER_BOUND; } /* Compute errMax such that errMax approximates ell * accuracy * 15/32 but is surely no greater */ mpfr_init2(fifthteenThirtySecond,12); /* 15/32 can be written on 12 bits */ mpfr_set_ui(fifthteenThirtySecond,15,GMP_RNDD); /* exact as 15 holds on 12 bits */ mpfr_div_ui(fifthteenThirtySecond,fifthteenThirtySecond,32,GMP_RNDD); /* exact, 32 is a power of 2 */ mpfr_init2(errMax,prec); mpfr_mul(errMax,ell,accuracy,GMP_RNDD); /* round down to get lesser value */ mpfr_mul(errMax,errMax,fifthteenThirtySecond,GMP_RNDD); /* round down to get lesser value */ mpfr_clear(fifthteenThirtySecond); /* Compute T such that the absolute error is <= errMax */ maximumAllowedN = 16 * getDegree(poly); if (maximumAllowedN < 32) maximumAllowedN = 32; T = NULL; if (!computeTaylorModelOfLeastDegree(&T, func, dom, errMax, maximumAllowedN, NULL, prec)) { mpfr_clear(ell); mpfr_clear(gamma); mpfr_clear(errMax); return SUPNORM_NO_TAYLOR; } /* Compute bound that approximates bound = ell * (1 + accuracy/2) but surely no greater */ /* Hence, proving that ||p-T|| <= bound surely proves that ||p-T|| <= ell*(1+accuracy/2) */ mpfr_init2(bound,prec); mpfr_div_ui(bound,accuracy,2,GMP_RNDD); /* exact, but round-down anyway */ mpfr_add_ui(bound,bound,1,GMP_RNDD); /* round-down to get lesser value */ mpfr_mul(bound,ell,bound,GMP_RNDD); /* round-down to get lesser value */ /* Represent bound as a node * (a polynomial) that we can give to subPolynomialsExactly(node *p1, node *p2) */ boundAsNode = makeConstant(bound); /* Compute (build) s1 = bound - (p - T) and s2 = bound - (T - p) */ pMinusT = subPolynomialsExactly(poly, T); TMinusp = subPolynomialsExactly(T, poly); s1 = subPolynomialsExactly(boundAsNode, pMinusT); s2 = subPolynomialsExactly(boundAsNode, TMinusp); /* Check now that s1 and s2 are both positive on the domain dom The case when s1 or s2 have a point where they are not positive should never happen. The check just ensures the safety of the algorithm, i.e. validates it. */ if ( (!isPolynomialWithConstantDyadicFiniteRealCoefficients(s1)) || (!isPolynomialWithConstantDyadicFiniteRealCoefficients(s2))) { /* I believe that this is dead code. It is here to cover the case where checkDegreeTaylorModel would successfully return, but the returned polynomial would contain non-dyadic coefficients. I think that this cannot happen. */ mpfr_clear(ell); mpfr_clear(gamma); mpfr_clear(errMax); mpfr_clear(bound); free_memory(T); free_memory(boundAsNode); free_memory(s1); free_memory(s2); free_memory(pMinusT); free_memory(TMinusp); return SUPNORM_NO_TAYLOR; } if ((!showPositivity(s1, dom, prec)) || (!showPositivity(s2, dom, prec))) { /* At least one of s1 or s2 has a point in dom where it is non-positive We clear the used memory and return the appropriate failure code. */ mpfr_clear(ell); mpfr_clear(gamma); mpfr_clear(errMax); mpfr_clear(bound); free_memory(T); free_memory(boundAsNode); free_memory(s1); free_memory(s2); free_memory(pMinusT); free_memory(TMinusp); return SUPNORM_COULD_NOT_SHOW_POSITIVITY; } /* If we are here, we know that s1 and s2 are positive and we can easily deduce the upper bound from the lower bound ell. We take u approximating ell * (1 + 31/32 * accuracy) and surely no less than it. */ mpfr_init2(u,prec); mpfr_init2(thirtyoneThirtySecond,12); /* 31/32 holds on 12 bits */ mpfr_set_ui(thirtyoneThirtySecond,31,GMP_RNDU); /* exact, 31 holds on 12 bits */ mpfr_div_ui(thirtyoneThirtySecond,thirtyoneThirtySecond,32,GMP_RNDU); /* exact, 32 is a power of 2 */ mpfr_mul(u,thirtyoneThirtySecond,accuracy,GMP_RNDU); /* round-up as all quantities are positive and we want an upper bound */ mpfr_add_ui(u,u,1,GMP_RNDU); /* round-up as all quantities are positive and we want an upper bound */ mpfr_mul(u,ell,u,GMP_RNDU); /* round-up as all quantities are positive and we want an upper bound */ /* Set the result */ sollya_mpfi_interv_fr(result,ell,u); /* Clear all used memory */ mpfr_clear(ell); mpfr_clear(gamma); mpfr_clear(errMax); mpfr_clear(bound); mpfr_clear(u); mpfr_clear(thirtyoneThirtySecond); free_memory(T); free_memory(boundAsNode); free_memory(s1); free_memory(s2); free_memory(pMinusT); free_memory(TMinusp); /* Return success */ return SUPNORM_NO_ERROR; } /* Compute the supremum norm on eps = p/f - 1 over dom The supremum norm is computed with an enclosure error less than accuracy, i.e. the obtained interval [l,u] satisfies in the end: abs(u-l/l) <= accuracy If everything works fine, result is affected with an interval safely enclosing the supremum norm. The return value is then *zero* (i.e. SUPNORM_NO_ERROR). Otherwise, if an error occurs, the return value is non-zero. The number of the return value then corresponds to a special error message meaning (see #defines above). No warning message is ever displayed by this function. The computing precision is prec. We are ensured that this function is called only if * poly is a polynomial * dom is a closed non-empty interval containing only numbers that is not reduced to a point, * accuracy is a positive number. In the case when the computation fails but there is hope in obtaining a result by bisection, the algorithm may assign a point in the interior of dom to bisectPoint. The global bisection code will then try to bisect at that point. If no value is assigned, the global bisection will be performed at the midpoint of dom. This means: if you just want default behavior for the bisection (in the midpoint), then do not touch bisectPoint. This function may assume that the expression poly / func - 1 is likely not have any removable singularities in dom, i.e. it can assume that func is likely not to vanish in dom. We do not care about removable singularities in the expression of func. In such a case, the relative supnorm may simply fail for now. The singularity parameter is just to be passed on to the Taylor Form code. */ int supnormRelativeNoSingularity(sollya_mpfi_t result, node *poly, node *func, sollya_mpfi_t dom, mpfr_t accuracy, mp_prec_t prec, mpfr_t *singularity, mpfr_t bisectPoint) { mpfr_t F, ell, gamma, thirtyoneThirtySecond, u, errMax, midDom, signT, bound; mp_prec_t pr; sollya_mpfi_t ellInterval, accuracyInterval, fifthteenThirtySecondInterval, FInterval, errMaxInterval, onePlusUInterval, uInterval; node *T; int maximumAllowedN, signAsInt; node *s1, *s2, *boundTimesT, *pMinusT, *TMinusp; UNUSED_PARAM(bisectPoint); /* Makes compiler happy */ signAsInt = -2; /* End of compiler happiness */ /* Compute F such that forall x in dom |func(x)| >= F */ mpfr_init2(F,prec); if (!computeAbsoluteMinimum(F, func, dom, prec)) { /* If we are here, we could not compute a valid lower bound on the absolute value of func, i.e. a bound that seems to be non-zero. */ mpfr_clear(F); return SUPNORM_CANNOT_COMPUTE_ABSOLUTE_INF; } /* Check that F is really non-zero and a real */ if ((!mpfr_number_p(F)) || mpfr_zero_p(F)) { mpfr_clear(F); return SUPNORM_CANNOT_COMPUTE_ABSOLUTE_INF; } /* Compute ell such that ell <= || p / f - 1 || with an accuracy gamma = accuracy/32 */ mpfr_init2(ell,prec); mpfr_init2(gamma,mpfr_get_prec(accuracy)); mpfr_div_ui(gamma,accuracy,32,GMP_RNDN); /* exact, but it doesn't matter anyway */ if (!computeSupnormLowerBound(ell, poly, func, dom, gamma, RELATIVE, prec)) { /* Before returning, we do a quick heuristical check if we had a chance with this level of working precision */ mpfr_abs(ell,accuracy,GMP_RNDD); /* heuristic anyway */ mpfr_log2(ell,ell,GMP_RNDD); /* heuristic anyway */ mpfr_floor(ell,ell); mpfr_neg(ell,ell,GMP_RNDU); pr = mpfr_get_ui(ell,GMP_RNDD); mpfr_clear(F); mpfr_clear(ell); mpfr_clear(gamma); if (pr > prec) { return SUPNORM_NOT_ENOUGH_WORKING_PRECISION; } return SUPNORM_CANNOT_COMPUTE_LOWER_BOUND; } /* Compute a presumed upper bound for the supremum norm that we will try to validate. Take u approximating ell * (1 + 31/32 * accuracy) but surely no less than it. */ mpfr_init2(u,prec); mpfr_init2(thirtyoneThirtySecond,12); /* 31/32 holds on 12 bits */ mpfr_set_ui(thirtyoneThirtySecond,31,GMP_RNDU); /* exact, 31 holds on 12 bits */ mpfr_div_ui(thirtyoneThirtySecond,thirtyoneThirtySecond,32,GMP_RNDU); /* exact, 32 is a power of 2 */ mpfr_mul(u,thirtyoneThirtySecond,accuracy,GMP_RNDU); /* round-up as all quantities are positive and we want an upper bound */ mpfr_add_ui(u,u,1,GMP_RNDU); /* round-up as all quantities are positive and we want an upper bound */ mpfr_mul(u,ell,u,GMP_RNDU); /* round-up as all quantities are positive and we want an upper bound */ /* Compute a maxium absolute error for the Taylor polynomial Take a value errMax approximating ell * accuracy * (15/32) * 1/(1+u) * F/(1+15*accuracy/32) but being surely no greater than it (with u approximating ell*(1+31*accuracy/32) but surely no lesser than it). We just use interval arithmetic to be sure to have a bound no greater than the approximated quantity. */ /* Get memory */ mpfr_init2(errMax, prec); sollya_mpfi_init2(ellInterval,prec); sollya_mpfi_init2(accuracyInterval,mpfr_get_prec(accuracy)); sollya_mpfi_init2(fifthteenThirtySecondInterval,12); sollya_mpfi_init2(FInterval,mpfr_get_prec(F)); sollya_mpfi_init2(errMaxInterval, prec); sollya_mpfi_init2(uInterval,mpfr_get_prec(u)); sollya_mpfi_init2(onePlusUInterval, prec); /* Initialize */ sollya_mpfi_set_fr(accuracyInterval,accuracy); sollya_mpfi_set_ui(fifthteenThirtySecondInterval,15); sollya_mpfi_div_ui(fifthteenThirtySecondInterval,fifthteenThirtySecondInterval,32); sollya_mpfi_set_fr(FInterval,F); sollya_mpfi_set_fr(uInterval,u); sollya_mpfi_set_fr(ellInterval,ell); /* Compute in IA */ sollya_mpfi_mul(errMaxInterval,fifthteenThirtySecondInterval,accuracyInterval); /* errMaxInterval <- 15/32 * accuracy */ sollya_mpfi_add_ui(errMaxInterval,errMaxInterval,1); /* errMaxInterval <- 1 + errMaxInterval = 1 + 15/32 * accuracy */ sollya_mpfi_div(errMaxInterval,FInterval,errMaxInterval); /* errMaxInterval <- F/errMaxInterval = F/(1+15/32*accuracy) */ sollya_mpfi_add_ui(onePlusUInterval,uInterval,1); /* onePlusUInterval <- 1 + u */ sollya_mpfi_div(errMaxInterval,errMaxInterval,onePlusUInterval); /* errMaxInterval <- errMaxInterval/onePlusUInterval = 1/(1+u) * F/(1+15/32*accuracy) */ sollya_mpfi_mul(errMaxInterval,errMaxInterval,fifthteenThirtySecondInterval); /* errMaxInterval <- 15/32 * errMaxInterval = 15/32 * 1/(1+u) * F/(1+15/32*accuracy) */ sollya_mpfi_mul(errMaxInterval,errMaxInterval,accuracyInterval); /* errMaxInterval <- errMaxInterval * accuracy = accuracy * 15/32 * 1/(1+u) * F/(1+15/32*accuracy) */ sollya_mpfi_mul(errMaxInterval,errMaxInterval,ellInterval); /* errMaxInterval <- ell * errMaxInterval = ell * accuracy * 15/32 * 1/(1+u) * F/(1+15/32*accuracy) */ /* Get the lower bound of the result */ sollya_mpfi_get_left(errMax,errMaxInterval); /* Clear memory */ sollya_mpfi_clear(errMaxInterval); sollya_mpfi_clear(FInterval); sollya_mpfi_clear(fifthteenThirtySecondInterval); sollya_mpfi_clear(accuracyInterval); sollya_mpfi_clear(ellInterval); sollya_mpfi_clear(onePlusUInterval); sollya_mpfi_clear(uInterval); /* Compute T such that the absolute error is <= errMax */ maximumAllowedN = 16 * getDegree(poly); if (maximumAllowedN < 32) maximumAllowedN = 32; T = NULL; if (!computeTaylorModelOfLeastDegree(&T, func, dom, errMax, maximumAllowedN, singularity, prec)) { mpfr_clear(F); mpfr_clear(ell); mpfr_clear(gamma); mpfr_clear(u); mpfr_clear(thirtyoneThirtySecond); mpfr_clear(errMax); return SUPNORM_NO_TAYLOR; } /* Determine the sign of T in the middle of dom We really need to be sure of the sign, so if we can't determine it, we fail. */ mpfr_init2(midDom,sollya_mpfi_get_prec(dom)); sollya_mpfi_mid(midDom,dom); if (!determineSignAtPoint(&signAsInt,T,midDom,prec)) { mpfr_clear(F); mpfr_clear(ell); mpfr_clear(gamma); mpfr_clear(u); mpfr_clear(thirtyoneThirtySecond); mpfr_clear(errMax); mpfr_clear(midDom); free_memory(T); return SUPNORM_CANNOT_DETERMINE_SIGN_OF_T; } /* Here, we know the sign of T at mid(dom), we just have to translate it to an mpfr value */ mpfr_init2(signT,12); if (signAsInt < 0) mpfr_set_si(signT,-1,GMP_RNDN); /* exact */ else mpfr_set_si(signT,1,GMP_RNDN); /* exact */ /* Compute bound that approximates bound = ell * (1 + accuracy/2) but surely no greater */ mpfr_init2(bound,prec); mpfr_div_ui(bound,accuracy,2,GMP_RNDD); /* exact, but round-down anyway */ mpfr_add_ui(bound,bound,1,GMP_RNDD); /* round-down to get lesser value */ mpfr_mul(bound,ell,bound,GMP_RNDD); /* round-down to get lesser value */ /* Integrate the sign of T at mid(dom) into bound */ mpfr_mul(bound,bound,signT,GMP_RNDN); /* exact as signT one of -1 or 1 */ /* Scale T by bound */ boundTimesT = scalePolynomialExactly(T, bound); /* boundTimesT = |T|*ell*(1+accuracy/2) */ /* Compute (build) s1 = boundTimesT - (p - T) and s2 = boundTimesT - (T - p) */ pMinusT = subPolynomialsExactly(poly, T); TMinusp = subPolynomialsExactly(T, poly); s1 = subPolynomialsExactly(boundTimesT, pMinusT); s2 = subPolynomialsExactly(boundTimesT, TMinusp); /* Check now that s1 and s2 are both positive on the domain dom The case when s1 or s2 have a point where they are not positive should never happen. The check just ensures the safety of the algorithm, i.e. validates it. */ if ( (!isPolynomialWithConstantDyadicFiniteRealCoefficients(s1)) || (!isPolynomialWithConstantDyadicFiniteRealCoefficients(s2))) { /* I believe that this is dead code. It is here to cover the case where checkDegreeTaylorModel would successfully return, but the returned polynomial would contain non-dyadic coefficients. I think that this cannot happen. */ mpfr_clear(F); mpfr_clear(ell); mpfr_clear(gamma); mpfr_clear(u); mpfr_clear(thirtyoneThirtySecond); mpfr_clear(errMax); mpfr_clear(midDom); mpfr_clear(bound); mpfr_clear(signT); free_memory(T); free_memory(boundTimesT); free_memory(s1); free_memory(s2); free_memory(pMinusT); free_memory(TMinusp); return SUPNORM_NO_TAYLOR; } if ((!showPositivity(s1, dom, prec)) || (!showPositivity(s2, dom, prec))) { /* At least one of s1 or s2 has a point in dom where it is non-positive We clear the used memory and return the appropriate failure code. */ mpfr_clear(F); mpfr_clear(ell); mpfr_clear(gamma); mpfr_clear(u); mpfr_clear(thirtyoneThirtySecond); mpfr_clear(errMax); mpfr_clear(midDom); mpfr_clear(bound); mpfr_clear(signT); free_memory(T); free_memory(boundTimesT); free_memory(pMinusT); free_memory(TMinusp); free_memory(s1); free_memory(s2); return SUPNORM_COULD_NOT_SHOW_POSITIVITY; } /* Here, we know the supnorm as [ell,u] and we have validated it. */ /* Set the result */ sollya_mpfi_interv_fr(result,ell,u); /* Clear all used memory */ mpfr_clear(F); mpfr_clear(ell); mpfr_clear(gamma); mpfr_clear(u); mpfr_clear(thirtyoneThirtySecond); mpfr_clear(errMax); mpfr_clear(midDom); mpfr_clear(bound); mpfr_clear(signT); free_memory(T); free_memory(boundTimesT); free_memory(pMinusT); free_memory(TMinusp); free_memory(s1); free_memory(s2); /* Return success */ return SUPNORM_NO_ERROR; } /* Compute the supremum norm on eps = p/f - 1 over dom The supremum norm is computed with an enclosure error less than accuracy, i.e. the obtained interval [l,u] satisfies in the end: abs(u-l/l) <= accuracy If everything works fine, result is affected with an interval safely enclosing the supremum norm. The return value is then *zero* (i.e. SUPNORM_NO_ERROR). Otherwise, if an error occurs, the return value is non-zero. The number of the return value then corresponds to a special error message meaning (see #defines above). No warning message is ever displayed by this function. The computing precision is prec. We are ensured that this function is called only if * poly is a polynomial * dom is a closed non-empty interval containing only numbers that is not reduced to a point, * accuracy is a positive number. In the case when the computation fails but there is hope in obtaining a result by bisection, the algorithm may assign a point in the interior of dom to bisectPoint. The global bisection code will then try to bisect at that point. If no value is assigned, the global bisection will be performed at the midpoint of dom. This means: if you just want default behavior for the bisection (in the midpoint), then do not touch bisectPoint. This function is supposed to overcome a removable singularity at singularity. There might be other singularities of poly/func-1 in the domain dom. In this case, the function may fail. It is not supposed to fail, though, if singularity is the only removable singularity of poly/func - 1 in the domain dom. However, we do not care about removable singularities in the expression of func. In such a case, the relative supnorm may simply fail for now. It may assign a new value to bisectPoint if desired. */ int supnormRelativeSingularity(sollya_mpfi_t result, node *poly, node *func, sollya_mpfi_t dom, mpfr_t accuracy, mpfr_t singularity, mp_prec_t prec, mpfr_t bisectPoint) { int deg, k, n, res; node *pTilde, *fTilde, *fTildeUnsimplified; mpfr_t kAsMpfr, mySingularity; /* Makes compiler happy */ k = -1; /* End of compiler happiness */ /* Determine the degree of poly */ deg = getDegree(poly); if (deg < 0) { /* Strange things are happening, we return an error */ return SUPNORM_SOME_ERROR; } /* Determine a maximum order */ n = deg; if (n < 2) n = 2; if (!determineOrderOfZero(&k, func, singularity, n, prec)) { /* We couldn't determine the order of the presumed singularity. Hence we fail with the appropriate error code. */ return SUPNORM_CANNOT_DETERMINE_ORDER_OF_SINGU; } /* Now we know that func has a singularity at singularity of order k We have to check now if we can divide poly by (x-singularity)^k */ pTilde = NULL; if (!dividePolyByXMinusX0ToTheK(&pTilde,poly,singularity,k,prec)) { /* Here, we couldn't divide poly by (x-singularity)^k We return the appropriate error code. */ return SUPNORM_SINGULARITY_NOT_REMOVED; } /* If we are here, we know that pTilde = poly/((x-singularity)^k) We now build fTilde = func/(x-singularity)^k */ mpfr_init2(kAsMpfr,5 + 8 * sizeof(k)); mpfr_set_si(kAsMpfr,k,GMP_RNDN); /* exact as per what precedes */ fTildeUnsimplified = makeDiv(copyTree(func), makePow(makeSub(makeVariable(),makeConstant(singularity)), makeConstant(kAsMpfr))); fTilde = simplifyTreeErrorfree(fTildeUnsimplified); free_memory(fTildeUnsimplified); /* Now copy singularity into a local variable ('cause that stupid C, in some versions, prohibits taking a pointer on an argument) */ mpfr_init2(mySingularity,mpfr_get_prec(singularity)); mpfr_set(mySingularity,singularity,GMP_RNDN); /* exact, the precision is the same */ /* Now call the relative supremum norm with pTilde and fTilde, passing on the singularity as the development point for fTilde. */ res = supnormRelativeNoSingularity(result, pTilde, fTilde, dom, accuracy, prec, &mySingularity, bisectPoint); /* Free all locally used memory */ free_memory(pTilde); free_memory(fTilde); mpfr_clear(kAsMpfr); mpfr_clear(mySingularity); /* Return the result obtained */ return res; } /* Compute the supremum norm on eps = p/f - 1 over dom The supremum norm is computed with an enclosure error less than accuracy, i.e. the obtained interval [l,u] satisfies in the end: abs(u-l/l) <= accuracy If everything works fine, result is affected with an interval safely enclosing the supremum norm. The return value is then *zero* (i.e. SUPNORM_NO_ERROR). Otherwise, if an error occurs, the return value is non-zero. The number of the return value then corresponds to a special error message meaning (see #defines above). No warning message is ever displayed by this function. The computing precision is prec. We are ensured that this function is called only if * poly is a polynomial * dom is a closed non-empty interval containing only numbers that is not reduced to a point, * accuracy is a positive number. In the case when the computation fails but there is hope in obtaining a result by bisection, the algorithm may assign a point in the interior of dom to bisectPoint. The global bisection code will then try to bisect at that point. If no value is assigned, the global bisection will be performed at the midpoint of dom. This means: if you just want default behavior for the bisection (in the midpoint), then do not touch bisectPoint. This function is supposed to detect and overcome false singularities. However, it is also supposed to perform a fast check first, i.e. it is not supposed to do a length detection of zeros of func if the (IA) image of func over dom does not contain zero. The use of void evaluateInterval(sollya_mpfi_t y, node *func, node *deriv, sollya_mpfi_t x); comes handy here (remark that deriv may be set to NULL). To begin with, we do not care about removable singularities in the expression of func. In such a case, the relative supnorm may simply fail for now. However, removable singularities in poly/func must be detected (after a fast check if there aren't any) and overcome. This must work for cases when there is one singularity in dom, though. If there are several singularities, bisection will eventually split the interval. If appropriate set bisectPoint to something reasonable. */ int supnormRelative(sollya_mpfi_t result, node *poly, node *func, sollya_mpfi_t dom, mpfr_t accuracy, mp_prec_t prec, mpfr_t bisectPoint) { int numberOfSingularities; mpfr_t singularity, myBisect, oldBisect; int degree, res; /* Initialize the result to "Error" */ res = SUPNORM_SOME_ERROR; /* We use the degree of the polynomial as an indication of how many removable singularities poly/func might maximally have. */ degree = getDegree(poly); if (degree < 5) degree = 5; mpfr_init2(myBisect,mpfr_get_prec(bisectPoint)); mpfr_set(myBisect,bisectPoint,GMP_RNDN); /* exact */ mpfr_init2(singularity, prec); /* Quickly determine if there is a possible singularity and if yes, where it is and if it is the only one */ numberOfSingularities = determinePossibleZeroAndBisectPoint(singularity, myBisect, func, dom, degree, prec); /* Do the right thing depending on how many singularities have been determined */ if ((numberOfSingularities == 0) || (numberOfSingularities == -1)) { mpfr_clear(singularity); mpfr_clear(myBisect); /* Launch computation with the conviction that there is no singularity */ res = supnormRelativeNoSingularity(result, poly, func, dom, accuracy, prec, NULL, bisectPoint); if ((res == SUPNORM_SOME_ERROR) && (numberOfSingularities == -1)) res = SUPNORM_SINGULARITY_NOT_DETECTED; } else { mpfr_init2(oldBisect,mpfr_get_prec(bisectPoint)); mpfr_set(oldBisect,bisectPoint,GMP_RNDN); /* Launch computation with the conviction that there is a singularity at singularity */ res = supnormRelativeSingularity(result, poly, func, dom, accuracy, singularity, prec, oldBisect); if (res != SUPNORM_NO_ERROR) { if (numberOfSingularities == 2) { /* The supnorm failed and we know of another possible singularity and hence of a good bisection point */ mpfr_set(bisectPoint, myBisect, GMP_RNDN); /* That's all approximations */ if (res == SUPNORM_SOME_ERROR) res = SUPNORM_ANOTHER_SINGULARITY_IN_DOM; } else { /* The supnorm failed but we do not know of another possible bisection point We hence set bisectPoint to the value that value suggested to us by the supnormRelativeSingularity function. */ mpfr_set(bisectPoint, oldBisect, GMP_RNDN); /* bisectPoint does not change if supnormRelativeSingularity didn't touch oldBisect */ } } mpfr_clear(singularity); mpfr_clear(myBisect); mpfr_clear(oldBisect); } return res; } /* Compute the supremum norm on eps = p - f resp. eps = p/f - 1 over dom eps is defined according to the mode parameter: if mode = ABSOLUTE then eps = p - f else eps = p/f -1 The supremum norm is computed with an enclosure error less than accuracy, i.e. the obtained interval [l,u] satisfies in the end: abs(u-l/l) <= accuracy If everything works fine, result is affected with an interval safely enclosing the supremum norm. The return value is then *zero* (i.e. SUPNORM_NO_ERROR). Otherwise, if an error occurs, the return value is non-zero. The number of the return value then corresponds to a special error message meaning (see #defines above). No warning message is ever displayed by this function. The computing precision is prec. We are ensured that this function is called only if * poly is a polynomial * dom is a closed non-empty interval containing only numbers that is not reduced to a point, * accuracy is a positive number. In the case when the computation fails but there is hope in obtaining a result by bisection, the algorithm may assign a point in the interior of dom to bisectPoint. The global bisection code will then try to bisect at that point. If no value is assigned, the global bisection will be performed at the midpoint of dom. This means: if you just want default behavior for the bisection (in the midpoint), then do not touch bisectPoint. */ int supremumNormInner(sollya_mpfi_t result, node *poly, node *func, sollya_mpfi_t dom, int mode, mpfr_t accuracy, mp_prec_t prec, mpfr_t bisectPoint) { int res; if (mode == ABSOLUTE) { res = supnormAbsolute(result,poly,func,dom,accuracy,prec,bisectPoint); } else { res = supnormRelative(result,poly,func,dom,accuracy,prec,bisectPoint); } return res; } /* Compute the supremum norm on eps = p - f resp. eps = p/f - 1 over [a,b] eps is defined according to the mode parameter: if mode = ABSOLUTE then eps = p - f else eps = p/f -1 The supremum norm is computed with an enclosure error less than accuracy, i.e. the obtained interval [l,u] satisfies in the end: abs(u-l/l) <= accuracy If everything works fine, result is affected with an interval safely enclosing the supremum norm. The return value is then *zero* (i.e. SUPNORM_NO_ERROR). Otherwise, if an error occurs, the return value reflects the last error message of the recursive calls. We are ensured that this function is called only if * poly is a polynomial * a and b, a < b, form an interval [a,b] that is not reduced to a point * accuracy is a positive number, * diameter is a non-negative number. The algorithm is allowed to stop if a result has been found or if abs(b-a) is less than diameter. */ int supremumNormBisectInner(sollya_mpfi_t result, node *poly, node *func, mpfr_t a, mpfr_t b, int mode, mpfr_t accuracy, mpfr_t diameter, mp_prec_t prec) { int resFirst, resLeft, resRight; mp_prec_t p1, p2; sollya_mpfi_t dom, resultLeft, resultRight; mpfr_t c, width; mpfr_t ll, lr, ul, ur; p1 = mpfr_get_prec(a); p2 = mpfr_get_prec(b); if (p2 > p1) p1 = p2; sollya_mpfi_init2(dom,p1); sollya_mpfi_interv_fr(dom,a,b); mpfr_init2(c, p1 + 1); mpfr_add(c,a,b,GMP_RNDN); mpfr_div_2ui(c,c,1,GMP_RNDN); /* Call inner supnorm algorithm on whole interval */ resFirst = supremumNormInner(result, poly, func, dom, mode, accuracy, prec, c); sollya_mpfi_clear(dom); /* If everything worked fine on the whole interval, we do not need to bisect */ if (resFirst == SUPNORM_NO_ERROR) { mpfr_clear(c); return SUPNORM_NO_ERROR; } /* Some error occurred, check if we still need to bisect or if we have reached diameter */ mpfr_init2(width,p1); mpfr_sub(width,b,a,GMP_RNDU); if (mpfr_cmp(width,diameter) < 0) { /* We have reached diameter, we return the latest error code */ mpfr_clear(c); mpfr_clear(width); return resFirst; } mpfr_clear(width); /* Here, we have to bisect. We check that the bisection point is a number in the interior of [a,b]. If it is not, we set it to the middle of [a,b]. */ if ((!mpfr_number_p(c)) || (mpfr_cmp(c,a) <= 0) || (mpfr_cmp(b,c) <= 0)) { mpfr_add(c,a,b,GMP_RNDN); mpfr_div_2ui(c,c,1,GMP_RNDN); } /* Bisect */ p2 = sollya_mpfi_get_prec(result); sollya_mpfi_init2(resultLeft,p2); resLeft = supremumNormBisectInner(resultLeft, poly, func, a, c, mode, accuracy, diameter, prec); if (resLeft != SUPNORM_NO_ERROR) { /* The bisection recursively failed on the left sub-interval [a,c] Return the error code returned by that recursive call. */ mpfr_clear(c); sollya_mpfi_clear(resultLeft); return resLeft; } /* Here, resLeft == SUPNORM_NO_ERROR */ sollya_mpfi_init2(resultRight,p2); resRight = supremumNormBisectInner(resultRight, poly, func, c, b, mode, accuracy, diameter, prec); if (resRight != SUPNORM_NO_ERROR) { /* The bisection recursively failed on the right sub-interval [c,b] Return the error code returned by that recursive call. */ mpfr_clear(c); sollya_mpfi_clear(resultLeft); sollya_mpfi_clear(resultRight); return resRight; } /* Here, resLeft == SUPNORM_NO_ERROR and resRight == SUPNORM_NO_ERROR This means both recursive calls worked without error. We combine the results by taking the max of the lower resp. the upper bounds. */ mpfr_init2(ll,p2); mpfr_init2(lr,p2); mpfr_init2(ul,p2); mpfr_init2(ur,p2); sollya_mpfi_get_left(ll,resultLeft); sollya_mpfi_get_right(ul,resultLeft); sollya_mpfi_get_left(lr,resultRight); sollya_mpfi_get_right(ur,resultRight); if (mpfr_cmp(ll,lr) > 0) mpfr_set(lr,ll,GMP_RNDN); /* exact */ if (mpfr_cmp(ul,ur) > 0) mpfr_set(ur,ul,GMP_RNDN); /* exact */ sollya_mpfi_interv_fr(result,lr,ur); mpfr_clear(ll); mpfr_clear(lr); mpfr_clear(ul); mpfr_clear(ur); sollya_mpfi_clear(resultLeft); sollya_mpfi_clear(resultRight); mpfr_clear(c); return SUPNORM_NO_ERROR; } mp_prec_t mp_prec_abs(mp_prec_t p) { int64_t t; mp_prec_t pp; t = (int64_t) p; if (t < ((int64_t) 0)) t = -t; pp = (mp_prec_t) t; return pp; } /* Compute the supremum norm on eps = p - f resp. eps = p/f - 1 over [a,b] eps is defined according to the mode parameter: if mode = ABSOLUTE then eps = p - f else eps = p/f -1 The supremum norm is computed with an enclosure error less than accuracy, i.e. the obtained interval [l,u] satisfies in the end: abs(u-l/l) <= accuracy If everything works fine, result is affected with an interval safely enclosing the supremum norm. The return value is then non-zero. Otherwise, if an error occurs, the return value is 0. We are ensured that this function is called only if * poly is a polynomial * a and b, a < b, form an interval [a,b] that is not reduced to a point * accuracy is a positive number, * diameter is a non-negative number. The algorithm is allowed to stop if a result has been found or if abs(b-a) is less than diameter. */ int supremumNormBisect(sollya_mpfi_t result, node *poly, node *func, mpfr_t a, mpfr_t b, int mode, mpfr_t accuracy, mpfr_t diameter) { int res; mp_prec_t prec, p; mpfr_t temp; prec = getToolPrecision() + 25; /*p = sollya_mpfi_get_prec(result);*/ /* Compute p = -floor(log2(accuracy)) to get the number of bits we need in the end */ mpfr_init2(temp, 8 * sizeof(mp_prec_t) + 10); mpfr_log2(temp,accuracy,GMP_RNDD); mpfr_floor(temp,temp); mpfr_neg(temp,temp,GMP_RNDU); p = mpfr_get_ui(temp,GMP_RNDD); mpfr_clear(temp); /*if the requested accuracy (p) is close to prec, increase prec*/ if ((mp_prec_t) mp_prec_abs(p-prec) < (mp_prec_t) (p/2)) { if (p>prec) prec = p + (p/2); if (p<=prec) prec = prec + (p/2); } if (prec < (p + p/2) / 4) { prec = p + p/2; } res = supremumNormBisectInner(result, poly, func, a, b, mode, accuracy, diameter, prec); if (res == 0) return 1; /* everything's fine */ /* In the following, perform error handling (messaging and return 0) */ switch (res) { case SUPNORM_NO_TAYLOR: printMessage(1,SOLLYA_MSG_SUPNORM_NO_TAYLOR,"Warning: during supnorm computation, no suitable Taylor form could be found.\n"); break; case SUPNORM_NOT_ENOUGH_WORKING_PRECISION: printMessage(1,SOLLYA_MSG_SUPNORM_NOT_ENOUGH_WORKING_PRECISION,"Warning: during supnorm computation, no result could be found as the working precision seems to be too low.\n"); break; case SUPNORM_SINGULARITY_NOT_REMOVED: printMessage(1,SOLLYA_MSG_SUPNORM_SINGULARITY_NOT_REMOVED,"Warning: during supnorm computation, a singularity in the expression tree could not be removed.\n"); break; case SUPNORM_COULD_NOT_SHOW_POSITIVITY: printMessage(1,SOLLYA_MSG_SUPNORM_COULD_NOT_SHOW_POSITIVITY,"Warning: during supnorm computation, the positivity of a polynomial could not be established.\n"); break; case SUPNORM_SINGULARITY_NOT_DETECTED: printMessage(1,SOLLYA_MSG_SUPNORM_SINGULARITY_NOT_DETECTED,"Warning: during supnorm computation, a false singularity could not be detected.\n"); break; case SUPNORM_ANOTHER_SINGULARITY_IN_DOM: printMessage(1,SOLLYA_MSG_SUPNORM_ANOTHER_SINGULARITY_IN_DOM,"Warning: during supnorm computation, there appeared to be at least two singularities in the domain. More bisection is needed.\n"); break; case SUPNORM_CANNOT_COMPUTE_LOWER_BOUND: printMessage(1,SOLLYA_MSG_SUPNORM_CANNOT_COMPUTE_LOWER_BOUND,"Warning: during supnorm computation, it was not possible to determine a valid lower bound for the error function.\n"); break; case SUPNORM_CANNOT_COMPUTE_ABSOLUTE_INF: printMessage(1,SOLLYA_MSG_SUPNORM_CANNOT_COMPUTE_ABSOLUTE_INF,"Warning: during supnorm computation, it was not possible to determine a valid lower bound for the absolute value of the function.\n"); break; case SUPNORM_CANNOT_DETERMINE_SIGN_OF_T: printMessage(1,SOLLYA_MSG_SUPNORM_CANNOT_DETERMINE_SIGN_OF_T,"Warning: during supnorm computation, it was not possible to safely determine the sign of the Taylor polynomial.\n"); break; case SUPNORM_CANNOT_DETERMINE_ORDER_OF_SINGU: printMessage(1,SOLLYA_MSG_SUPNORM_CANNOT_DETERMINE_ORDER_OF_SINGU,"Warning: during supnorm computation, it was not possible to safely determine the order of a presume zero of the given function.\n"); break; default: printMessage(1,SOLLYA_MSG_SUPNORM_GENERIC_ERROR,"Warning: during supnorm computation, some generic error occurred. No further description is available.\n"); } return 0; } /* Compute the supremum norm on eps = p - f resp. eps = p/f - 1 at a, i.e. evaluate abs(eps) at a. eps is defined according to the mode parameter: if mode = ABSOLUTE then eps = p - f else eps = p/f -1 The supremum norm is computed with an enclosure error less than accuracy, i.e. the obtained interval [l,u] satisfies in the end: abs(u-l/l) <= accuracy If everything works fine, result is affected with an interval safely enclosing the supremum norm. The return value is then non-zero. Otherwise, if an error occurs, the return value is 0. We are ensured that this function is called only if * poly is a polynomial * a is a number, * accuracy is a positive number, * diameter is a non-negative number. */ int supremumNormDegenerate(sollya_mpfi_t result, node *poly, node *func, mpfr_t a, int mode, mpfr_t accuracy) { node *absEps; int res; mpfr_t temp, y, ya, yb; unsigned int pr; mp_prec_t prec, pp; int tempRes; mpfr_t absAccuracy; if (mode == ABSOLUTE) { /* Construct absEps = abs(poly - func) */ absEps = makeAbs(makeSub(copyTree(poly),copyTree(func))); } else { /* Construct absEps = abs(poly/func - 1) */ absEps = makeAbs(makeSub(makeDiv(copyTree(poly),copyTree(func)),makeConstantDouble(1.0))); } /* Compute pr = -floor(log2(accuracy)) to get the number of bits we need in the end */ mpfr_init2(temp, 8 * sizeof(mp_prec_t) + 10); mpfr_init2(absAccuracy,mpfr_get_prec(accuracy)); mpfr_abs(absAccuracy,accuracy,GMP_RNDN); /* exact */ mpfr_log2(temp,absAccuracy,GMP_RNDD); mpfr_clear(absAccuracy); mpfr_floor(temp,temp); mpfr_neg(temp,temp,GMP_RNDU); pr = mpfr_get_ui(temp,GMP_RNDD); mpfr_clear(temp); prec = getToolPrecision(); if ((mp_prec_t) pr > (mp_prec_t) 2048 * prec) { printMessage(1,SOLLYA_MSG_SUPNORM_ACCURACY_TOO_HIGH,"Warning: the given accuracy depasses the current maximum precision of %d bits.\n",2048 * prec); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the precision of the tool.\n"); sollya_mpfi_set_nan(result); free_memory(absEps); return 0; } if ((mp_prec_t) pr < prec) pp = prec; else pp = prec; pp += 10; mpfr_init2(y,pp); tempRes = evaluateFaithful(y, absEps, a, pp); res = 0; if (tempRes == 1) { res = 1; pp = mpfr_get_prec(y) - 5; mpfr_init2(ya,pp); mpfr_init2(yb,pp); mpfr_set(ya,y,GMP_RNDD); mpfr_set(yb,y,GMP_RNDU); mpfr_nextbelow(ya); mpfr_nextbelow(ya); mpfr_nextabove(yb); mpfr_nextabove(yb); if (mpfr_sgn(ya) < 0) { mpfr_set_si(ya,0,GMP_RNDN); } sollya_mpfi_interv_fr(result,ya,yb); mpfr_clear(ya); mpfr_clear(yb); } else { printMessage(1,SOLLYA_MSG_SUPNORM_COULD_NOT_FAITHFULLY_EVAL_ERROR_FUNC,"Warning: could not perform a faithful evaluation of the error function between the given polynomial and the given function at the given point.\n"); sollya_mpfi_set_nan(result); } free_memory(absEps); mpfr_clear(y); return res; } /* Checks if all coefficients of poly can be written as ratios of floating-point numbers Returns 0 if poly is not a polynomial or is a polynomial that does contain irrational coefficients. Returns a non-zero value otherwise. */ int hasOnlyMpqCoefficients(node *poly) { node **coefficients; int degree, i, res, okay; node *simplified; if (!isPolynomial(poly)) return 0; getCoefficients(°ree,&coefficients,poly); if (degree < 0) return 0; res = 1; for (i=0;i<=degree;i++) { if (coefficients[i] != NULL) { simplified = simplifyRationalErrorfree(coefficients[i]); okay = 0; if ((accessThruMemRef(simplified)->nodeType == CONSTANT) && (mpfr_number_p(*(accessThruMemRef(simplified)->value)))) okay = 1; else { if ((accessThruMemRef(simplified)->nodeType == DIV) && (((accessThruMemRef(accessThruMemRef(simplified)->child1)->nodeType == CONSTANT) && (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(simplified)->child1)->value)))) && ((accessThruMemRef(accessThruMemRef(simplified)->child2)->nodeType == CONSTANT) && (mpfr_number_p(*(accessThruMemRef(accessThruMemRef(simplified)->child2)->value)))))) okay = 1; } free_memory(simplified); if (!okay) { res = 0; break; } } } for (i=0;i<=degree;i++) { if (coefficients[i] != NULL) free_memory(coefficients[i]); } safeFree(coefficients); return res; } /* Compute the supremum norm on eps = p - f resp. eps = p/f - 1 over dom eps is defined according to the mode parameter: if mode = ABSOLUTE then eps = p - f else eps = p/f -1 The supremum norm is computed with an enclosure error less than accuracy, i.e. the interval [l,u] obtained satisfies in the end: abs(u-l/l) <= abs(accuracy) If everything works fine, result is affected with an interval safely enclosing the supremum norm. The return value is then non-zero. Otherwise, if an error occurs, the return value is 0 and result is affected with [NaN;NaN]. A warning is printed in this case. */ int supremumnorm(sollya_mpfi_t result, node *poly, node *func, sollya_mpfi_t dom, int mode, mpfr_t accuracy) { mpfr_t a, b, diameter, temp, absAccuracy; mp_prec_t tempPrec; int res; if (!isPolynomial(poly)) { printMessage(1,SOLLYA_MSG_GIVEN_FUNCTION_IS_NO_POLYNOMIAL,"Warning: the given expression is not a polynomial.\n"); sollya_mpfi_set_nan(result); return 0; } tempPrec = sollya_mpfi_get_prec(dom); mpfr_init2(a,tempPrec); mpfr_init2(b,tempPrec); sollya_mpfi_get_left(a,dom); sollya_mpfi_get_right(b,dom); if (!(mpfr_number_p(a) && mpfr_number_p(b))) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_NO_CLOSED_INTERVAL_ON_THE_REALS,"Warning: the given domain is not a closed interval on the reals.\n"); sollya_mpfi_set_nan(result); mpfr_clear(a); mpfr_clear(b); return 0; } if (mpfr_cmp(a,b) > 0) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_EMPTY,"Warning: the given domain is empty.\n"); sollya_mpfi_set_nan(result); mpfr_clear(a); mpfr_clear(b); return 0; } if (mpfr_cmp(a,b) == 0) { printMessage(1,SOLLYA_MSG_DOMAIN_IS_REDUCED_TO_A_POINT_WILL_SIMPLY_EVAL,"Warning: the given domain is reduced to a point. Replacing the supremum norm with an evaluation.\n"); res = supremumNormDegenerate(result,poly,func,a,mode,accuracy); if (!res) { printMessage(1,SOLLYA_MSG_SUPNORM_COULD_NOT_EVALUATE_ERROR_FUNC,"Warning: could not evaluate the error function between the given polynomial and the given function at this point.\n"); sollya_mpfi_set_nan(result); } mpfr_clear(a); mpfr_clear(b); return 1; } if (!mpfr_number_p(accuracy)) { printMessage(1,SOLLYA_MSG_ACCUARCY_INDICATION_IS_NOT_A_REAL_NUMBER,"Warning: the given accuracy is not a real number.\n"); sollya_mpfi_set_nan(result); mpfr_clear(a); mpfr_clear(b); return 0; } if (mpfr_zero_p(accuracy)) { printMessage(1,SOLLYA_MSG_ACCUARCY_INDICATION_IS_ZERO,"Warning: the given accuracy is zero. In order to ensure the termination of the supremum norm algorithm, the accuracy parameter must be non-zero.\n"); sollya_mpfi_set_nan(result); mpfr_clear(a); mpfr_clear(b); return 0; } if (!hasOnlyMpqCoefficients(poly)) { printMessage(1,SOLLYA_MSG_POLYNOMIAL_HAS_NON_DYADIC_COEFFICIENTS,"Warning: the coefficients of the given polynomial cannot all be written as ratios of floating-point numbers.\nSupremum norm computation is only possible on such polynomials. Try to use roundcoefficients().\n"); sollya_mpfi_set_nan(result); mpfr_clear(a); mpfr_clear(b); return 0; } /* Here, we know that the interval is proper (no NaNs, no Infs) and that it is not reduced to a point. We know that accuracy is a non-zero number and that poly is a polynomial whose coefficients can be written in floating-point numbers or ratios of floating-point numbers. We will call supremumNormBisect with diam * width(dom) and abs(accuracy). */ mpfr_init2(temp,tempPrec * 4); mpfr_init2(diameter, tempPrec * 4 + 53); mpfr_sub(temp,b,a,GMP_RNDU); getToolDiameter(diameter); mpfr_mul(diameter,diameter,temp,GMP_RNDU); mpfr_abs(diameter,diameter,GMP_RNDN); mpfr_init2(absAccuracy,mpfr_get_prec(accuracy)); mpfr_abs(absAccuracy,accuracy,GMP_RNDN); /* exact */ res = supremumNormBisect(result,poly,func,a,b,mode,absAccuracy,diameter); if (!res) { printMessage(1,SOLLYA_MSG_SUPNORM_SAFE_ENCLOSURE_COULD_NOT_BE_COMPUTED,"Warning: an error occurred during supremum norm computation. A safe enclosure of the supremum norm could not be computed.\n"); sollya_mpfi_set_nan(result); } mpfr_clear(a); mpfr_clear(b); mpfr_clear(temp); mpfr_clear(diameter); mpfr_clear(absAccuracy); return res; } sollya-6.0+ds/supnorm.h000066400000000000000000000052151300174114700151410ustar00rootroot00000000000000/* Copyright 2010 by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. and Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, Contributors Ch. Lauter, M. Joldes christoph.lauter@ens-lyon.org joldes@laas.fr This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef SUPNORM_H #define SUPNORM_H #include #include "mpfi-compat.h" #include "execute.h" #include #include "expression.h" #include "infnorm.h" #include "autodiff.h" #include "taylorform.h" #include "chain.h" #include "sturm.h" int supremumnorm(sollya_mpfi_t result, node *poly, node *func, sollya_mpfi_t dom, int mode, mpfr_t accuracy); #endif /* SUPNORM_H */ sollya-6.0+ds/taylor.c000066400000000000000000000137571300174114700147550ustar00rootroot00000000000000/* Copyright 2006-2011 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include #include "taylor.h" #include "expression.h" #include "general.h" node *taylor(node* tree, int degree, node* point, mp_prec_t prec) { node *copy, *temp, *temp2, *fderiv, *fderivsubst, *denominator, *numerator, *expon, *variable, *term, *pointTemp; mpfr_t *value; mpz_t denominatorGMP; int i; if (!isConstant(point)) { printMessage(1,SOLLYA_MSG_DEVELOPMENT_POINT_NOT_CONSTANT,"Warning: the expression given for the development point is not constant.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Will evaluate the expression in %s = 0 before using it as development point.\n",((variablename == NULL) ? "_x_" : variablename)); temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = CONSTANT; value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,prec); mpfr_set_d(*value,0.0,GMP_RNDN); temp->value = value; temp2 = substitute(point,temp); pointTemp = simplifyTreeErrorfree(temp2); free_memory(temp); free_memory(temp2); } else { pointTemp = copyTree(point); } value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,prec); mpfr_set_d(*value,0.0,GMP_RNDN); copy = (node *) safeMalloc(sizeof(node)); copy->nodeType = CONSTANT; copy->value = value; mpz_init(denominatorGMP); fderiv = copyTree(tree); for (i=0;i<=degree;i++) { temp = substitute(fderiv,pointTemp); fderivsubst = simplifyTreeErrorfree(temp); free_memory(temp); mpz_fac_ui(denominatorGMP,(unsigned int) i); value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,prec); if(mpfr_set_z(*value,denominatorGMP,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_COMPUTATION_OF_TAYLOR_COEFFICIENT,"Warning: rounding occurred on computing a taylor constant factor.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } denominator = (node *) safeMalloc(sizeof(node)); denominator->nodeType = CONSTANT; denominator->value = value; value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,prec); mpfr_set_d(*value,1.0,GMP_RNDN); numerator = (node *) safeMalloc(sizeof(node)); numerator->nodeType = CONSTANT; numerator->value = value; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = DIV; temp->child1 = numerator; temp->child2 = denominator; temp2 = (node *) safeMalloc(sizeof(node)); temp2->nodeType = MUL; temp2->child1 = temp; temp2->child2 = fderivsubst; variable = (node *) safeMalloc(sizeof(node)); variable->nodeType = VARIABLE; value = (mpfr_t *) safeMalloc(sizeof(mpfr_t)); mpfr_init2(*value,prec); if(mpfr_set_si(*value,i,GMP_RNDN) != 0) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_COMPUTATION_OF_TAYLOR_POWER,"Warning: rounding occurred on computing a taylor exponent.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the working precision.\n"); } } expon = (node *) safeMalloc(sizeof(node)); expon->nodeType = CONSTANT; expon->value = value; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = POW; temp->child1 = variable; temp->child2 = expon; term = (node *) safeMalloc(sizeof(node)); term->nodeType = MUL; term->child1 = temp2; term->child2 = temp; temp = (node *) safeMalloc(sizeof(node)); temp->nodeType = ADD; temp->child1 = copy; temp->child2 = term; copy = temp; temp = differentiate(fderiv); free_memory(fderiv); fderiv = temp; } mpz_clear(denominatorGMP); free_memory(fderiv); temp = horner(copy); free_memory(copy); free_memory(pointTemp); return temp; } sollya-6.0+ds/taylor.h000066400000000000000000000044141300174114700147500ustar00rootroot00000000000000/* Copyright 2006-2009 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 Contributor Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef TAYLOR_H #define TAYLOR_H #include "expression.h" node *taylor(node* tree, int degree, node* point, mp_prec_t prec); #endif /* ifdef TAYLOR_H*/ sollya-6.0+ds/taylorform.c000066400000000000000000001367531300174114700156430ustar00rootroot00000000000000/* Copyright 2009-2012 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2) and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors S. Chevillard, M. Joldes, Ch. Lauter sylvain.chevillard@ens-lyon.fr joldes@laas.fr christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include "taylorform.h" #include "external.h" #include "infnorm.h" #include "autodiff.h" #include "general.h" #include #include /* This function creates an empty taylor model */ tModel* createEmptytModel(int n, sollya_mpfi_t x0, sollya_mpfi_t x){ tModel* t; mp_prec_t prec; int i; prec = getToolPrecision(); t= (tModel *)safeMalloc(sizeof(tModel)); sollya_mpfi_init2(t->rem_bound, prec); sollya_mpfi_init2(t->poly_bound, prec); sollya_mpfi_init2(t->x, prec); sollya_mpfi_set(t->x, x); sollya_mpfi_init2(t->x0, prec); sollya_mpfi_set(t->x0, x0); t->n = n; t->poly_array = (sollya_mpfi_t *)safeCalloc(n,sizeof(sollya_mpfi_t)); for(i=0;ipoly_array[i], prec); } return t; } /* This function dealocates a taylor model */ void cleartModel(tModel *t){ int i; for(i=0;in;i++) sollya_mpfi_clear(t->poly_array[i]); safeFree(t->poly_array); sollya_mpfi_clear(t->rem_bound); sollya_mpfi_clear(t->poly_bound); sollya_mpfi_clear(t->x); sollya_mpfi_clear(t->x0); safeFree(t); } /* This function pretty prints a taylor model */ void printtModel(tModel *t){ int i; sollyaPrintf("\nTaylor model of order, %d expanded in ", t->n); printInterval(t->x0); sollyaPrintf("over "); printInterval(t->x); sollyaPrintf("\nCoeffs:"); for(i=0;in;i++) { printInterval(t->poly_array[i]); if (i<(t->n)-1) sollyaPrintf(", "); } sollyaPrintf("\nremainder = "); printInterval(t->rem_bound); sollyaPrintf(",\nbound = "); printInterval(t->poly_bound); sollyaPrintf("\n"); } /* The convention for all the following functions is: the tmodel given as parameter has to be created previously */ /* This function sets the taylor model t with constant ct */ void consttModel(tModel*t, sollya_mpfi_t ct){ int i,n; n=t->n; for(i=1;ipoly_array[i], 0); } sollya_mpfi_set(t->poly_array[0], ct); sollya_mpfi_set(t->poly_bound, ct); sollya_mpfi_set_ui(t->rem_bound, 0); } /* Check that models are compatible one with another: i.e. they can be added, mulitplied, copied, etc. */ int tModelsAreCompatible(tModel *t1, tModel *t2) { return ((t1 != NULL) && (t2 != NULL) && (sollya_mpfi_equal_p(t1->x, t2->x) || (sollya_mpfi_nan_p(t1->x) && sollya_mpfi_nan_p(t2->x))) && (sollya_mpfi_equal_p(t1->x0, t2->x0) || (sollya_mpfi_nan_p(t1->x0) && sollya_mpfi_nan_p(t2->x0))) && (t1->n == t2->n)); } /* This function returns a copy of the taylor model tt */ void copytModel(tModel *t, tModel *tt){ int i; if (!tModelsAreCompatible(t, tt)) { printMessage(0, SOLLYA_MSG_ERROR_IN_TAYLORFORM_COPYING_INCOMPAT_MODELS, "Error in taylorform: trying to copy incompatible models.\n"); printMessage(0, SOLLYA_MSG_CONTINUATION, "No modification is made.\n"); return; } for(i=0;in;i++) { sollya_mpfi_set(t->poly_array[i], tt->poly_array[i]); } sollya_mpfi_set(t->rem_bound, tt->rem_bound); sollya_mpfi_set(t->poly_bound, tt->poly_bound); return; } /* Bound p(x-x0) over I, where p is a polynomial of degree n, given by the list of its coefficients */ void boundTranslatedPolynomialByHorner(sollya_mpfi_t bound, int n, sollya_mpfi_t *coeffs, sollya_mpfi_t x0, sollya_mpfi_t I){ sollya_mpfi_t temp; mp_prec_t prec; prec = getToolPrecision(); sollya_mpfi_init2(temp, prec); sollya_mpfi_sub(temp, I, x0); symbolic_poly_evaluation_horner(bound, coeffs, temp, n); sollya_mpfi_clear(temp); } /* This function computes an interval bound for a polynomial */ /* Maybe, it will be smarter than just Horner, one day */ /* For testing purpose, is is possible to plug an uncertified */ /* polynomialBound function instead of Horner here */ void polynomialBoundSharp(sollya_mpfi_t *bound, int n, sollya_mpfi_t *coeffs, sollya_mpfi_t x0, sollya_mpfi_t I){ boundTranslatedPolynomialByHorner(*bound,n,coeffs,x0,I); } /* This function transforms a polynomial with interval coeffs into a poly with mpfr coeffs and a small remainder Parameters: -- input: n - degree of poly p - array of given coeffs x0 - expansion point x - interval -- output: rc - mpfr coeffs errors - errors around the coeffs rc rest - remainder */ void mpfr_get_poly(mpfr_t *rc, sollya_mpfi_t *errors_array, sollya_mpfi_t rest, int n, sollya_mpfi_t *p, sollya_mpfi_t x0, sollya_mpfi_t x){ int i; sollya_mpfi_t *errors; sollya_mpfi_t temp; mp_prec_t prec; prec = getToolPrecision(); errors = (sollya_mpfi_t *)safeCalloc((n+1),sizeof(sollya_mpfi_t)); for (i=0; i<=n; i++) sollya_mpfi_init2(errors[i], prec); sollya_mpfi_init2(temp, prec); for (i=0; i<=n; i++){ sollya_mpfi_mid(rc[i], p[i]); sollya_mpfi_sub_fr(errors[i], p[i], rc[i]); if (errors_array != NULL) sollya_mpfi_set(errors_array[i], errors[i]); } sollya_mpfi_sub(temp, x, x0); symbolic_poly_evaluation_horner(rest, errors, temp, n); for (i=0; i<=n; i++) sollya_mpfi_clear(errors[i]); safeFree(errors); sollya_mpfi_clear(temp); return; } void multiplication_TM(tModel *t, tModel *t1, tModel *t2, int mode){ /* We will multiply two taylor models of order n; and obtain a new taylor model of order n */ int n,i,j; sollya_mpfi_t *r; /* used to store the least significant coeffs of the product */ tModel *tt; sollya_mpfi_t temp1, temp2; sollya_mpfi_t bound1, bound2, bound3; mp_prec_t prec; prec = getToolPrecision(); if ( (!tModelsAreCompatible(t1, t2)) || (!tModelsAreCompatible(t, t1)) ) { printMessage(0, SOLLYA_MSG_ERROR_IN_TAYLORFORM_MULTIPLYING_INCOMPAT_MODELS, "Error in taylorform: trying to multiply incompatible models.\n"); printMessage(0, SOLLYA_MSG_CONTINUATION,"No modification is made.\n"); return; } n = t->n; /* aux tm for doing the multiplications */ tt = createEmptytModel(n, t->x0, t->x); for(i=0; i<=n-1; i++){ sollya_mpfi_set_ui(tt->poly_array[i], 0); } sollya_mpfi_init2(temp1, prec); sollya_mpfi_init2(temp2, prec); sollya_mpfi_init2(bound1, prec); sollya_mpfi_init2(bound2, prec); sollya_mpfi_init2(bound3, prec); /* bound1 <- delta2*B(T1) + delta1*B(T2) */ sollya_mpfi_mul(temp1, t1->poly_bound, t2->rem_bound); sollya_mpfi_mul(temp2, t1->rem_bound, t2->poly_bound); sollya_mpfi_add(bound1, temp1, temp2); /**************************************************************************************/ /* Compute the product of the two polynomials */ /* */ /* The product has degree 2n-2: the first n coefficients are stored in tt->poly_array */ /* and the (n-1) remaining coefficients are stored in r. */ /* When mode = ABSOLUTE, r = [0, 0 ...., 0, r0, ..., r(n-2)] */ /* it represents the polynomial T1*T2|[n....2n-2] */ /* When mode = RELATIVE, r = [r0, ..., r(n-2), 0, 0, ....] */ /* it represents the polynomial T1*T2|[n....2n-2] / (x-x0)^n */ /**************************************************************************************/ r = (sollya_mpfi_t *)safeCalloc((2*n-1),sizeof(sollya_mpfi_t)); for(i=0; i < 2*n-1; i++){ sollya_mpfi_init2(r[i], prec); sollya_mpfi_set_ui(r[i],0); } for(i=0; ipoly_array[i], t2->poly_array[j]); if ( (i+j) < n ) sollya_mpfi_add(tt->poly_array[i+j], tt->poly_array[i+j], temp1); else if (mode==RELATIVE) sollya_mpfi_add(r[i+j-n], r[i+j-n], temp1); else sollya_mpfi_add(r[i+j], r[i+j], temp1); } } /* bound2 <- B(T1*T2|[n....2n-2]) or B(T1*T2|[n....2n-2]/(x-x0)^n) depending on the mode */ if (mode == RELATIVE) polynomialBoundSharp(&bound2, n-2, r, t->x0, t->x); else polynomialBoundSharp(&bound2, 2*n-2, r, t->x0, t->x); /* bound3 <- delta1*delta2*B((x-x0)^n) or delta1*delta2 depending on the mode */ sollya_mpfi_mul(bound3, t1->rem_bound, t2->rem_bound); if (mode == RELATIVE) { sollya_mpfi_sub(temp1,t->x,t->x0); sollya_mpfi_set_ui(temp2, n); sollya_mpfi_pow(temp1, temp1, temp2); sollya_mpfi_mul(bound3, bound3, temp1); } /* We are multiplying taylor models: *considering the RELATIVE error We are given: (T1,delta1*(x-x0)^n (T2,delta2*(x-x0)^n The product is: (T1*T2|[0...n-1], {delta1*B(T2)+delta2*B(T1)+delta1*delta2*B((x-x0)^n)+B(T1*T2|[n...2*n-2]/(x-x0)^n)} *(x-x0)^n *considering the ABSOLUTE error We are given: (T1,delta1) (T2,delta2) The product is: (T1*T2|[0...n-1], {delta1*B(T2)+delta2*B(T1)+delta1*delta2+B(T1*T2|[n...2*n-2])} */ sollya_mpfi_add(tt->rem_bound, bound1, bound2); sollya_mpfi_add(tt->rem_bound, tt->rem_bound, bound3); /* now the remainder bound is completely computed */ /* we compute the new polynomial bound for the new model */ polynomialBoundSharp(&temp1, n-1,tt->poly_array,t->x0,t->x); sollya_mpfi_set(tt->poly_bound,temp1); for(i=0;i<2*n-1;i++) sollya_mpfi_clear(r[i]); safeFree(r); sollya_mpfi_clear(temp1); sollya_mpfi_clear(temp2); sollya_mpfi_clear(bound1); sollya_mpfi_clear(bound2); sollya_mpfi_clear(bound3); copytModel(t,tt); cleartModel(tt); return; } /* This function computes the tm for addition of two given tm's The addition of two taylor models is the same, regardless the mode, absolute or relative - We put the parameter just to have some coherence with the other functions */ void addition_TM(tModel *t,tModel *t1, tModel *t2, int mode){ int i; int n; tModel *tt; UNUSED_PARAM(mode); if ( (!tModelsAreCompatible(t1, t2)) || (!tModelsAreCompatible(t, t1)) ) { printMessage(0, SOLLYA_MSG_ERROR_IN_TAYLORFORM_MULTIPLYING_INCOMPAT_MODELS, "Error in taylorform: trying to multiply incompatible models.\n"); printMessage(0, SOLLYA_MSG_CONTINUATION, "No modification is made.\n"); return; } n=t->n; tt=createEmptytModel(n,t->x0,t->x); for(i=0;ipoly_array[i], t1->poly_array[i], t2->poly_array[i]); sollya_mpfi_add(tt->rem_bound, t1->rem_bound, t2->rem_bound); polynomialBoundSharp(&tt->poly_bound, n-1, tt->poly_array, t->x0, t->x); copytModel(t,tt); cleartModel(tt); return; } /* This function computes the tm for multiplication by a constant */ void ctMultiplication_TM(tModel*d, tModel*s, sollya_mpfi_t c,int mode){ int i; int n; tModel *tt; UNUSED_PARAM(mode); n=s->n; tt=createEmptytModel(n, s->x0, s->x); for(i=0; ipoly_array[i], s->poly_array[i], c); sollya_mpfi_mul(tt->rem_bound, s->rem_bound, c); sollya_mpfi_mul(tt->poly_bound, s->poly_bound, c); copytModel(d,tt); cleartModel(tt); } #define MONOTONE_REMAINDER_BASE_FUNCTION 0 #define MONOTONE_REMAINDER_LIBRARY_FUNCTION 1 #define MONOTONE_REMAINDER_INV 2 #define MONOTONE_REMAINDER_CONSTPOWERVAR 3 #define MONOTONE_REMAINDER_VARCONSTPOWER 4 #define MONOTONE_REMAINDER_PROCEDURE_FUNCTION 5 /* This function computes a taylor remainder for a function on an interval, assuming the n-th derivative in the absolute case and the n+1 derivative in the relative case has constant sign over the considered interval. typeOfFunction is used to separate the cases: * MONOTONE_REMAINDER_BASE_FUNCTION --> we consider a base function, represented by its nodeType (p and f are useless) * MONOTONE_REMAINDER_LIBRARY_FUNCTION --> we consider a base function, represented by its nodeType (p and nodeType are useless) * MONOTONE_REMAINDER_PROCEDURE_FUNCTION --> we consider a base function, represented by its nodeType (p and nodeType are useless) * MONOTONE_REMAINDER_INV --> we consider (x -> 1/x) (nodeType, f, and p are useless) * MONOTONE_REMAINDER_CONSTPOWERVAR --> we consider (x -> p^x) (nodeType and f are useless) * MONOTONE_REMAINDER_VARCONSTPOWER --> we consider (x -> x^p) (nodeType and f are useless) The coeffs of the series expansion are given as an array of mpfi's, developed over x, in x0. For more details, see Lemmas 5.11 and following from Roland Zumkeller's thesis. It returns 1 in case of success, and 0 if the computed bound is useless (i.e. if inf(x) or sup(x) and x0 intersect) */ /* FIXME: maybe boundx0 can be safely replaced by [0] */ int computeMonotoneRemainder(sollya_mpfi_t *bound, int mode, int typeOfFunction, int nodeType, node *f, mpfr_t p, int n, sollya_mpfi_t *poly_array, sollya_mpfi_t x0, sollya_mpfi_t x, int *silent){ sollya_mpfi_t xinf, xsup; mpfr_t xinfFr, xsupFr; sollya_mpfi_t bound1, bound2, boundx0, boundf1, boundf2, boundfx0; sollya_mpfi_t p_interv; sollya_mpfi_t pow; mp_prec_t prec; int ok=1; prec = getToolPrecision(); sollya_mpfi_init2(xinf, prec); sollya_mpfi_init2(xsup, prec); mpfr_init2(xinfFr, prec); mpfr_init2(xsupFr, prec); sollya_mpfi_init2(bound1, prec); sollya_mpfi_init2(bound2, prec); sollya_mpfi_init2(boundx0, prec); sollya_mpfi_init2(boundf1, prec); sollya_mpfi_init2(boundf2, prec); sollya_mpfi_init2(boundfx0, prec); sollya_mpfi_init2(p_interv, prec); sollya_mpfi_get_left(xinfFr,x); sollya_mpfi_get_right(xsupFr,x); sollya_mpfi_set_fr(xinf, xinfFr); sollya_mpfi_set_fr(xsup, xsupFr); polynomialBoundSharp(&bound1, n-1, poly_array, x0, xinf); /* enclosure of p(xinf-x0) */ polynomialBoundSharp(&bound2, n-1, poly_array, x0, xsup); /* enclosure of p(xsup-x0) */ if ((mode==ABSOLUTE)&&(n%2==0)) polynomialBoundSharp(&boundx0, n-1, poly_array, x0, x0); /* enclosure of p(x0-x0) */ /* enclosure of f(xinf) and f(xsup) */ switch(typeOfFunction) { case MONOTONE_REMAINDER_BASE_FUNCTION: baseFunction_diff(&boundf1,nodeType,xinf,0, silent); baseFunction_diff(&boundf2,nodeType,xsup,0, silent); if ((mode==ABSOLUTE)&&(n%2==0)) baseFunction_diff(&boundfx0,nodeType,x0,0, silent); break; case MONOTONE_REMAINDER_LIBRARY_FUNCTION: libraryFunction_diff(&boundf1, accessThruMemRef(f), xinf, 0, silent); libraryFunction_diff(&boundf2, accessThruMemRef(f), xsup, 0, silent); if ((mode==ABSOLUTE)&&(n%2==0)) libraryFunction_diff(&boundfx0, accessThruMemRef(f), x0, 0, silent); break; case MONOTONE_REMAINDER_PROCEDURE_FUNCTION: procedureFunction_diff(&boundf1, accessThruMemRef(f), xinf, 0, silent); procedureFunction_diff(&boundf2, accessThruMemRef(f), xsup, 0, silent); if ((mode==ABSOLUTE)&&(n%2==0)) procedureFunction_diff(&boundfx0, accessThruMemRef(f), x0, 0, silent); break; case MONOTONE_REMAINDER_INV: sollya_mpfi_inv(boundf1, xinf); sollya_mpfi_inv(boundf2, xsup); if ((mode==ABSOLUTE)&&(n%2==0)) sollya_mpfi_inv(boundfx0, x0); break; case MONOTONE_REMAINDER_CONSTPOWERVAR: sollya_mpfi_set_fr(p_interv, p); sollya_mpfi_pow(boundf1, xinf, p_interv); sollya_mpfi_pow(boundf2, xsup, p_interv); if ((mode==ABSOLUTE)&&(n%2==0)) sollya_mpfi_pow(boundfx0, x0, p_interv); break; case MONOTONE_REMAINDER_VARCONSTPOWER: sollya_mpfi_set_fr(p_interv,p); sollya_mpfi_pow(boundf1, p_interv, xinf); sollya_mpfi_pow(boundf2, p_interv, xsup); if ((mode==ABSOLUTE)&&(n%2==0)) sollya_mpfi_pow(boundfx0, p_interv, x0); break; default: printMessage(0, SOLLYA_MSG_ERROR_IN_TAYLORFORM_UNKNOWN_FUNC_FOR_ZUMKELLER, "Error in taylorform: unknown type of function used with Zumkeller's technique\n"); return 0; } sollya_mpfi_sub(bound1,boundf1,bound1); /* enclosure of f(xinf)-p(xinf-x0) */ sollya_mpfi_sub(bound2,boundf2,bound2); /* enclosure of f(xsup)-p(xsup-x0) */ if ((mode==ABSOLUTE)&&(n%2==0)) sollya_mpfi_sub(boundx0,boundfx0,boundx0); /* enclosure of f(x0)-p(x0-x0) */ if (mode==ABSOLUTE){ /* in the case when n-1 is even, the remainder is bounded by the values it takes on the two extremas of the interval */ sollya_mpfi_union(*bound, bound1, bound2); /* in the case when n-1 is odd, the remainder is in the convex hull determined by the two extremas and the value in x0 (which is 0, theoretically, but since x0 is a small interval... */ if (n%2==0) sollya_mpfi_union(*bound,*bound,boundx0); ok=1; } else { /* for RELATIVE, we have to bound: -- (f(xinf)-p(xinf-x0))/(xinf-x0)^n -- (f(xsup)-p(xsup-x0))/(xsup-x0)^n If ever xsup\cap x0 is not empty, the computed bound is infinite, so, there is no point in applying this remark, we return ok=0, such that we can fall back to the simple case. */ ok=1; sollya_mpfi_init2(pow, prec); sollya_mpfi_set_ui(pow, n); sollya_mpfi_sub(xinf, xinf, x0); sollya_mpfi_pow(xinf,xinf,pow); sollya_mpfi_div(bound1, bound1, xinf); sollya_mpfi_sub(xsup, xsup, x0); sollya_mpfi_pow(xsup,xsup,pow); sollya_mpfi_div(bound2, bound2, xsup); sollya_mpfi_union(*bound, bound1, bound2); if ( (sollya_mpfi_has_zero(xinf))|| (sollya_mpfi_has_zero(xsup)) ) ok=0; sollya_mpfi_clear(pow); } mpfr_clear(xinfFr); mpfr_clear(xsupFr); sollya_mpfi_clear(xinf); sollya_mpfi_clear(xsup); sollya_mpfi_clear(bound1); sollya_mpfi_clear(bound2); sollya_mpfi_clear(boundx0); sollya_mpfi_clear(boundf1); sollya_mpfi_clear(boundf2); sollya_mpfi_clear(boundfx0); sollya_mpfi_clear(p_interv); return ok; } /* This function computes a taylor model for a function, with the same convention as with computeMonotoneRemainder */ void base_TMAux(tModel *t, int typeOfFunction, int nodeType, node *f, mpfr_t p, int n, sollya_mpfi_t x0, sollya_mpfi_t x, int mode, int *silent){ int i, useZ; tModel *tt; sollya_mpfi_t *nDeriv; sollya_mpfi_t temp, pow; mpfr_t minusOne; mp_prec_t prec; prec = getToolPrecision(); tt = createEmptytModel(n,x0,x); /* We use AD for computing bound on the derivatives: -- we need the nth derivative for usual Absolute & Relative cases -- In order to try to apply Zumkeller Remark in Absolute case, we also need the nth derivative -- In order to try to apply Zumkeller Remark in Relative case, we need the (n+1)th derivative */ if (mode==RELATIVE) { nDeriv= (sollya_mpfi_t *)safeCalloc((n+2),sizeof(sollya_mpfi_t)); for(i=0;i<=n+1;i++) sollya_mpfi_init2(nDeriv[i], prec); } else { nDeriv= (sollya_mpfi_t *)safeCalloc((n+1),sizeof(sollya_mpfi_t)); for(i=0;i<=n;i++) sollya_mpfi_init2(nDeriv[i], prec); } switch(typeOfFunction) { case MONOTONE_REMAINDER_BASE_FUNCTION: baseFunction_diff(tt->poly_array,nodeType,x0, n-1, silent); baseFunction_diff(nDeriv, nodeType, x, (mode==RELATIVE)?(n+1):n, silent); break; case MONOTONE_REMAINDER_LIBRARY_FUNCTION: libraryFunction_diff(tt->poly_array, accessThruMemRef(f), x0, n-1, silent); libraryFunction_diff(nDeriv, accessThruMemRef(f), x, (mode==RELATIVE)?(n+1):n, silent); break; case MONOTONE_REMAINDER_PROCEDURE_FUNCTION: procedureFunction_diff(tt->poly_array, accessThruMemRef(f), x0, n-1, silent); procedureFunction_diff(nDeriv, accessThruMemRef(f), x, (mode==RELATIVE)?(n+1):n, silent); break; case MONOTONE_REMAINDER_INV: mpfr_init2(minusOne, prec); mpfr_set_si(minusOne, -1, GMP_RNDN); constantPower_diff(tt->poly_array, x0, minusOne, n-1, silent); constantPower_diff(nDeriv, x, minusOne, (mode==RELATIVE)?(n+1):n, silent); mpfr_clear(minusOne); break; case MONOTONE_REMAINDER_CONSTPOWERVAR: constantPower_diff(tt->poly_array, x0, p, n-1, silent); constantPower_diff(nDeriv, x, p, (mode==RELATIVE)?(n+1):n, silent); break; case MONOTONE_REMAINDER_VARCONSTPOWER: powerFunction_diff(tt->poly_array, p, x0, n-1, silent); powerFunction_diff(nDeriv, p, x, (mode==RELATIVE)?(n+1):n, silent); break; default: printMessage(0, SOLLYA_MSG_ERROR_IN_TAYLORFORM_UNKNOWN_FUNC_FOR_ZUMKELLER, "Error in taylorform: unknown type of function used with Zumkeller's technique\n"); return; } /* Use Zumkeller technique to improve the bound in the absolute case, when the nth derivative has constant sign */ /* Use an adaptation of Zumkeller technique to improve the bound in the relative case, when the (n+1)th derivative has constant sign */ useZ=0; if ( ((mode==ABSOLUTE)&&((sollya_mpfi_is_nonpos(nDeriv[n]) > 0)||(sollya_mpfi_is_nonneg(nDeriv[n]) > 0))) || ((mode==RELATIVE)&&((sollya_mpfi_is_nonpos(nDeriv[n+1]) > 0)||(sollya_mpfi_is_nonneg(nDeriv[n+1]) > 0))) ){ useZ= computeMonotoneRemainder(&tt->rem_bound, mode, typeOfFunction, nodeType, f, p, n, tt->poly_array, x0,x, silent); } if (useZ==0){ /* just keep the bound obtained using AD */ sollya_mpfi_set(tt->rem_bound, nDeriv[n]); /* if we are in the case of the absolute error, we have to multiply by (x-x0)^n */ if (mode==ABSOLUTE) { sollya_mpfi_init2(pow, prec); sollya_mpfi_set_ui(pow, n); sollya_mpfi_init2(temp, prec); sollya_mpfi_sub(temp,x,x0); sollya_mpfi_pow(temp, temp, pow); sollya_mpfi_mul(tt->rem_bound,tt->rem_bound,temp); sollya_mpfi_clear(pow); sollya_mpfi_clear(temp); } } /* bound the polynomial obtained */ polynomialBoundSharp(&tt->poly_bound, n-1,tt->poly_array,t->x0,t->x); copytModel(t,tt); cleartModel(tt); if (mode==RELATIVE) { for(i=0;i<=n+1;i++) sollya_mpfi_clear(nDeriv[i]); } else { for(i=0;i<=n;i++) sollya_mpfi_clear(nDeriv[i]); } safeFree(nDeriv); } /* composition: g o f VERY IMPORTANT ASSUMPTIONS: We are given a taylor model for the function f in x0, over x, order n and a taylor model for basic function g in y0 over y, order n with: f->poly_array[0] \subseteq y0 range(f->poly)+ f->rem_bound \subseteq y Note that these assumptions ARE NOT CHECKED inside the function. If these assumptions are true, it returns a valid taylor model for g(f(x)) in x0 over x. */ void composition_TM(tModel *t,tModel *g, tModel *f, int mode){ int i; int n; tModel *tt, *partial_tmul,*tinterm,*tmul ; mp_prec_t prec; sollya_mpfi_t temp; prec = getToolPrecision(); n=f->n; /* create a taylor model equal to the model of f, but the constant coeff, which is zero */ tmul = createEmptytModel(n, f->x0, f->x); copytModel(tmul,f); sollya_mpfi_set_ui(tmul->poly_array[0],0); sollya_mpfi_sub(tmul->poly_bound, f->poly_bound, f->poly_array[0]); /* partial_tmul is used to represent the successive powers of tmul */ partial_tmul=createEmptytModel(n,f->x0,f->x); copytModel(partial_tmul, tmul); /* initialize a temporary model */ tinterm = createEmptytModel(n, f->x0, f->x); /* Constructs the model to be returned */ tt=createEmptytModel(n, f->x0, f->x); consttModel(tt, g->poly_array[0]); for(i=1; ipoly_array[i], mode); addition_TM(tt, tt, tinterm, mode); multiplication_TM(partial_tmul, partial_tmul, tmul, mode); } /* Now, partial_tmul represents tmul^n */ if (mode==RELATIVE) { sollya_mpfi_init2(temp, prec); sollya_mpfi_mul(temp, partial_tmul->rem_bound, g->rem_bound); sollya_mpfi_add(tt->rem_bound, tt->rem_bound, temp); sollya_mpfi_clear(temp); } else sollya_mpfi_add(tt->rem_bound,tt->rem_bound,g->rem_bound); polynomialBoundSharp(&tt->poly_bound, n-1, tt->poly_array, tt->x0, tt->x); copytModel(t,tt); cleartModel(tt); cleartModel(partial_tmul); cleartModel(tmul); cleartModel(tinterm); } /* This function computes a tm of order n from a given tm of higher order */ void reduceOrder_TM(tModel*d, tModel*s, int n){ int i; int oldn; sollya_mpfi_t *remTerms; tModel *tt; sollya_mpfi_t pow; sollya_mpfi_t temp, temp2; mp_prec_t prec; oldn=s->n; prec = getToolPrecision(); if (n>oldn) { printMessage(0, SOLLYA_MSG_ERROR_IN_TAYLORFORM_TRYING_TO_INCREASE_DEGREE, "Error: taylorform: trying to increase the order of a TM\n"); return; } tt=createEmptytModel(n,s->x0,s->x); for(i=0;ipoly_array[i], s->poly_array[i]); /* we are left with terms from n up to oldn-1 */ remTerms= (sollya_mpfi_t *)safeCalloc((oldn-n),sizeof(sollya_mpfi_t)); for(i=n;ipoly_array[i]); } sollya_mpfi_init2(temp, prec); polynomialBoundSharp(&temp, oldn-n-1, remTerms, tt->x0, tt->x); polynomialBoundSharp(&tt->poly_bound, n-1,tt->poly_array,tt->x0,tt->x); sollya_mpfi_init2(pow, prec); sollya_mpfi_init2(temp2, prec); sollya_mpfi_set_ui(pow,oldn-n); sollya_mpfi_sub(temp2,tt->x,tt->x0); sollya_mpfi_pow(temp2,temp2,pow); sollya_mpfi_mul(temp2,temp2,s->rem_bound); sollya_mpfi_add(tt->rem_bound,temp2,temp); copytModel(d,tt); cleartModel(tt); sollya_mpfi_clear(temp); sollya_mpfi_clear(temp2); sollya_mpfi_clear(pow); for(i=0;in; newn=oldn-l-1; tt=createEmptytModel(newn,s->x0,s->x); for (i=l+1;ipoly_array[i-l-1],s->poly_array[i]); } /*remainder: it is the same, since this remove coeffs is equivalent to a formal simplification //by (x-x0)^(oldn-newn) //Delta * (x-x0)^oldn --> Delta*(x-x0)^newn */ sollya_mpfi_set(tt->rem_bound,s->rem_bound); polynomialBoundSharp(&tt->poly_bound, newn-1,tt->poly_array,tt->x0,tt->x); copytModel(d,tt); cleartModel(tt); } void taylor_model(tModel *t, node *f, int n, sollya_mpfi_t x0, sollya_mpfi_t x, int mode) { int i; node *simplifiedChild1, *simplifiedChild2; sollya_mpfi_t temp1,temp2; tModel *tt, *child1_tm, *child2_tm, *ctPowVar_tm, *varCtPower_tm, *logx_tm, *expx_tm, *logf_tm; /*used by division*/ sollya_mpfi_t gx0,rangeg; tModel *ttt, *inv_tm, *child1Extended_tm, *child2Extended_tm, *child1RemoveCoeffs_tm,*child2RemoveCoeffs_tm; int orderUpperBound; int silent = 0; sollya_mpfi_t powx; sollya_mpfi_t ct, minusOne; /*used by base functions*/ sollya_mpfi_t fx0,rangef,pow; switch (accessThruMemRef(f)->nodeType) { case VARIABLE: tt=createEmptytModel(n,x0,x); sollya_mpfi_set(tt->poly_array[0],x0); if (n==1){ if (mode==RELATIVE){ sollya_mpfi_set_ui(tt->rem_bound,1); sollya_mpfi_set(tt->poly_bound,x0); } else{ /*absolute*/ sollya_mpfi_sub(tt->rem_bound,x,x0); sollya_mpfi_set(tt->poly_bound,x0); } } else{ sollya_mpfi_set_ui(tt->rem_bound,0); sollya_mpfi_set_ui(tt->poly_array[1],1); for (i=2;ipoly_array[i],0); } sollya_mpfi_set(tt->poly_bound,x); } copytModel(t,tt); cleartModel(tt); break; case PI_CONST: case CONSTANT: case LIBRARYCONSTANT: sollya_mpfi_init2(ct, getToolPrecision()); tt=createEmptytModel(n,x0,x); if (accessThruMemRef(f)->nodeType == PI_CONST) sollya_mpfi_const_pi(ct); else if (accessThruMemRef(f)->nodeType == LIBRARYCONSTANT) libraryConstantToInterval(ct, accessThruMemRef(f)); else sollya_mpfi_set_fr(ct, *(accessThruMemRef(f)->value)); consttModel(tt,ct); sollya_mpfi_set_ui(tt->rem_bound,0); sollya_mpfi_set(tt->poly_bound,ct); copytModel(t,tt); cleartModel(tt); sollya_mpfi_clear(ct); break; case NEG: tt=createEmptytModel(n,x0,x); /*create a new empty taylor model the child */ child1_tm=createEmptytModel(n, x0, x); /*all taylor_model on the child */ taylor_model(child1_tm, accessThruMemRef(f)->child1,n,x0,x,mode); /*do the necessary chages from child to parent */ for(i=0;ipoly_array[i], child1_tm->poly_array[i]); sollya_mpfi_neg(tt->rem_bound,child1_tm->rem_bound); sollya_mpfi_neg(tt->poly_bound,child1_tm->poly_bound); copytModel(t,tt); /*clear old taylor models */ cleartModel(child1_tm); cleartModel(tt); break; case ADD: /*create a new empty taylor model the children */ tt=createEmptytModel(n,x0,x); child1_tm=createEmptytModel(n, x0,x); child2_tm=createEmptytModel(n, x0,x); /*call taylor_model on the children */ taylor_model(child1_tm, accessThruMemRef(f)->child1,n,x0,x,mode); taylor_model(child2_tm, accessThruMemRef(f)->child2,n,x0,x,mode); addition_TM(tt,child1_tm, child2_tm,mode); copytModel(t,tt); /*clear old taylor model */ cleartModel(child1_tm); cleartModel(child2_tm); cleartModel(tt); break; case SUB: tt=createEmptytModel(n,x0,x); /*create a new empty taylor model the children*/ child1_tm=createEmptytModel(n, x0,x); child2_tm=createEmptytModel(n, x0,x); /*call taylor_model on the children */ taylor_model(child1_tm, accessThruMemRef(f)->child1,n,x0,x,mode); taylor_model(child2_tm, accessThruMemRef(f)->child2,n,x0,x,mode); /*do the necessary chages from children to parent */ sollya_mpfi_init2(minusOne,getToolPrecision()); sollya_mpfi_set_si(minusOne,-1); ctMultiplication_TM(child2_tm,child2_tm, minusOne,mode); addition_TM(tt,child1_tm, child2_tm,mode); copytModel(t,tt); /*clear old taylor model */ cleartModel(child1_tm); cleartModel(child2_tm); cleartModel(tt); sollya_mpfi_clear(minusOne); break; case MUL: tt=createEmptytModel(n,x0,x); /*create a new empty taylor model the children */ child1_tm=createEmptytModel(n,x0,x); child2_tm=createEmptytModel(n, x0,x); /*call taylor_model on the children*/ taylor_model(child1_tm, accessThruMemRef(f)->child1,n,x0,x,mode); taylor_model(child2_tm, accessThruMemRef(f)->child2,n,x0,x,mode); /*do the necessary chages from children to parent*/ multiplication_TM(tt,child1_tm, child2_tm,mode); copytModel(t,tt); /*clear old taylor model*/ cleartModel(child1_tm); cleartModel(child2_tm); cleartModel(tt); break; case DIV: /*child1 * inverse(child2)*/ tt=createEmptytModel(n,x0,x); /*check whether g(x0)is zero*/ sollya_mpfi_init2(gx0, getToolPrecision()); evaluateInterval(gx0,accessThruMemRef(f)->child2, NULL, x0) ; ttt=createEmptytModel(n,x0,x); if ((sollya_mpfi_is_zero(gx0))&& (mode==RELATIVE)){ orderUpperBound=10; /*create a new empty taylor model the child*/ child1Extended_tm=createEmptytModel(n+orderUpperBound,x0,x); child2Extended_tm=createEmptytModel(n+orderUpperBound,x0,x); /*call taylor_model for the children*/ taylor_model(child1Extended_tm, accessThruMemRef(f)->child1,n+orderUpperBound,x0,x,mode); taylor_model(child2Extended_tm, accessThruMemRef(f)->child2,n+orderUpperBound,x0,x,mode); /*reduce order taylor model*/ int l; l=0; while((sollya_mpfi_is_zero(child1Extended_tm->poly_array[l])) && (sollya_mpfi_is_zero(child2Extended_tm->poly_array[l]))){ l++;} /*printf("The order of the zero is: %d",l);*/ /*remove coeffs that are 0*/ child1RemoveCoeffs_tm=createEmptytModel(n+orderUpperBound-l,x0,x); child2RemoveCoeffs_tm=createEmptytModel(n+orderUpperBound-l,x0,x); removeCoeffs_TM(child1RemoveCoeffs_tm, child1Extended_tm, l-1); removeCoeffs_TM(child2RemoveCoeffs_tm, child2Extended_tm, l-1); child1_tm=createEmptytModel(n,x0,x); child2_tm=createEmptytModel(n,x0,x); reduceOrder_TM(child1_tm,child1RemoveCoeffs_tm,n); reduceOrder_TM(child2_tm,child2RemoveCoeffs_tm,n); /*printf("\nThe reduced tm are:\n"); printtModel(child1_tm); printtModel(child2_tm); */ cleartModel(child1RemoveCoeffs_tm); cleartModel(child2RemoveCoeffs_tm); cleartModel(child1Extended_tm); cleartModel(child2Extended_tm); }/*we have reduced the poles, we have taylor models of order n, we apply the basic division*/ else{/*just create tms or order n directly*/ /*create a new empty taylor model the child*/ child1_tm=createEmptytModel(n,x0,x); child2_tm=createEmptytModel(n,x0,x); /*call taylor_model for the children*/ taylor_model(child1_tm, accessThruMemRef(f)->child1,n,x0,x,mode); taylor_model(child2_tm, accessThruMemRef(f)->child2,n,x0,x,mode); } sollya_mpfi_set(gx0,child2_tm->poly_array[0]); sollya_mpfi_init2(rangeg, getToolPrecision()); sollya_mpfi_init2(powx, getToolPrecision()); sollya_mpfi_set_ui(powx,n); if (mode==RELATIVE){ sollya_mpfi_sub(rangeg, child2_tm->x,child2_tm->x0); sollya_mpfi_pow(rangeg,rangeg,powx); sollya_mpfi_mul(rangeg,rangeg,child2_tm->rem_bound); sollya_mpfi_add(rangeg,rangeg, child2_tm->poly_bound); } else { sollya_mpfi_add(rangeg,child2_tm->rem_bound,child2_tm->poly_bound); } inv_tm=createEmptytModel(n,gx0,rangeg); base_TMAux(inv_tm, MONOTONE_REMAINDER_INV, 0, NULL, NULL, n, gx0, rangeg,mode,&silent); composition_TM(ttt,inv_tm,child2_tm,mode); multiplication_TM(tt, ttt, child1_tm,mode); /*clear old children*/ cleartModel(child1_tm); cleartModel(child2_tm); cleartModel(inv_tm); cleartModel(ttt); copytModel(t,tt); cleartModel(tt); sollya_mpfi_clear(rangeg); sollya_mpfi_clear(powx); sollya_mpfi_clear(gx0); break; case SQRT: case EXP: case LOG: case LOG_2: case LOG_10: case SIN: case COS: case TAN: case ASIN: case ACOS: case ATAN: case SINH: case COSH: case TANH: case ASINH: case ACOSH: case ATANH: case ABS: case SINGLE: case QUAD: case HALFPRECISION: case DOUBLE: case DOUBLEDOUBLE: case TRIPLEDOUBLE: case ERF: case ERFC: case LOG_1P: case EXP_M1: case DOUBLEEXTENDED: case CEIL: case FLOOR: case NEARESTINT: case LIBRARYFUNCTION: case PROCEDUREFUNCTION: tt=createEmptytModel(n,x0,x); /*create a new empty taylor model the child*/ child1_tm=createEmptytModel(n,x0,x); /*call taylor_model on the child*/ taylor_model(child1_tm, accessThruMemRef(f)->child1,n,x0,x,mode); /*compute tm for the basic case*/ sollya_mpfi_init2(fx0,getToolPrecision()); sollya_mpfi_init2(rangef, getToolPrecision()); sollya_mpfi_init2(pow, getToolPrecision()); sollya_mpfi_set_ui(pow,n); evaluateInterval(fx0, accessThruMemRef(f)->child1, NULL, x0); if (mode==RELATIVE){ sollya_mpfi_sub(rangef, x,x0); sollya_mpfi_pow(rangef,rangef,pow); sollya_mpfi_mul(rangef,rangef,child1_tm->rem_bound); sollya_mpfi_add(rangef,rangef, child1_tm->poly_bound); } else{ sollya_mpfi_add(rangef,child1_tm->rem_bound, child1_tm->poly_bound); } child2_tm=createEmptytModel(n,fx0,rangef); if (accessThruMemRef(f)->nodeType == LIBRARYFUNCTION) base_TMAux(child2_tm, MONOTONE_REMAINDER_LIBRARY_FUNCTION, 0, accessThruMemRef(f), NULL, n, fx0, rangef,mode,&silent); else if (accessThruMemRef(f)->nodeType == PROCEDUREFUNCTION) base_TMAux(child2_tm, MONOTONE_REMAINDER_PROCEDURE_FUNCTION, 0, accessThruMemRef(f), NULL, n, fx0, rangef,mode,&silent); else base_TMAux(child2_tm, MONOTONE_REMAINDER_BASE_FUNCTION, accessThruMemRef(f)->nodeType, NULL, NULL, n, fx0, rangef,mode,&silent); composition_TM(tt,child2_tm, child1_tm,mode); cleartModel(child1_tm); cleartModel(child2_tm); copytModel(t,tt); cleartModel(tt); sollya_mpfi_clear(fx0); sollya_mpfi_clear(rangef); sollya_mpfi_clear(pow); break; case POW: /*create the result taylorModel*/ tt=createEmptytModel(n,x0,x); simplifiedChild2=simplifyTreeErrorfree(accessThruMemRef(f)->child2); simplifiedChild1=simplifyTreeErrorfree(accessThruMemRef(f)->child1); if ((accessThruMemRef(simplifiedChild2)->nodeType==CONSTANT) &&(accessThruMemRef(simplifiedChild1)->nodeType==CONSTANT)) { /*we have the ct1^ct2 case*/ /* printf("We are in the ct1^ct2 case");*/ sollya_mpfi_init2(temp1, getToolPrecision()); sollya_mpfi_set_fr(temp1, *(accessThruMemRef(simplifiedChild1)->value)); sollya_mpfi_init2(temp2, getToolPrecision()); sollya_mpfi_set_fr(temp2, *(accessThruMemRef(simplifiedChild2)->value)); sollya_mpfi_pow(temp1,temp1,temp2); consttModel(tt,temp1); copytModel(t,tt); cleartModel(tt); sollya_mpfi_clear(temp1); sollya_mpfi_clear(temp2); } else if (accessThruMemRef(simplifiedChild2)->nodeType==CONSTANT) { /*we have the f^p case*/ /*printf("We are in the f^p case");*/ /*sollya_mpfi_t powx,fx0,rangef;*/ /*create a new empty taylor model the child*/ child1_tm=createEmptytModel(n,x0,x); /*call taylor_model for the child*/ taylor_model(child1_tm, accessThruMemRef(f)->child1,n,x0,x,mode); /*printf("\n\n-----------taylormodel child1: \n");*/ /*printtModel(child1_tm);*/ /*printf("-----------------------------\n");*/ sollya_mpfi_init2(fx0,getToolPrecision()); evaluateInterval(fx0, accessThruMemRef(f)->child1, NULL, x0); sollya_mpfi_init2(rangef, getToolPrecision()); sollya_mpfi_init2(powx, getToolPrecision()); sollya_mpfi_set_ui(powx,n); if (mode==RELATIVE){ sollya_mpfi_sub(rangef, child1_tm->x,child1_tm->x0); sollya_mpfi_pow(rangef,rangef,powx); sollya_mpfi_mul(rangef,rangef,child1_tm->rem_bound); sollya_mpfi_add(rangef,rangef, child1_tm->poly_bound); } else{ sollya_mpfi_add(rangef,child1_tm->rem_bound, child1_tm->poly_bound); } /*create tm for x^p over ragef in fx0*/ ctPowVar_tm=createEmptytModel(n,fx0,rangef); base_TMAux(ctPowVar_tm, MONOTONE_REMAINDER_CONSTPOWERVAR, 0, NULL, *(accessThruMemRef(simplifiedChild2)->value), n, fx0,rangef,mode,&silent); /*printf("\n\n-----------taylormodel child1: \n");*/ /*printtModel(ctPowVar_tm);*/ /*printf("-----------------------------\n");*/ composition_TM(tt,ctPowVar_tm,child1_tm,mode); /*clear old child*/ cleartModel(child1_tm); cleartModel(ctPowVar_tm); copytModel(t,tt); cleartModel(tt); sollya_mpfi_clear(rangef); sollya_mpfi_clear(powx); sollya_mpfi_clear(fx0); } else if (accessThruMemRef(simplifiedChild1)->nodeType==CONSTANT) { /*we have the p^f case*/ /*sollya_mpfi_t powx,fx0,rangef; */ /*create a new empty taylor model the child*/ child2_tm=createEmptytModel(n,x0,x); /*call taylor_model for the child*/ taylor_model(child2_tm, accessThruMemRef(f)->child2,n,x0,x,mode); sollya_mpfi_init2(fx0,getToolPrecision()); evaluateInterval(fx0, accessThruMemRef(f)->child2, NULL, x0); sollya_mpfi_init2(rangef, getToolPrecision()); sollya_mpfi_init2(powx, getToolPrecision()); sollya_mpfi_set_ui(powx,n); if (mode==RELATIVE){ sollya_mpfi_sub(rangef, child2_tm->x,child2_tm->x0); sollya_mpfi_pow(rangef,rangef,powx); sollya_mpfi_mul(rangef,rangef,child2_tm->rem_bound); sollya_mpfi_add(rangef,rangef, child2_tm->poly_bound); } else{ sollya_mpfi_add(rangef,child2_tm->rem_bound, child2_tm->poly_bound); } /*create tm for p^x over ragef in fx0*/ varCtPower_tm=createEmptytModel(n,fx0,rangef); base_TMAux(varCtPower_tm, MONOTONE_REMAINDER_VARCONSTPOWER, 0, NULL, *(accessThruMemRef(simplifiedChild1)->value), n, fx0,rangef,mode,&silent ); composition_TM(tt,varCtPower_tm,child2_tm,mode); /*clear old child*/ cleartModel(child2_tm); cleartModel(varCtPower_tm); copytModel(t,tt); cleartModel(tt); sollya_mpfi_clear(rangef); sollya_mpfi_clear(powx); sollya_mpfi_clear(fx0); } else { /*printf("We are in the f^g case");*/ /*exp(g log(f))*/ /* sollya_mpfi_t powx,fx0,rangef;*/ /*create a new empty taylor model the children*/ child1_tm=createEmptytModel(n,x0,x); child2_tm=createEmptytModel(n,x0,x); /*call taylor_model for child 2 = g*/ taylor_model(child2_tm, accessThruMemRef(f)->child2,n,x0,x,mode); /*call taylor_model for child 1 = f*/ taylor_model(child1_tm, accessThruMemRef(f)->child1,n,x0,x,mode); /*create taylor_model for log (child 1) = log(f)*/ sollya_mpfi_init2(fx0,getToolPrecision()); evaluateInterval(fx0, accessThruMemRef(f)->child1, NULL, x0); sollya_mpfi_init2(rangef, getToolPrecision()); sollya_mpfi_init2(powx, getToolPrecision()); sollya_mpfi_set_ui(powx,n); if (mode==RELATIVE){ sollya_mpfi_sub(rangef, child1_tm->x,child1_tm->x0); sollya_mpfi_pow(rangef,rangef,powx); sollya_mpfi_mul(rangef,rangef,child1_tm->rem_bound); sollya_mpfi_add(rangef,rangef, child1_tm->poly_bound); } else{ sollya_mpfi_add(rangef,child1_tm->rem_bound, child1_tm->poly_bound); } logx_tm=createEmptytModel(n,fx0,rangef); base_TMAux(logx_tm, MONOTONE_REMAINDER_BASE_FUNCTION, LOG, NULL, NULL, n, fx0, rangef,mode, &silent); logf_tm=createEmptytModel(n,x0,x); composition_TM(logf_tm,logx_tm,child1_tm,mode); /*-------------------------------------------*/ /*multiply g by log f*/ ttt=createEmptytModel(n,x0,x); multiplication_TM(ttt,logf_tm,child2_tm,mode); /*------------------------------------------*/ sollya_mpfi_init2(gx0,getToolPrecision()); evaluateInterval(gx0, accessThruMemRef(f)->child2, NULL, x0); sollya_mpfi_log(fx0,fx0); sollya_mpfi_mul(gx0,gx0,fx0); sollya_mpfi_set_ui(powx,n); if (mode==RELATIVE){ sollya_mpfi_sub(rangef, ttt->x,ttt->x0); sollya_mpfi_pow(rangef,rangef,powx); sollya_mpfi_mul(rangef,rangef,ttt->rem_bound); sollya_mpfi_add(rangef,rangef, ttt->poly_bound); } else{ sollya_mpfi_add(rangef,ttt->rem_bound, ttt->poly_bound); } expx_tm=createEmptytModel(n,gx0,rangef); base_TMAux(expx_tm, MONOTONE_REMAINDER_BASE_FUNCTION, EXP, NULL, NULL, n, gx0, rangef, mode, &silent); composition_TM(tt,expx_tm,ttt,mode); /*clear old child*/ cleartModel(child2_tm); cleartModel(child1_tm); cleartModel(ttt); cleartModel(expx_tm); cleartModel(logx_tm); cleartModel(logf_tm); copytModel(t,tt); cleartModel(tt); sollya_mpfi_clear(rangef); sollya_mpfi_clear(powx); sollya_mpfi_clear(fx0); sollya_mpfi_clear(gx0); } free_memory(simplifiedChild2); free_memory(simplifiedChild1); break; default: sollyaFprintf(stderr,"Error: TM: unknown identifier (%d) in the tree\n",accessThruMemRef(f)->nodeType); exit(1); /* }*/ } return; } chain *constructChain(sollya_mpfi_t *err, int n){ chain *l; sollya_mpfi_t *elem; int i; l = NULL; for(i=n;i>=0;i--){ elem= (sollya_mpfi_t*)safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*elem,getToolPrecision()); sollya_mpfi_set(*elem,err[i]); l=addElement(l, elem); } return l; } void printMpfiChain(chain *c) { chain *curr=c; sollyaPrintf("["); while(curr!=NULL) { printInterval( *(sollya_mpfi_t *)(curr->value)); curr=curr->next; } sollyaPrintf("]\n"); return; } /* The argument n given as an input of tayloform is the desired *degree* of T. However, PLEASE NOTE THAT IN ALL OTHER FUNCTIONS, n-1 IS THE DEGREE OF T. This is why we begin by adjusting n in the first place. */ void taylorform(node **T, chain **errors, sollya_mpfi_t **delta, node *f, int n, sollya_mpfi_t *x0, sollya_mpfi_t *d, int mode) { tModel *t; sollya_mpfi_t x0Int; mpfr_t *coeffsMpfr; sollya_mpfi_t *coeffsErrors; int i; chain *err; sollya_mpfi_t *rest; sollya_mpfi_t myD; /* Adjust n to the notion of degree in the taylor command */ n++; /* Check if degree is at least 1, once it has been adjusted */ if (n < 1) { printMessage(1,SOLLYA_MSG_DEGREE_OF_TAYLORFORM_MUST_BE_AT_LEAST_ZERO,"Warning: the degree of a Taylor Model must be at least 0.\n"); *T = NULL; return; } if (d != NULL) { sollya_mpfi_init2(myD,sollya_mpfi_get_prec(*d)); sollya_mpfi_set(myD,*d); } else { sollya_mpfi_init2(myD,sollya_mpfi_get_prec(*x0)); sollya_mpfi_set(myD,*x0); } sollya_mpfi_init2(x0Int,getToolPrecision()); sollya_mpfi_set(x0Int,*x0); t=createEmptytModel(n,x0Int,myD); /*printf("we have created an emptytm");*/ taylor_model(t,f,n,x0Int,myD, mode); /*printtModel(t);*/ coeffsMpfr= (mpfr_t *)safeCalloc((n),sizeof(mpfr_t)); coeffsErrors = (sollya_mpfi_t *)safeCalloc((n),sizeof(sollya_mpfi_t)); rest= (sollya_mpfi_t*)safeMalloc(sizeof(sollya_mpfi_t)); sollya_mpfi_init2(*rest,getToolPrecision()); for(i=0;in -1,t->poly_array, t->x0,t->x); /*create T;*/ *T=makePolynomial(coeffsMpfr, (t->n)-1); /*create errors;*/ err=constructChain(coeffsErrors,t->n-1); /*printMpfiChain(err);*/ *errors = err; /* if (mode == ABSOLUTE) { sollya_mpfi_init2(pow, getToolPrecision()); sollya_mpfi_set_si(pow, t->n); sollya_mpfi_init2(temp,getToolPrecision()); sollya_mpfi_sub(temp, t->x, t->x0); sollya_mpfi_pow(temp, temp,pow); sollya_mpfi_mul(*rest,temp, t->rem_bound); sollya_mpfi_clear(pow); sollya_mpfi_clear(temp); } else { sollya_mpfi_set(*rest,t->rem_bound); } */ if (d != NULL) { sollya_mpfi_set(*rest,t->rem_bound); *delta=rest; } else { sollya_mpfi_clear(*rest); safeFree(rest); } for(i=0;i $@ @echo "TESTFILES=\""$(@:.sh=)"\"" >> $@ @cat "$(srcdir)/check.proto" >> $@ @chmod +x $@ sollya-6.0+ds/tests-lib/check.proto000066400000000000000000000027371300174114700173430ustar00rootroot00000000000000TEST=0 for i in $TESTFILES do if ! test -e "${srcdir}/$i.reference" then if ! test -e $i then echo "Unexpected error: executable $i not found. Are you in the right directory?" >&2 else echo "Unexpected error: file ${srcdir}/$i.reference seems to be missing." >&2 fi TEST=1 else if test -s "${srcdir}/$i.reference" then ./$i > $i.output < /dev/null code=$? if test $code -ne 0 then ############################################################ ##### $i.reference exists but $i returns an error code ##### ############################################################ TEST=$code else if ! diff $i.output "${srcdir}/$i.reference" > /dev/null then ################################################################## ##### $i.reference exists, $i does not return an error code, ##### ##### but its output is incorrect. ##### ################################################################## TEST=1 fi fi test -e $i.output && test $TEST -eq 0 && rm $i.output else if ! ./$i > /dev/null < /dev/null then ############################################################### ##### $i.reference is empty but $i returns an error code. ##### ############################################################### TEST=1 fi fi fi done exit $TEST sollya-6.0+ds/tests-lib/libraryexample.c000066400000000000000000000040361300174114700203570ustar00rootroot00000000000000#include #include #include #include int myownlog(mpfi_t result, mpfi_t x, int n) { if(n==0) { /* Implementation of the neperian logarithm */ if(mpfi_nan_p(x)) { mpfr_t a; mpfr_init2(a,mpfi_get_prec(result)); mpfi_interv_fr(result,a,a); mpfr_clear(a); return 0; } if(mpfi_has_zero(x)) { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } else { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfi_get_left(a,x); mpfr_log(a,a, GMP_RNDD); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } } if(n==1) { /* Implementation of 1/x */ mpfi_inv(result,x); return 0; } if(n==2) { /* Implementation of -1/x^2 */ mpfi_t temp; mpfi_init2(temp, mpfi_get_prec(result)); mpfi_sqr(temp, x); mpfi_inv(temp, temp); mpfi_neg(result, temp); mpfi_clear(temp); return 0; } /* else */ mpfr_t a,b; mpfr_init2(a, mpfi_get_prec(result)); mpfr_init2(b, mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfr_set_inf(b, 1); mpfi_interv_fr(result,a,b); mpfr_clear(a); mpfr_clear(b); return 0; } void euler_gamma(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } int funny_impl(char *str, int i, mpfr_t v) { printf(">>>%s<<<>>>%d<<<>>>%ld<<<\n", str, i, (long int) mpfr_get_si(v,GMP_RNDN)); return (i == 17); } int funny(int *res, void **args) { *res = funny_impl(((char *) (args[0])), *((int *) (args[1])), *((mpfr_t *) (args[2]))); return 1; } int zeit_impl() { return (int) time(NULL); } int zeit(int *res) { *res = zeit_impl(); return 1; } sollya-6.0+ds/tests-lib/tabs.c000066400000000000000000000004141300174114700162640ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_abs(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tabs.reference000066400000000000000000000000101300174114700177700ustar00rootroot00000000000000abs(_x_)sollya-6.0+ds/tests-lib/tabsolute.c000066400000000000000000000003101300174114700173300ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_absolute(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tabsolute.reference000066400000000000000000000000101300174114700210410ustar00rootroot00000000000000absolutesollya-6.0+ds/tests-lib/tacos.c000066400000000000000000000004151300174114700164450ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_acos(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tacos.reference000066400000000000000000000000111300174114700201510ustar00rootroot00000000000000acos(_x_)sollya-6.0+ds/tests-lib/tacosh.c000066400000000000000000000004161300174114700166160ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_acosh(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tacosh.reference000066400000000000000000000000121300174114700203220ustar00rootroot00000000000000acosh(_x_)sollya-6.0+ds/tests-lib/tadd.c000066400000000000000000000005311300174114700162470ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2, f; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_constant_from_double(1.0); f = sollya_lib_add(f1, f2); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tadd.reference000066400000000000000000000000071300174114700177610ustar00rootroot00000000000000_x_ + 1sollya-6.0+ds/tests-lib/tand.c000066400000000000000000000034411300174114700162640ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { int message = sollya_lib_get_msg_id(msg); (void)data; /* Avoiding "unused parameter" warning */ if (message == SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED) sollya_lib_printf("The following test produces a typing error\n"); else sollya_lib_printf("Unexpected message\n"); return 0; } int main(void) { sollya_obj_t true, false, a, b, res; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); true = sollya_lib_true(); false = sollya_lib_false(); a = sollya_lib_copy_obj(true); b = sollya_lib_copy_obj(true); res = sollya_lib_and(a, b); sollya_lib_printf("%b and %b gives %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_copy_obj(true); b = sollya_lib_copy_obj(false); res = sollya_lib_and(a, b); sollya_lib_printf("%b and %b gives %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_copy_obj(false); b = sollya_lib_copy_obj(true); res = sollya_lib_and(a, b); sollya_lib_printf("%b and %b gives %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_copy_obj(false); b = sollya_lib_copy_obj(false); res = sollya_lib_and(a, b); sollya_lib_printf("%b and %b gives %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(17); b = sollya_lib_string("Hello"); res = sollya_lib_and(a, b); sollya_lib_printf("%b and %b gives %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); sollya_lib_clear_obj(true); sollya_lib_clear_obj(false); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tand.reference000066400000000000000000000002571300174114700200020ustar00rootroot00000000000000true and true gives true true and false gives false false and true gives false false and false gives false The following test produces a typing error 17 and Hello gives error sollya-6.0+ds/tests-lib/tannotatefunction.c000066400000000000000000000023261300174114700211020ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f, g, h, dom, delta; mpfr_t x, y; sollya_lib_init(); f = sollya_lib_parse_string("exp(_x_)"); g = sollya_lib_parse_string("function(proc(X,n,p) { var res, oldPrec;\n" " oldPrec = prec;\n" " prec = p!;\n" " \"Using procedure function exponential\";\n" " res = exp(X);\n" " prec = oldPrec!;\n" " return res;\n" " })"); dom = sollya_lib_parse_string("[-5;5]"); delta = sollya_lib_parse_string("[0]"); h = sollya_lib_annotatefunction(f, g, dom, delta, NULL); mpfr_init2(x, 24); mpfr_init2(y, 24); mpfr_set_si(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, h, x, NULL); mpfr_set_si(x, 6, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, h, x, NULL); mpfr_clear(y); mpfr_clear(x); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g); sollya_lib_clear_obj(dom); sollya_lib_clear_obj(delta); sollya_lib_clear_obj(h); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tannotatefunction.reference000066400000000000000000000000001300174114700226010ustar00rootroot00000000000000sollya-6.0+ds/tests-lib/tappend.c000066400000000000000000000030121300174114700167630ustar00rootroot00000000000000#include #define A_DIM 9 int callback(sollya_msg_t msg, void *data) { int message = sollya_lib_get_msg_id(msg); (void)data; /* Avoiding "unused parameter" warning */ switch(message) { case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("Caught the message that a certain expression is not correctly typed.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[A_DIM], b[A_DIM * A_DIM]; int i, j; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = sollya_lib_parse_string("[||]"); a[1] = sollya_lib_parse_string("[|1|]"); a[2] = sollya_lib_parse_string("[|1,2|]"); a[3] = sollya_lib_parse_string("[|1,...,17...|]"); a[4] = sollya_lib_parse_string("[|\"Hello\"|]"); a[5] = sollya_lib_parse_string("[|\"Hello\",\"World\"|]"); a[6] = sollya_lib_parse_string("[|\"land\",\"of\",\"milk\",\"and\",\"honey\"|]"); a[7] = sollya_lib_string("Hello "); a[8] = SOLLYA_CONST(19.25); for (i=0;i int main(void) { sollya_obj_t f[4]; sollya_obj_t d[4]; sollya_obj_t temp1, temp2; int i; sollya_lib_init(); f[0] = SOLLYA_SIN(SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(1.0))); d[0] = sollya_lib_range(temp1 = SOLLYA_CONST(-3.0), temp2 = SOLLYA_CONST(3.0)); sollya_lib_clear_obj(temp1); sollya_lib_clear_obj(temp2); f[1] = SOLLYA_ADD(SOLLYA_SIN(SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(1.0))),SOLLYA_CONST(2.0)); d[1] = sollya_lib_range(temp1 = SOLLYA_CONST(-3.0), temp2 = SOLLYA_CONST(3.0)); sollya_lib_clear_obj(temp1); sollya_lib_clear_obj(temp2); f[2] = SOLLYA_SIN(SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(1.0))); d[2] = sollya_lib_range(temp1 = SOLLYA_CONST(1.0), temp2 = SOLLYA_CONST(7.0)); sollya_lib_clear_obj(temp1); sollya_lib_clear_obj(temp2); f[3] = SOLLYA_ADD(SOLLYA_SIN(SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(1.0))),SOLLYA_CONST(2.0)); d[3] = sollya_lib_range(temp1 = SOLLYA_CONST(1.0), temp2 = SOLLYA_CONST(7.0)); sollya_lib_clear_obj(temp1); sollya_lib_clear_obj(temp2); for (i=0;i<4;i++) { sollya_lib_asciiplot(f[i],d[i]); sollya_lib_printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"); } for (i=0;i<4;i++) { sollya_lib_clear_obj(f[i]); } for (i=0;i<4;i++) { sollya_lib_clear_obj(d[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tasciiplot.reference000066400000000000000000000170201300174114700212230ustar00rootroot00000000000000 | xxxxxxxx |xx xxx xx xx xx | x x | xx xx | x x | x x | x x | x x | xx x | x --------------------------x-----------+-------------------------x----------- xx | x x | x x | x x | x x | x x | xx xx | x x | x xx | xx xx | xx xx | xxxxxxxx | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | xxxxxxxx |xx xxx xx xx xx | x x | xx xx | x x | x x | x x | x x | xx x | x x | x xx | x x | x x | x x | x x | x x | xx xx | x x | x xx | xx xx | xx xx | xxxxxxxx | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ xxxxxx xx xxx xx xx x x xx xx x x x x x xx x x xx x x x --------------x---------------------------------------x--------------------- x x x x x x x x x xx xx x x x x xx xx x xx xx xxx xxx xxxxxxx ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ xxxxxx xx xxx xx xx x x xx xx x x x x x xx x x xx x x x x x x x x x x x x x x xx xx x x x x xx xx x xx xx xxx xxx xxxxxxx ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ sollya-6.0+ds/tests-lib/tasin.c000066400000000000000000000004151300174114700164520ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_asin(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tasin.reference000066400000000000000000000000111300174114700201560ustar00rootroot00000000000000asin(_x_)sollya-6.0+ds/tests-lib/tasinh.c000066400000000000000000000004161300174114700166230ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_asinh(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tasinh.reference000066400000000000000000000000121300174114700203270ustar00rootroot00000000000000asinh(_x_)sollya-6.0+ds/tests-lib/tatan.c000066400000000000000000000004151300174114700164430ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_atan(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tatan.reference000066400000000000000000000000111300174114700201470ustar00rootroot00000000000000atan(_x_)sollya-6.0+ds/tests-lib/tatanh.c000066400000000000000000000004161300174114700166140ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_atanh(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tatanh.reference000066400000000000000000000000121300174114700203200ustar00rootroot00000000000000atanh(_x_)sollya-6.0+ds/tests-lib/tbashexecute.c000066400000000000000000000004731300174114700200240ustar00rootroot00000000000000#include int main(void) { sollya_obj_t bashCommand; sollya_lib_init(); bashCommand = sollya_lib_string("echo \"Hallo Welt!\" | sed -e 's/a/e/g;s/elt/orld/g;' | tr 'a-z' 'A-Z'"); sollya_lib_bashexecute(bashCommand); sollya_lib_clear_obj(bashCommand); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbashexecute.reference000066400000000000000000000000151300174114700215300ustar00rootroot00000000000000HELLO WORLD! sollya-6.0+ds/tests-lib/tbinary.c000066400000000000000000000003061300174114700170030ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_binary(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbinary.reference000066400000000000000000000000061300174114700205140ustar00rootroot00000000000000binarysollya-6.0+ds/tests-lib/tboolean_list_ops.c000066400000000000000000000026471300174114700210640ustar00rootroot00000000000000#include #include int main(void) { sollya_boolean_list_t list1, iter, list2; int a, b, c, d, e; int i; sollya_lib_init(); a = 1; b = 0; c = 1; d = 1; e = 0; list1 = sollya_lib_construct_boolean_list(a, sollya_lib_construct_boolean_list(b, sollya_lib_construct_boolean_list(c, sollya_lib_construct_boolean_list(d, NULL)))); for (iter = list1, i = 0; !sollya_lib_is_empty_boolean_list(iter); iter = sollya_lib_get_boolean_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list1 before copy and modification of the copy: %s\n", i, (sollya_lib_get_boolean_list_head(iter)?"true":"false")); } list2 = sollya_lib_copy_boolean_list(list1); list2 = sollya_lib_construct_boolean_list(e, list2); for (iter = list1, i = 0; !sollya_lib_is_empty_boolean_list(iter); iter = sollya_lib_get_boolean_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list1 after copy and modification of the copy: %s\n", i, (sollya_lib_get_boolean_list_head(iter)?"true":"false")); } for (iter = list2, i = 0; !sollya_lib_is_empty_boolean_list(iter); iter = sollya_lib_get_boolean_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list2 after copy and modification of the copy: %s\n", i, (sollya_lib_get_boolean_list_head(iter)?"true":"false")); } sollya_lib_clear_boolean_list(list1); sollya_lib_clear_boolean_list(list2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tboolean_list_ops.reference000066400000000000000000000015741300174114700225760ustar00rootroot000000000000000-th element in list1 before copy and modification of the copy: true 1-th element in list1 before copy and modification of the copy: false 2-th element in list1 before copy and modification of the copy: true 3-th element in list1 before copy and modification of the copy: true 0-th element in list1 after copy and modification of the copy: true 1-th element in list1 after copy and modification of the copy: false 2-th element in list1 after copy and modification of the copy: true 3-th element in list1 after copy and modification of the copy: true 0-th element in list2 after copy and modification of the copy: false 1-th element in list2 after copy and modification of the copy: true 2-th element in list2 after copy and modification of the copy: false 3-th element in list2 after copy and modification of the copy: true 4-th element in list2 after copy and modification of the copy: true sollya-6.0+ds/tests-lib/tbuild_end_elliptic_list.c000066400000000000000000000047121300174114700223710ustar00rootroot00000000000000#include int main(void) { sollya_obj_t listobj, tmp; sollya_lib_init(); /* Empty end-elliptic list from nothing: expecting error */ listobj = sollya_lib_build_end_elliptic_list(NULL); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* Empty end-elliptic list with an invalid pointer after NULL: expecting error */ listobj = sollya_lib_build_end_elliptic_list(NULL, 0x1); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* List with one non-integer element, with invalide pointer after NULL */ listobj = sollya_lib_build_end_elliptic_list(SOLLYA_COS(SOLLYA_X_), NULL, 0x1); sollya_lib_printf("%b. ", listobj); if (sollya_lib_get_element_in_list(&tmp, listobj, 2)) { sollya_lib_printf("listobj[2] is %b\n", tmp); sollya_lib_clear_obj(tmp); } else sollya_lib_printf("listobj[2] does not exist.\n"); sollya_lib_clear_obj(listobj); /* List with one integer element, with invalid pointer after NULL*/ listobj = sollya_lib_build_end_elliptic_list(SOLLYA_CONST(3.), NULL, 0x1); sollya_lib_printf("%b. ", listobj); if (sollya_lib_get_element_in_list(&tmp, listobj, 2)) { sollya_lib_printf("listobj[2] is %b\n", tmp); sollya_lib_clear_obj(tmp); } else sollya_lib_printf("listobj[2] does not exist.\n"); sollya_lib_clear_obj(listobj); /* List from an array. Ends with a non-integer element */ listobj = sollya_lib_build_end_elliptic_list(SOLLYA_COS(SOLLYA_X_), SOLLYA_CONST(3.), sollya_lib_double_obj(), NULL); sollya_lib_printf("%b. ", listobj); if (sollya_lib_get_element_in_list(&tmp, listobj, 4)) { sollya_lib_printf("listobj[2] is %b\n", tmp); sollya_lib_clear_obj(tmp); } else sollya_lib_printf("listobj[2] does not exist.\n"); sollya_lib_clear_obj(listobj); /* List from an array with 2 elements of the array. Ends with an integer element */ listobj = sollya_lib_build_end_elliptic_list(SOLLYA_COS(SOLLYA_X_), SOLLYA_CONST(3.), NULL); sollya_lib_printf("%b. ", listobj); if (sollya_lib_get_element_in_list(&tmp, listobj, 4)) { sollya_lib_printf("listobj[4] is %b\n", tmp); sollya_lib_clear_obj(tmp); } else sollya_lib_printf("listobj[4] does not exist.\n"); sollya_lib_clear_obj(listobj); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_end_elliptic_list.reference000066400000000000000000000002431300174114700241000ustar00rootroot00000000000000error error [|cos(_x_)...|]. listobj[2] is cos(_x_) [|3...|]. listobj[2] is 5 [|cos(_x_), 3, double...|]. listobj[2] is double [|cos(_x_), 3...|]. listobj[4] is 6 sollya-6.0+ds/tests-lib/tbuild_function_abs.c000066400000000000000000000004041300174114700213470ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_abs(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_abs.reference000066400000000000000000000000101300174114700230540ustar00rootroot00000000000000abs(_x_)sollya-6.0+ds/tests-lib/tbuild_function_acos.c000066400000000000000000000004051300174114700215300ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_acos(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_acos.reference000066400000000000000000000000111300174114700232350ustar00rootroot00000000000000acos(_x_)sollya-6.0+ds/tests-lib/tbuild_function_acosh.c000066400000000000000000000004061300174114700217010ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_acosh(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_acosh.reference000066400000000000000000000000121300174114700234060ustar00rootroot00000000000000acosh(_x_)sollya-6.0+ds/tests-lib/tbuild_function_add.c000066400000000000000000000004771300174114700213440ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f, f1, f2; sollya_lib_init(); f1 = sollya_lib_build_function_free_variable(); f2 = sollya_lib_constant_from_double(1.0); f = sollya_lib_build_function_add(f1, f2); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_add.reference000066400000000000000000000000071300174114700230450ustar00rootroot00000000000000_x_ + 1sollya-6.0+ds/tests-lib/tbuild_function_asin.c000066400000000000000000000004051300174114700215350ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_asin(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_asin.reference000066400000000000000000000000111300174114700232420ustar00rootroot00000000000000asin(_x_)sollya-6.0+ds/tests-lib/tbuild_function_asinh.c000066400000000000000000000004061300174114700217060ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_asinh(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_asinh.reference000066400000000000000000000000121300174114700234130ustar00rootroot00000000000000asinh(_x_)sollya-6.0+ds/tests-lib/tbuild_function_atan.c000066400000000000000000000004051300174114700215260ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_atan(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_atan.reference000066400000000000000000000000111300174114700232330ustar00rootroot00000000000000atan(_x_)sollya-6.0+ds/tests-lib/tbuild_function_atanh.c000066400000000000000000000004061300174114700216770ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_atanh(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_atanh.reference000066400000000000000000000000121300174114700234040ustar00rootroot00000000000000atanh(_x_)sollya-6.0+ds/tests-lib/tbuild_function_ceil.c000066400000000000000000000004051300174114700215170ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_ceil(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_ceil.reference000066400000000000000000000000111300174114700232240ustar00rootroot00000000000000ceil(_x_)sollya-6.0+ds/tests-lib/tbuild_function_cos.c000066400000000000000000000004041300174114700213660ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_cos(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_cos.reference000066400000000000000000000000101300174114700230730ustar00rootroot00000000000000cos(_x_)sollya-6.0+ds/tests-lib/tbuild_function_cosh.c000066400000000000000000000004051300174114700215370ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_cosh(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_cosh.reference000066400000000000000000000000111300174114700232440ustar00rootroot00000000000000cosh(_x_)sollya-6.0+ds/tests-lib/tbuild_function_div.c000066400000000000000000000004771300174114700213760ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f, f1, f2; sollya_lib_init(); f1 = sollya_lib_build_function_free_variable(); f2 = sollya_lib_constant_from_double(2.0); f = sollya_lib_build_function_div(f1, f2); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_div.reference000066400000000000000000000000071300174114700230770ustar00rootroot00000000000000_x_ / 2sollya-6.0+ds/tests-lib/tbuild_function_double.c000066400000000000000000000004071300174114700220570ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_double(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_double.reference000066400000000000000000000000131300174114700235640ustar00rootroot00000000000000double(_x_)sollya-6.0+ds/tests-lib/tbuild_function_double_double.c000066400000000000000000000004161300174114700234110ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_double_double(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_double_double.reference000066400000000000000000000000211300174114700251150ustar00rootroot00000000000000doubledouble(_x_)sollya-6.0+ds/tests-lib/tbuild_function_doubleextended.c000066400000000000000000000004171300174114700236010ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_doubleextended(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_doubleextended.reference000066400000000000000000000000231300174114700253060ustar00rootroot00000000000000doubleextended(_x_)sollya-6.0+ds/tests-lib/tbuild_function_erf.c000066400000000000000000000004041300174114700213560ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_erf(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_erf.reference000066400000000000000000000000101300174114700230630ustar00rootroot00000000000000erf(_x_)sollya-6.0+ds/tests-lib/tbuild_function_erfc.c000066400000000000000000000004051300174114700215220ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_erfc(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_erfc.reference000066400000000000000000000000111300174114700232270ustar00rootroot00000000000000erfc(_x_)sollya-6.0+ds/tests-lib/tbuild_function_exp.c000066400000000000000000000004041300174114700213760ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_exp(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_exp.reference000066400000000000000000000000101300174114700231030ustar00rootroot00000000000000exp(_x_)sollya-6.0+ds/tests-lib/tbuild_function_expm1.c000066400000000000000000000004061300174114700216360ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_expm1(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_expm1.reference000066400000000000000000000000121300174114700233430ustar00rootroot00000000000000expm1(_x_)sollya-6.0+ds/tests-lib/tbuild_function_floor.c000066400000000000000000000004061300174114700217250ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_floor(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_floor.reference000066400000000000000000000000121300174114700234320ustar00rootroot00000000000000floor(_x_)sollya-6.0+ds/tests-lib/tbuild_function_free_variable.c000066400000000000000000000003341300174114700233720ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_free_variable.reference000066400000000000000000000000031300174114700250770ustar00rootroot00000000000000_x_sollya-6.0+ds/tests-lib/tbuild_function_halfprecision.c000066400000000000000000000004161300174114700234330ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_halfprecision(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_halfprecision.reference000066400000000000000000000000221300174114700251400ustar00rootroot00000000000000halfprecision(_x_)sollya-6.0+ds/tests-lib/tbuild_function_libraryconstant.c000066400000000000000000000142221300174114700240230ustar00rootroot00000000000000#include #include #include #include void euler_gamma(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } void stupid1(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid2(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid3(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid4(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid5(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid6(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid7(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } int main(void) { sollya_obj_t f[15]; int i; void *ptr; char str[256]; char str2[256]; mpfr_t x,y; sollya_lib_init(); /* Normal use */ f[0] = sollya_lib_build_function_libraryconstant("superconst", euler_gamma); sollya_lib_printf("%b (expecting superconst)\n", f[0]); mpfr_init2(x, 30); mpfr_init2(y, 50); mpfr_set_ui(x, 0, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f[0], x, NULL); sollya_lib_printf("%v (expecting: 0.5772...)\n", y); sollya_lib_clear_obj(f[0]); f[0] = sollya_lib_parse_string("superconst"); sollya_lib_evaluate_function_at_point(y, f[0], x, NULL); sollya_lib_printf("%v (expecting: 0.5772...)\n", y); /* Trying to rebind a constant already bounded */ f[1] = sollya_lib_build_function_libraryconstant("*]%", euler_gamma); sollya_lib_printf("%b (expecting superconst)\n", f[1]); f[2] = sollya_lib_build_function_libraryconstant("superconst", euler_gamma); sollya_lib_printf("%b (expecting superconst)\n", f[2]); f[3] = sollya_lib_build_function_libraryconstant("foo", euler_gamma); sollya_lib_printf("%b (expecting superconst)\n", f[3]); f[4] = sollya_lib_build_function_libraryconstant(NULL, euler_gamma); sollya_lib_printf("%b (expecting superconst)\n", f[4]); f[5] = sollya_lib_build_function_libraryconstant("pi", euler_gamma); sollya_lib_printf("%b (expecting superconst)\n", f[5]); for(i=1;i<=5;i++) { f[6] = sollya_lib_cmp_equal(f[0], f[i]); sollya_lib_printf("%b (expecting true)\n", f[6]); sollya_lib_clear_obj(f[6]); } /* Trying to bind a function to an already assigned name */ f[6] = sollya_lib_build_function_libraryconstant("superconst", stupid1); sollya_lib_printf("%b (expecting superconst_0)\n", f[6]); /* Leaving NULL as first argument */ f[7] = sollya_lib_build_function_libraryconstant(NULL, stupid2); sollya_lib_sprintf(str, "%b", f[7]); sollya_lib_sprintf(str2, "const_%p", stupid2); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the first argument is NULL is conform to the semantic.\n"); else { strcpy(str2, "stupid2"); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the first argument is NULL is conform to the semantic.\n"); else sollya_lib_printf("The behavior when the first argument is *NOT* conform to the semantic.\n"); } /* Unauthorized names */ f[8] = sollya_lib_build_function_libraryconstant("e]xp", stupid3); sollya_lib_printf("%b (expecting exp_0)\n", f[8]); f[9] = sollya_lib_build_function_libraryconstant("]0", stupid4); sollya_lib_sprintf(str, "%b", f[9]); sollya_lib_sprintf(str2, "const_%p", stupid4); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the first argument is NULL is conform to the semantic.\n"); else { strcpy(str2, "stupid4"); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the first argument is NULL is conform to the semantic.\n"); else sollya_lib_printf("The behavior when the first argument is *NOT* conform to the semantic.\n"); } f[10] = sollya_lib_build_function_libraryconstant("0]a", stupid5); sollya_lib_printf("%b (expecting a)\n", f[10]); /* Pointer to non-valid functions, together with NULL/illicit as second argument */ f[11] = sollya_lib_build_function_libraryconstant(NULL, (void (*)(mpfr_t, mp_prec_t)) (((char *) stupid6)+((int) 17))); sollya_lib_sprintf(str, "%b", f[11]); sollya_lib_sprintf(str2, "const_%p", (void (*)(mpfr_t, mp_prec_t)) (((char *) stupid6)+((int) 17))); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[11], str2); f[12] = sollya_lib_build_function_libraryconstant(NULL, (void (*)(mpfr_t, mp_prec_t)) (((char *) stupid7)-((int) 17))); sollya_lib_sprintf(str, "%b", f[12]); sollya_lib_sprintf(str2, "const_%p", (void (*)(mpfr_t, mp_prec_t)) (((char *) stupid7)-((int) 17))); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[12], str2); f[13] = sollya_lib_build_function_libraryconstant("", (void (*)(mpfr_t, mp_prec_t))(&x)); sollya_lib_sprintf(str, "%b", f[13]); sollya_lib_sprintf(str2, "const_%p", &x); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[13], str2); ptr = malloc(1); f[14] = sollya_lib_build_function_libraryconstant("*]%", (void (*)(mpfr_t, mp_prec_t))(ptr)); sollya_lib_sprintf(str, "%b", f[14]); sollya_lib_sprintf(str2, "const_%p", ptr); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[14], str2); for(i=0;i<=14;i++) sollya_lib_clear_obj(f[i]); free(ptr); mpfr_clear(x); mpfr_clear(y); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_libraryconstant.reference000066400000000000000000000015261300174114700255420ustar00rootroot00000000000000superconst (expecting superconst) 0.57721566490153275452712477999739348888397216796875 (expecting: 0.5772...) 0.57721566490153275452712477999739348888397216796875 (expecting: 0.5772...) superconst (expecting superconst) superconst (expecting superconst) superconst (expecting superconst) superconst (expecting superconst) superconst (expecting superconst) true (expecting true) true (expecting true) true (expecting true) true (expecting true) true (expecting true) superconst_0 (expecting superconst_0) The behavior when the first argument is NULL is conform to the semantic. exp_0 (expecting exp_0) The behavior when the first argument is NULL is conform to the semantic. a (expecting a) Testing NULL/invalid ptr combination: OK Testing NULL/invalid ptr combination: OK Testing NULL/invalid ptr combination: OK Testing NULL/invalid ptr combination: OK sollya-6.0+ds/tests-lib/tbuild_function_libraryconstant_with_data.c000066400000000000000000000042171300174114700260520ustar00rootroot00000000000000#include #include #include #include #include typedef struct data_struct_t { char text[32]; int counter; } data_t; void euler_gamma(mpfr_t res, mp_prec_t prec, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } void euler_gamma2(mpfr_t res, mp_prec_t prec, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } void dealloc(void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf("Deallocation function called for the data pointer (%s<<<>>>%d)\n", data->text, data->counter); return; } int main(void) { sollya_obj_t f,g; mpfr_t x,y; data_t data = { "Hello world", 0 }; sollya_lib_init(); f = sollya_lib_build_function_libraryconstant_with_data("superconst", euler_gamma, &data, NULL); sollya_lib_printf("%b (expecting: superconst)\n", f); mpfr_init2(x, 30); mpfr_init2(y, 50); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: 0.5772...)\n", y); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("superconst"); sollya_lib_printf("%b (expecting: superconst)\n", f); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: 0.5772...)\n", y); sollya_lib_clear_obj(f); f = sollya_lib_libraryconstant_with_data("superconst2", euler_gamma2, &data, dealloc); g = SOLLYA_ADD(SOLLYA_CONST(2), sollya_lib_copy_obj(f)); sollya_lib_printf("%b (expecting: superconst2)\n", f); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: 0.5772...)\n", y); sollya_lib_clear_obj(f); sollya_lib_printf("Deallocation function must not yet have been called\n"); sollya_lib_clear_obj(g); mpfr_clear(x); mpfr_clear(y); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_libraryconstant_with_data.reference000066400000000000000000000010411300174114700275560ustar00rootroot00000000000000superconst (expecting: superconst) >>>>Hello world<<<<>>>>0<<<< 0.57721566490153275452712477999739348888397216796875 (expecting: 0.5772...) superconst (expecting: superconst) >>>>Hello world<<<<>>>>1<<<< 0.57721566490153275452712477999739348888397216796875 (expecting: 0.5772...) superconst2 (expecting: superconst2) >>>>Hello world<<<<>>>>2<<<< 0.57721566490153275452712477999739348888397216796875 (expecting: 0.5772...) Deallocation function must not yet have been called Deallocation function called for the data pointer (Hello world<<<>>>3) sollya-6.0+ds/tests-lib/tbuild_function_libraryfunction.c000066400000000000000000000201351300174114700240170ustar00rootroot00000000000000#include #include #include #include #include int myownlog(mpfi_t result, mpfi_t x, int n) { if(n==0) { /* Implementation of the neperian logarithm */ if(mpfi_nan_p(x)) { mpfr_t a; mpfr_init2(a,mpfi_get_prec(result)); mpfi_interv_fr(result,a,a); mpfr_clear(a); return 0; } if(mpfi_has_zero(x)) { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } else { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfi_get_left(a,x); mpfr_log(a,a, GMP_RNDD); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } } if(n==1) { /* Implementation of 1/x */ mpfi_inv(result,x); return 0; } if(n==2) { /* Implementation of -1/x^2 */ mpfi_t temp; mpfi_init2(temp, mpfi_get_prec(result)); mpfi_sqr(temp, x); mpfi_inv(temp, temp); mpfi_neg(result, temp); mpfi_clear(temp); return 0; } /* else */ mpfr_t a,b; mpfr_init2(a, mpfi_get_prec(result)); mpfr_init2(b, mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfr_set_inf(b, 1); mpfi_interv_fr(result,a,b); mpfr_clear(a); mpfr_clear(b); return 0; } int stupid1(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid2(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid3(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid4(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid5(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid6(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid7(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int main(void) { sollya_obj_t f[15]; mpfr_t x,y; int i; void *ptr; char str[256]; char str2[256]; sollya_lib_init(); f[0] = sollya_lib_free_variable(); /* Testing normal use */ f[1] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "superfunc", myownlog); sollya_lib_printf("%b (expecting: superfunc)\n", f[1]); mpfr_init2(x, 30); mpfr_init2(y, 50); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f[1], x, NULL); sollya_lib_printf("%v (expecting: approximate value of log(2))\n", y); sollya_lib_clear_obj(f[1]); f[1] = sollya_lib_parse_string("diff(superfunc(sin(_x_)))"); sollya_lib_printf("%b (expecting: (diff(superfunc))(sin(_x_)) * cos(_x_))\n", f[1]); sollya_lib_clear_obj(f[1]); f[1] = sollya_lib_parse_string("diff(superfunc(_x_))"); sollya_lib_printf("%b (expecting: diff(superfunc))\n", f[1]); sollya_lib_clear_obj(f[1]); f[1] = sollya_lib_parse_string("superfunc"); /* Trying to rebind a function already bounded */ f[2] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "superfunc", myownlog); sollya_lib_printf("%b (expecting superfunc)\n", f[2]); f[3] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "foo", myownlog); sollya_lib_printf("%b (expecting superfunc)\n", f[3]); f[4] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, NULL, myownlog); sollya_lib_printf("%b (expecting superfunc)\n", f[4]); f[5] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "exp", myownlog); sollya_lib_printf("%b (expecting superfunc)\n", f[5]); for(i=2;i<=5;i++) { f[6] = sollya_lib_cmp_equal(f[1], f[i]); sollya_lib_printf("%b (expecting true)\n", f[6]); sollya_lib_clear_obj(f[6]); } /* Trying to bind a function to an already assigned name */ f[6] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "superfunc", stupid1); sollya_lib_printf("%b (expecting superfunc_0)\n", f[6]); /* Leaving NULL as second argument */ f[7] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, NULL, stupid2); sollya_lib_sprintf(str, "%b", f[7]); sollya_lib_sprintf(str2, "func_%p", stupid2); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the second argument is NULL is conform to the semantic.\n"); else { strcpy(str2, "stupid2"); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the second argument is NULL is conform to the semantic.\n"); else sollya_lib_printf("The behavior when the second argument is *NOT* conform to the semantic.\n"); } /* Unauthorized names */ f[8] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "e]xp", stupid3); sollya_lib_printf("%b (expecting exp_0)\n", f[8]); f[9] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "]0", stupid4); sollya_lib_sprintf(str, "%b", f[9]); sollya_lib_sprintf(str2, "func_%p", stupid4); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the second argument is NULL is conform to the semantic.\n"); else { strcpy(str2, "stupid4"); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the second argument is NULL is conform to the semantic.\n"); else sollya_lib_printf("The behavior when the second argument is *NOT* conform to the semantic.\n"); } f[10] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "0]a", stupid5); sollya_lib_printf("%b (expecting a)\n", f[10]); /* Pointer to non-valid functions, together with NULL/illicit as second argument */ f[11] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, NULL, (int (*)(mpfi_t, mpfi_t, int)) (((char *) stupid6)+((int) 17))); sollya_lib_sprintf(str, "%b", f[11]); sollya_lib_sprintf(str2, "func_%p", (int (*)(mpfi_t, mpfi_t, int)) (((char *) stupid6)+((int) 17))); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[11], str2); f[12] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, NULL, (int (*)(mpfi_t, mpfi_t, int)) (((char *) stupid7)-((int) 17))); sollya_lib_sprintf(str, "%b", f[12]); sollya_lib_sprintf(str2, "func_%p", (int (*)(mpfi_t, mpfi_t, int)) (((char *) stupid7)-((int) 17))); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[12], str2); f[13] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "", (int (*)(mpfi_t, mpfi_t, int))(&x)); sollya_lib_sprintf(str, "%b", f[13]); sollya_lib_sprintf(str2, "func_%p", &x); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[13], str2); ptr = malloc(1); f[14] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "*]%", (int (*)(mpfi_t, mpfi_t, int))(ptr)); sollya_lib_sprintf(str, "%b", f[14]); sollya_lib_sprintf(str2, "func_%p", ptr); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[14], str2); for(i=0;i<=14;i++) sollya_lib_clear_obj(f[i]); mpfr_clear(x); mpfr_clear(y); free(ptr); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_libraryfunction.reference000066400000000000000000000015421300174114700255340ustar00rootroot00000000000000superfunc (expecting: superfunc) 0.6931471805599453972490664455108344554901123046875 (expecting: approximate value of log(2)) (diff(superfunc))(sin(_x_)) * cos(_x_) (expecting: (diff(superfunc))(sin(_x_)) * cos(_x_)) diff(superfunc) (expecting: diff(superfunc)) superfunc (expecting superfunc) superfunc (expecting superfunc) superfunc (expecting superfunc) superfunc (expecting superfunc) true (expecting true) true (expecting true) true (expecting true) true (expecting true) superfunc_0 (expecting superfunc_0) The behavior when the second argument is NULL is conform to the semantic. exp_0 (expecting exp_0) The behavior when the second argument is NULL is conform to the semantic. a (expecting a) Testing NULL/invalid ptr combination: OK Testing NULL/invalid ptr combination: OK Testing NULL/invalid ptr combination: OK Testing NULL/invalid ptr combination: OK sollya-6.0+ds/tests-lib/tbuild_function_libraryfunction_with_data.c000066400000000000000000000121031300174114700260370ustar00rootroot00000000000000#include #include #include #include #include typedef struct data_struct_t { char text[32]; int counter; } data_t; int myownlog(mpfi_t result, mpfi_t x, int n, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; if(n==0) { /* Implementation of the neperian logarithm */ if(mpfi_nan_p(x)) { mpfr_t a; mpfr_init2(a,mpfi_get_prec(result)); mpfi_interv_fr(result,a,a); mpfr_clear(a); return 0; } if(mpfi_has_zero(x)) { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } else { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfi_get_left(a,x); mpfr_log(a,a, GMP_RNDD); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } } if(n==1) { /* Implementation of 1/x */ mpfi_inv(result,x); return 0; } if(n==2) { /* Implementation of -1/x^2 */ mpfi_t temp; mpfi_init2(temp, mpfi_get_prec(result)); mpfi_sqr(temp, x); mpfi_inv(temp, temp); mpfi_neg(result, temp); mpfi_clear(temp); return 0; } /* else */ mpfr_t a,b; mpfr_init2(a, mpfi_get_prec(result)); mpfr_init2(b, mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfr_set_inf(b, 1); mpfi_interv_fr(result,a,b); mpfr_clear(a); mpfr_clear(b); return 0; } int myownlog2(mpfi_t result, mpfi_t x, int n, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; if(n==0) { /* Implementation of the neperian logarithm */ if(mpfi_nan_p(x)) { mpfr_t a; mpfr_init2(a,mpfi_get_prec(result)); mpfi_interv_fr(result,a,a); mpfr_clear(a); return 0; } if(mpfi_has_zero(x)) { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } else { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfi_get_left(a,x); mpfr_log(a,a, GMP_RNDD); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } } if(n==1) { /* Implementation of 1/x */ mpfi_inv(result,x); return 0; } if(n==2) { /* Implementation of -1/x^2 */ mpfi_t temp; mpfi_init2(temp, mpfi_get_prec(result)); mpfi_sqr(temp, x); mpfi_inv(temp, temp); mpfi_neg(result, temp); mpfi_clear(temp); return 0; } /* else */ mpfr_t a,b; mpfr_init2(a, mpfi_get_prec(result)); mpfr_init2(b, mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfr_set_inf(b, 1); mpfi_interv_fr(result,a,b); mpfr_clear(a); mpfr_clear(b); return 0; } void dealloc(void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf("Deallocation function called for the data pointer (%s<<<>>>%d)\n", data->text, data->counter); return; } int main(void) { sollya_obj_t f,g; mpfr_t x,y; data_t data = { "Hello world", 0 }; sollya_lib_init(); f = sollya_lib_build_function_libraryfunction_with_data(SOLLYA_X_, "superfunc", myownlog, &data, NULL); sollya_lib_printf("%b (expecting: superfunc)\n", f); mpfr_init2(x, 30); mpfr_init2(y, 50); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: approximate value of log(2))\n", y); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("diff(superfunc(sin(_x_)))"); sollya_lib_printf("%b (expecting: (diff(superfunc))(sin(_x_)) * cos(_x_))\n", f); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("diff(superfunc(_x_))"); sollya_lib_printf("%b (expecting: diff(superfunc))\n", f); mpfr_set_ui(x, 4, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: approximate value of 1/4)\n", y); sollya_lib_clear_obj(f); f = sollya_lib_build_function_libraryfunction_with_data(SOLLYA_X_, "superfunc2", myownlog2, &data, dealloc); g = SOLLYA_ADD(SOLLYA_CONST(3), sollya_lib_copy_obj(f)); sollya_lib_printf("%b (expecting: superfunc2)\n", f); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: approximate value of log(2))\n", y); sollya_lib_clear_obj(f); sollya_lib_printf("Deallocation function must not yet have been called\n"); sollya_lib_clear_obj(g); mpfr_clear(x); mpfr_clear(y); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_libraryfunction_with_data.reference000066400000000000000000000012031300174114700275520ustar00rootroot00000000000000superfunc (expecting: superfunc) >>>>Hello world<<<<>>>>0<<<< 0.6931471805599453972490664455108344554901123046875 (expecting: approximate value of log(2)) (diff(superfunc))(sin(_x_)) * cos(_x_) (expecting: (diff(superfunc))(sin(_x_)) * cos(_x_)) diff(superfunc) (expecting: diff(superfunc)) >>>>Hello world<<<<>>>>1<<<< 0.25 (expecting: approximate value of 1/4) superfunc2 (expecting: superfunc2) >>>>Hello world<<<<>>>>2<<<< 0.6931471805599453972490664455108344554901123046875 (expecting: approximate value of log(2)) Deallocation function must not yet have been called Deallocation function called for the data pointer (Hello world<<<>>>3) sollya-6.0+ds/tests-lib/tbuild_function_log.c000066400000000000000000000004041300174114700213630ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_log(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_log.reference000066400000000000000000000000101300174114700230700ustar00rootroot00000000000000log(_x_)sollya-6.0+ds/tests-lib/tbuild_function_log10.c000066400000000000000000000004061300174114700215260ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_log10(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_log10.reference000066400000000000000000000000121300174114700232330ustar00rootroot00000000000000log10(_x_)sollya-6.0+ds/tests-lib/tbuild_function_log1p.c000066400000000000000000000004061300174114700216260ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_log1p(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_log1p.reference000066400000000000000000000000121300174114700233330ustar00rootroot00000000000000log1p(_x_)sollya-6.0+ds/tests-lib/tbuild_function_log2.c000066400000000000000000000004051300174114700214460ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_log2(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_log2.reference000066400000000000000000000000111300174114700231530ustar00rootroot00000000000000log2(_x_)sollya-6.0+ds/tests-lib/tbuild_function_mul.c000066400000000000000000000004771300174114700214110ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f, f1, f2; sollya_lib_init(); f1 = sollya_lib_build_function_free_variable(); f2 = sollya_lib_constant_from_double(2.0); f = sollya_lib_build_function_mul(f1, f2); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_mul.reference000066400000000000000000000000071300174114700231120ustar00rootroot00000000000000_x_ * 2sollya-6.0+ds/tests-lib/tbuild_function_nearestint.c000066400000000000000000000004131300174114700227560ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_nearestint(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_nearestint.reference000066400000000000000000000000171300174114700244720ustar00rootroot00000000000000nearestint(_x_)sollya-6.0+ds/tests-lib/tbuild_function_neg.c000066400000000000000000000004041300174114700213530ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_neg(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_neg.reference000066400000000000000000000000041300174114700230630ustar00rootroot00000000000000-_x_sollya-6.0+ds/tests-lib/tbuild_function_pi.c000066400000000000000000000003211300174114700212100ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_pi(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_pi.reference000066400000000000000000000000021300174114700227200ustar00rootroot00000000000000pisollya-6.0+ds/tests-lib/tbuild_function_pow.c000066400000000000000000000004771300174114700214210ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f, f1, f2; sollya_lib_init(); f1 = sollya_lib_build_function_free_variable(); f2 = sollya_lib_constant_from_double(2.0); f = sollya_lib_build_function_pow(f1, f2); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_pow.reference000066400000000000000000000000051300174114700231200ustar00rootroot00000000000000_x_^2sollya-6.0+ds/tests-lib/tbuild_function_procedurefunction.c000066400000000000000000000012121300174114700243360ustar00rootroot00000000000000#include #include int main(void) { sollya_obj_t f1; mpfr_t x,y; sollya_lib_init(); f1 = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); f1 = sollya_lib_build_function_procedurefunction(SOLLYA_X_, f1); sollya_lib_printf("%b\n", f1); mpfr_init2(x, 30); mpfr_init2(y, 50); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y,f1, x, NULL); sollya_lib_printf("%v (expecting approximate value of exp(2))\n", y); sollya_lib_clear_obj(f1); mpfr_clear(x); mpfr_clear(y); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_procedurefunction.reference000066400000000000000000000003151300174114700260550ustar00rootroot00000000000000function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; }) 7.3890560989306521832986618392169475555419921875 (expecting approximate value of exp(2)) sollya-6.0+ds/tests-lib/tbuild_function_quad.c000066400000000000000000000004051300174114700215350ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_quad(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_quad.reference000066400000000000000000000000111300174114700232420ustar00rootroot00000000000000quad(_x_)sollya-6.0+ds/tests-lib/tbuild_function_sin.c000066400000000000000000000004041300174114700213730ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_sin(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_sin.reference000066400000000000000000000000101300174114700231000ustar00rootroot00000000000000sin(_x_)sollya-6.0+ds/tests-lib/tbuild_function_single.c000066400000000000000000000004071300174114700220660ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_single(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_single.reference000066400000000000000000000000131300174114700235730ustar00rootroot00000000000000single(_x_)sollya-6.0+ds/tests-lib/tbuild_function_sinh.c000066400000000000000000000004051300174114700215440ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_sinh(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_sinh.reference000066400000000000000000000000111300174114700232510ustar00rootroot00000000000000sinh(_x_)sollya-6.0+ds/tests-lib/tbuild_function_sqrt.c000066400000000000000000000004051300174114700215740ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_sqrt(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_sqrt.reference000066400000000000000000000000111300174114700233010ustar00rootroot00000000000000sqrt(_x_)sollya-6.0+ds/tests-lib/tbuild_function_sub.c000066400000000000000000000004771300174114700214050ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f, f1, f2; sollya_lib_init(); f1 = sollya_lib_build_function_free_variable(); f2 = sollya_lib_constant_from_double(1.0); f = sollya_lib_build_function_sub(f1, f2); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_sub.reference000066400000000000000000000000071300174114700231060ustar00rootroot00000000000000_x_ - 1sollya-6.0+ds/tests-lib/tbuild_function_tan.c000066400000000000000000000004041300174114700213640ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_tan(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_tan.reference000066400000000000000000000000101300174114700230710ustar00rootroot00000000000000tan(_x_)sollya-6.0+ds/tests-lib/tbuild_function_tanh.c000066400000000000000000000004051300174114700215350ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_tanh(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_tanh.reference000066400000000000000000000000111300174114700232420ustar00rootroot00000000000000tanh(_x_)sollya-6.0+ds/tests-lib/tbuild_function_triple_double.c000066400000000000000000000004161300174114700234360ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_build_function_free_variable(); f = sollya_lib_build_function_triple_double(f); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_function_triple_double.reference000066400000000000000000000000211300174114700251420ustar00rootroot00000000000000tripledouble(_x_)sollya-6.0+ds/tests-lib/tbuild_list.c000066400000000000000000000016211300174114700176520ustar00rootroot00000000000000#include int main(void) { sollya_obj_t listobj; sollya_lib_init(); /* Empty list from nothing */ listobj = sollya_lib_build_list(NULL); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* Empty list with invalid pointers after NULL */ listobj = sollya_lib_build_list(NULL, 0x1); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* List with one element */ listobj = sollya_lib_build_list(SOLLYA_CONST(3.), NULL, 0x1); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* List of three elements */ listobj = sollya_lib_build_list(SOLLYA_COS(SOLLYA_X_), SOLLYA_CONST(3.), sollya_lib_double_obj(), NULL); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tbuild_list.reference000066400000000000000000000000521300174114700213630ustar00rootroot00000000000000[| |] [| |] [|3|] [|cos(_x_), 3, double|] sollya-6.0+ds/tests-lib/tcanonical.c000066400000000000000000000016401300174114700174500ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a[5], b[5]; int i; sollya_lib_init(); a[0] = SOLLYA_POW(SOLLYA_SUB(SOLLYA_POW(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_CONST(2.0),SOLLYA_X_),SOLLYA_CONST(-3.0)),SOLLYA_CONST(3)),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(5))),SOLLYA_CONST(2.0)); /* ( (2x+(-3))^3 - x^5 )^2 = 729 - 2916*x + 4860*x^2 - 4320*x^3 + 2160*x^4 - 522*x^5 - 44*x^6 + 72*x^7 - 16*x^8 + x^10 */ a[1] = SOLLYA_EXP(SOLLYA_X_); a[2] = SOLLYA_ADD(sollya_lib_copy_obj(a[0]),SOLLYA_SIN(sollya_lib_copy_obj(a[0]))); a[3] = sollya_lib_parse_string("3 * x^5 + 2 * x^4 + 7 * x"); a[4] = sollya_lib_canonical(a[3]); for (i=0;i<5;i++) { b[i] = sollya_lib_canonical(a[i]); sollya_lib_printf("%b with all polynomial subtrees written in the canonical basis is %b.\n",a[i],b[i]); } for (i=0;i<5;i++) { sollya_lib_clear_obj(a[i]); sollya_lib_clear_obj(b[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcanonical.reference000066400000000000000000000015421300174114700211650ustar00rootroot00000000000000((2 * x + (-3))^3 - x^5)^2 with all polynomial subtrees written in the canonical basis is 729 + -2916 * x + 4860 * x^2 + -4320 * x^3 + 2160 * x^4 + -522 * x^5 + -44 * x^6 + 72 * x^7 + -16 * x^8 + x^10. exp(x) with all polynomial subtrees written in the canonical basis is exp(x). ((2 * x + (-3))^3 - x^5)^2 + sin(((2 * x + (-3))^3 - x^5)^2) with all polynomial subtrees written in the canonical basis is 729 + -2916 * x + 4860 * x^2 + -4320 * x^3 + 2160 * x^4 + -522 * x^5 + -44 * x^6 + 72 * x^7 + -16 * x^8 + x^10 + sin(729 + -2916 * x + 4860 * x^2 + -4320 * x^3 + 2160 * x^4 + -522 * x^5 + -44 * x^6 + 72 * x^7 + -16 * x^8 + x^10). 3 * x^5 + 2 * x^4 + 7 * x with all polynomial subtrees written in the canonical basis is 7 * x + 2 * x^4 + 3 * x^5. 7 * x + 2 * x^4 + 3 * x^5 with all polynomial subtrees written in the canonical basis is 7 * x + 2 * x^4 + 3 * x^5. sollya-6.0+ds/tests-lib/tceil.c000066400000000000000000000004151300174114700164340ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_ceil(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tceil.reference000066400000000000000000000000111300174114700201400ustar00rootroot00000000000000ceil(_x_)sollya-6.0+ds/tests-lib/tcheckinfnorm.c000066400000000000000000000112351300174114700201700ustar00rootroot00000000000000#include #define A_DIM 8 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST: sollya_lib_printf("Caught the message: a certain expression should have been constant and has been faithfully rounded.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[A_DIM]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* checkinfnorm(sin(x),[0;1.75], 1); */ for (i=0;i int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: sollya_lib_printf("The following test is not certified (both values are probably equal)\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: sollya_lib_printf("The test will rely on pure FP evaluation.\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL: sollya_lib_printf("Warning: the following test involves a NaN\n"); break; default: sollya_lib_printf("Unexpected warning %d\n", message); } return 0; } int main(void) { sollya_obj_t a, b, c, d, res; mpfr_t tmp1, tmp2; double nan = 0./0.; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* First run with autosimplify = on */ sollya_lib_printf("First run with autosimplify = on\n\n"); a = sollya_lib_on(); sollya_lib_set_autosimplify(a); sollya_lib_clear_obj(a); /* Equality between numbers */ a = SOLLYA_CONST(17); b = SOLLYA_CONST(42); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(42); b = SOLLYA_CONST(17); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(17); b = SOLLYA_CONST(17); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between arithmetical expressions */ a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); b = SOLLYA_MUL(b, SOLLYA_ADD(SOLLYA_CONST(1), sollya_lib_parse_string("1b-200"))); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between arithmetical expressions that are not faithfully evaluable */ a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(0); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(0); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving NaN produced by evaluation */ a = SOLLYA_CONST(1); b = SOLLYA_LOG(SOLLYA_CONST(-17)); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_LOG(SOLLYA_CONST(-17)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving infinity */ a = SOLLYA_CONST(1); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving errors */ a = sollya_lib_error(); b = SOLLYA_CONST(17); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_error(); b = sollya_lib_error(); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = sollya_lib_error(); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving NaN */ a = SOLLYA_CONST(nan); b = SOLLYA_CONST(nan); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = SOLLYA_CONST(1); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Commutativity */ a = SOLLYA_ADD(SOLLYA_CONST(2), SOLLYA_X_); b = SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(2)); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between equal intervals but with bounds at different precisions */ a = sollya_lib_parse_string("[1;2]"); mpfr_init2(tmp1, 20); /* not the current precision */ mpfr_init2(tmp2, 30); /* not the current precision */ mpfr_set_ui(tmp1, 1, GMP_RNDN); mpfr_set_ui(tmp2, 2, GMP_RNDN); b = sollya_lib_range_from_bounds(tmp1, tmp2); mpfr_clear(tmp1); mpfr_clear(tmp2); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b (even when bounds are stored at different precisions)\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* More involved expression */ a = sollya_lib_parse_string("1 + exp(sin(x + log(x^2)))"); c = SOLLYA_CONST(40); sollya_lib_set_prec(c); sollya_lib_clear_obj(c); b = sollya_lib_parse_string("sin(x + log(x^2))"); b = SOLLYA_ADD(SOLLYA_CONST(1), SOLLYA_EXP(b)); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b (even when constructed at different precisions)\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between strings */ a = sollya_lib_string("Hello!"); b = sollya_lib_string("Hella!"); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_string("Hello!"); b = sollya_lib_string("ello!"); c = sollya_lib_string("H"); d = sollya_lib_concat(c, b); res = sollya_lib_cmp_equal(a, d); sollya_lib_printf("%b == %b returns %b\n\n", a, d, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(d); sollya_lib_clear_obj(res); /* Second run with autosimplify = off */ sollya_lib_printf("Second run with autosimplify = off\n\n"); a = sollya_lib_off(); sollya_lib_set_autosimplify(a); sollya_lib_clear_obj(a); /* Equality between numbers */ a = SOLLYA_CONST(17); b = SOLLYA_CONST(42); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(42); b = SOLLYA_CONST(17); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(17); b = SOLLYA_CONST(17); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between arithmetical expressions */ a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); b = SOLLYA_MUL(b, SOLLYA_ADD(SOLLYA_CONST(1), sollya_lib_parse_string("1b-200"))); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between arithmetical expressions that are not faithfully evaluable */ a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(0); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(0); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving NaN produced by evaluation */ a = SOLLYA_CONST(1); b = SOLLYA_LOG(SOLLYA_CONST(-17)); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_LOG(SOLLYA_CONST(-17)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving infinity */ a = SOLLYA_CONST(1); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving errors */ a = sollya_lib_error(); b = SOLLYA_CONST(17); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_error(); b = sollya_lib_error(); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = sollya_lib_error(); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving NaN */ a = SOLLYA_CONST(nan); b = SOLLYA_CONST(nan); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = SOLLYA_CONST(1); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Commutativity */ a = SOLLYA_ADD(SOLLYA_CONST(2), SOLLYA_X_); b = SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(2)); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between equal intervals but with bounds at different precisions */ a = sollya_lib_parse_string("[1;2]"); mpfr_init2(tmp1, 20); /* not the current precision */ mpfr_init2(tmp2, 30); /* not the current precision */ mpfr_set_ui(tmp1, 1, GMP_RNDN); mpfr_set_ui(tmp2, 2, GMP_RNDN); b = sollya_lib_range_from_bounds(tmp1, tmp2); mpfr_clear(tmp1); mpfr_clear(tmp2); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b (even when bounds are stored at different precisions)\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* More involved expression */ a = sollya_lib_parse_string("1 + exp(sin(x + log(x^2)))"); c = SOLLYA_CONST(40); sollya_lib_set_prec(c); sollya_lib_clear_obj(c); b = sollya_lib_parse_string("sin(x + log(x^2))"); b = SOLLYA_ADD(SOLLYA_CONST(1), SOLLYA_EXP(b)); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b (even when constructed at different precisions)\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between strings */ a = sollya_lib_string("Hello!"); b = sollya_lib_string("Hella!"); res = sollya_lib_cmp_equal(a, b); sollya_lib_printf("%b == %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_string("Hello!"); b = sollya_lib_string("ello!"); c = sollya_lib_string("H"); d = sollya_lib_concat(c, b); res = sollya_lib_cmp_equal(a, d); sollya_lib_printf("%b == %b returns %b\n\n", a, d, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(d); sollya_lib_clear_obj(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcmp_equal.reference000066400000000000000000000070411300174114700212040ustar00rootroot00000000000000First run with autosimplify = on 17 == 42 returns false 42 == 17 returns false 17 == 17 returns true The following test is not certified (both values are probably equal) sin((pi) / 3) == sqrt(3) / 2 returns true sin((pi) / 3) == sqrt(3) / 2 * (1 + 6.2230152778611417071440640537801242405902521687212e-61) returns false sin((pi) / 3) - sqrt(3) / 2 == 1 returns false The test will rely on pure FP evaluation. sin((pi) / 3) - sqrt(3) / 2 == 0 returns true 1 == sin((pi) / 3) - sqrt(3) / 2 returns false The test will rely on pure FP evaluation. 0 == sin((pi) / 3) - sqrt(3) / 2 returns true Warning: the following test involves a NaN 1 == log(-17) returns false Warning: the following test involves a NaN log(-17) == 1 returns false The test will rely on pure FP evaluation. 1 == tan((pi) / 2)^2 returns false The test will rely on pure FP evaluation. 1 == -(tan((pi) / 2)^2) returns false The test will rely on pure FP evaluation. tan((pi) / 2)^2 == 1 returns false The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) == 1 returns false The test will rely on pure FP evaluation. infty == -(tan((pi) / 2)^2) returns false The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) == infty returns false The test will rely on pure FP evaluation. infty == tan((pi) / 2)^2 returns false The test will rely on pure FP evaluation. tan((pi) / 2)^2 == infty returns false error == 17 returns false error == error returns false NaN == error returns false NaN == NaN returns false NaN == 1 returns false 2 + _x_ == _x_ + 2 returns true [1;2] == [1;2] returns true (even when bounds are stored at different precisions) 1 + exp(sin(x + log(x^2))) == 1 + exp(sin(x + log(x^2))) returns true (even when constructed at different precisions) Hello! == Hella! returns false Hello! == Hello! returns true Second run with autosimplify = off 17 == 42 returns false 42 == 17 returns false 17 == 17 returns true The following test is not certified (both values are probably equal) sin((pi) / 3) == sqrt(3) / 2 returns true sin((pi) / 3) == sqrt(3) / 2 * (1 + 6.22301527786e-61) returns false sin((pi) / 3) - sqrt(3) / 2 == 1 returns false The test will rely on pure FP evaluation. sin((pi) / 3) - sqrt(3) / 2 == 0 returns true 1 == sin((pi) / 3) - sqrt(3) / 2 returns false The test will rely on pure FP evaluation. 0 == sin((pi) / 3) - sqrt(3) / 2 returns true Warning: the following test involves a NaN 1 == log(-17) returns false Warning: the following test involves a NaN log(-17) == 1 returns false The test will rely on pure FP evaluation. 1 == tan((pi) / 2)^2 returns false The test will rely on pure FP evaluation. 1 == -(tan((pi) / 2)^2) returns false The test will rely on pure FP evaluation. tan((pi) / 2)^2 == 1 returns false The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) == 1 returns false The test will rely on pure FP evaluation. infty == -(tan((pi) / 2)^2) returns false The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) == infty returns false The test will rely on pure FP evaluation. infty == tan((pi) / 2)^2 returns false The test will rely on pure FP evaluation. tan((pi) / 2)^2 == infty returns false error == 17 returns false error == error returns false NaN == error returns false NaN == NaN returns false NaN == 1 returns false 2 + x == x + 2 returns false [1;2] == [1;2] returns true (even when bounds are stored at different precisions) 1 + exp(sin(x + log(x^2))) == 1 + exp(sin(x + log(x^2))) returns true (even when constructed at different precisions) Hello! == Hella! returns false Hello! == Hello! returns true sollya-6.0+ds/tests-lib/tcmp_greater.c000066400000000000000000000205071300174114700200140ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: sollya_lib_printf("The following test is not certified (both values are probably equal)\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: sollya_lib_printf("The test will rely on pure FP evaluation.\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL: sollya_lib_printf("Warning: the following test involves a NaN\n"); break; case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The following expression is not correctly typed.\n"); break; default: sollya_lib_printf("Unexpected warning %d\n", message); } return 0; } int main(void) { sollya_obj_t a, b, res; double nan = 0./0.; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* Inequality between numbers */ a = SOLLYA_CONST(17); b = SOLLYA_CONST(42); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(42); b = SOLLYA_CONST(17); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(17); b = SOLLYA_CONST(17); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality between arithmetical expressions */ a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); b = SOLLYA_MUL(b, SOLLYA_ADD(SOLLYA_CONST(1), sollya_lib_parse_string("1b-200"))); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality between arithmetical expressions that are not faithfully evaluable */ a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(0); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(0); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving NaN produced by evaluation */ a = SOLLYA_CONST(1); b = SOLLYA_LOG(SOLLYA_CONST(-17)); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_LOG(SOLLYA_CONST(-17)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving infinity */ a = SOLLYA_CONST(1); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving errors */ a = sollya_lib_error(); b = SOLLYA_CONST(17); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_error(); b = sollya_lib_error(); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = sollya_lib_error(); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving NaN */ a = SOLLYA_CONST(nan); b = SOLLYA_CONST(nan); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = SOLLYA_CONST(1); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality between strings */ a = sollya_lib_string("Hello!"); b = sollya_lib_string("Hella!"); res = sollya_lib_cmp_greater(a, b); sollya_lib_printf("%b > %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcmp_greater.reference000066400000000000000000000032411300174114700215240ustar00rootroot0000000000000017 > 42 returns false 42 > 17 returns true 17 > 17 returns false The following test is not certified (both values are probably equal) sin((pi) / 3) > sqrt(3) / 2 returns false sin((pi) / 3) > sqrt(3) / 2 * (1 + 6.2230152778611417071440640537801242405902521687212e-61) returns false sin((pi) / 3) - sqrt(3) / 2 > 1 returns false The test will rely on pure FP evaluation. sin((pi) / 3) - sqrt(3) / 2 > 0 returns false 1 > sin((pi) / 3) - sqrt(3) / 2 returns true The test will rely on pure FP evaluation. 0 > sin((pi) / 3) - sqrt(3) / 2 returns false Warning: the following test involves a NaN 1 > log(-17) returns false Warning: the following test involves a NaN log(-17) > 1 returns false The test will rely on pure FP evaluation. 1 > tan((pi) / 2)^2 returns false The test will rely on pure FP evaluation. 1 > -(tan((pi) / 2)^2) returns true The test will rely on pure FP evaluation. tan((pi) / 2)^2 > 1 returns true The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) > 1 returns false The test will rely on pure FP evaluation. infty > -(tan((pi) / 2)^2) returns true The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) > infty returns false The test will rely on pure FP evaluation. infty > tan((pi) / 2)^2 returns true The test will rely on pure FP evaluation. tan((pi) / 2)^2 > infty returns false The following expression is not correctly typed. error > 17 returns error The following expression is not correctly typed. error > error returns error The following expression is not correctly typed. NaN > error returns error NaN > NaN returns false NaN > 1 returns false The following expression is not correctly typed. Hello! > Hella! returns error sollya-6.0+ds/tests-lib/tcmp_greater_equal.c000066400000000000000000000207661300174114700212120ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: sollya_lib_printf("The following test is not certified (both values are probably equal)\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: sollya_lib_printf("The test will rely on pure FP evaluation.\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL: sollya_lib_printf("Warning: the following test involves a NaN\n"); break; case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The following expression is not correctly typed.\n"); break; default: sollya_lib_printf("Unexpected warning %d\n", message); } return 0; } int main(void) { sollya_obj_t a, b, res; double nan = 0./0.; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* Inequality between numbers */ a = SOLLYA_CONST(17); b = SOLLYA_CONST(42); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(42); b = SOLLYA_CONST(17); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(17); b = SOLLYA_CONST(17); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality between arithmetical expressions */ a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); b = SOLLYA_MUL(b, SOLLYA_ADD(SOLLYA_CONST(1), sollya_lib_parse_string("1b-200"))); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality between arithmetical expressions that are not faithfully evaluable */ a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(0); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(0); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving NaN produced by evaluation */ a = SOLLYA_CONST(1); b = SOLLYA_LOG(SOLLYA_CONST(-17)); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_LOG(SOLLYA_CONST(-17)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving infinity */ a = SOLLYA_CONST(1); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving errors */ a = sollya_lib_error(); b = SOLLYA_CONST(17); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_error(); b = sollya_lib_error(); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = sollya_lib_error(); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving NaN */ a = SOLLYA_CONST(nan); b = SOLLYA_CONST(nan); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = SOLLYA_CONST(1); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality between strings */ a = sollya_lib_string("Hello!"); b = sollya_lib_string("Hella!"); res = sollya_lib_cmp_greater_equal(a, b); sollya_lib_printf("%b >= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcmp_greater_equal.reference000066400000000000000000000032661300174114700227220ustar00rootroot0000000000000017 >= 42 returns false 42 >= 17 returns true 17 >= 17 returns true The following test is not certified (both values are probably equal) sin((pi) / 3) >= sqrt(3) / 2 returns true sin((pi) / 3) >= sqrt(3) / 2 * (1 + 6.2230152778611417071440640537801242405902521687212e-61) returns false sin((pi) / 3) - sqrt(3) / 2 >= 1 returns false The test will rely on pure FP evaluation. sin((pi) / 3) - sqrt(3) / 2 >= 0 returns true 1 >= sin((pi) / 3) - sqrt(3) / 2 returns true The test will rely on pure FP evaluation. 0 >= sin((pi) / 3) - sqrt(3) / 2 returns true Warning: the following test involves a NaN 1 >= log(-17) returns false Warning: the following test involves a NaN log(-17) >= 1 returns false The test will rely on pure FP evaluation. 1 >= tan((pi) / 2)^2 returns false The test will rely on pure FP evaluation. 1 >= -(tan((pi) / 2)^2) returns true The test will rely on pure FP evaluation. tan((pi) / 2)^2 >= 1 returns true The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) >= 1 returns false The test will rely on pure FP evaluation. infty >= -(tan((pi) / 2)^2) returns true The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) >= infty returns false The test will rely on pure FP evaluation. infty >= tan((pi) / 2)^2 returns true The test will rely on pure FP evaluation. tan((pi) / 2)^2 >= infty returns false The following expression is not correctly typed. error >= 17 returns error The following expression is not correctly typed. error >= error returns error The following expression is not correctly typed. NaN >= error returns error NaN >= NaN returns false NaN >= 1 returns false The following expression is not correctly typed. Hello! >= Hella! returns error sollya-6.0+ds/tests-lib/tcmp_in.c000066400000000000000000000155721300174114700167770ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: sollya_lib_printf("The test will rely on pure FP evaluation.\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: sollya_lib_printf("The following inclusion test is not certified (probably equal to one of the endpoints)\n"); break; case SOLLYA_MSG_ONLY_ONE_ENDPOINT_OF_RANGE_IS_NAN: sollya_lib_printf("Only one endpoint of the interval is NaN. Will replace it by [NaN,NaN]\n"); break; case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The following expression is not correctly typed.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a, b, res; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a = SOLLYA_CONST(1); b = sollya_lib_parse_string("[1,2]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(4); b = sollya_lib_parse_string("[1,2]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("17 + log2(13)/log2(9)"); b = sollya_lib_parse_string("[18,19]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("17 + log2(13)/log2(9)"); b = sollya_lib_parse_string("[1,2]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); b = sollya_lib_parse_string("[1,2]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); b = sollya_lib_parse_string("[0,2]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); b = sollya_lib_parse_string("[-1,0]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); b = sollya_lib_parse_string("[-1,1]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("sin(pi/6)"); b = sollya_lib_parse_string("[1/2,1]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("sin(pi/6)"); b = sollya_lib_parse_string("[0,1/2]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("sin(pi/6)"); b = sollya_lib_parse_string("[0,1]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("sin(pi/6)"); b = sollya_lib_parse_string("[1,2]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[1,2]"); b = sollya_lib_parse_string("[3,4]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[2,3]"); b = sollya_lib_parse_string("[1,4]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[1,3]"); b = sollya_lib_parse_string("[2,4]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_string("e"); b = sollya_lib_string("Hello"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = sollya_lib_string("H1llo"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Testing inclusion when NaN is a bound */ a = sollya_lib_parse_string("[@NaN@,3]"); b = sollya_lib_parse_string("[2,4]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[@NaN@,5]"); b = sollya_lib_parse_string("[2,4]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[2,4]"); b = sollya_lib_parse_string("[@NaN@,3]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[2,4]"); b = sollya_lib_parse_string("[@NaN@,5]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[@NaN@,4]"); b = sollya_lib_parse_string("[2, @NaN@]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[@NaN@,4]"); b = sollya_lib_parse_string("[@NaN@, 5]"); res = sollya_lib_cmp_in(a, b); sollya_lib_printf("%b in %b returns %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcmp_in.reference000066400000000000000000000033421300174114700205030ustar00rootroot000000000000001 in [1;2] returns true 4 in [1;2] returns false 17 + log2(13) / log2(9) in [18;19] returns true 17 + log2(13) / log2(9) in [1;2] returns false sin((pi) / 3) - sqrt(3) / 2 in [1;2] returns false The test will rely on pure FP evaluation. sin((pi) / 3) - sqrt(3) / 2 in [0;2] returns true The test will rely on pure FP evaluation. sin((pi) / 3) - sqrt(3) / 2 in [-1;0] returns true sin((pi) / 3) - sqrt(3) / 2 in [-1;1] returns true The following inclusion test is not certified (probably equal to one of the endpoints) sin((pi) / 6) in [0.5;1] returns true The following inclusion test is not certified (probably equal to one of the endpoints) sin((pi) / 6) in [0;0.5] returns true sin((pi) / 6) in [0;1] returns true sin((pi) / 6) in [1;2] returns false [1;2] in [3;4] returns false [2;3] in [1;4] returns true [1;3] in [2;4] returns false The following expression is not correctly typed. e in Hello returns error The following expression is not correctly typed. 1 in H1llo returns error Only one endpoint of the interval is NaN. Will replace it by [NaN,NaN] [NaN;NaN] in [2;4] returns false Only one endpoint of the interval is NaN. Will replace it by [NaN,NaN] [NaN;NaN] in [2;4] returns false Only one endpoint of the interval is NaN. Will replace it by [NaN,NaN] [2;4] in [NaN;NaN] returns false Only one endpoint of the interval is NaN. Will replace it by [NaN,NaN] [2;4] in [NaN;NaN] returns false Only one endpoint of the interval is NaN. Will replace it by [NaN,NaN] Only one endpoint of the interval is NaN. Will replace it by [NaN,NaN] [NaN;NaN] in [NaN;NaN] returns false Only one endpoint of the interval is NaN. Will replace it by [NaN,NaN] Only one endpoint of the interval is NaN. Will replace it by [NaN,NaN] [NaN;NaN] in [NaN;NaN] returns false sollya-6.0+ds/tests-lib/tcmp_less.c000066400000000000000000000203741300174114700173330ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: sollya_lib_printf("The following test is not certified (both values are probably equal)\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: sollya_lib_printf("The test will rely on pure FP evaluation.\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL: sollya_lib_printf("Warning: the following test involves a NaN\n"); break; case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The following expression is not correctly typed.\n"); break; default: sollya_lib_printf("Unexpected warning %d\n", message); } return 0; } int main(void) { sollya_obj_t a, b, res; double nan = 0./0.; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* Inequality between numbers */ a = SOLLYA_CONST(17); b = SOLLYA_CONST(42); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(42); b = SOLLYA_CONST(17); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(17); b = SOLLYA_CONST(17); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality between arithmetical expressions */ a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); b = SOLLYA_MUL(b, SOLLYA_ADD(SOLLYA_CONST(1), sollya_lib_parse_string("1b-200"))); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality between arithmetical expressions that are not faithfully evaluable */ a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(0); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(0); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving NaN produced by evaluation */ a = SOLLYA_CONST(1); b = SOLLYA_LOG(SOLLYA_CONST(-17)); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_LOG(SOLLYA_CONST(-17)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving infinity */ a = SOLLYA_CONST(1); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving errors */ a = sollya_lib_error(); b = SOLLYA_CONST(17); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_error(); b = sollya_lib_error(); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = sollya_lib_error(); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving NaN */ a = SOLLYA_CONST(nan); b = SOLLYA_CONST(nan); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = SOLLYA_CONST(1); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality between strings */ a = sollya_lib_string("Hello!"); b = sollya_lib_string("Hella!"); res = sollya_lib_cmp_less(a, b); sollya_lib_printf("%b < %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcmp_less.reference000066400000000000000000000032401300174114700210400ustar00rootroot0000000000000017 < 42 returns true 42 < 17 returns false 17 < 17 returns false The following test is not certified (both values are probably equal) sin((pi) / 3) < sqrt(3) / 2 returns false sin((pi) / 3) < sqrt(3) / 2 * (1 + 6.2230152778611417071440640537801242405902521687212e-61) returns true sin((pi) / 3) - sqrt(3) / 2 < 1 returns true The test will rely on pure FP evaluation. sin((pi) / 3) - sqrt(3) / 2 < 0 returns false 1 < sin((pi) / 3) - sqrt(3) / 2 returns false The test will rely on pure FP evaluation. 0 < sin((pi) / 3) - sqrt(3) / 2 returns false Warning: the following test involves a NaN 1 < log(-17) returns false Warning: the following test involves a NaN log(-17) < 1 returns false The test will rely on pure FP evaluation. 1 < tan((pi) / 2)^2 returns true The test will rely on pure FP evaluation. 1 < -(tan((pi) / 2)^2) returns false The test will rely on pure FP evaluation. tan((pi) / 2)^2 < 1 returns false The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) < 1 returns true The test will rely on pure FP evaluation. infty < -(tan((pi) / 2)^2) returns false The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) < infty returns true The test will rely on pure FP evaluation. infty < tan((pi) / 2)^2 returns false The test will rely on pure FP evaluation. tan((pi) / 2)^2 < infty returns true The following expression is not correctly typed. error < 17 returns error The following expression is not correctly typed. error < error returns error The following expression is not correctly typed. NaN < error returns error NaN < NaN returns false NaN < 1 returns false The following expression is not correctly typed. Hello! < Hella! returns error sollya-6.0+ds/tests-lib/tcmp_less_equal.c000066400000000000000000000206531300174114700205220ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: sollya_lib_printf("The following test is not certified (both values are probably equal)\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: sollya_lib_printf("The test will rely on pure FP evaluation.\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL: sollya_lib_printf("Warning: the following test involves a NaN\n"); break; case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The following expression is not correctly typed.\n"); break; default: sollya_lib_printf("Unexpected warning %d\n", message); } return 0; } int main(void) { sollya_obj_t a, b, res; double nan = 0./0.; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* Inequality between numbers */ a = SOLLYA_CONST(17); b = SOLLYA_CONST(42); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(42); b = SOLLYA_CONST(17); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(17); b = SOLLYA_CONST(17); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality between arithmetical expressions */ a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); b = SOLLYA_MUL(b, SOLLYA_ADD(SOLLYA_CONST(1), sollya_lib_parse_string("1b-200"))); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality between arithmetical expressions that are not faithfully evaluable */ a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(0); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(0); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving NaN produced by evaluation */ a = SOLLYA_CONST(1); b = SOLLYA_LOG(SOLLYA_CONST(-17)); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_LOG(SOLLYA_CONST(-17)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving infinity */ a = SOLLYA_CONST(1); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving errors */ a = sollya_lib_error(); b = SOLLYA_CONST(17); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_error(); b = sollya_lib_error(); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = sollya_lib_error(); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality involving NaN */ a = SOLLYA_CONST(nan); b = SOLLYA_CONST(nan); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = SOLLYA_CONST(1); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Inequality between strings */ a = sollya_lib_string("Hello!"); b = sollya_lib_string("Hella!"); res = sollya_lib_cmp_less_equal(a, b); sollya_lib_printf("%b <= %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcmp_less_equal.reference000066400000000000000000000032651300174114700222360ustar00rootroot0000000000000017 <= 42 returns true 42 <= 17 returns false 17 <= 17 returns true The following test is not certified (both values are probably equal) sin((pi) / 3) <= sqrt(3) / 2 returns true sin((pi) / 3) <= sqrt(3) / 2 * (1 + 6.2230152778611417071440640537801242405902521687212e-61) returns true sin((pi) / 3) - sqrt(3) / 2 <= 1 returns true The test will rely on pure FP evaluation. sin((pi) / 3) - sqrt(3) / 2 <= 0 returns true 1 <= sin((pi) / 3) - sqrt(3) / 2 returns false The test will rely on pure FP evaluation. 0 <= sin((pi) / 3) - sqrt(3) / 2 returns true Warning: the following test involves a NaN 1 <= log(-17) returns false Warning: the following test involves a NaN log(-17) <= 1 returns false The test will rely on pure FP evaluation. 1 <= tan((pi) / 2)^2 returns true The test will rely on pure FP evaluation. 1 <= -(tan((pi) / 2)^2) returns false The test will rely on pure FP evaluation. tan((pi) / 2)^2 <= 1 returns false The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) <= 1 returns true The test will rely on pure FP evaluation. infty <= -(tan((pi) / 2)^2) returns false The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) <= infty returns true The test will rely on pure FP evaluation. infty <= tan((pi) / 2)^2 returns false The test will rely on pure FP evaluation. tan((pi) / 2)^2 <= infty returns true The following expression is not correctly typed. error <= 17 returns error The following expression is not correctly typed. error <= error returns error The following expression is not correctly typed. NaN <= error returns error NaN <= NaN returns false NaN <= 1 returns false The following expression is not correctly typed. Hello! <= Hella! returns error sollya-6.0+ds/tests-lib/tcmp_not_equal.c000066400000000000000000000467721300174114700203660ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: sollya_lib_printf("The following test is not certified (both values are probably equal)\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: sollya_lib_printf("The test will rely on pure FP evaluation.\n"); break; case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL: sollya_lib_printf("Warning: the following test involves a NaN\n"); break; default: sollya_lib_printf("Unexpected warning %d\n", message); } return 0; } int main(void) { sollya_obj_t a, b, c, d, res; mpfr_t tmp1, tmp2; double nan = 0./0.; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* First run with autosimplify = on */ sollya_lib_printf("First run with autosimplify = on\n\n"); a = sollya_lib_on(); sollya_lib_set_autosimplify(a); sollya_lib_clear_obj(a); /* Equality between numbers */ a = SOLLYA_CONST(17); b = SOLLYA_CONST(42); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(42); b = SOLLYA_CONST(17); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(17); b = SOLLYA_CONST(17); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between arithmetical expressions */ a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); b = SOLLYA_MUL(b, SOLLYA_ADD(SOLLYA_CONST(1), sollya_lib_parse_string("1b-200"))); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between arithmetical expressions that are not faithfully evaluable */ a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(0); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(0); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving NaN produced by evaluation */ a = SOLLYA_CONST(1); b = SOLLYA_LOG(SOLLYA_CONST(-17)); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_LOG(SOLLYA_CONST(-17)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving infinity */ a = SOLLYA_CONST(1); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving errors */ a = sollya_lib_error(); b = SOLLYA_CONST(17); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_error(); b = sollya_lib_error(); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = sollya_lib_error(); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving NaN */ a = SOLLYA_CONST(nan); b = SOLLYA_CONST(nan); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = SOLLYA_CONST(1); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Commutativity */ a = SOLLYA_ADD(SOLLYA_CONST(2), SOLLYA_X_); b = SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(2)); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between equal intervals but with bounds at different precisions */ a = sollya_lib_parse_string("[1;2]"); mpfr_init2(tmp1, 20); /* not the current precision */ mpfr_init2(tmp2, 30); /* not the current precision */ mpfr_set_ui(tmp1, 1, GMP_RNDN); mpfr_set_ui(tmp2, 2, GMP_RNDN); b = sollya_lib_range_from_bounds(tmp1, tmp2); mpfr_clear(tmp1); mpfr_clear(tmp2); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b (even when bounds are stored at different precisions)\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* More involved expression */ a = sollya_lib_parse_string("1 + exp(sin(x + log(x^2)))"); c = SOLLYA_CONST(40); sollya_lib_set_prec(c); sollya_lib_clear_obj(c); b = sollya_lib_parse_string("sin(x + log(x^2))"); b = SOLLYA_ADD(SOLLYA_CONST(1), SOLLYA_EXP(b)); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b (even when constructed at different precisions)\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between strings */ a = sollya_lib_string("Hello!"); b = sollya_lib_string("Hella!"); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_string("Hello!"); b = sollya_lib_string("ello!"); c = sollya_lib_string("H"); d = sollya_lib_concat(c, b); res = sollya_lib_cmp_not_equal(a, d); sollya_lib_printf("%b != %b returns %b\n\n", a, d, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(d); sollya_lib_clear_obj(res); /* Second run with autosimplify = off */ sollya_lib_printf("Second run with autosimplify = off\n\n"); a = sollya_lib_off(); sollya_lib_set_autosimplify(a); sollya_lib_clear_obj(a); /* Equality between numbers */ a = SOLLYA_CONST(17); b = SOLLYA_CONST(42); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(42); b = SOLLYA_CONST(17); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(17); b = SOLLYA_CONST(17); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between arithmetical expressions */ a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))); b = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); b = SOLLYA_MUL(b, SOLLYA_ADD(SOLLYA_CONST(1), sollya_lib_parse_string("1b-200"))); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between arithmetical expressions that are not faithfully evaluable */ a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); b = SOLLYA_CONST(0); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(0); b = SOLLYA_SUB(SOLLYA_SIN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(3))), SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2))); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving NaN produced by evaluation */ a = SOLLYA_CONST(1); b = SOLLYA_LOG(SOLLYA_CONST(-17)); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_LOG(SOLLYA_CONST(-17)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving infinity */ a = SOLLYA_CONST(1); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(1); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = SOLLYA_CONST(1); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = SOLLYA_CONST(1); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_NEG(SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2))); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("@Inf@;"); b = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_POW(SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))), SOLLYA_CONST(2)); b = sollya_lib_parse_string("@Inf@;"); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving errors */ a = sollya_lib_error(); b = SOLLYA_CONST(17); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_error(); b = sollya_lib_error(); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = sollya_lib_error(); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality involving NaN */ a = SOLLYA_CONST(nan); b = SOLLYA_CONST(nan); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); b = SOLLYA_CONST(1); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Commutativity */ a = SOLLYA_ADD(SOLLYA_CONST(2), SOLLYA_X_); b = SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(2)); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between equal intervals but with bounds at different precisions */ a = sollya_lib_parse_string("[1;2]"); mpfr_init2(tmp1, 20); /* not the current precision */ mpfr_init2(tmp2, 30); /* not the current precision */ mpfr_set_ui(tmp1, 1, GMP_RNDN); mpfr_set_ui(tmp2, 2, GMP_RNDN); b = sollya_lib_range_from_bounds(tmp1, tmp2); mpfr_clear(tmp1); mpfr_clear(tmp2); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b (even when bounds are stored at different precisions)\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* More involved expression */ a = sollya_lib_parse_string("1 + exp(sin(x + log(x^2)))"); c = SOLLYA_CONST(40); sollya_lib_set_prec(c); sollya_lib_clear_obj(c); b = sollya_lib_parse_string("sin(x + log(x^2))"); b = SOLLYA_ADD(SOLLYA_CONST(1), SOLLYA_EXP(b)); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b (even when constructed at different precisions)\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); /* Equality between strings */ a = sollya_lib_string("Hello!"); b = sollya_lib_string("Hella!"); res = sollya_lib_cmp_not_equal(a, b); sollya_lib_printf("%b != %b returns %b\n\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_string("Hello!"); b = sollya_lib_string("ello!"); c = sollya_lib_string("H"); d = sollya_lib_concat(c, b); res = sollya_lib_cmp_not_equal(a, d); sollya_lib_printf("%b != %b returns %b\n\n", a, d, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(d); sollya_lib_clear_obj(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcmp_not_equal.reference000066400000000000000000000070231300174114700220640ustar00rootroot00000000000000First run with autosimplify = on 17 != 42 returns true 42 != 17 returns true 17 != 17 returns false The following test is not certified (both values are probably equal) sin((pi) / 3) != sqrt(3) / 2 returns false sin((pi) / 3) != sqrt(3) / 2 * (1 + 6.2230152778611417071440640537801242405902521687212e-61) returns true sin((pi) / 3) - sqrt(3) / 2 != 1 returns true The test will rely on pure FP evaluation. sin((pi) / 3) - sqrt(3) / 2 != 0 returns false 1 != sin((pi) / 3) - sqrt(3) / 2 returns true The test will rely on pure FP evaluation. 0 != sin((pi) / 3) - sqrt(3) / 2 returns false Warning: the following test involves a NaN 1 != log(-17) returns false Warning: the following test involves a NaN log(-17) != 1 returns false The test will rely on pure FP evaluation. 1 != tan((pi) / 2)^2 returns true The test will rely on pure FP evaluation. 1 != -(tan((pi) / 2)^2) returns true The test will rely on pure FP evaluation. tan((pi) / 2)^2 != 1 returns true The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) != 1 returns true The test will rely on pure FP evaluation. infty != -(tan((pi) / 2)^2) returns true The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) != infty returns true The test will rely on pure FP evaluation. infty != tan((pi) / 2)^2 returns true The test will rely on pure FP evaluation. tan((pi) / 2)^2 != infty returns true error != 17 returns false error != error returns false NaN != error returns false NaN != NaN returns false NaN != 1 returns false 2 + _x_ != _x_ + 2 returns false [1;2] != [1;2] returns false (even when bounds are stored at different precisions) 1 + exp(sin(x + log(x^2))) != 1 + exp(sin(x + log(x^2))) returns false (even when constructed at different precisions) Hello! != Hella! returns true Hello! != Hello! returns false Second run with autosimplify = off 17 != 42 returns true 42 != 17 returns true 17 != 17 returns false The following test is not certified (both values are probably equal) sin((pi) / 3) != sqrt(3) / 2 returns false sin((pi) / 3) != sqrt(3) / 2 * (1 + 6.22301527786e-61) returns true sin((pi) / 3) - sqrt(3) / 2 != 1 returns true The test will rely on pure FP evaluation. sin((pi) / 3) - sqrt(3) / 2 != 0 returns false 1 != sin((pi) / 3) - sqrt(3) / 2 returns true The test will rely on pure FP evaluation. 0 != sin((pi) / 3) - sqrt(3) / 2 returns false Warning: the following test involves a NaN 1 != log(-17) returns false Warning: the following test involves a NaN log(-17) != 1 returns false The test will rely on pure FP evaluation. 1 != tan((pi) / 2)^2 returns true The test will rely on pure FP evaluation. 1 != -(tan((pi) / 2)^2) returns true The test will rely on pure FP evaluation. tan((pi) / 2)^2 != 1 returns true The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) != 1 returns true The test will rely on pure FP evaluation. infty != -(tan((pi) / 2)^2) returns true The test will rely on pure FP evaluation. -(tan((pi) / 2)^2) != infty returns true The test will rely on pure FP evaluation. infty != tan((pi) / 2)^2 returns true The test will rely on pure FP evaluation. tan((pi) / 2)^2 != infty returns true error != 17 returns false error != error returns false NaN != error returns false NaN != NaN returns false NaN != 1 returns false 2 + x != x + 2 returns true [1;2] != [1;2] returns false (even when bounds are stored at different precisions) 1 + exp(sin(x + log(x^2))) != 1 + exp(sin(x + log(x^2))) returns false (even when constructed at different precisions) Hello! != Hella! returns true Hello! != Hello! returns false sollya-6.0+ds/tests-lib/tcmp_objs_structurally.c000066400000000000000000000774001300174114700221610ustar00rootroot00000000000000#include int cmp(int *res, void **args) { sollya_obj_t *true_args = (sollya_obj_t *)args; *res = sollya_lib_cmp_objs_structurally(true_args[0], true_args[1]); return 1; } int hcmp(int *res, void **args) { sollya_obj_t *true_args = (sollya_obj_t *)args; int64_t h1,h2; h1 = sollya_lib_hash(true_args[0]); h2 = sollya_lib_hash(true_args[1]); *res = (h1 == h2); return 1; } static char *test_proc_string = "proc () {\n" " var a, b, k, f, g, p, proc_aux, g1;\n" "\n" " /* Comparing basic object of the same type */\n" " print(\"Comparing 1 and 1:\"); a = 1; b = 1; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing 1 and 2:\"); a = 1; b = 2; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing [||] and [||]:\"); a = [||]; b = [||]; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing [||] and [|1|]:\"); a = [||]; b = [|1|]; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing [1,2] and [1,2]:\"); a = [1,2]; b = [1,2]; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing [1,2] and [1,3]:\"); a = [1,2]; b = [1,3]; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing \\\"Hello\\\" and \\\"Hello\\\":\"); a = \"Hello\"; b = \"Hello\"; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing \\\"Hello\\\" and \\\"Hello!\\\":\"); a = \"Hello\"; b = \"Hello!\"; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " \n" " /* Playing with ellipses in lists */\n" " print(\"Comparing [|1,2,3...|] and [|1,2,3|]:\"); a = [|1,2,3...|]; b = [|1,2,3|]; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing [|1,2,3...|] and [|1,2,3,4...|]:\"); a = [|1,2,3...|]; b = [|1,2,3,4...|]; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " a[0]; b[0];\n" " a[10]; b[10];\n" " /* Does the result change after expanding part of the list? */\n" " cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " \n" " print(\"Comparing [|D,D...|] and [|D...|]:\"); a = [|D,D...|]; b = [|D...|]; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " a[0]; b[0];\n" " a[10]; b[10];\n" " /* Does the result change after expanding part of the list? */\n" " cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " \n" " /* And if we provide exactly the same? */\n" " a = [|D,D...|]; b = [|D,D...|]; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " \n" " print(\"Comparing [|1,...,5|] and [|1,2,3,4,5|]:\"); a = [|1,...,5|]; b = [|1,2,3,4,5|];\n" " cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " a[0]; b[0];\n" " a[3]; b[3];\n" " /* Does the result change after expanding part of the list? */\n" " cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " \n" " /* Things obviously not equal because having different types */\n" " print(\"Comparing [||] and 1:\"); a = [||]; b = 1; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing [|1|] and 1:\"); a = [|1|]; b = 1; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " \n" " /* Do NaN, error and Inf compare equal to themselves? */\n" " print(\"Comparing @NaN@ and @NaN@:\"); a = @NaN@; b = @NaN@; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing @Inf@ and @Inf@:\"); a = @Inf@; b = @Inf@; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing error and error:\"); a = error; b = error; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing error and @NaN@:\"); a = error; b = @NaN@; cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " \n" " /* Expressions mathematically equal */\n" " print(\"Comparing log(x) and log(x):\"); a = log(x); b = log(x); cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing log10(x) and log(x)/log(10):\"); a = log10(x); b = log(x)/log(10); cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing exp(x)+1 and 1+exp(x):\"); a = exp(x)+1; b = 1+exp(x); cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing a = cos(x)^sin(x) and exp(sin(x)*log(cos(x)))):\"); a = cos(x)^sin(x); b = exp(sin(x)*log(cos(x))); cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " print(\"Comparing exp(x)*sin(x) and sin(x)*exp(x):\"); a = exp(x)*sin(x); b = sin(x)*exp(x); cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " \n" " /* Testing polynomials */\n" " print(\"Comparing (x+1)^3 and x^3+3*x^2+3*x+1:\"); a = (x+1)^3; b = x^3+3*x^2+3*x+1;\n" " cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " \n" " a(5); b(5);\n" " /* Does it change after an evaluation? */\n" " cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " \n" " a == b;\n" " /* And after an equality test? */\n" " cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " \n" " da = diff(a); db = diff(b);\n" " cmp(da,db); cmp(db,da); hcmp(da,db); cmp(da,db); cmp(db,da);\n" " /* And after differentiating */\n" " cmp(a,b); cmp(b,a); hcmp(a,b); cmp(a,b); cmp(b,a);\n" " \n" " /* Structural comparison of annotated functions */\n" " f = exp(x);\n" " procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ \" (X=\" @ X @ \", f=\" @ f @ \", p=\" @ p @ \" res=\"@ res @ \")\"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; };\n" " procedure g1(X,n,p) { return proc_aux(X,n,p, \"Annotation 1\", f); };\n" " g = annotatefunction(f, function(g1), [0,1], [-1b-40, 1b-40]);\n" " prec=15;\n" " f(1b-1);\n" " g(1b-2);\n" " h = exp(x);\n" " h(1b-3);\n" " print(\"Comparison of an annotated function and its non-annotated version:\");\n" " cmp(f,g); cmp(g,f); hcmp(f,g); cmp(f,g); cmp(g,f);\n" " cmp(g,h); cmp(h,g); hcmp(g,h); cmp(g,h); cmp(h,g);\n" " s = diff(g);\n" " s(1b-4);\n" " print(\"Same comparison with diff(exp):\");\n" " s == g;\n" " cmp(s,g); cmp(g,s); hcmp(s,g); cmp(s,g); cmp(g,s);\n" " cmp(s,h); cmp(h,s); hcmp(s,h); cmp(s,h); cmp(h,s);\n" " \n" " /* Structural comparison of polynomials in different\n" " representation froms when they have no expression attached.\n" " */\n" " k = 15;\n" " p = (1 + x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 3;\n" " p = (1 + x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 2;\n" " p = (1 + x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 1;\n" " p = (1 + x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 15;\n" " p = (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 14;\n" " p = (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 3;\n" " p = (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 2;\n" " p = (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 1;\n" " p = (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 15;\n" " p = x^3 * (1 + x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 3;\n" " p = x^3 * (1 + x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 2;\n" " p = x^3 * (1 + x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 1;\n" " p = x^3 * (1 + x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 15;\n" " p = x^3 * (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 14;\n" " p = x^3 * (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 3;\n" " p = x^3 * (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 2;\n" " p = x^3 * (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 1;\n" " p = x^3 * (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 15;\n" " p = x^4 * (1 + x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 3;\n" " p = x^4 * (1 + x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 2;\n" " p = x^4 * (1 + x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 1;\n" " p = x^4 * (1 + x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 15;\n" " p = x^4 * (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 14;\n" " p = x^4 * (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 3;\n" " p = x^4 * (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 2;\n" " p = x^4 * (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 1;\n" " p = x^4 * (1 + x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 15;\n" " p = (1 + 17 * x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 3;\n" " p = (1 + 17 * x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 2;\n" " p = (1 + 17 * x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 1;\n" " p = (1 + 17 * x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 15;\n" " p = (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 14;\n" " p = (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 3;\n" " p = (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 2;\n" " p = (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 1;\n" " p = (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 15;\n" " p = x^3 * (1 + 17 * x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 3;\n" " p = x^3 * (1 + 17 * x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 2;\n" " p = x^3 * (1 + 17 * x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 1;\n" " p = x^3 * (1 + 17 * x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 15;\n" " p = x^3 * (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 14;\n" " p = x^3 * (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 3;\n" " p = x^3 * (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 2;\n" " p = x^3 * (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 1;\n" " p = x^3 * (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 15;\n" " p = x^4 * (1 + 17 * x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 3;\n" " p = x^4 * (1 + 17 * x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 2;\n" " p = x^4 * (1 + 17 * x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 1;\n" " p = x^4 * (1 + 17 * x)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 15;\n" " p = x^4 * (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 14;\n" " p = x^4 * (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 3;\n" " p = x^4 * (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 2;\n" " p = x^4 * (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" " \n" " k = 1;\n" " p = x^4 * (1 + 17 * x^2)^k;\n" " a = horner(p);\n" " b = canonical(p);\n" " \n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"a =\", a);\n" " print(\"b =\", b);\n" " cmp(a, b); cmp(b, a); hcmp(a, b); cmp(a, b); cmp(b, a);\n" " print(\"-----------------\");\n" "}\n"; int main(void) { sollya_obj_t a, b, c, d, e; mpfr_t tmp1, tmp2; sollya_obj_t cmp_obj, hcmp_obj, test_proc_obj, test_res_obj; sollya_externalprocedure_type_t argTypes[2] = { SOLLYA_EXTERNALPROC_TYPE_OBJECT, SOLLYA_EXTERNALPROC_TYPE_OBJECT }; sollya_lib_init(); a = SOLLYA_ADD(SOLLYA_CONST(2), SOLLYA_CONST(3)); b = SOLLYA_CONST(5); c = sollya_lib_simplify(a); if (sollya_lib_cmp_objs_structurally(a,b)) sollya_lib_printf("2+3 is structurally equal to 5\n"); else sollya_lib_printf("2+3 is *NOT* structurally equal to 5\n"); if (sollya_lib_cmp_objs_structurally(b,c)) sollya_lib_printf("5 is structurally equal to the result of simplify(2+3)\n"); else sollya_lib_printf("5 is *NOT* structurally equal to the result of simplify(2+3)\n"); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); /* Commutativity */ a = SOLLYA_ADD(SOLLYA_CONST(2), SOLLYA_X_); b = SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(2)); if (sollya_lib_cmp_objs_structurally(a,b)) sollya_lib_printf("2+x is structurally equal to x+2\n"); else sollya_lib_printf("2+x is *NOT* structurally equal to x+2\n"); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); /* Structural equality between objs that are not expressions */ a = sollya_lib_parse_string("[1;2]"); mpfr_init2(tmp1, 20); /* not the current precision */ mpfr_init2(tmp2, 30); /* not the current precision */ mpfr_set_ui(tmp1, 1, GMP_RNDN); mpfr_set_ui(tmp2, 2, GMP_RNDN); b = sollya_lib_range_from_bounds(tmp1, tmp2); mpfr_clear(tmp1); mpfr_clear(tmp2); c = sollya_lib_copy_obj(a); if (sollya_lib_cmp_objs_structurally(a,b)) sollya_lib_printf("Intervals with identical bounds but stored at different precisions are structurally equal\n"); else sollya_lib_printf("Intervals with identical bounds but stored at different precisions are *NOT* structurally equal\n"); if (sollya_lib_cmp_objs_structurally(a,c)) sollya_lib_printf("Identical intervals are structurally equal\n"); else sollya_lib_printf("Identical intervals are *NOT* structurally equal\n"); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); a = sollya_lib_on(); b = sollya_lib_on(); c = sollya_lib_off(); if (sollya_lib_cmp_objs_structurally(a,b)) sollya_lib_printf("on is structurally equal to on\n"); else sollya_lib_printf("on is not structurally equal to on\n"); if (sollya_lib_cmp_objs_structurally(a,c)) sollya_lib_printf("on is structurally equal to off\n"); else sollya_lib_printf("on is *NOT* structurally equal to off\n"); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); /* Structural equality between strings */ a = sollya_lib_string("Hello!"); b = sollya_lib_string("Hella!"); c = sollya_lib_string("ello!"); d = sollya_lib_string("H"); e = sollya_lib_concat(d, c); if (sollya_lib_cmp_objs_structurally(a,b)) sollya_lib_printf("%b is structurally equal to %b\n", a, b); else sollya_lib_printf("%b is *NOT* structurally equal to %b\n", a, b); if (sollya_lib_cmp_objs_structurally(a,e)) sollya_lib_printf("%b is structurally equal to %b\n", a, e); else sollya_lib_printf("%b is *NOT* structurally equal to %b\n", a, e); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(d); sollya_lib_clear_obj(e); /* More involved expression */ a = sollya_lib_parse_string("1 + exp(sin(x + log(x^2)))"); c = SOLLYA_CONST(40); sollya_lib_set_prec(c); sollya_lib_clear_obj(c); b = sollya_lib_parse_string("sin(x + log(x^2))"); b = SOLLYA_ADD(SOLLYA_CONST(1), SOLLYA_EXP(b)); if (sollya_lib_cmp_objs_structurally(a,b)) sollya_lib_printf("%b is structurally equal to %b, even if defined at different precisions\n", a, b); else sollya_lib_printf("%b is *NOT* structurally equal to %b, even if defined at different precisions\n", a, b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); /* Complex tests */ cmp_obj = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_BOOLEAN, argTypes, 2, "cmp", cmp); hcmp_obj = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_BOOLEAN, argTypes, 2, "hcmp", hcmp); test_proc_obj = sollya_lib_parse_string(test_proc_string); sollya_lib_printf("Running the complex comparison tests\n"); test_res_obj = sollya_lib_apply(test_proc_obj, NULL); sollya_lib_printf("The complex comparison tests are done\n"); sollya_lib_printf("Object returned by the complex comparison tests: \"%b\"\n", test_res_obj); sollya_lib_clear_obj(hcmp_obj); sollya_lib_clear_obj(cmp_obj); sollya_lib_clear_obj(test_proc_obj); sollya_lib_clear_obj(test_res_obj); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcmp_objs_structurally.reference000066400000000000000000000450471300174114700236770ustar00rootroot000000000000002+3 is *NOT* structurally equal to 5 5 is structurally equal to the result of simplify(2+3) 2+x is *NOT* structurally equal to x+2 Intervals with identical bounds but stored at different precisions are structurally equal Identical intervals are structurally equal on is structurally equal to on on is *NOT* structurally equal to off Hello! is *NOT* structurally equal to Hella! Hello! is structurally equal to Hello! 1 + exp(sin(x + log(x^2))) is structurally equal to 1 + exp(sin(x + log(x^2))), even if defined at different precisions Running the complex comparison tests Comparing 1 and 1: true true true true true Comparing 1 and 2: false false false false false Comparing [||] and [||]: true true true true true Comparing [||] and [|1|]: false false false false false Comparing [1,2] and [1,2]: true true true true true Comparing [1,2] and [1,3]: false false false false false Comparing "Hello" and "Hello": true true true true true Comparing "Hello" and "Hello!": false false false false false Comparing [|1,2,3...|] and [|1,2,3|]: false false false false false Comparing [|1,2,3...|] and [|1,2,3,4...|]: false false false false false 1 1 11 11 false false false false false Comparing [|D,D...|] and [|D...|]: false false false false false double double double double false false false false false true true true true true Comparing [|1,...,5|] and [|1,2,3,4,5|]: true true true true true 1 1 4 4 true true true true true Comparing [||] and 1: false false false false false Comparing [|1|] and 1: false false false false false Comparing @NaN@ and @NaN@: true true true true true Comparing @Inf@ and @Inf@: true true true true true Comparing error and error: true true true true true Comparing error and @NaN@: false false false false false Comparing log(x) and log(x): true true true true true Comparing log10(x) and log(x)/log(10): false false false false false Comparing exp(x)+1 and 1+exp(x): false false false false false Comparing a = cos(x)^sin(x) and exp(sin(x)*log(cos(x)))): false false false false false Comparing exp(x)*sin(x) and sin(x)*exp(x): false false false false false Comparing (x+1)^3 and x^3+3*x^2+3*x+1: false false true false false 216 216 false false true false false true false false true false false true true true true true false false true false false The precision has been set to 15 bits. Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1.64874 Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1.284 Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1.1332 Comparison of an annotated function and its non-annotated version: true true true true true true true true true true Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1.0645 Same comparison with diff(exp): true true true true true true true true true true true false false true false false a = 1 + x * (15 + x * (105 + x * (455 + x * (1365 + x * (3003 + x * (5005 + x * (6435 + x * (6435 + x * (5005 + x * (3003 + x * (1365 + x * (455 + x * (105 + x * (15 + x)))))))))))))) b = 1 + 15 * x + 105 * x^2 + 455 * x^3 + 1365 * x^4 + 3003 * x^5 + 5005 * x^6 + 6435 * x^7 + 6435 * x^8 + 5005 * x^9 + 3003 * x^10 + 1365 * x^11 + 455 * x^12 + 105 * x^13 + 15 * x^14 + x^15 false false true false false ----------------- false false true false false a = 1 + x * (3 + x * (3 + x)) b = 1 + 3 * x + 3 * x^2 + x^3 false false true false false ----------------- false false true false false a = 1 + x * (2 + x) b = 1 + 2 * x + x^2 false false true false false ----------------- true true true true true a = 1 + x b = 1 + x true true true true true ----------------- false false true false false a = 1 + x^2 * (15 + x^2 * (105 + x^2 * (455 + x^2 * (1365 + x^2 * (3003 + x^2 * (5005 + x^2 * (6435 + x^2 * (6435 + x^2 * (5005 + x^2 * (3003 + x^2 * (1365 + x^2 * (455 + x^2 * (105 + x^2 * (15 + x^2)))))))))))))) b = 1 + 15 * x^2 + 105 * x^4 + 455 * x^6 + 1365 * x^8 + 3003 * x^10 + 5005 * x^12 + 6435 * x^14 + 6435 * x^16 + 5005 * x^18 + 3003 * x^20 + 1365 * x^22 + 455 * x^24 + 105 * x^26 + 15 * x^28 + x^30 false false true false false ----------------- false false true false false a = 1 + x^2 * (14 + x^2 * (91 + x^2 * (364 + x^2 * (1001 + x^2 * (2002 + x^2 * (3003 + x^2 * (3432 + x^2 * (3003 + x^2 * (2002 + x^2 * (1001 + x^2 * (364 + x^2 * (91 + x^2 * (14 + x^2))))))))))))) b = 1 + 14 * x^2 + 91 * x^4 + 364 * x^6 + 1001 * x^8 + 2002 * x^10 + 3003 * x^12 + 3432 * x^14 + 3003 * x^16 + 2002 * x^18 + 1001 * x^20 + 364 * x^22 + 91 * x^24 + 14 * x^26 + x^28 false false true false false ----------------- false false true false false a = 1 + x^2 * (3 + x^2 * (3 + x^2)) b = 1 + 3 * x^2 + 3 * x^4 + x^6 false false true false false ----------------- false false true false false a = 1 + x^2 * (2 + x^2) b = 1 + 2 * x^2 + x^4 false false true false false ----------------- true true true true true a = 1 + x^2 b = 1 + x^2 true true true true true ----------------- false false true false false a = x^3 * (1 + x * (15 + x * (105 + x * (455 + x * (1365 + x * (3003 + x * (5005 + x * (6435 + x * (6435 + x * (5005 + x * (3003 + x * (1365 + x * (455 + x * (105 + x * (15 + x))))))))))))))) b = x^3 + 15 * x^4 + 105 * x^5 + 455 * x^6 + 1365 * x^7 + 3003 * x^8 + 5005 * x^9 + 6435 * x^10 + 6435 * x^11 + 5005 * x^12 + 3003 * x^13 + 1365 * x^14 + 455 * x^15 + 105 * x^16 + 15 * x^17 + x^18 false false true false false ----------------- false false true false false a = x^3 * (1 + x * (3 + x * (3 + x))) b = x^3 + 3 * x^4 + 3 * x^5 + x^6 false false true false false ----------------- false false true false false a = x^3 * (1 + x * (2 + x)) b = x^3 + 2 * x^4 + x^5 false false true false false ----------------- false false true false false a = x^3 * (1 + x) b = x^3 + x^4 false false true false false ----------------- false false true false false a = x^3 * (1 + x^2 * (15 + x^2 * (105 + x^2 * (455 + x^2 * (1365 + x^2 * (3003 + x^2 * (5005 + x^2 * (6435 + x^2 * (6435 + x^2 * (5005 + x^2 * (3003 + x^2 * (1365 + x^2 * (455 + x^2 * (105 + x^2 * (15 + x^2))))))))))))))) b = x^3 + 15 * x^5 + 105 * x^7 + 455 * x^9 + 1365 * x^11 + 3003 * x^13 + 5005 * x^15 + 6435 * x^17 + 6435 * x^19 + 5005 * x^21 + 3003 * x^23 + 1365 * x^25 + 455 * x^27 + 105 * x^29 + 15 * x^31 + x^33 false false true false false ----------------- false false true false false a = x^3 * (1 + x^2 * (14 + x^2 * (91 + x^2 * (364 + x^2 * (1001 + x^2 * (2002 + x^2 * (3003 + x^2 * (3432 + x^2 * (3003 + x^2 * (2002 + x^2 * (1001 + x^2 * (364 + x^2 * (91 + x^2 * (14 + x^2)))))))))))))) b = x^3 + 14 * x^5 + 91 * x^7 + 364 * x^9 + 1001 * x^11 + 2002 * x^13 + 3003 * x^15 + 3432 * x^17 + 3003 * x^19 + 2002 * x^21 + 1001 * x^23 + 364 * x^25 + 91 * x^27 + 14 * x^29 + x^31 false false true false false ----------------- false false true false false a = x^3 * (1 + x^2 * (3 + x^2 * (3 + x^2))) b = x^3 + 3 * x^5 + 3 * x^7 + x^9 false false true false false ----------------- false false true false false a = x^3 * (1 + x^2 * (2 + x^2)) b = x^3 + 2 * x^5 + x^7 false false true false false ----------------- false false true false false a = x^3 * (1 + x^2) b = x^3 + x^5 false false true false false ----------------- false false true false false a = x^4 * (1 + x * (15 + x * (105 + x * (455 + x * (1365 + x * (3003 + x * (5005 + x * (6435 + x * (6435 + x * (5005 + x * (3003 + x * (1365 + x * (455 + x * (105 + x * (15 + x))))))))))))))) b = x^4 + 15 * x^5 + 105 * x^6 + 455 * x^7 + 1365 * x^8 + 3003 * x^9 + 5005 * x^10 + 6435 * x^11 + 6435 * x^12 + 5005 * x^13 + 3003 * x^14 + 1365 * x^15 + 455 * x^16 + 105 * x^17 + 15 * x^18 + x^19 false false true false false ----------------- false false true false false a = x^4 * (1 + x * (3 + x * (3 + x))) b = x^4 + 3 * x^5 + 3 * x^6 + x^7 false false true false false ----------------- false false true false false a = x^4 * (1 + x * (2 + x)) b = x^4 + 2 * x^5 + x^6 false false true false false ----------------- false false true false false a = x^4 * (1 + x) b = x^4 + x^5 false false true false false ----------------- false false true false false a = x^4 * (1 + x^2 * (15 + x^2 * (105 + x^2 * (455 + x^2 * (1365 + x^2 * (3003 + x^2 * (5005 + x^2 * (6435 + x^2 * (6435 + x^2 * (5005 + x^2 * (3003 + x^2 * (1365 + x^2 * (455 + x^2 * (105 + x^2 * (15 + x^2))))))))))))))) b = x^4 + 15 * x^6 + 105 * x^8 + 455 * x^10 + 1365 * x^12 + 3003 * x^14 + 5005 * x^16 + 6435 * x^18 + 6435 * x^20 + 5005 * x^22 + 3003 * x^24 + 1365 * x^26 + 455 * x^28 + 105 * x^30 + 15 * x^32 + x^34 false false true false false ----------------- false false true false false a = x^4 * (1 + x^2 * (14 + x^2 * (91 + x^2 * (364 + x^2 * (1001 + x^2 * (2002 + x^2 * (3003 + x^2 * (3432 + x^2 * (3003 + x^2 * (2002 + x^2 * (1001 + x^2 * (364 + x^2 * (91 + x^2 * (14 + x^2)))))))))))))) b = x^4 + 14 * x^6 + 91 * x^8 + 364 * x^10 + 1001 * x^12 + 2002 * x^14 + 3003 * x^16 + 3432 * x^18 + 3003 * x^20 + 2002 * x^22 + 1001 * x^24 + 364 * x^26 + 91 * x^28 + 14 * x^30 + x^32 false false true false false ----------------- false false true false false a = x^4 * (1 + x^2 * (3 + x^2 * (3 + x^2))) b = x^4 + 3 * x^6 + 3 * x^8 + x^10 false false true false false ----------------- false false true false false a = x^4 * (1 + x^2 * (2 + x^2)) b = x^4 + 2 * x^6 + x^8 false false true false false ----------------- false false true false false a = x^4 * (1 + x^2) b = x^4 + x^6 false false true false false ----------------- false false true false false a = 1 + x * (255 + x * (30345 + x * (2235415 + x * (114006165 + x * (4263830571 + x * (120808532845 + x * (2640529360755 + x * (44888999132835 + x * (593532321867485 + x * (6054029683048347 + x * (46781138459919045 + x * (265093117939541255 + x * (1039980693455123385 + x * (2525667398391013935 + x * 2862423051509815793)))))))))))))) b = 1 + 255 * x + 30345 * x^2 + 2235415 * x^3 + 114006165 * x^4 + 4263830571 * x^5 + 120808532845 * x^6 + 2640529360755 * x^7 + 44888999132835 * x^8 + 593532321867485 * x^9 + 6054029683048347 * x^10 + 46781138459919045 * x^11 + 265093117939541255 * x^12 + 1039980693455123385 * x^13 + 2525667398391013935 * x^14 + 2862423051509815793 * x^15 false false true false false ----------------- false false true false false a = 1 + x * (51 + x * (867 + x * 4913)) b = 1 + 51 * x + 867 * x^2 + 4913 * x^3 false false true false false ----------------- false false true false false a = 1 + x * (34 + x * 289) b = 1 + 34 * x + 289 * x^2 false false true false false ----------------- false false true false false a = 1 + x * 17 b = 1 + 17 * x false false true false false ----------------- false false true false false a = 1 + x^2 * (255 + x^2 * (30345 + x^2 * (2235415 + x^2 * (114006165 + x^2 * (4263830571 + x^2 * (120808532845 + x^2 * (2640529360755 + x^2 * (44888999132835 + x^2 * (593532321867485 + x^2 * (6054029683048347 + x^2 * (46781138459919045 + x^2 * (265093117939541255 + x^2 * (1039980693455123385 + x^2 * (2525667398391013935 + x^2 * 2862423051509815793)))))))))))))) b = 1 + 255 * x^2 + 30345 * x^4 + 2235415 * x^6 + 114006165 * x^8 + 4263830571 * x^10 + 120808532845 * x^12 + 2640529360755 * x^14 + 44888999132835 * x^16 + 593532321867485 * x^18 + 6054029683048347 * x^20 + 46781138459919045 * x^22 + 265093117939541255 * x^24 + 1039980693455123385 * x^26 + 2525667398391013935 * x^28 + 2862423051509815793 * x^30 false false true false false ----------------- false false true false false a = 1 + x^2 * (238 + x^2 * (26299 + x^2 * (1788332 + x^2 * (83604521 + x^2 * (2842553714 + x^2 * (72485119707 + x^2 * (1408282325736 + x^2 * (20948199595323 + x^2 * (237412928746994 + x^2 * (2018009894349449 + x^2 * (12474970255978412 + x^2 * (53018623587908251 + x^2 * (138664092460683118 + x^2 * 168377826559400929))))))))))))) b = 1 + 238 * x^2 + 26299 * x^4 + 1788332 * x^6 + 83604521 * x^8 + 2842553714 * x^10 + 72485119707 * x^12 + 1408282325736 * x^14 + 20948199595323 * x^16 + 237412928746994 * x^18 + 2018009894349449 * x^20 + 12474970255978412 * x^22 + 53018623587908251 * x^24 + 138664092460683118 * x^26 + 168377826559400929 * x^28 false false true false false ----------------- false false true false false a = 1 + x^2 * (51 + x^2 * (867 + x^2 * 4913)) b = 1 + 51 * x^2 + 867 * x^4 + 4913 * x^6 false false true false false ----------------- false false true false false a = 1 + x^2 * (34 + x^2 * 289) b = 1 + 34 * x^2 + 289 * x^4 false false true false false ----------------- false false true false false a = 1 + x^2 * 17 b = 1 + 17 * x^2 false false true false false ----------------- false false true false false a = x^3 * (1 + x * (255 + x * (30345 + x * (2235415 + x * (114006165 + x * (4263830571 + x * (120808532845 + x * (2640529360755 + x * (44888999132835 + x * (593532321867485 + x * (6054029683048347 + x * (46781138459919045 + x * (265093117939541255 + x * (1039980693455123385 + x * (2525667398391013935 + x * 2862423051509815793))))))))))))))) b = x^3 + 255 * x^4 + 30345 * x^5 + 2235415 * x^6 + 114006165 * x^7 + 4263830571 * x^8 + 120808532845 * x^9 + 2640529360755 * x^10 + 44888999132835 * x^11 + 593532321867485 * x^12 + 6054029683048347 * x^13 + 46781138459919045 * x^14 + 265093117939541255 * x^15 + 1039980693455123385 * x^16 + 2525667398391013935 * x^17 + 2862423051509815793 * x^18 false false true false false ----------------- false false true false false a = x^3 * (1 + x * (51 + x * (867 + x * 4913))) b = x^3 + 51 * x^4 + 867 * x^5 + 4913 * x^6 false false true false false ----------------- false false true false false a = x^3 * (1 + x * (34 + x * 289)) b = x^3 + 34 * x^4 + 289 * x^5 false false true false false ----------------- false false true false false a = x^3 * (1 + x * 17) b = x^3 + 17 * x^4 false false true false false ----------------- false false true false false a = x^3 * (1 + x^2 * (255 + x^2 * (30345 + x^2 * (2235415 + x^2 * (114006165 + x^2 * (4263830571 + x^2 * (120808532845 + x^2 * (2640529360755 + x^2 * (44888999132835 + x^2 * (593532321867485 + x^2 * (6054029683048347 + x^2 * (46781138459919045 + x^2 * (265093117939541255 + x^2 * (1039980693455123385 + x^2 * (2525667398391013935 + x^2 * 2862423051509815793))))))))))))))) b = x^3 + 255 * x^5 + 30345 * x^7 + 2235415 * x^9 + 114006165 * x^11 + 4263830571 * x^13 + 120808532845 * x^15 + 2640529360755 * x^17 + 44888999132835 * x^19 + 593532321867485 * x^21 + 6054029683048347 * x^23 + 46781138459919045 * x^25 + 265093117939541255 * x^27 + 1039980693455123385 * x^29 + 2525667398391013935 * x^31 + 2862423051509815793 * x^33 false false true false false ----------------- false false true false false a = x^3 * (1 + x^2 * (238 + x^2 * (26299 + x^2 * (1788332 + x^2 * (83604521 + x^2 * (2842553714 + x^2 * (72485119707 + x^2 * (1408282325736 + x^2 * (20948199595323 + x^2 * (237412928746994 + x^2 * (2018009894349449 + x^2 * (12474970255978412 + x^2 * (53018623587908251 + x^2 * (138664092460683118 + x^2 * 168377826559400929)))))))))))))) b = x^3 + 238 * x^5 + 26299 * x^7 + 1788332 * x^9 + 83604521 * x^11 + 2842553714 * x^13 + 72485119707 * x^15 + 1408282325736 * x^17 + 20948199595323 * x^19 + 237412928746994 * x^21 + 2018009894349449 * x^23 + 12474970255978412 * x^25 + 53018623587908251 * x^27 + 138664092460683118 * x^29 + 168377826559400929 * x^31 false false true false false ----------------- false false true false false a = x^3 * (1 + x^2 * (51 + x^2 * (867 + x^2 * 4913))) b = x^3 + 51 * x^5 + 867 * x^7 + 4913 * x^9 false false true false false ----------------- false false true false false a = x^3 * (1 + x^2 * (34 + x^2 * 289)) b = x^3 + 34 * x^5 + 289 * x^7 false false true false false ----------------- false false true false false a = x^3 * (1 + x^2 * 17) b = x^3 + 17 * x^5 false false true false false ----------------- false false true false false a = x^4 * (1 + x * (255 + x * (30345 + x * (2235415 + x * (114006165 + x * (4263830571 + x * (120808532845 + x * (2640529360755 + x * (44888999132835 + x * (593532321867485 + x * (6054029683048347 + x * (46781138459919045 + x * (265093117939541255 + x * (1039980693455123385 + x * (2525667398391013935 + x * 2862423051509815793))))))))))))))) b = x^4 + 255 * x^5 + 30345 * x^6 + 2235415 * x^7 + 114006165 * x^8 + 4263830571 * x^9 + 120808532845 * x^10 + 2640529360755 * x^11 + 44888999132835 * x^12 + 593532321867485 * x^13 + 6054029683048347 * x^14 + 46781138459919045 * x^15 + 265093117939541255 * x^16 + 1039980693455123385 * x^17 + 2525667398391013935 * x^18 + 2862423051509815793 * x^19 false false true false false ----------------- false false true false false a = x^4 * (1 + x * (51 + x * (867 + x * 4913))) b = x^4 + 51 * x^5 + 867 * x^6 + 4913 * x^7 false false true false false ----------------- false false true false false a = x^4 * (1 + x * (34 + x * 289)) b = x^4 + 34 * x^5 + 289 * x^6 false false true false false ----------------- false false true false false a = x^4 * (1 + x * 17) b = x^4 + 17 * x^5 false false true false false ----------------- false false true false false a = x^4 * (1 + x^2 * (255 + x^2 * (30345 + x^2 * (2235415 + x^2 * (114006165 + x^2 * (4263830571 + x^2 * (120808532845 + x^2 * (2640529360755 + x^2 * (44888999132835 + x^2 * (593532321867485 + x^2 * (6054029683048347 + x^2 * (46781138459919045 + x^2 * (265093117939541255 + x^2 * (1039980693455123385 + x^2 * (2525667398391013935 + x^2 * 2862423051509815793))))))))))))))) b = x^4 + 255 * x^6 + 30345 * x^8 + 2235415 * x^10 + 114006165 * x^12 + 4263830571 * x^14 + 120808532845 * x^16 + 2640529360755 * x^18 + 44888999132835 * x^20 + 593532321867485 * x^22 + 6054029683048347 * x^24 + 46781138459919045 * x^26 + 265093117939541255 * x^28 + 1039980693455123385 * x^30 + 2525667398391013935 * x^32 + 2862423051509815793 * x^34 false false true false false ----------------- false false true false false a = x^4 * (1 + x^2 * (238 + x^2 * (26299 + x^2 * (1788332 + x^2 * (83604521 + x^2 * (2842553714 + x^2 * (72485119707 + x^2 * (1408282325736 + x^2 * (20948199595323 + x^2 * (237412928746994 + x^2 * (2018009894349449 + x^2 * (12474970255978412 + x^2 * (53018623587908251 + x^2 * (138664092460683118 + x^2 * 168377826559400929)))))))))))))) b = x^4 + 238 * x^6 + 26299 * x^8 + 1788332 * x^10 + 83604521 * x^12 + 2842553714 * x^14 + 72485119707 * x^16 + 1408282325736 * x^18 + 20948199595323 * x^20 + 237412928746994 * x^22 + 2018009894349449 * x^24 + 12474970255978412 * x^26 + 53018623587908251 * x^28 + 138664092460683118 * x^30 + 168377826559400929 * x^32 false false true false false ----------------- false false true false false a = x^4 * (1 + x^2 * (51 + x^2 * (867 + x^2 * 4913))) b = x^4 + 51 * x^6 + 867 * x^8 + 4913 * x^10 false false true false false ----------------- false false true false false a = x^4 * (1 + x^2 * (34 + x^2 * 289)) b = x^4 + 34 * x^6 + 289 * x^8 false false true false false ----------------- false false true false false a = x^4 * (1 + x^2 * 17) b = x^4 + 17 * x^6 false false true false false ----------------- The complex comparison tests are done Object returned by the complex comparison tests: "void" sollya-6.0+ds/tests-lib/tcoeff.c000066400000000000000000000033441300174114700166060ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a[7], b[5], c[7 * 5]; int i, j; sollya_lib_init(); a[0] = SOLLYA_ADD(SOLLYA_X_, SOLLYA_ADD(SOLLYA_CONST(1.0),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)))); a[1] = SOLLYA_ADD(SOLLYA_MUL(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_CONST(5.0),SOLLYA_X_),SOLLYA_CONST(7.0)),SOLLYA_X_),SOLLYA_CONST(9.0)); a[2] = SOLLYA_ADD(SOLLYA_ADD(SOLLYA_X_, SOLLYA_ADD(SOLLYA_CONST(1.0),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)))), SOLLYA_ADD(SOLLYA_MUL(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_CONST(5.0),SOLLYA_X_),SOLLYA_CONST(7.0)),SOLLYA_X_),SOLLYA_CONST(9.0))); a[3] = SOLLYA_ADD(SOLLYA_X_, SOLLYA_ADD(SOLLYA_EXP(SOLLYA_CONST(1.0)),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)))); a[4] = SOLLYA_ADD(SOLLYA_MUL(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_LOG(SOLLYA_CONST(5.0)),SOLLYA_X_),SOLLYA_ATAN(SOLLYA_CONST(7.0))),SOLLYA_X_),SOLLYA_ERFC(SOLLYA_CONST(9.0))); a[5] = SOLLYA_ADD(SOLLYA_ADD(SOLLYA_X_, SOLLYA_ADD(SOLLYA_EXP(SOLLYA_CONST(1.0)),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)))), SOLLYA_ADD(SOLLYA_MUL(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_LOG(SOLLYA_CONST(5.0)),SOLLYA_X_),SOLLYA_ATAN(SOLLYA_CONST(7.0))),SOLLYA_X_),SOLLYA_ERFC(SOLLYA_CONST(9.0)))); a[6] = SOLLYA_EXP(SOLLYA_X_); b[0] = SOLLYA_CONST(0.0); b[1] = SOLLYA_CONST(1.0); b[2] = SOLLYA_CONST(2.0); b[3] = SOLLYA_CONST(3.0); b[4] = SOLLYA_CONST(17.0); for (i=0;i<7;i++) { for (j=0;j<5;j++) { c[i * 5 + j] = sollya_lib_coeff(a[i],b[j]); sollya_lib_printf("The coefficient of order %b in %b is %b\n",b[j],a[i],c[i * 5 + j]); } } for (i=0;i<7;i++) { sollya_lib_clear_obj(a[i]); } for (i=0;i<5;i++) { sollya_lib_clear_obj(b[i]); } for (i=0;i<7*5;i++) { sollya_lib_clear_obj(c[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcoeff.reference000066400000000000000000000045061300174114700203230ustar00rootroot00000000000000The coefficient of order 0 in _x_ + 1 + _x_^2 is 1 The coefficient of order 1 in _x_ + 1 + _x_^2 is 1 The coefficient of order 2 in _x_ + 1 + _x_^2 is 1 The coefficient of order 3 in _x_ + 1 + _x_^2 is 0 The coefficient of order 17 in _x_ + 1 + _x_^2 is 0 The coefficient of order 0 in (5 * _x_ + 7) * _x_ + 9 is 9 The coefficient of order 1 in (5 * _x_ + 7) * _x_ + 9 is 7 The coefficient of order 2 in (5 * _x_ + 7) * _x_ + 9 is 5 The coefficient of order 3 in (5 * _x_ + 7) * _x_ + 9 is 0 The coefficient of order 17 in (5 * _x_ + 7) * _x_ + 9 is 0 The coefficient of order 0 in _x_ + 1 + _x_^2 + (5 * _x_ + 7) * _x_ + 9 is 10 The coefficient of order 1 in _x_ + 1 + _x_^2 + (5 * _x_ + 7) * _x_ + 9 is 8 The coefficient of order 2 in _x_ + 1 + _x_^2 + (5 * _x_ + 7) * _x_ + 9 is 6 The coefficient of order 3 in _x_ + 1 + _x_^2 + (5 * _x_ + 7) * _x_ + 9 is 0 The coefficient of order 17 in _x_ + 1 + _x_^2 + (5 * _x_ + 7) * _x_ + 9 is 0 The coefficient of order 0 in _x_ + exp(1) + _x_^2 is exp(1) The coefficient of order 1 in _x_ + exp(1) + _x_^2 is 1 The coefficient of order 2 in _x_ + exp(1) + _x_^2 is 1 The coefficient of order 3 in _x_ + exp(1) + _x_^2 is 0 The coefficient of order 17 in _x_ + exp(1) + _x_^2 is 0 The coefficient of order 0 in (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is erfc(9) The coefficient of order 1 in (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is atan(7) The coefficient of order 2 in (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is log(5) The coefficient of order 3 in (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is 0 The coefficient of order 17 in (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is 0 The coefficient of order 0 in _x_ + exp(1) + _x_^2 + (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is exp(1) + erfc(9) The coefficient of order 1 in _x_ + exp(1) + _x_^2 + (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is 1 + atan(7) The coefficient of order 2 in _x_ + exp(1) + _x_^2 + (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is 1 + log(5) The coefficient of order 3 in _x_ + exp(1) + _x_^2 + (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is 0 The coefficient of order 17 in _x_ + exp(1) + _x_^2 + (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is 0 The coefficient of order 0 in exp(_x_) is 0 The coefficient of order 1 in exp(_x_) is 0 The coefficient of order 2 in exp(_x_) is 0 The coefficient of order 3 in exp(_x_) is 0 The coefficient of order 17 in exp(_x_) is 0 sollya-6.0+ds/tests-lib/tconcat.c000066400000000000000000000047221300174114700167740ustar00rootroot00000000000000#include #define A_DIM 17 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("Caught the message that a certain expression is not correctly typed.\n"); break; case SOLLYA_MSG_EXPR_OR_COMMAND_COULD_NOT_BE_HANDLED: sollya_lib_printf("Caught the message that a certain command could not be executed.\n"); break; case SOLLYA_MSG_FOR_IN_LOOP_OVER_END_ELLIPTIC_LIST_NOT_ALLOWED: sollya_lib_printf("Caught the message that a loop over an end-elliptic list is not allowed.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[A_DIM], b[A_DIM * A_DIM]; int i, j; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = sollya_lib_parse_string("[||]"); a[1] = sollya_lib_parse_string("[|1|]"); a[2] = sollya_lib_parse_string("[|1,2|]"); a[3] = sollya_lib_parse_string("[|1,...,17|]"); a[4] = sollya_lib_parse_string("[|1,...,17...|]"); a[5] = sollya_lib_parse_string("[|\"Hello\"|]"); a[6] = sollya_lib_parse_string("[|\"Hello\",\"World\"|]"); a[7] = sollya_lib_parse_string("[|\"land\",\"of\",\"milk\",\"and\",\"honey\"|]"); a[8] = sollya_lib_parse_string("[|\"land\",\"of\",\"milk\",\"and\",\"honey\"...|]"); a[9] = sollya_lib_parse_string("[|17...|]"); a[10] = sollya_lib_parse_string("[|\"Rudolph the red-nosed reindeer\"...|]"); a[11] = sollya_lib_string("Hello "); a[12] = sollya_lib_string("world"); a[13] = sollya_lib_string(""); a[14] = sollya_lib_parse_string("proc(L = ...) { var r, i; r = 0; for i in L do r = r + i; return r; }"); a[15] = sollya_lib_parse_string("proc(L = ...) { var i; for i in L do i; return exp(_x_); }"); a[16] = sollya_lib_parse_string("proc(a,b) { return a + b; }"); for (i=0;i #include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); if (message==SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST) sollya_lib_printf("Caught the message about the fact that faithful rounding has occurred.\n"); else sollya_lib_printf("Unexpected message caught.\n"); return 0; } int main(void) { sollya_obj_t a, a2, prec, tmp; mpfr_t b; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); tmp = sollya_lib_binary(); sollya_lib_set_display(tmp); sollya_lib_clear_obj(tmp); mpfr_init2(b, 40); mpfr_const_pi(b, GMP_RNDN); a = sollya_lib_constant(b); a2 = sollya_lib_parse_string("round(pi, 40, RN)"); sollya_lib_printf("%b\n%b (should be the same as above)\n", a, a2); mpfr_out_str(stdout, 2, 0, b, GMP_RNDN); sollya_lib_printf(" (should represent the same number as above)\n"); sollya_lib_clear_obj(a); sollya_lib_clear_obj(a2); prec = sollya_lib_constant_from_int(20); sollya_lib_set_prec(prec); sollya_lib_clear_obj(prec); a = sollya_lib_constant(b); sollya_lib_printf("%b (should be the same as above)\n", a); sollya_lib_clear_obj(a); mpfr_clear(b); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tconstant.reference000066400000000000000000000004601300174114700210650ustar00rootroot000000000000001.100100100001111110110101010001000100001_2 * 2^(1) 1.100100100001111110110101010001000100001_2 * 2^(1) (should be the same as above) 1.100100100001111110110101010001000100001e1 (should represent the same number as above) 1.100100100001111110110101010001000100001_2 * 2^(1) (should be the same as above) sollya-6.0+ds/tests-lib/tconstant_from_double.c000066400000000000000000000054211300174114700217300ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); if (message==SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT) sollya_lib_printf("Caught the message about rounding while reading a constant.\n"); else sollya_lib_printf("Unexpected message caught.\n"); return 0; } int main(void) { sollya_obj_t a, a2, prec, tmp; double d; volatile double e; volatile double f; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); tmp = sollya_lib_binary(); sollya_lib_set_display(tmp); sollya_lib_clear_obj(tmp); prec = sollya_lib_constant_from_int(53); sollya_lib_set_prec(prec); sollya_lib_clear_obj(prec); a2 = sollya_lib_parse_string("3.141592653589793"); prec = sollya_lib_constant_from_int(100); sollya_lib_set_prec(prec); sollya_lib_clear_obj(prec); d = -3.141592653589793; a = sollya_lib_constant_from_double(d); sollya_lib_printf("%b\n-%b (should be the same as above)\n", a, a2); sollya_lib_clear_obj(a); sollya_lib_clear_obj(a2); prec = sollya_lib_constant_from_int(20); sollya_lib_set_prec(prec); sollya_lib_clear_obj(prec); a = sollya_lib_constant_from_double(d); sollya_lib_printf("%b (should be the same as above)\n", a); sollya_lib_clear_obj(a); d = 3.141592653589793; a = sollya_lib_constant_from_double(d); sollya_lib_printf("-%b (should be the same as above)\n", a); sollya_lib_clear_obj(a); d = 0.; a = sollya_lib_constant_from_double(d); sollya_lib_printf("%b (should be 0)\n", a); sollya_lib_clear_obj(a); d = 0./0.; /* NaN */ a = sollya_lib_constant_from_double(d); sollya_lib_printf("%b (should be NaN)\n", a); sollya_lib_clear_obj(a); d = 1/0.; d = (d>0)?d:(-d); /* +Inf */ a = sollya_lib_constant_from_double(d); sollya_lib_printf("%b (should be +Inf)\n", a); sollya_lib_clear_obj(a); prec = sollya_lib_constant_from_int(53); sollya_lib_set_prec(prec); sollya_lib_clear_obj(prec); a2 = sollya_lib_parse_string("D(5.4611528809225927e-310)"); e = 1.787648654869691154845095994269186112904125380971e-159; f = 3.0549363634996046820519793932136176997894027405723e-151; d = e * f; /* subnormal */ a = sollya_lib_constant_from_double(d); sollya_lib_printf("%b\n%b (should be the same as above)\n", a, a2); sollya_lib_clear_obj(a2); a2 = sollya_lib_parse_string("5.4611528809225927e-310"); sollya_lib_printf("%b (should *NOT* be the same, but the previous entry should be a prefix of this one)\n", a2); sollya_lib_clear_obj(a2); sollya_lib_clear_obj(a); d = -1.0e300; d *= 1e300; /* overflow */ a = sollya_lib_constant_from_double(d); sollya_lib_printf("%b (should be -Inf)\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tconstant_from_double.reference000066400000000000000000000016111300174114700234410ustar00rootroot00000000000000Caught the message about rounding while reading a constant. -1.1001001000011111101101010100010001000010110100011_2 * 2^(1) -1.1001001000011111101101010100010001000010110100011_2 * 2^(1) (should be the same as above) -1.1001001000011111101101010100010001000010110100011_2 * 2^(1) (should be the same as above) -1.1001001000011111101101010100010001000010110100011_2 * 2^(1) (should be the same as above) 0 (should be 0) NaN (should be NaN) infty (should be +Inf) Caught the message about rounding while reading a constant. 1.10010010000111111011010101000100010000101101_2 * 2^(-1028) 1.10010010000111111011010101000100010000101101_2 * 2^(-1028) (should be the same as above) Caught the message about rounding while reading a constant. 1.1001001000011111101101010100010001000010110100011_2 * 2^(-1028) (should *NOT* be the same, but the previous entry should be a prefix of this one) -infty (should be -Inf) sollya-6.0+ds/tests-lib/tconstant_from_int.c000066400000000000000000000015011300174114700212430ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a, prec; int b; sollya_lib_init(); b = -5; a = sollya_lib_constant_from_int(b); sollya_lib_printf("%b (should be %d)\n", a, b); sollya_lib_clear_obj(a); b = 7; a = sollya_lib_constant_from_int(b); sollya_lib_printf("%b (should be %d)\n", a, b); sollya_lib_clear_obj(a); /* overflow */ b = 1234567890; b *= 1234567890; b *= 123456; a = sollya_lib_constant_from_int(b); sollya_lib_printf("%b (should be %d)\n", a, b); sollya_lib_clear_obj(a); prec = sollya_lib_constant_from_int(20); sollya_lib_set_prec(prec); sollya_lib_clear_obj(prec); b = 4194304; /* Does not fit on 20 bits */ a = sollya_lib_constant_from_int(b); sollya_lib_printf("%b (should be %d)\n", a, b); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tconstant_from_int.reference000066400000000000000000000001421300174114700227570ustar00rootroot00000000000000-5 (should be -5) 7 (should be 7) -1310385920 (should be -1310385920) 4194304 (should be 4194304) sollya-6.0+ds/tests-lib/tconstant_from_int64.c000066400000000000000000000017511300174114700214240ustar00rootroot00000000000000#include #include int main(void) { sollya_obj_t a, prec; int64_t b; sollya_lib_init(); b = INT64_C(-5); a = sollya_lib_constant_from_int64(b); sollya_lib_printf("%b (should be %" PRId64 ")\n", a, (long long int)b); sollya_lib_clear_obj(a); b = INT64_C(7); a = sollya_lib_constant_from_int64(b); sollya_lib_printf("%b (should be %" PRId64 ")\n", a, (long long int)b); sollya_lib_clear_obj(a); /* overflow */ b = INT64_C(1234567890); b *= INT64_C(1234567890); b *= INT64_C(123456); a = sollya_lib_constant_from_int64(b); sollya_lib_printf("%b (should be %" PRId64 ")\n", a, (long long int)b); sollya_lib_clear_obj(a); prec = SOLLYA_CONST(20); sollya_lib_set_prec(prec); sollya_lib_clear_obj(prec); b = INT64_C(4194304); /* Does not fit on 20 bits */ a = sollya_lib_constant_from_int64(b); sollya_lib_printf("%b (should be %" PRId64 ")\n", a, (long long int)b); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tconstant_from_int64.reference000066400000000000000000000001641300174114700231350ustar00rootroot00000000000000-5 (should be -5) 7 (should be 7) -8801677559039977216 (should be -8801677559039977216) 4194304 (should be 4194304) sollya-6.0+ds/tests-lib/tconstant_from_mpq.c000066400000000000000000000013411300174114700212500ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; mpq_t b; sollya_lib_init(); mpq_init(b); mpq_set_ui(b, 17, 1); a = sollya_lib_constant_from_mpq(b); sollya_lib_printf("%r has been converted to %b\n\n", b, a); sollya_lib_clear_obj(a); mpq_set_si(b, -42, 1); a = sollya_lib_constant_from_mpq(b); sollya_lib_printf("%r has been converted to %b\n\n", b, a); sollya_lib_clear_obj(a); mpq_set_str(b, "-1606938044258990275541962092341162602522202993782792835301377/1532495540865888858358347027150309183618739122183602169", 10); a = sollya_lib_constant_from_mpq(b); sollya_lib_printf("%r has been converted to %b\n\n", b, a); sollya_lib_clear_obj(a); mpq_clear(b); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tconstant_from_mpq.reference000066400000000000000000000005251300174114700227670ustar00rootroot0000000000000017 / 1 has been converted to 17 -42 / 1 has been converted to -42 -1606938044258990275541962092341162602522202993782792835301377 / 1532495540865888858358347027150309183618739122183602169 has been converted to -1.606938044258990275541962092341162602522202993782792835301377e60 / 1.532495540865888858358347027150309183618739122183602169e54 sollya-6.0+ds/tests-lib/tconstant_from_mpz.c000066400000000000000000000013251300174114700212630ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; mpz_t b; sollya_lib_init(); mpz_init(b); mpz_set_ui(b, 17); a = sollya_lib_constant_from_mpz(b); gmp_printf("%Zd", b); sollya_lib_printf(" has been converted to %b\n\n", a); sollya_lib_clear_obj(a); mpz_set_si(b, -42); a = sollya_lib_constant_from_mpz(b); gmp_printf("%Zd", b); sollya_lib_printf(" has been converted to %b\n\n", a); sollya_lib_clear_obj(a); mpz_set_str(b, "1606938044258990275541962092341162602522202993782792835301377", 10); a = sollya_lib_constant_from_mpz(b); gmp_printf("%Zd", b); sollya_lib_printf(" has been converted to %b\n\n", a); sollya_lib_clear_obj(a); mpz_clear(b); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tconstant_from_mpz.reference000066400000000000000000000003231300174114700227740ustar00rootroot0000000000000017 has been converted to 17 -42 has been converted to -42 1606938044258990275541962092341162602522202993782792835301377 has been converted to 1.606938044258990275541962092341162602522202993782792835301377e60 sollya-6.0+ds/tests-lib/tconstant_from_uint64.c000066400000000000000000000016701300174114700216110ustar00rootroot00000000000000#include #include int main(void) { sollya_obj_t a, prec; uint64_t b; sollya_lib_init(); b = UINT64_C(-5); a = sollya_lib_constant_from_uint64(b); sollya_lib_printf("%b (should be %" PRIu64 ")\n", a, b); sollya_lib_clear_obj(a); b = UINT64_C(7); a = sollya_lib_constant_from_uint64(b); sollya_lib_printf("%b (should be %" PRIu64 ")\n", a, b); sollya_lib_clear_obj(a); /* overflow */ b = UINT64_C(1234567890); b *= UINT64_C(1234567890); b *= UINT64_C(123456); a = sollya_lib_constant_from_uint64(b); sollya_lib_printf("%b (should be %" PRIu64 ")\n", a, b); sollya_lib_clear_obj(a); prec = SOLLYA_CONST(20); sollya_lib_set_prec(prec); sollya_lib_clear_obj(prec); b = UINT64_C(4194304); /* Does not fit on 20 bits */ a = sollya_lib_constant_from_uint64(b); sollya_lib_printf("%b (should be %" PRIu64 ")\n", a, b); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tconstant_from_uint64.reference000066400000000000000000000002261300174114700233210ustar00rootroot0000000000000018446744073709551611 (should be 18446744073709551611) 7 (should be 7) 9645066514669574400 (should be 9645066514669574400) 4194304 (should be 4194304) sollya-6.0+ds/tests-lib/tconstant_list_ops.c000066400000000000000000000034501300174114700212670ustar00rootroot00000000000000#include #include mpfr_t *tconstant_list_ops_make_mpfr_ptr(double x) { mpfr_t *res; res = (mpfr_t *) malloc(sizeof(mpfr_t)); if (res == NULL) exit(1); mpfr_init2(*res, 64); mpfr_set_d(*res, x, GMP_RNDN); return res; } int main(void) { sollya_constant_list_t list1, iter, list2; mpfr_t *a, *b, *c, *d, *e; int i; sollya_lib_init(); a = tconstant_list_ops_make_mpfr_ptr(0.5); b = tconstant_list_ops_make_mpfr_ptr(1.25); c = tconstant_list_ops_make_mpfr_ptr(3.75); d = tconstant_list_ops_make_mpfr_ptr(9.125); e = tconstant_list_ops_make_mpfr_ptr(17.0e17); list1 = sollya_lib_construct_constant_list(a, sollya_lib_construct_constant_list(b, sollya_lib_construct_constant_list(c, sollya_lib_construct_constant_list(d, NULL)))); for (iter = list1, i = 0; !sollya_lib_is_empty_constant_list(iter); iter = sollya_lib_get_constant_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list1 before copy and modification of the copy: %v\n", i, *sollya_lib_get_constant_list_head(iter)); } list2 = sollya_lib_copy_constant_list(list1); list2 = sollya_lib_construct_constant_list(e, list2); for (iter = list1, i = 0; !sollya_lib_is_empty_constant_list(iter); iter = sollya_lib_get_constant_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list1 after copy and modification of the copy: %v\n", i, *sollya_lib_get_constant_list_head(iter)); } for (iter = list2, i = 0; !sollya_lib_is_empty_constant_list(iter); iter = sollya_lib_get_constant_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list2 after copy and modification of the copy: %v\n", i, *sollya_lib_get_constant_list_head(iter)); } sollya_lib_clear_constant_list(list1); sollya_lib_clear_constant_list(list2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tconstant_list_ops.reference000066400000000000000000000016071300174114700230050ustar00rootroot000000000000000-th element in list1 before copy and modification of the copy: 0.5 1-th element in list1 before copy and modification of the copy: 1.25 2-th element in list1 before copy and modification of the copy: 3.75 3-th element in list1 before copy and modification of the copy: 9.125 0-th element in list1 after copy and modification of the copy: 0.5 1-th element in list1 after copy and modification of the copy: 1.25 2-th element in list1 after copy and modification of the copy: 3.75 3-th element in list1 after copy and modification of the copy: 9.125 0-th element in list2 after copy and modification of the copy: 1700000000000000000 1-th element in list2 after copy and modification of the copy: 0.5 2-th element in list2 after copy and modification of the copy: 1.25 3-th element in list2 after copy and modification of the copy: 3.75 4-th element in list2 after copy and modification of the copy: 9.125 sollya-6.0+ds/tests-lib/tconstruct_function.c000066400000000000000000000347031300174114700214600ustar00rootroot00000000000000#include #include #include void euler_gamma(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } int stupid1(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } char *type_to_string(sollya_base_function_t type) { switch (type) { case SOLLYA_BASE_FUNC_ASINH: return "SOLLYA_BASE_FUNC_ASINH"; case SOLLYA_BASE_FUNC_LIBRARYCONSTANT: return "SOLLYA_BASE_FUNC_LIBRARYCONSTANT"; case SOLLYA_BASE_FUNC_CONSTANT: return "SOLLYA_BASE_FUNC_CONSTANT"; case SOLLYA_BASE_FUNC_PI: return "SOLLYA_BASE_FUNC_PI"; case SOLLYA_BASE_FUNC_LIBRARYFUNCTION: return "SOLLYA_BASE_FUNC_LIBRARYFUNCTION"; case SOLLYA_BASE_FUNC_PROCEDUREFUNCTION: return "SOLLYA_BASE_FUNC_PROCEDUREFUNCTION"; case SOLLYA_BASE_FUNC_POW: return "SOLLYA_BASE_FUNC_POW"; default: return "UNKNOWN"; } } int main(void) { sollya_base_function_t type; sollya_obj_t f, obj1, obj2, obj3; int res; sollya_lib_init(); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_ASINH; obj1 = SOLLYA_X_; res = sollya_lib_construct_function(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_ASINH; obj1 = SOLLYA_X_; obj2 = sollya_lib_parse_string("[|1,2|]"); res = sollya_lib_construct_function(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_ASINH; obj1 = sollya_lib_parse_string("[1,2]"); obj2 = SOLLYA_X_; res = sollya_lib_construct_function(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_ASINH; obj1 = sollya_lib_parse_string("[|1,2|]"); obj2 = SOLLYA_X_; res = sollya_lib_construct_function(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_LIBRARYCONSTANT; obj1 = SOLLYA_X_; res = sollya_lib_construct_function(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_LIBRARYCONSTANT; obj1 = sollya_lib_parse_string("[|1,2|]"); res = sollya_lib_construct_function(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_LIBRARYCONSTANT; obj1 = sollya_lib_libraryconstant("superconst", euler_gamma); res = sollya_lib_construct_function(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_CONSTANT; obj1 = sollya_lib_libraryconstant("superconst", euler_gamma); res = sollya_lib_construct_function(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_CONSTANT; obj1 = SOLLYA_CONST(3.0); res = sollya_lib_construct_function(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_PI; res = sollya_lib_construct_function(&f, type, NULL); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_PI; obj1 = SOLLYA_CONST(3.0); res = sollya_lib_construct_function(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_LIBRARYFUNCTION; obj1 = SOLLYA_CONST(3.0); obj2 = sollya_lib_parse_string("[|1,2|]"); res = sollya_lib_construct_function(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_LIBRARYFUNCTION; obj1 = SOLLYA_CONST(3.0); obj2 = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "superfunc", stupid1); res = sollya_lib_construct_function(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_LIBRARYFUNCTION; obj1 = SOLLYA_CONST(3.0); obj2 = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "superfunc", stupid1); res = sollya_lib_construct_function(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_PROCEDUREFUNCTION; obj1 = sollya_lib_parse_string("[1,2]"); obj2 = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "superfunc", stupid1); res = sollya_lib_construct_function(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_PROCEDUREFUNCTION; obj1 = sollya_lib_parse_string("[1,2]"); obj2 = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); obj2 = sollya_lib_build_function_procedurefunction(SOLLYA_X_, obj2); res = sollya_lib_construct_function(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_PROCEDUREFUNCTION; obj1 = SOLLYA_CONST(3.0); obj2 = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); obj2 = sollya_lib_build_function_procedurefunction(SOLLYA_COS(SOLLYA_X_), obj2); res = sollya_lib_construct_function(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_POW; obj1 = SOLLYA_X_; obj2 = SOLLYA_CONST(3.0); res = sollya_lib_construct_function(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_POW; obj1 = SOLLYA_X_; obj2 = SOLLYA_X_; obj3 = sollya_lib_parse_string("[|1,2|]"); res = sollya_lib_construct_function(&f, type, obj1, obj2, obj3); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tconstruct_function.reference000066400000000000000000000044711300174114700231730ustar00rootroot00000000000000Constructed asinh(_x_) from type=SOLLYA_BASE_FUNC_ASINH, obj1=_x_, obj2=NULL and obj3=NULL Constructed asinh(_x_) from type=SOLLYA_BASE_FUNC_ASINH, obj1=_x_, obj2=[|1, 2|] and obj3=NULL Constructed [0.88137358701954302523260932497979230902816032826163;1.443635475178810342493276740273105269405553003157] from type=SOLLYA_BASE_FUNC_ASINH, obj1=[1;2], obj2=_x_ and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_ASINH, obj1=[|1, 2|], obj2=_x_ and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_LIBRARYCONSTANT, obj1=_x_, obj2=NULL and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_LIBRARYCONSTANT, obj1=[|1, 2|], obj2=NULL and obj3=NULL Constructed superconst from type=SOLLYA_BASE_FUNC_LIBRARYCONSTANT, obj1=superconst, obj2=NULL and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_CONSTANT, obj1=superconst, obj2=NULL and obj3=NULL Constructed 3 from type=SOLLYA_BASE_FUNC_CONSTANT, obj1=3, obj2=NULL and obj3=NULL Constructed pi from type=SOLLYA_BASE_FUNC_PI, obj1=NULL, obj2=NULL and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_PI, obj1=3, obj2=NULL and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_LIBRARYFUNCTION, obj1=3, obj2=[|1, 2|] and obj3=NULL Constructed 0 from type=SOLLYA_BASE_FUNC_LIBRARYFUNCTION, obj1=3, obj2=superfunc and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_LIBRARYFUNCTION, obj1=3, obj2=superfunc(cos(_x_)) and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_PROCEDUREFUNCTION, obj1=[1;2], obj2=superfunc(cos(_x_)) and obj3=NULL Constructed [2.7182818284590452353602874713526624977572470936999;7.3890560989306502272304274605750078131803155705519] from type=SOLLYA_BASE_FUNC_PROCEDUREFUNCTION, obj1=[1;2], obj2=function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; }) and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_PROCEDUREFUNCTION, obj1=3, obj2=(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; }))(cos(_x_)) and obj3=NULL Constructed _x_^3 from type=SOLLYA_BASE_FUNC_POW, obj1=_x_, obj2=3 and obj3=NULL Constructed _x_^_x_ from type=SOLLYA_BASE_FUNC_POW, obj1=_x_, obj2=_x_ and obj3=[|1, 2|] sollya-6.0+ds/tests-lib/tcopy_obj.c000066400000000000000000000021111300174114700173170ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a,b, tmp; sollya_lib_init(); a = SOLLYA_COS(SOLLYA_ADD(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(1))); b = sollya_lib_copy_obj(a); sollya_lib_printf("b = %b [should be cos(exp(_x_) + 1)]\n", b); sollya_lib_clear_obj(a); sollya_lib_printf("b = %b [should be cos(exp(_x_) + 1)]\n", b); a = SOLLYA_SIN(SOLLYA_CONST(3)); sollya_lib_printf("b = %b [should be cos(exp(_x_) + 1)]\n\n", b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = sollya_lib_build_list(SOLLYA_COS(SOLLYA_X_), SOLLYA_CONST(3), NULL); b = sollya_lib_copy_obj(a); sollya_lib_printf("b = %b [should be [|cos(_x_), 3|]]\n", b); sollya_lib_get_element_in_list(&tmp, a, 0); sollya_lib_clear_obj(tmp); sollya_lib_printf("b = %b [should be [|cos(_x_), 3|]]\n", b); sollya_lib_clear_obj(a); sollya_lib_printf("b = %b [should be [|cos(_x_), 3|]]\n", b); a = SOLLYA_SIN(SOLLYA_CONST(3)); sollya_lib_printf("b = %b [should be [|cos(_x_), 3|]]\n\n", b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcopy_obj.reference000066400000000000000000000005361300174114700210440ustar00rootroot00000000000000b = cos(exp(_x_) + 1) [should be cos(exp(_x_) + 1)] b = cos(exp(_x_) + 1) [should be cos(exp(_x_) + 1)] b = cos(exp(_x_) + 1) [should be cos(exp(_x_) + 1)] b = [|cos(_x_), 3|] [should be [|cos(_x_), 3|]] b = [|cos(_x_), 3|] [should be [|cos(_x_), 3|]] b = [|cos(_x_), 3|] [should be [|cos(_x_), 3|]] b = [|cos(_x_), 3|] [should be [|cos(_x_), 3|]] sollya-6.0+ds/tests-lib/tcos.c000066400000000000000000000004141300174114700163030ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_cos(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcos.reference000066400000000000000000000000101300174114700200070ustar00rootroot00000000000000cos(_x_)sollya-6.0+ds/tests-lib/tcosh.c000066400000000000000000000004151300174114700164540ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_cosh(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcosh.reference000066400000000000000000000000111300174114700201600ustar00rootroot00000000000000cosh(_x_)sollya-6.0+ds/tests-lib/tcreate_structure.c000066400000000000000000000027021300174114700211040ustar00rootroot00000000000000#include #include int main(void) { sollya_obj_t a[8]; int r[5]; int i; sollya_lib_init(); for (i=0;i<8;i++) a[i] = NULL; for (i=0;i<5;i++) r[i] = 0; a[0] = sollya_lib_parse_string("{ .a = 5; .b = exp(_x_); .c = { .d = 17; .e = sin(_x_) }}"); a[1] = SOLLYA_EXP(SOLLYA_ASIN(SOLLYA_X_)); a[2] = SOLLYA_LOG(SOLLYA_ATAN(SOLLYA_X_)); r[0] = sollya_lib_create_structure(&(a[3]), NULL, "u", a[1]); sollya_lib_printf("Adding element \"%s\" with content %b to an empty thing: %s, yielding %b\n","u",a[1],(r[0]?"Success":"Failure"),a[3]); r[1] = sollya_lib_create_structure(&(a[4]), a[3], "v", a[2]); sollya_lib_printf("Adding element \"%s\" with content %b to %b: %s, yielding %b\n","v",a[2],a[3],(r[1]?"Success":"Failure"),a[4]); r[2] = sollya_lib_create_structure(&(a[5]), a[0], "v", a[3]); sollya_lib_printf("Adding element \"%s\" with content %b to %b: %s, yielding %b\n","v",a[3],a[0],(r[2]?"Success":"Failure"),a[5]); r[3] = sollya_lib_create_structure(&(a[6]), a[1], "v", a[3]); sollya_lib_printf("Adding element \"%s\" with content %b to %b: %s, yielding %b\n","v",a[3],a[1],(r[3]?"Success":"Failure"),a[6]); r[4] = sollya_lib_create_structure(&(a[7]), a[4], "u", a[3]); sollya_lib_printf("Adding element \"%s\" with content %b to %b: %s, yielding %b\n","u",a[3],a[4],(r[4]?"Success":"Failure"),a[7]); for (i=0;i<8;i++) if (a[i] != NULL) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tcreate_structure.reference000066400000000000000000000013531300174114700226210ustar00rootroot00000000000000Adding element "u" with content exp(asin(_x_)) to an empty thing: Success, yielding { .u = exp(asin(_x_)) } Adding element "v" with content log(atan(_x_)) to { .u = exp(asin(_x_)) }: Success, yielding { .v = log(atan(_x_)), .u = exp(asin(_x_)) } Adding element "v" with content { .u = exp(asin(_x_)) } to { .a = 5, .b = exp(_x_), .c = { .d = 17, .e = sin(_x_) } }: Success, yielding { .v = { .u = exp(asin(_x_)) }, .c = { .d = 17, .e = sin(_x_) }, .b = exp(_x_), .a = 5 } Adding element "v" with content { .u = exp(asin(_x_)) } to exp(asin(_x_)): Failure, yielding NULL Adding element "u" with content { .u = exp(asin(_x_)) } to { .v = log(atan(_x_)), .u = exp(asin(_x_)) }: Success, yielding { .u = { .u = exp(asin(_x_)) }, .v = log(atan(_x_)) } sollya-6.0+ds/tests-lib/tdecimal.c000066400000000000000000000003071300174114700171160ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_decimal(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdecimal.reference000066400000000000000000000000071300174114700206270ustar00rootroot00000000000000decimalsollya-6.0+ds/tests-lib/tdecompose_externalprocedure.c000066400000000000000000000131161300174114700233130ustar00rootroot00000000000000#include #include #include char *externalprocTypeToString(sollya_externalprocedure_type_t t) { switch (t) { case SOLLYA_EXTERNALPROC_TYPE_VOID: return "void"; case SOLLYA_EXTERNALPROC_TYPE_CONSTANT: return "constant"; case SOLLYA_EXTERNALPROC_TYPE_FUNCTION: return "function"; case SOLLYA_EXTERNALPROC_TYPE_RANGE: return "range"; case SOLLYA_EXTERNALPROC_TYPE_INTEGER: return "integer"; case SOLLYA_EXTERNALPROC_TYPE_STRING: return "string"; case SOLLYA_EXTERNALPROC_TYPE_BOOLEAN: return "boolean"; case SOLLYA_EXTERNALPROC_TYPE_OBJECT: return "object"; case SOLLYA_EXTERNALPROC_TYPE_CONSTANT_LIST: return "list of constant"; case SOLLYA_EXTERNALPROC_TYPE_FUNCTION_LIST: return "list of function"; case SOLLYA_EXTERNALPROC_TYPE_RANGE_LIST: return "list of range"; case SOLLYA_EXTERNALPROC_TYPE_INTEGER_LIST: return "list of integer"; case SOLLYA_EXTERNALPROC_TYPE_STRING_LIST: return "list of string"; case SOLLYA_EXTERNALPROC_TYPE_BOOLEAN_LIST: return "list of boolean"; case SOLLYA_EXTERNALPROC_TYPE_OBJECT_LIST: return "list of object"; default: break; } return "unknown"; } int succ_impl(int a) { return a + 1; } int succ(int *res, void **args) { *res = succ_impl(*((int *) (args[0]))); return 1; } int main(void) { int i; sollya_obj_t f[4]; int res; sollya_externalprocedure_type_t result_type; sollya_externalprocedure_type_t *argument_types; sollya_externalprocedure_type_t myArgTypes[1]; int arity; void *func; void *args[3]; int result; int myInt; mpfr_t myMpfr; sollya_lib_init(); f[0] = SOLLYA_COS(SOLLYA_X_); f[1] = sollya_lib_parse_string("(proc() { externalproc(funny, \"./libraryexample.a\", (string, integer, constant) -> boolean); return funny;})()"); f[2] = sollya_lib_parse_string("(proc() { externalproc(zeit, \"./libraryexample.a\", void -> integer); return zeit;})()"); myArgTypes[0] = SOLLYA_EXTERNALPROC_TYPE_INTEGER; f[3] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_INTEGER, myArgTypes, 1, "succ", succ); argument_types = NULL; res = sollya_lib_decompose_externalprocedure(&result_type, &argument_types, &arity, &func, f[0]); if (res) { sollya_lib_printf("sollya_lib_decompose_externalprocedure has signaled success on \"%b\" while it should not have worked.\n", f[0]); sollya_lib_free(argument_types); } else { sollya_lib_printf("sollya_lib_decompose_externalprocedure correctly signals that \"%b\" cannot be decomposed as an external function.\n", f[0]); } argument_types = NULL; res = sollya_lib_decompose_externalprocedure(&result_type, &argument_types, &arity, &func, f[1]); if (res) { sollya_lib_printf("sollya_lib_decompose_externalprocedure has worked on \"%b\": arity = %d, result type = %s, argument types = ", f[1], arity, externalprocTypeToString(result_type)); for (i=0;i>>Hello world<<<>>>42<<<>>>1664<<< The function has signaled success, the result is false sollya_lib_decompose_externalprocedure has worked on "zeit": arity = 0, result type = integer, argument types = Trying out the function The function has signaled success, the result is okay sollya_lib_decompose_externalprocedure has worked on "succ": arity = 1, result type = integer, argument types = integer Trying out the function The function has signaled success, the result is 42 sollya-6.0+ds/tests-lib/tdecompose_externalprocedure_with_data.c000066400000000000000000000350511300174114700253410ustar00rootroot00000000000000#include #include #include #include #include typedef struct data_struct_t { char text[32]; int counter; } data_t; char *externalprocTypeToString(sollya_externalprocedure_type_t t) { switch (t) { case SOLLYA_EXTERNALPROC_TYPE_VOID: return "void"; case SOLLYA_EXTERNALPROC_TYPE_CONSTANT: return "constant"; case SOLLYA_EXTERNALPROC_TYPE_FUNCTION: return "function"; case SOLLYA_EXTERNALPROC_TYPE_RANGE: return "range"; case SOLLYA_EXTERNALPROC_TYPE_INTEGER: return "integer"; case SOLLYA_EXTERNALPROC_TYPE_STRING: return "string"; case SOLLYA_EXTERNALPROC_TYPE_BOOLEAN: return "boolean"; case SOLLYA_EXTERNALPROC_TYPE_OBJECT: return "object"; case SOLLYA_EXTERNALPROC_TYPE_CONSTANT_LIST: return "list of constant"; case SOLLYA_EXTERNALPROC_TYPE_FUNCTION_LIST: return "list of function"; case SOLLYA_EXTERNALPROC_TYPE_RANGE_LIST: return "list of range"; case SOLLYA_EXTERNALPROC_TYPE_INTEGER_LIST: return "list of integer"; case SOLLYA_EXTERNALPROC_TYPE_STRING_LIST: return "list of string"; case SOLLYA_EXTERNALPROC_TYPE_BOOLEAN_LIST: return "list of boolean"; case SOLLYA_EXTERNALPROC_TYPE_OBJECT_LIST: return "list of object"; default: break; } return "unknown"; } void dealloc(void *data) { (void) data; return; } int successor_impl(int a) { return a + 1; } int successor(int *res, void **args, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; *res = successor_impl(*((int *) (args[0]))); return 1; } int successor_bis(int *res, void **args, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; *res = successor_impl(*((int *) (args[0]))); return 1; } int strange_impl(char *str, int i, mpfr_t v) { sollya_lib_printf(">>>%s<<<>>>%d<<<>>>%v<<<\n", str, i, v); return (i == 17); } int strange(int *res, void **args, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; *res = strange_impl(((char *) (args[0])), *((int *) (args[1])), *((mpfr_t *) (args[2]))); return 1; } int strange_bis(int *res, void **args, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; *res = strange_impl(((char *) (args[0])), *((int *) (args[1])), *((mpfr_t *) (args[2]))); return 1; } int empty_func(void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int empty_func2() { sollya_lib_printf("External procedure only doing a side effect number 2\n"); return 1; } void dealloc2(void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf("Deallocation function called for the data pointer (%s<<<>>>%d)\n", data->text, data->counter); return; } int main(void) { sollya_obj_t f[20]; sollya_externalprocedure_type_t argTypes[3]; sollya_externalprocedure_type_t result_type; sollya_externalprocedure_type_t *argument_types; int res; int arity; int i; char str1[1024]; char str2[1024]; char str3[1024]; data_t data = { "Hello world", 0 }; data_t tryData = { "Grias Eahna Good.", 17 }; void *func; void *resData; int myInt; int result; void *args[3]; mpfr_t myMpfr; void (*resDealloc)(void *); sollya_lib_init(); argTypes[0] = SOLLYA_EXTERNALPROC_TYPE_INTEGER; f[0] = sollya_lib_externalprocedure_with_data(SOLLYA_EXTERNALPROC_TYPE_INTEGER, argTypes, 1, "succ", successor, &data, NULL); sollya_lib_printf("%b\n", f[0]); sollya_lib_autoprint(f[0], NULL); f[1] = SOLLYA_CONST_SI64(16); f[2] = sollya_lib_apply(f[0], f[1], NULL); sollya_lib_printf("%b\n", f[2]); result_type = (sollya_externalprocedure_type_t) -1; argument_types = NULL; arity = -1; func = NULL; resData = NULL; resDealloc = NULL; res = sollya_lib_decompose_externalprocedure_with_data(&result_type, &argument_types, &arity, &func, &resData, &resDealloc, f[0]); if (res) { sollya_lib_printf("sollya_lib_decompose_externalprocedure_with_data has worked on \"%b\": arity = %d, result type = %s, argument types = ", f[0], arity, externalprocTypeToString(result_type)); for (i=0;i>>>Hello world<<<<>>>>0<<<< 17 sollya_lib_decompose_externalprocedure_with_data has worked on "succ": arity = 1, result type = integer, argument types = integer The function pointer is okay The data pointer is okay The deallocation function pointer is okay Trying out the function >>>>Grias Eahna Good.<<<<>>>>17<<<< The function has signaled success, the result is 43, the data counter is 18 The behavior when no name is suggested is conform to the semantic >>>>Hello world<<<<>>>>1<<<< 17 sollya_lib_decompose_externalprocedure_with_data has worked: arity = 1, result type = integer, argument types = integer The function pointer is okay The data pointer is okay The deallocation function pointer is okay Trying out the function >>>>Grias Eahna Good.<<<<>>>>18<<<< The function has signaled success, the result is 43, the data counter is 19 strange_proc strange_proc Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation to 165 bits will be used. >>>>Hello world<<<<>>>>2<<<< >>>Coucou<<<>>>17<<<>>>2.7182818284590452353602874713526624977572470937<<< true sollya_lib_decompose_externalprocedure_with_data has worked on "strange_proc": arity = 3, result type = boolean, argument types = string integer constant The function pointer is okay The data pointer is okay The deallocation function pointer is okay Trying out the function >>>>Grias Eahna Good.<<<<>>>>19<<<< >>>Hello world<<<>>>42<<<>>>1664<<< The function has signaled success, the result is false, the data counter is 20 The behavior when no name is suggested is conform to the semantic Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation to 165 bits will be used. >>>>Hello world<<<<>>>>3<<<< >>>Coucou<<<>>>42<<<>>>2.7182818284590452353602874713526624977572470937<<< false sollya_lib_decompose_externalprocedure_with_data has worked: arity = 3, result type = boolean, argument types = string integer constant The function pointer is okay The data pointer is okay The deallocation function pointer is okay Trying out the function >>>>Grias Eahna Good.<<<<>>>>20<<<< >>>Hello world<<<>>>42<<<>>>1664<<< The function has signaled success, the result is false, the data counter is 21 >>>>Hello world<<<<>>>>4<<<< External procedure only doing a side effect void sollya_lib_decompose_externalprocedure_with_data has worked: arity = 0, result type = void, argument types = The function pointer is okay The data pointer is okay The deallocation function pointer is okay External procedure only doing a side effect number 2 void sollya_lib_decompose_externalprocedure_with_data did not work (as expected) on something not constructed with sollya_lib_externalprocedure_with_data Deallocation function called for the data pointer (Hello world<<<>>>5) sollya-6.0+ds/tests-lib/tdecompose_function.c000066400000000000000000000442531300174114700214130ustar00rootroot00000000000000#include #include #include char *pretty_print(sollya_base_function_t type) { switch(type) { case SOLLYA_BASE_FUNC_ABS: return "SOLLYA_BASE_FUNC_ABS"; case SOLLYA_BASE_FUNC_ACOS: return "SOLLYA_BASE_FUNC_ACOS"; case SOLLYA_BASE_FUNC_ACOSH: return "SOLLYA_BASE_FUNC_ACOSH"; case SOLLYA_BASE_FUNC_ADD: return "SOLLYA_BASE_FUNC_ADD"; case SOLLYA_BASE_FUNC_ASIN: return "SOLLYA_BASE_FUNC_ASIN"; case SOLLYA_BASE_FUNC_ASINH: return "SOLLYA_BASE_FUNC_ASINH"; case SOLLYA_BASE_FUNC_ATAN: return "SOLLYA_BASE_FUNC_ATAN"; case SOLLYA_BASE_FUNC_ATANH: return "SOLLYA_BASE_FUNC_ATANH"; case SOLLYA_BASE_FUNC_CEIL: return "SOLLYA_BASE_FUNC_CEIL"; case SOLLYA_BASE_FUNC_CONSTANT: return "SOLLYA_BASE_FUNC_CONSTANT"; case SOLLYA_BASE_FUNC_COS: return "SOLLYA_BASE_FUNC_COS"; case SOLLYA_BASE_FUNC_COSH: return "SOLLYA_BASE_FUNC_COSH"; case SOLLYA_BASE_FUNC_DIV: return "SOLLYA_BASE_FUNC_DIV"; case SOLLYA_BASE_FUNC_DOUBLE: return "SOLLYA_BASE_FUNC_DOUBLE"; case SOLLYA_BASE_FUNC_DOUBLEDOUBLE: return "SOLLYA_BASE_FUNC_DOUBLEDOUBLE"; case SOLLYA_BASE_FUNC_DOUBLEEXTENDED: return "SOLLYA_BASE_FUNC_DOUBLEEXTENDED"; case SOLLYA_BASE_FUNC_ERF: return "SOLLYA_BASE_FUNC_ERF"; case SOLLYA_BASE_FUNC_ERFC: return "SOLLYA_BASE_FUNC_ERFC"; case SOLLYA_BASE_FUNC_EXP: return "SOLLYA_BASE_FUNC_EXP"; case SOLLYA_BASE_FUNC_EXP_M1: return "SOLLYA_BASE_FUNC_EXP_M1"; case SOLLYA_BASE_FUNC_FLOOR: return "SOLLYA_BASE_FUNC_FLOOR"; case SOLLYA_BASE_FUNC_FREE_VARIABLE: return "SOLLYA_BASE_FUNC_FREE_VARIABLE"; case SOLLYA_BASE_FUNC_HALFPRECISION: return "SOLLYA_BASE_FUNC_HALFPRECISION"; case SOLLYA_BASE_FUNC_LIBRARYCONSTANT: return "SOLLYA_BASE_FUNC_LIBRARYCONSTANT"; case SOLLYA_BASE_FUNC_LIBRARYFUNCTION: return "SOLLYA_BASE_FUNC_LIBRARYFUNCTION"; case SOLLYA_BASE_FUNC_LOG: return "SOLLYA_BASE_FUNC_LOG"; case SOLLYA_BASE_FUNC_LOG_10: return "SOLLYA_BASE_FUNC_LOG_10"; case SOLLYA_BASE_FUNC_LOG_1P: return "SOLLYA_BASE_FUNC_LOG_1P"; case SOLLYA_BASE_FUNC_LOG_2: return "SOLLYA_BASE_FUNC_LOG_2"; case SOLLYA_BASE_FUNC_MUL: return "SOLLYA_BASE_FUNC_MUL"; case SOLLYA_BASE_FUNC_NEARESTINT: return "SOLLYA_BASE_FUNC_NEARESTINT"; case SOLLYA_BASE_FUNC_NEG: return "SOLLYA_BASE_FUNC_NEG"; case SOLLYA_BASE_FUNC_PI: return "SOLLYA_BASE_FUNC_PI"; case SOLLYA_BASE_FUNC_POW: return "SOLLYA_BASE_FUNC_POW"; case SOLLYA_BASE_FUNC_PROCEDUREFUNCTION: return "SOLLYA_BASE_FUNC_PROCEDUREFUNCTION"; case SOLLYA_BASE_FUNC_QUAD: return "SOLLYA_BASE_FUNC_QUAD"; case SOLLYA_BASE_FUNC_SIN: return "SOLLYA_BASE_FUNC_SIN"; case SOLLYA_BASE_FUNC_SINGLE: return "SOLLYA_BASE_FUNC_SINGLE"; case SOLLYA_BASE_FUNC_SINH: return "SOLLYA_BASE_FUNC_SINH"; case SOLLYA_BASE_FUNC_SQRT: return "SOLLYA_BASE_FUNC_SQRT"; case SOLLYA_BASE_FUNC_SUB: return "SOLLYA_BASE_FUNC_SUB"; case SOLLYA_BASE_FUNC_TAN: return "SOLLYA_BASE_FUNC_TAN"; case SOLLYA_BASE_FUNC_TANH: return "SOLLYA_BASE_FUNC_TANH"; case SOLLYA_BASE_FUNC_TRIPLEDOUBLE: return"SOLLYA_BASE_FUNC_TRIPLEDOUBLE"; default: return "Unknown type"; } } void euler_gamma(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } int stupid1(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } /* Note: given as an example in the documentation. We suppose that the library has already been initialized */ int is_made_of_constants(sollya_obj_t f) { sollya_obj_t tmp1 = NULL; sollya_obj_t tmp2 = NULL; int n, r, res; sollya_base_function_t type; r = sollya_lib_decompose_function(f, &type, &n, &tmp1, &tmp2, NULL); if (!r) { sollya_lib_printf("%b is not a mathematical function.", f); res = 0; } else if (n >= 3) { sollya_lib_printf("Unexpected error: %b has more than two arguments.\n", f); res = 0; } else { switch (type) { case SOLLYA_BASE_FUNC_FREE_VARIABLE: res = 0; break; case SOLLYA_BASE_FUNC_PI: res = 1; break; case SOLLYA_BASE_FUNC_CONSTANT: res = 1; break; case SOLLYA_BASE_FUNC_LIBRARYCONSTANT: res = 1; break; default: res = is_made_of_constants(tmp1); if ((res) && (n==2)) res = is_made_of_constants(tmp2); } } if (tmp1) sollya_lib_clear_obj(tmp1); if (tmp2) sollya_lib_clear_obj(tmp2); return res; } int main(void) { sollya_obj_t f, tmp, tmp2, tmp3; sollya_base_function_t type; sollya_obj_t g[3]; int n; int res; sollya_lib_init(); /* Constant */ f = SOLLYA_PI; type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Another constant */ f = SOLLYA_CONST(3); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* A library constant constant */ f = sollya_lib_libraryconstant("superconst", euler_gamma); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Free variable */ f = SOLLYA_X_; type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Elementary function */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Procedure function */ tmp = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); tmp = sollya_lib_build_function_procedurefunction(SOLLYA_X_, tmp); tmp2 = sollya_lib_diff(tmp); tmp3 = SOLLYA_SIN(SOLLYA_X_); f = sollya_lib_apply(tmp2, tmp3, NULL); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(tmp); sollya_lib_clear_obj(tmp2); sollya_lib_clear_obj(tmp3); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* arithmetic operator */ f = SOLLYA_ADD(SOLLYA_X_, sollya_lib_build_function_libraryfunction(SOLLYA_X_, "stupid1", stupid1)); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* A Sollya object that is not an expression */ f = sollya_lib_absolute(); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Another one */ f = sollya_lib_parse_string("[1,2]"); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /*************************************************************/ /* Testing what happens when NULL is encountered prematurely */ /*************************************************************/ /* As second argument */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, NULL, &n, &g[1], &g[2]); if (res) sollya_lib_printf("NULL given as 2nd argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As third argument */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("NULL given as 3rd argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fourth argument */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("NULL given as 4th argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fourth argument in a binary operator */ f = SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17)); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("NULL given as 4th argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fifth argument in a binary operator */ f = SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17)); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, &g[0], NULL, &g[2]); if (res) sollya_lib_printf("NULL given as 5th argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[0], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fourth argument in a library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("NULL given as 4th argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fifth argument in a library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_decompose_function(f, &type, &n, &g[0], NULL, &g[2]); if (res) sollya_lib_printf("NULL given as 5th argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[0], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /*******************************************************/ /* Testing the function presented in the documentation */ /*******************************************************/ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_PI), "stupid1", stupid1); if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); f = sollya_lib_libraryconstant("superconst", euler_gamma); f = SOLLYA_MUL(SOLLYA_ADD(SOLLYA_PI, SOLLYA_CONST(1)), f); if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); f = SOLLYA_X_; if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); f = SOLLYA_SIN(SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(1))); if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); f = SOLLYA_SIN(SOLLYA_EXP(SOLLYA_CONST(1))); if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("[0,1]"); if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); f = sollya_lib_relative(); if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdecompose_function.reference000066400000000000000000000044741300174114700231300ustar00rootroot00000000000000pi: type = SOLLYA_BASE_FUNC_PI, n = 0, subfunctions = pi, NULL and NULL. 3: type = SOLLYA_BASE_FUNC_CONSTANT, n = 0, subfunctions = 3, NULL and NULL. superconst: type = SOLLYA_BASE_FUNC_LIBRARYCONSTANT, n = 0, subfunctions = superconst, NULL and NULL. _x_: type = SOLLYA_BASE_FUNC_FREE_VARIABLE, n = 1, subfunctions = _x_, NULL and NULL. exp(sin(_x_) + 17): type = SOLLYA_BASE_FUNC_EXP, n = 1, subfunctions = sin(_x_) + 17, NULL and NULL. (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(sin(_x_)): type = SOLLYA_BASE_FUNC_PROCEDUREFUNCTION, n = 1, subfunctions = sin(_x_), diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })) and NULL. stupid1(cos(_x_)): type = SOLLYA_BASE_FUNC_LIBRARYFUNCTION, n = 1, subfunctions = cos(_x_), stupid1 and NULL. _x_ + stupid1: type = SOLLYA_BASE_FUNC_ADD, n = 2, subfunctions = _x_, stupid1 and NULL. absolute is not a functional expression (type=Unknown type. Expecting 'Unknown type') [1;2] is not a functional expression (type=Unknown type. Expecting 'Unknown type') NULL given as 2nd argument. exp(sin(_x_) + 17): type = Unknown type, n = 1, subfunctions = sin(_x_) + 17 and NULL. NULL given as 3rd argument. exp(sin(_x_) + 17): type = SOLLYA_BASE_FUNC_EXP, n = -1, subfunctions = sin(_x_) + 17 and NULL. NULL given as 4th argument. exp(sin(_x_) + 17): type = SOLLYA_BASE_FUNC_EXP, n = 1, subfunctions = NULL and NULL. NULL given as 4th argument. sin(_x_) + 17: type = SOLLYA_BASE_FUNC_ADD, n = 2, subfunctions = NULL and NULL. NULL given as 5th argument. sin(_x_) + 17: type = SOLLYA_BASE_FUNC_ADD, n = 2, subfunctions = sin(_x_) and NULL. NULL given as 4th argument. stupid1(cos(_x_)): type = SOLLYA_BASE_FUNC_LIBRARYFUNCTION, n = 1, subfunctions = NULL and NULL. NULL given as 5th argument. stupid1(cos(_x_)): type = SOLLYA_BASE_FUNC_LIBRARYFUNCTION, n = 1, subfunctions = cos(_x_) and NULL. stupid1(cos(_x_)) is *NOT* made of constants. stupid1(cos(pi)) is made of constants. ((pi) + 1) * superconst is made of constants. _x_ is *NOT* made of constants. sin(_x_ + 1) is *NOT* made of constants. sin(exp(1)) is made of constants. [0;1] is not a mathematical function.[0;1] is *NOT* made of constants. relative is not a mathematical function.relative is *NOT* made of constants. sollya-6.0+ds/tests-lib/tdecompose_libraryconstant.c000066400000000000000000000057571300174114700230120ustar00rootroot00000000000000#include #include void stupid1(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid2(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 1, GMP_RNDN); return; } int main(void) { sollya_obj_t f[13]; void (*libfun)(mpfr_t, mp_prec_t) = NULL; int res = -1; int i; sollya_lib_init(); f[0] = sollya_lib_parse_string("(proc() {euler_gamma = libraryconstant(\"./libraryexample.a\"); return euler_gamma;})()"); /* Trying to decompose an object that is *not* a library constant */ f[1] = SOLLYA_COS(SOLLYA_CONST(4)); f[2] = sollya_lib_add(f[0], f[1]); res = sollya_lib_decompose_libraryconstant(&libfun, f[2]); if (res) sollya_lib_printf("sollya_lib_decompose_libraryconstant should not succeed on %b but it did.\n", f[2]); /* Trying to decompose a library constant created by parse_string */ /* Trying also to recompose an object with the function pointer that we get and to test if both objects compare equal. */ res = -1; libfun = NULL; res = sollya_lib_decompose_libraryconstant(&libfun, f[0]); f[3] = sollya_lib_libraryconstant("should_not_be_used", libfun); f[4] = SOLLYA_COS(SOLLYA_CONST(4)); f[5] = sollya_lib_add(f[3], f[4]); f[6] = sollya_lib_cmp_equal(f[2], f[5]); if (!res) sollya_lib_printf("sollya_lib_decompose_libraryconstant should succeed on %b. It did not.\n", f[0]); else { sollya_lib_printf("%b == %b gives %b (expecting true)\n", f[2], f[5], f[6]); } /* Trying to decompose a library constant created with sollya_lib_libraryconstant */ /* Trying also to recompose an object with the function pointer that we get and to test if both objects compare equal. */ res = -1; libfun = NULL; f[7] = sollya_lib_libraryconstant("foo", stupid1); res = sollya_lib_decompose_libraryconstant(&libfun, f[7]); f[8] = sollya_lib_libraryconstant("should_not_be_used", libfun); f[9] = sollya_lib_cmp_equal(f[7], f[8]); if (!res) sollya_lib_printf("sollya_lib_decompose_libraryconstant should succeed on %b. It did not.\n", f[7]); else { sollya_lib_printf("%b == %b gives %b (expecting true)\n", f[7], f[8], f[9]); } /* Trying to decompose a library constant created with sollya_lib_build_function_libraryconstant */ /* Trying also to recompose an object with the function pointer that we get and to test if both objects compare equal. */ res = -1; libfun = NULL; f[10] = sollya_lib_build_function_libraryconstant("bar", stupid2); res = sollya_lib_decompose_libraryconstant(&libfun, f[10]); f[11] = sollya_lib_libraryconstant("should_not_be_used", libfun); f[12] = sollya_lib_cmp_equal(f[10], f[11]); if (!res) sollya_lib_printf("sollya_lib_decompose_libraryconstant should succeed on %b. It did not.\n", f[10]); else { sollya_lib_printf("%b == %b gives %b (expecting true)\n", f[10], f[11], f[12]); } for(i=0;i<=12;i++) sollya_lib_clear_obj(f[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdecompose_libraryconstant.reference000066400000000000000000000002271300174114700245110ustar00rootroot00000000000000euler_gamma + cos(4) == euler_gamma + cos(4) gives true (expecting true) foo == foo gives true (expecting true) bar == bar gives true (expecting true) sollya-6.0+ds/tests-lib/tdecompose_libraryconstant_with_data.c000066400000000000000000000102071300174114700250200ustar00rootroot00000000000000#include #include #include #include #include typedef struct data_struct_t { char text[32]; int counter; } data_t; void dealloc(void *data) { (void) data; return; } void euler_gamma(mpfr_t res, mp_prec_t prec, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } void euler_gamma2(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } int main(void) { sollya_obj_t f; mpfr_t x,y; data_t data = { "Hello world", 0 }; void (*func)(mpfr_t, mp_prec_t, void *); void *ptr; void (*resDealloc)(void *); sollya_lib_init(); f = sollya_lib_libraryconstant_with_data("superconst", euler_gamma, &data, dealloc); sollya_lib_printf("%b (expecting: superconst)\n", f); mpfr_init2(x, 30); mpfr_init2(y, 50); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: 0.5772...)\n", y); func = NULL; ptr = NULL; resDealloc = NULL; if (sollya_lib_decompose_libraryconstant_with_data(&func, &ptr, &resDealloc, f)) { sollya_lib_printf("Decomposition of %b succeeded\n", f); sollya_lib_printf("The function pointer is %s\n", ((func == euler_gamma) ? "okay" : "wrong")); sollya_lib_printf("The data pointer is %s\n", ((ptr == ((void *) (&data))) ? "okay" : "wrong")); sollya_lib_printf("The deallocation function pointer is %s\n", ((((void *) resDealloc) == ((void *) dealloc)) ? "okay" : "wrong")); } else { sollya_lib_printf("Could not decompose %b\n", f); } sollya_lib_clear_obj(f); f = sollya_lib_parse_string("superconst"); sollya_lib_printf("%b (expecting: superconst)\n", f); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: 0.5772...)\n", y); func = NULL; ptr = NULL; resDealloc = NULL; if (sollya_lib_decompose_libraryconstant_with_data(&func, &ptr, &resDealloc, f)) { sollya_lib_printf("Decomposition of %b succeeded\n", f); sollya_lib_printf("The function pointer is %s\n", ((func == euler_gamma) ? "okay" : "wrong")); sollya_lib_printf("The data pointer is %s\n", ((ptr == ((void *) (&data))) ? "okay" : "wrong")); sollya_lib_printf("The deallocation function pointer is %s\n", ((((void *) resDealloc) == ((void *) dealloc)) ? "okay" : "wrong")); } else { sollya_lib_printf("Could not decompose %b\n", f); } sollya_lib_clear_obj(f); f = SOLLYA_PI; sollya_lib_printf("%b (expecting: pi)\n", f); func = NULL; ptr = NULL; resDealloc = NULL; if (sollya_lib_decompose_libraryconstant_with_data(&func, &ptr, &resDealloc, f)) { sollya_lib_printf("Decomposition of %b succeeded\n", f); } else { sollya_lib_printf("Could not decompose %b\n", f); } sollya_lib_clear_obj(f); f = sollya_lib_libraryconstant("superconst2", euler_gamma2); sollya_lib_printf("%b (expecting: superconst2)\n", f); func = NULL; ptr = NULL; resDealloc = NULL; if (sollya_lib_decompose_libraryconstant_with_data(&func, &ptr, &resDealloc, f)) { sollya_lib_printf("Decomposition of %b succeeded\n", f); } else { sollya_lib_printf("Could not decompose %b\n", f); } sollya_lib_clear_obj(f); f = sollya_lib_libraryconstant_with_data("superconst3", euler_gamma, &data, NULL); sollya_lib_printf("%b (expecting: superconst)\n", f); func = NULL; ptr = NULL; resDealloc = NULL; if (sollya_lib_decompose_libraryconstant_with_data(&func, &ptr, &resDealloc, f)) { sollya_lib_printf("Decomposition of %b succeeded\n", f); sollya_lib_printf("The function pointer is %s\n", ((func == euler_gamma) ? "okay" : "wrong")); sollya_lib_printf("The data pointer is %s\n", ((ptr == ((void *) (&data))) ? "okay" : "wrong")); sollya_lib_printf("The deallocation function pointer is %s\n", ((((void *) resDealloc) == NULL) ? "okay" : "wrong")); } else { sollya_lib_printf("Could not decompose %b\n", f); } sollya_lib_clear_obj(f); mpfr_clear(x); mpfr_clear(y); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdecompose_libraryconstant_with_data.reference000066400000000000000000000014741300174114700265420ustar00rootroot00000000000000superconst (expecting: superconst) >>>>Hello world<<<<>>>>0<<<< 0.57721566490153275452712477999739348888397216796875 (expecting: 0.5772...) Decomposition of superconst succeeded The function pointer is okay The data pointer is okay The deallocation function pointer is okay superconst (expecting: superconst) >>>>Hello world<<<<>>>>1<<<< 0.57721566490153275452712477999739348888397216796875 (expecting: 0.5772...) Decomposition of superconst succeeded The function pointer is okay The data pointer is okay The deallocation function pointer is okay pi (expecting: pi) Could not decompose pi superconst2 (expecting: superconst2) Could not decompose superconst2 superconst (expecting: superconst) Decomposition of superconst succeeded The function pointer is okay The data pointer is okay The deallocation function pointer is okay sollya-6.0+ds/tests-lib/tdecompose_libraryfunction.c000066400000000000000000000105061300174114700227720ustar00rootroot00000000000000#include #include #include int stupid1(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid2(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 1); return 0; } int main(void) { sollya_obj_t f[36]; int (*libfun)(mpfi_t, mpfi_t, int) = NULL; int deriv = -1; int res = -1; int i; sollya_lib_init(); f[0] = sollya_lib_parse_string("(proc() {myownlog = library(\"./libraryexample.a\"); return myownlog;})()"); f[1] = SOLLYA_COS(SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(1))); /* Trying to decompose an object that is *not* a library function */ f[2] = sollya_lib_apply(f[0], f[1], NULL); f[3] = sollya_lib_diff(f[2]); res = sollya_lib_decompose_libraryfunction(&libfun, &deriv, &f[4], f[3]); if (res) sollya_lib_printf("sollya_lib_decompose_libraryfunction should not succeed on %b but it did.\n", f[3]); /* Trying to decompose a library function created by parse_string */ /* Trying also to recompose an object with the function pointer that we get and to test if both objects compare equal. */ f[4] = sollya_lib_diff(f[0]); f[5] = sollya_lib_apply(f[4], f[1], NULL); deriv = -1; libfun = NULL; res = sollya_lib_decompose_libraryfunction(&libfun, &deriv, &f[6], f[5]); f[7] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "should_not_be_used", libfun); f[8] = sollya_lib_diff(f[7]); f[9] = sollya_lib_apply(f[8], f[1], NULL); f[10] = sollya_lib_cmp_equal(f[5], f[9]); if (!res) sollya_lib_printf("sollya_lib_decompose_libraryfunction should succeed on %b. It did not.\n", f[5]); else { sollya_lib_printf("Decomposing %b gives deriv=%d and the sub-object %b.\n", f[5], deriv, f[6]); sollya_lib_printf("%b == %b gives %b (expecting true)\n", f[5], f[9], f[10]); } /* Trying to decompose a library function created with sollya_lib_libraryfunction */ /* Trying also to recompose an object with the function pointer that we get and to test if both objects compare equal. */ f[11] = SOLLYA_X_; f[12] = sollya_lib_libraryfunction(f[11], "foo", stupid1); f[13] = sollya_lib_diff(f[12]); f[14] = sollya_lib_diff(f[13]); f[15] = SOLLYA_EXP(SOLLYA_X_); f[16] = sollya_lib_apply(f[14], f[15], NULL); deriv = -1; libfun = NULL; res = sollya_lib_decompose_libraryfunction(&libfun, &deriv, &f[17], f[16]); f[18] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "should_not_be_used", libfun); f[19] = sollya_lib_diff(f[18]); f[20] = sollya_lib_diff(f[19]); f[21] = sollya_lib_copy_obj(f[15]); f[22] = sollya_lib_apply(f[20], f[21], NULL); f[23] = sollya_lib_cmp_equal(f[16], f[22]); if (!res) sollya_lib_printf("sollya_lib_decompose_libraryfunction should succeed on %b. It did not.\n", f[16]); else { sollya_lib_printf("Decomposing %b gives deriv=%d and the sub-object %b.\n", f[16], deriv, f[17]); sollya_lib_printf("%b == %b gives %b (expecting true)\n", f[16], f[22], f[23]); } /* Trying to decompose a library function created with sollya_lib_build_function_libraryfunction */ /* Trying also to recompose an object with the function pointer that we get and to test if both objects compare equal. */ f[24] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "bar", stupid2); f[25] = sollya_lib_diff(f[24]); f[26] = sollya_lib_diff(f[25]); f[27] = SOLLYA_LOG(SOLLYA_X_); f[28] = sollya_lib_apply(f[26], f[27], NULL); deriv = -1; libfun = NULL; res = sollya_lib_decompose_libraryfunction(&libfun, &deriv, &f[29], f[28]); f[30] = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "should_not_be_used", libfun); f[31] = sollya_lib_diff(f[30]); f[32] = sollya_lib_diff(f[31]); f[33] = sollya_lib_copy_obj(f[27]); f[34] = sollya_lib_apply(f[32], f[33], NULL); f[35] = sollya_lib_cmp_equal(f[28], f[34]); if (!res) sollya_lib_printf("sollya_lib_decompose_libraryfunction should succeed on %b. It did not.\n", f[28]); else { sollya_lib_printf("Decomposing %b gives deriv=%d and the sub-object %b.\n", f[28], deriv, f[29]); sollya_lib_printf("%b == %b gives %b (expecting true)\n", f[28], f[34], f[35]); } for(i=0;i<=35;i++) sollya_lib_clear_obj(f[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdecompose_libraryfunction.reference000066400000000000000000000010131300174114700244770ustar00rootroot00000000000000Decomposing (diff(myownlog))(cos(_x_ + 1)) gives deriv=1 and the sub-object cos(_x_ + 1). (diff(myownlog))(cos(_x_ + 1)) == (diff(myownlog))(cos(_x_ + 1)) gives true (expecting true) Decomposing (diff(diff(foo)))(exp(_x_)) gives deriv=2 and the sub-object exp(_x_). (diff(diff(foo)))(exp(_x_)) == (diff(diff(foo)))(exp(_x_)) gives true (expecting true) Decomposing (diff(diff(bar)))(log(_x_)) gives deriv=2 and the sub-object log(_x_). (diff(diff(bar)))(log(_x_)) == (diff(diff(bar)))(log(_x_)) gives true (expecting true) sollya-6.0+ds/tests-lib/tdecompose_libraryfunction_with_data.c000066400000000000000000000206701300174114700250210ustar00rootroot00000000000000#include #include #include #include #include typedef struct data_struct_t { char text[32]; int counter; } data_t; void dealloc(void *data) { (void) data; return; } int myownlog(mpfi_t result, mpfi_t x, int n, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; if(n==0) { /* Implementation of the neperian logarithm */ if(mpfi_nan_p(x)) { mpfr_t a; mpfr_init2(a,mpfi_get_prec(result)); mpfi_interv_fr(result,a,a); mpfr_clear(a); return 0; } if(mpfi_has_zero(x)) { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } else { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfi_get_left(a,x); mpfr_log(a,a, GMP_RNDD); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } } if(n==1) { /* Implementation of 1/x */ mpfi_inv(result,x); return 0; } if(n==2) { /* Implementation of -1/x^2 */ mpfi_t temp; mpfi_init2(temp, mpfi_get_prec(result)); mpfi_sqr(temp, x); mpfi_inv(temp, temp); mpfi_neg(result, temp); mpfi_clear(temp); return 0; } /* else */ mpfr_t a,b; mpfr_init2(a, mpfi_get_prec(result)); mpfr_init2(b, mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfr_set_inf(b, 1); mpfi_interv_fr(result,a,b); mpfr_clear(a); mpfr_clear(b); return 0; } int myownlog2(mpfi_t result, mpfi_t x, int n) { if(n==0) { /* Implementation of the neperian logarithm */ if(mpfi_nan_p(x)) { mpfr_t a; mpfr_init2(a,mpfi_get_prec(result)); mpfi_interv_fr(result,a,a); mpfr_clear(a); return 0; } if(mpfi_has_zero(x)) { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } else { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfi_get_left(a,x); mpfr_log(a,a, GMP_RNDD); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } } if(n==1) { /* Implementation of 1/x */ mpfi_inv(result,x); return 0; } if(n==2) { /* Implementation of -1/x^2 */ mpfi_t temp; mpfi_init2(temp, mpfi_get_prec(result)); mpfi_sqr(temp, x); mpfi_inv(temp, temp); mpfi_neg(result, temp); mpfi_clear(temp); return 0; } /* else */ mpfr_t a,b; mpfr_init2(a, mpfi_get_prec(result)); mpfr_init2(b, mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfr_set_inf(b, 1); mpfi_interv_fr(result,a,b); mpfr_clear(a); mpfr_clear(b); return 0; } int main(void) { sollya_obj_t g, f, h; mpfr_t x,y; data_t data = { "Hello world", 0 }; int (*func)(mpfi_t, mpfi_t, int, void *); int deriv; void *ptr; void (*resDealloc)(void *); sollya_lib_init(); g = sollya_lib_parse_string("sin(_x_^2)^2 * 1/3"); f = sollya_lib_libraryfunction_with_data(g, "superfunc", myownlog, &data, dealloc); sollya_lib_printf("%b (expecting: superfunc)\n", f); mpfr_init2(x, 30); mpfr_init2(y, 50); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: approximate value of log(sin(4)^2 * 1/3))\n", y); func = NULL; deriv = -1; h = NULL; ptr = NULL; resDealloc = NULL; if (sollya_lib_decompose_libraryfunction_with_data(&func, &deriv, &h, &ptr, &resDealloc, f)) { sollya_lib_printf("Decomposition of %b succeeded\n", f); sollya_lib_printf("h = %b\n", h); sollya_lib_printf("derivation order = %d\n", deriv); sollya_lib_printf("The function pointer is %s\n", ((func == myownlog) ? "okay" : "wrong")); sollya_lib_printf("The data pointer is %s\n", ((ptr == ((void *) (&data))) ? "okay" : "wrong")); sollya_lib_printf("The deallocation function pointer is %s\n", ((((void *) resDealloc) == ((void *) dealloc)) ? "okay" : "wrong")); sollya_lib_clear_obj(h); } else { sollya_lib_printf("Could not decompose %b\n", f); } sollya_lib_clear_obj(f); sollya_lib_clear_obj(g); f = sollya_lib_parse_string("diff(superfunc(sin(_x_)))"); sollya_lib_printf("%b (expecting: (diff(superfunc))(sin(_x_)) * cos(_x_))\n", f); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("diff(superfunc(_x_))"); sollya_lib_printf("%b (expecting: diff(superfunc))\n", f); mpfr_set_ui(x, 4, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: approximate value of 1/4)\n", y); func = NULL; deriv = -1; h = NULL; ptr = NULL; resDealloc = NULL; if (sollya_lib_decompose_libraryfunction_with_data(&func, &deriv, &h, &ptr, &resDealloc, f)) { sollya_lib_printf("Decomposition of %b succeeded\n", f); sollya_lib_printf("h = %b\n", h); sollya_lib_printf("derivation order = %d\n", deriv); sollya_lib_printf("The function pointer is %s\n", ((func == myownlog) ? "okay" : "wrong")); sollya_lib_printf("The data pointer is %s\n", ((ptr == ((void *) (&data))) ? "okay" : "wrong")); sollya_lib_printf("The deallocation function pointer is %s\n", ((((void *) resDealloc) == ((void *) dealloc)) ? "okay" : "wrong")); sollya_lib_clear_obj(h); } else { sollya_lib_printf("Could not decompose %b\n", f); } sollya_lib_clear_obj(f); f = sollya_lib_parse_string("sin(exp(_x_)) + 3"); sollya_lib_printf("%b (expecting: sin(exp(_x_)) + 3\n", f); func = NULL; deriv = -1; h = NULL; ptr = NULL; resDealloc = NULL; if (sollya_lib_decompose_libraryfunction_with_data(&func, &deriv, &h, &ptr, &resDealloc, f)) { sollya_lib_printf("Decomposition of %b succeeded\n", f); sollya_lib_printf("h = %b\n", h); sollya_lib_printf("derivation order = %d\n", deriv); sollya_lib_clear_obj(h); } else { sollya_lib_printf("Could not decompose %b\n", f); } sollya_lib_clear_obj(f); g = sollya_lib_parse_string("sin(_x_^2)^2 * 1/3"); f = sollya_lib_libraryfunction(g, "superfunc2", myownlog2); sollya_lib_printf("%b (expecting: superfunc2(sin(_x_^2)^2 / 3))\n", f); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: approximate value of log(sin(4)^2 * 1/3))\n", y); func = NULL; deriv = -1; h = NULL; ptr = NULL; resDealloc = NULL; if (sollya_lib_decompose_libraryfunction_with_data(&func, &deriv, &h, &ptr, &resDealloc, f)) { sollya_lib_printf("Decomposition of %b succeeded\n", f); sollya_lib_printf("h = %b\n", h); sollya_lib_printf("derivation order = %d\n", deriv); sollya_lib_clear_obj(h); } else { sollya_lib_printf("Could not decompose %b\n", f); } sollya_lib_clear_obj(f); sollya_lib_clear_obj(g); g = sollya_lib_parse_string("sin(_x_^2)^2 * 1/3"); f = sollya_lib_libraryfunction_with_data(g, "superfunc3", myownlog, &data, NULL); sollya_lib_printf("%b (expecting: superfunc3(sin(_x_^2)^2 / 3))\n", f); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: approximate value of log(sin(4)^2 * 1/3))\n", y); func = NULL; deriv = -1; h = NULL; ptr = NULL; resDealloc = NULL; if (sollya_lib_decompose_libraryfunction_with_data(&func, &deriv, &h, &ptr, &resDealloc, f)) { sollya_lib_printf("Decomposition of %b succeeded\n", f); sollya_lib_printf("h = %b\n", h); sollya_lib_printf("derivation order = %d\n", deriv); sollya_lib_printf("The function pointer is %s\n", ((func == myownlog) ? "okay" : "wrong")); sollya_lib_printf("The data pointer is %s\n", ((ptr == ((void *) (&data))) ? "okay" : "wrong")); sollya_lib_printf("The deallocation function pointer is %s\n", ((((void *) resDealloc) == NULL) ? "okay" : "wrong")); sollya_lib_clear_obj(h); } else { sollya_lib_printf("Could not decompose %b\n", f); } sollya_lib_clear_obj(f); sollya_lib_clear_obj(g); mpfr_clear(x); mpfr_clear(y); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdecompose_libraryfunction_with_data.reference000066400000000000000000000026741300174114700265410ustar00rootroot00000000000000superfunc(sin(_x_^2)^2 / 3) (expecting: superfunc) >>>>Hello world<<<<>>>>0<<<< -1.6559182168023571790627102018333971500396728515625 (expecting: approximate value of log(sin(4)^2 * 1/3)) Decomposition of superfunc(sin(_x_^2)^2 / 3) succeeded h = sin(_x_^2)^2 / 3 derivation order = 0 The function pointer is okay The data pointer is okay The deallocation function pointer is okay (diff(superfunc))(sin(_x_)) * cos(_x_) (expecting: (diff(superfunc))(sin(_x_)) * cos(_x_)) diff(superfunc) (expecting: diff(superfunc)) >>>>Hello world<<<<>>>>1<<<< 0.25 (expecting: approximate value of 1/4) Decomposition of diff(superfunc) succeeded h = _x_ derivation order = 1 The function pointer is okay The data pointer is okay The deallocation function pointer is okay sin(exp(_x_)) + 3 (expecting: sin(exp(_x_)) + 3 Could not decompose sin(exp(_x_)) + 3 superfunc2(sin(_x_^2)^2 / 3) (expecting: superfunc2(sin(_x_^2)^2 / 3)) -1.6559182168023571790627102018333971500396728515625 (expecting: approximate value of log(sin(4)^2 * 1/3)) Could not decompose superfunc2(sin(_x_^2)^2 / 3) superfunc(sin(_x_^2)^2 / 3) (expecting: superfunc3(sin(_x_^2)^2 / 3)) >>>>Hello world<<<<>>>>2<<<< -1.6559182168023571790627102018333971500396728515625 (expecting: approximate value of log(sin(4)^2 * 1/3)) Decomposition of superfunc(sin(_x_^2)^2 / 3) succeeded h = sin(_x_^2)^2 / 3 derivation order = 0 The function pointer is okay The data pointer is okay The deallocation function pointer is okay sollya-6.0+ds/tests-lib/tdecompose_procedurefunction.c000066400000000000000000000071331300174114700233200ustar00rootroot00000000000000#include #include #include int main(void) { sollya_obj_t f[31]; int deriv = -1; int res = -1; int i; sollya_lib_init(); f[0] = sollya_lib_parse_string("function(proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })"); f[1] = SOLLYA_COS(SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(1))); /* Trying to decompose an object that is *not* a procedure function */ f[2] = sollya_lib_apply(f[0], f[1], NULL); f[3] = sollya_lib_diff(f[2]); res = sollya_lib_decompose_procedurefunction(&f[4], &deriv, &f[5], f[3]); if (res) sollya_lib_printf("sollya_lib_decompose_procedurefunction should not succeed on %b but it did.\n", f[3]); /* Trying to decompose a procedure function created by parse_string */ /* Trying also to recompose an object with the function pointer that we get and to test if both objects compare equal. */ f[4] = sollya_lib_diff(f[0]); f[5] = sollya_lib_apply(f[4], f[1], NULL); deriv = -1; res = sollya_lib_decompose_procedurefunction(&f[6], &deriv, &f[7], f[5]); f[8] = SOLLYA_X_; f[9] = sollya_lib_procedurefunction(f[8], f[6]); f[10] = sollya_lib_diff(f[9]); f[11] = sollya_lib_apply(f[10], f[1], NULL); f[12] = sollya_lib_cmp_equal(f[5], f[11]); if (!res) sollya_lib_printf("sollya_lib_decompose_procedurefunction should succeed on %b. It did not.\n", f[5]); else { sollya_lib_printf("Decomposing %b gives deriv=%d and the sub-objects %b and %b.\n", f[5], deriv, f[6], f[7]); sollya_lib_printf("%b == %b gives %b (expecting true)\n", f[5], f[11], f[12]); } /* Trying to decompose a procedure function created with sollya_lib_procedurefunction */ /* Trying also to recompose an object with the function pointer that we get and to test if both objects compare equal. */ f[13] = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = 3*exp(X); prec = oldPrec!; return res; }"); f[14] = SOLLYA_X_; f[15] = sollya_lib_procedurefunction(f[14], f[13]); f[16] = sollya_lib_diff(f[15]); f[17] = sollya_lib_diff(f[16]); deriv = -1; res = sollya_lib_decompose_procedurefunction(&f[18], &deriv, &f[19], f[17]); f[20] = SOLLYA_X_; f[21] = sollya_lib_procedurefunction(f[20], f[18]); f[22] = sollya_lib_diff(f[21]); f[23] = sollya_lib_diff(f[22]); f[24] = sollya_lib_cmp_equal(f[17], f[23]); if (!res) sollya_lib_printf("sollya_lib_decompose_procedurefunction should succeed on %b. It did not.\n", f[17]); else { sollya_lib_printf("Decomposing %b gives deriv=%d and the sub-objects %b and %b.\n", f[17], deriv, f[18], f[19]); sollya_lib_printf("%b == %b gives %b (expecting true)\n", f[17], f[23], f[24]); } /* Trying to decompose a procedure function created with sollya_lib_build_function_procedurefunction */ f[25] = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = 17*exp(X); prec = oldPrec!; return res; }"); f[25] = sollya_lib_build_function_procedurefunction(SOLLYA_X_, f[25]); deriv = -1; res = sollya_lib_decompose_procedurefunction(&f[26], &deriv, &f[27], f[25]); f[28] = SOLLYA_X_; f[29] = sollya_lib_procedurefunction(f[28], f[26]); f[30] = sollya_lib_cmp_equal(f[25], f[29]); if (!res) sollya_lib_printf("sollya_lib_decompose_procedurefunction should succeed on %b. It did not.\n", f[25]); else { sollya_lib_printf("Decomposing %b gives deriv=%d and the sub-objects %b and %b.\n", f[25], deriv, f[26], f[27]); sollya_lib_printf("%b == %b gives %b (expecting true)\n", f[25], f[29], f[30]); } for(i=0;i<=30;i++) sollya_lib_clear_obj(f[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdecompose_procedurefunction.reference000066400000000000000000000034071300174114700250340ustar00rootroot00000000000000Decomposing (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(cos(_x_ + 1)) gives deriv=1 and the sub-objects proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; } and cos(_x_ + 1). (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(cos(_x_ + 1)) == (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(cos(_x_ + 1)) gives true (expecting true) Decomposing diff(diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = (3) * (exp(X)); prec = oldPrec!; return res; }))) gives deriv=2 and the sub-objects proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = (3) * (exp(X)); prec = oldPrec!; return res; } and _x_. diff(diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = (3) * (exp(X)); prec = oldPrec!; return res; }))) == diff(diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = (3) * (exp(X)); prec = oldPrec!; return res; }))) gives true (expecting true) Decomposing function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = (17) * (exp(X)); prec = oldPrec!; return res; }) gives deriv=0 and the sub-objects proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = (17) * (exp(X)); prec = oldPrec!; return res; } and _x_. function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = (17) * (exp(X)); prec = oldPrec!; return res; }) == function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = (17) * (exp(X)); prec = oldPrec!; return res; }) gives true (expecting true) sollya-6.0+ds/tests-lib/tdefault.c000066400000000000000000000003071300174114700171440ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_default(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdefault.reference000066400000000000000000000000071300174114700206550ustar00rootroot00000000000000defaultsollya-6.0+ds/tests-lib/tdegree.c000066400000000000000000000014301300174114700167510ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a[9], b[9]; int i; sollya_lib_init(); a[0] = SOLLYA_CONST(1.0); a[1] = SOLLYA_X_; a[2] = SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)); a[3] = SOLLYA_MUL(SOLLYA_X_,SOLLYA_X_); a[4] = SOLLYA_POW(SOLLYA_ADD(SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)),SOLLYA_CONST(1.0)),SOLLYA_CONST(5.0)); a[5] = SOLLYA_CONST(0.0); a[6] = SOLLYA_EXP(SOLLYA_X_); a[7] = SOLLYA_POW(SOLLYA_X_, SOLLYA_CONST(2.5)); a[8] = SOLLYA_POW(SOLLYA_POW(SOLLYA_X_, SOLLYA_CONST(2.5)), SOLLYA_CONST(2)); for (i=0;i<9;i++) { b[i] = sollya_lib_degree(a[i]); sollya_lib_printf("The degree of %b is %b.\n",a[i],b[i]); } for (i=0;i<9;i++) { sollya_lib_clear_obj(a[i]); sollya_lib_clear_obj(b[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdegree.reference000066400000000000000000000003731300174114700204720ustar00rootroot00000000000000The degree of 1 is 0. The degree of _x_ is 1. The degree of _x_^2 is 2. The degree of _x_ * _x_ is 2. The degree of (_x_^2 + 1)^5 is 10. The degree of 0 is 0. The degree of exp(_x_) is -1. The degree of _x_^2.5 is -1. The degree of (_x_^2.5)^2 is -1. sollya-6.0+ds/tests-lib/tdenominator.c000066400000000000000000000022511300174114700200370ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch (message) { case SOLLYA_MSG_EXPR_IS_NO_FRACTION: sollya_lib_printf("The following object is not a fraction.\n"); break; default: sollya_lib_printf("Unexpected message caught.\n"); } return 0; } int main(void) { sollya_obj_t a[4], b[4]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = SOLLYA_DIV(SOLLYA_CONST(17.0),SOLLYA_CONST(1001.0)); a[1] = SOLLYA_DIV(SOLLYA_ADD(SOLLYA_X_,SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0))), SOLLYA_ADD(SOLLYA_ADD(SOLLYA_X_,SOLLYA_MUL(SOLLYA_CONST(2.0),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)))),SOLLYA_CONST(1.0))); a[2] = sollya_lib_parse_string("((x + 1)/(x + 2)) * ((x + 3)/(x + 4))"); a[3] = SOLLYA_EXP(SOLLYA_DIV(SOLLYA_X_, SOLLYA_CONST(4))); for (i=0;i<4;i++) { b[i] = sollya_lib_denominator(a[i]); sollya_lib_printf("The denominator of %b is %b.\n",a[i],b[i]); } for (i=0;i<4;i++) { sollya_lib_clear_obj(a[i]); sollya_lib_clear_obj(b[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdenominator.reference000066400000000000000000000004361300174114700215560ustar00rootroot00000000000000The denominator of 17 / 1001 is 1001. The denominator of (x + x^2) / (x + 2 * x^2 + 1) is x + 2 * x^2 + 1. The following object is not a fraction. The denominator of (x + 1) / (x + 2) * (x + 3) / (x + 4) is 1. The following object is not a fraction. The denominator of exp(x / 4) is 1. sollya-6.0+ds/tests-lib/tdiff.c000066400000000000000000000040521300174114700164310ustar00rootroot00000000000000#include #define A_DIM 34 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[A_DIM], b[A_DIM]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = SOLLYA_CONST(17.0); a[1] = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_X_)); a[2] = sollya_lib_parse_string("(x + 1)^7"); a[3] = SOLLYA_SIN(SOLLYA_MUL(SOLLYA_CONST(17.0),SOLLYA_X_)); a[4] = SOLLYA_X_; a[5] = SOLLYA_ADD(SOLLYA_EXP(SOLLYA_X_),SOLLYA_ATAN(SOLLYA_X_)); a[6] = SOLLYA_SUB(SOLLYA_EXP(SOLLYA_X_),SOLLYA_ATAN(SOLLYA_X_)); a[7] = SOLLYA_MUL(SOLLYA_EXP(SOLLYA_X_),SOLLYA_ATAN(SOLLYA_X_)); a[8] = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_),SOLLYA_ATAN(SOLLYA_X_)); a[9] = SOLLYA_SQRT(SOLLYA_X_); a[10] = SOLLYA_EXP(SOLLYA_X_); a[11] = SOLLYA_LOG(SOLLYA_X_); a[12] = SOLLYA_LOG2(SOLLYA_X_); a[13] = SOLLYA_LOG10(SOLLYA_X_); a[14] = SOLLYA_SIN(SOLLYA_X_); a[15] = SOLLYA_COS(SOLLYA_X_); a[16] = SOLLYA_TAN(SOLLYA_X_); a[17] = SOLLYA_ASIN(SOLLYA_X_); a[18] = SOLLYA_ACOS(SOLLYA_X_); a[19] = SOLLYA_ATAN(SOLLYA_X_); a[20] = SOLLYA_POW(SOLLYA_EXP(SOLLYA_X_),SOLLYA_ATAN(SOLLYA_X_)); a[21] = SOLLYA_NEG(SOLLYA_X_); a[22] = SOLLYA_ABS(SOLLYA_X_); a[23] = SOLLYA_ERF(SOLLYA_X_); a[24] = SOLLYA_ERFC(SOLLYA_X_); a[25] = SOLLYA_LOG1P(SOLLYA_X_); a[26] = SOLLYA_EXPM1(SOLLYA_X_); a[27] = SOLLYA_SINH(SOLLYA_X_); a[28] = SOLLYA_COSH(SOLLYA_X_); a[29] = SOLLYA_TANH(SOLLYA_X_); a[30] = SOLLYA_ASINH(SOLLYA_X_); a[31] = SOLLYA_ACOSH(SOLLYA_X_); a[32] = SOLLYA_ATANH(SOLLYA_X_); a[33] = SOLLYA_PI; for (i=0;i #define NB_OF_TESTS 7 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_EXPRESSION_IS_CONSTANT: sollya_lib_printf("Caught message: a certain expression is constant.\n"); break; case SOLLYA_MSG_DOMAIN_IS_NO_CLOSED_INTERVAL_ON_THE_REALS: sollya_lib_printf("Caught message: the domain to compute on must be a closed subset of the real numbers.\n"); break; case SOLLYA_MSG_DOMAIN_IS_REDUCED_TO_A_POINT_WILL_SIMPLY_EVAL: sollya_lib_printf("Caught message: the domain is reduced to a point.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int boolean_not_eq(sollya_obj_t a, sollya_obj_t b) { sollya_obj_t tmp; int res; tmp = sollya_lib_cmp_not_equal(a,b); res = sollya_lib_is_true(tmp); sollya_lib_clear_obj(tmp); return res; } int main(void) { sollya_obj_t a[NB_OF_TESTS], b[NB_OF_TESTS], c[NB_OF_TESTS]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = SOLLYA_CONST(17.0); b[0] = sollya_lib_parse_string("[-1;1]"); a[1] = SOLLYA_X_; b[1] = sollya_lib_parse_string("[-1;1.5]"); a[2] = sollya_lib_parse_string("x^2 + x -1"); b[2] = sollya_lib_parse_string("[-2;1]"); a[3] = sollya_lib_parse_string("x^2 + x -1"); b[3] = sollya_lib_parse_string("[-2;2]"); a[4] = sollya_lib_parse_string("exp(x)"); b[4] = sollya_lib_parse_string("[-infty;2]"); a[5] = sollya_lib_parse_string("erf(x)"); b[5] = sollya_lib_parse_string("[-infty;infty]"); a[6] = sollya_lib_parse_string("exp(x)"); b[6] = sollya_lib_parse_string("[2;2]"); for (i=0;i #define NB_OF_TESTS 7 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_DOMAIN_IS_NO_CLOSED_INTERVAL_ON_THE_REALS: sollya_lib_printf("Caught the message: the given domain is not a closed subset of the reals.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[NB_OF_TESTS], b[NB_OF_TESTS], c[NB_OF_TESTS]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = SOLLYA_X_; b[0] = sollya_lib_parse_string("[1;2]"); a[1] = SOLLYA_X_; b[1] = sollya_lib_parse_string("[2;3]"); a[2] = sollya_lib_parse_string("2/sqrt(pi) * exp(-_x_^2)"); b[2] = sollya_lib_parse_string("[0;100]"); a[3] = sollya_lib_parse_string("2/sqrt(pi) * exp(-_x_^2)"); b[3] = sollya_lib_parse_string("[-5;5]"); a[4] = SOLLYA_EXP(SOLLYA_X_); b[4] = sollya_lib_parse_string("[0;1]"); a[5] = SOLLYA_EXP(SOLLYA_X_); b[5] = sollya_lib_parse_string("[-infty;1]"); a[6] = SOLLYA_EXP(SOLLYA_X_); b[6] = sollya_lib_parse_string("[1;infty]"); for (i=0;i #define A_DIM 8 int main(void) { sollya_obj_t a[A_DIM], b[A_DIM]; sollya_obj_t temp; int i; sollya_lib_init(); temp = sollya_lib_off(); sollya_lib_set_autosimplify(temp); sollya_lib_clear_obj(temp); a[0] = SOLLYA_SUB(SOLLYA_ADD(SOLLYA_X_,SOLLYA_CONST(2.0)),SOLLYA_ADD(SOLLYA_X_,SOLLYA_CONST(2.0))); a[1] = SOLLYA_ASIN(SOLLYA_EXP(SOLLYA_SUB(SOLLYA_ADD(SOLLYA_X_,SOLLYA_CONST(2.0)),SOLLYA_ADD(SOLLYA_X_,SOLLYA_CONST(2.0))))); a[2] = SOLLYA_SUB(sollya_lib_parse_string("exp(x) - 1"), sollya_lib_parse_string("expm1(x)")); a[3] = SOLLYA_ADD(SOLLYA_CONST(1.0),SOLLYA_CONST(1e-300)); a[4] = sollya_lib_parse_string("13/17 - 19/368"); a[5] = sollya_lib_parse_string("((x + 1)^5 + exp(3)) - ((x + 1)^(log10(100000)) + exp(3 + 1b-1000))"); a[6] = sollya_lib_parse_string("((x + 1)^5 + exp(3)) - ((x + 1)^5 + exp(3))"); a[7] = sollya_lib_parse_string("-log(13)/log(17) + x * (sin(pi/3) - sqrt(3)/2) + log2(13)/log2(17)"); for (i=0;i int main(void) { sollya_obj_t f1, f2, f; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_constant_from_double(2.0); f = sollya_lib_div(f1, f2); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdiv.reference000066400000000000000000000000071300174114700200130ustar00rootroot00000000000000_x_ / 2sollya-6.0+ds/tests-lib/tdouble.c000066400000000000000000000004171300174114700167740ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_double(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdouble.reference000066400000000000000000000000131300174114700205000ustar00rootroot00000000000000double(_x_)sollya-6.0+ds/tests-lib/tdouble_double.c000066400000000000000000000004261300174114700203260ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_double_double(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdouble_double.reference000066400000000000000000000000211300174114700220310ustar00rootroot00000000000000doubledouble(_x_)sollya-6.0+ds/tests-lib/tdouble_double_obj.c000066400000000000000000000003211300174114700211520ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_double_double_obj(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdouble_double_obj.reference000066400000000000000000000000141300174114700226650ustar00rootroot00000000000000doubledoublesollya-6.0+ds/tests-lib/tdouble_obj.c000066400000000000000000000003121300174114700176200ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_double_obj(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdouble_obj.reference000066400000000000000000000000061300174114700213340ustar00rootroot00000000000000doublesollya-6.0+ds/tests-lib/tdoubleextended.c000066400000000000000000000004271300174114700205160ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_doubleextended(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdoubleextended.reference000066400000000000000000000000231300174114700222220ustar00rootroot00000000000000doubleextended(_x_)sollya-6.0+ds/tests-lib/tdoubleextended_obj.c000066400000000000000000000003221300174114700213420ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_doubleextended_obj(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdoubleextended_obj.reference000066400000000000000000000000161300174114700230560ustar00rootroot00000000000000doubleextendedsollya-6.0+ds/tests-lib/tdyadic.c000066400000000000000000000003061300174114700167540ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_dyadic(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tdyadic.reference000066400000000000000000000000061300174114700204650ustar00rootroot00000000000000dyadicsollya-6.0+ds/tests-lib/tend_elliptic_list.c000066400000000000000000000047771300174114700212250ustar00rootroot00000000000000#include int main(void) { sollya_obj_t L[3]; volatile void *ptr; sollya_obj_t listobj, tmp; sollya_lib_init(); /* Empty end-elliptic list from nothing: expecting error */ listobj = sollya_lib_end_elliptic_list(NULL, 0); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); L[0] = SOLLYA_COS(SOLLYA_X_); L[1] = SOLLYA_CONST(3.); L[2] = sollya_lib_double_obj(); /* Empty end-elliptic list from an invalid pointer: expecting error */ ptr = (void *) 17; listobj = sollya_lib_end_elliptic_list((sollya_obj_t *)ptr, 0); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* Empty end-elliptic list from a valid pointer: expecting error */ listobj = sollya_lib_end_elliptic_list(L, 0); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* List with one non-integer element, out of an array of more elements */ listobj = sollya_lib_end_elliptic_list(L, 1); sollya_lib_printf("%b. ", listobj); if (sollya_lib_get_element_in_list(&tmp, listobj, 2)) { sollya_lib_printf("listobj[2] is %b\n", tmp); sollya_lib_clear_obj(tmp); } else sollya_lib_printf("listobj[2] does not exist.\n"); sollya_lib_clear_obj(listobj); /* List with one integer element, out of an array of more elements */ listobj = sollya_lib_end_elliptic_list(L+1, 1); sollya_lib_printf("%b. ", listobj); if (sollya_lib_get_element_in_list(&tmp, listobj, 2)) { sollya_lib_printf("listobj[2] is %b\n", tmp); sollya_lib_clear_obj(tmp); } else sollya_lib_printf("listobj[2] does not exist.\n"); sollya_lib_clear_obj(listobj); /* List from an array with all the elements of the array. Ends with a non-integer element */ listobj = sollya_lib_end_elliptic_list(L, 3); sollya_lib_printf("%b. ", listobj); if (sollya_lib_get_element_in_list(&tmp, listobj, 4)) { sollya_lib_printf("listobj[2] is %b\n", tmp); sollya_lib_clear_obj(tmp); } else sollya_lib_printf("listobj[2] does not exist.\n"); sollya_lib_clear_obj(listobj); /* List from an array with 2 elements of the array. Ends with an integer element */ listobj = sollya_lib_end_elliptic_list(L, 2); sollya_lib_printf("%b. ", listobj); if (sollya_lib_get_element_in_list(&tmp, listobj, 4)) { sollya_lib_printf("listobj[4] is %b\n", tmp); sollya_lib_clear_obj(tmp); } else sollya_lib_printf("listobj[4] does not exist.\n"); sollya_lib_clear_obj(listobj); sollya_lib_clear_obj(L[0]); sollya_lib_clear_obj(L[1]); sollya_lib_clear_obj(L[2]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tend_elliptic_list.reference000066400000000000000000000002511300174114700227200ustar00rootroot00000000000000error error error [|cos(_x_)...|]. listobj[2] is cos(_x_) [|3...|]. listobj[2] is 5 [|cos(_x_), 3, double...|]. listobj[2] is double [|cos(_x_), 3...|]. listobj[4] is 6 sollya-6.0+ds/tests-lib/terf.c000066400000000000000000000004141300174114700162730ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_erf(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/terf.reference000066400000000000000000000000101300174114700177770ustar00rootroot00000000000000erf(_x_)sollya-6.0+ds/tests-lib/terfc.c000066400000000000000000000004151300174114700164370ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_erfc(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/terfc.reference000066400000000000000000000000111300174114700201430ustar00rootroot00000000000000erfc(_x_)sollya-6.0+ds/tests-lib/terror.c000066400000000000000000000003051300174114700166470ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_error(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/terror.reference000066400000000000000000000000051300174114700203600ustar00rootroot00000000000000errorsollya-6.0+ds/tests-lib/tevaluate_function_at_constant_expression.c000066400000000000000000000607031300174114700261150ustar00rootroot00000000000000#include #include #include const char *get_status(sollya_fp_result_t s) { switch(s) { case SOLLYA_FP_OBJ_NO_FUNCTION: return "status: SOLLYA_FP_OBJ_NO_FUNCTION"; case SOLLYA_FP_PROVEN_EXACT: return "status: SOLLYA_FP_PROVEN_EXACT"; case SOLLYA_FP_CORRECTLY_ROUNDED: return "status: SOLLYA_FP_CORRECTLY_ROUNDED"; case SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT: return "status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT"; case SOLLYA_FP_FAITHFUL_PROVEN_INEXACT: return "status: SOLLYA_FP_FAITHFUL_PROVEN_INEXACT"; case SOLLYA_FP_FAITHFUL: return "status: SOLLYA_FP_FAITHFUL"; case SOLLYA_FP_BELOW_CUTOFF: return "status: SOLLYA_FP_BELOW_CUTOFF"; case SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD: return "status: SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD"; case SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_NOT_BELOW_THRESHOLD: return "status: SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_NOT_BELOW_THRESHOLD"; case SOLLYA_FP_NOT_FAITHFUL_ZERO_NOT_CONTAINED: return "status: SOLLYA_FP_NOT_FAITHFUL_ZERO_NOT_CONTAINED"; case SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED: return "status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED"; case SOLLYA_FP_INFINITY: return "status: SOLLYA_FP_INFINITY"; case SOLLYA_FP_FAILURE: return "status: SOLLYA_FP_FAILURE"; case SOLLYA_FP_CUTOFF_IS_NAN: return "status: SOLLYA_FP_CUTOFF_IS_NAN"; case SOLLYA_FP_EXPRESSION_NOT_CONSTANT: return "status: SOLLYA_FP_EXPRESSION_NOT_CONSTANT"; default: fprintf(stderr, "Unexpected case. Exiting.\n"); exit(1); } } /* tester cutoff = NaN, +inf, négatif */ int main(void) { sollya_fp_result_t res; sollya_obj_t f, x, powers; mpfr_t y, cutoff; mpfr_init2(y, 30); mpfr_init2(cutoff, 30); sollya_lib_init(); powers = sollya_lib_powers(); sollya_lib_set_display(powers); sollya_lib_clear_obj(powers); /* Evaluate a 0-ary function */ f = SOLLYA_PI; x = SOLLYA_CONST(3); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting one of 105414357 * 2^(-25) or 843314857 * 2^(-28)\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_PI; x = SOLLYA_CONST(3); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 105414357 * 2^(-25) or 843314857 * 2^(-28)\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_PI; x = SOLLYA_CONST(3); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 105414357 * 2^(-25) or 843314857 * 2^(-28)\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate a simple expression */ f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_CONST(0)), SOLLYA_CONST(4)); x = SOLLYA_CONST(3); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting 1 * 2^(-2)\n\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate an exact expression, but it is hard to decide that it is exact */ f = SOLLYA_ADD( SOLLYA_CONST(1), SOLLYA_SUB( SOLLYA_DIV(SOLLYA_LOG10(SOLLYA_X_), SOLLYA_LOG10(SOLLYA_CONST(2))), SOLLYA_DIV(SOLLYA_LOG(SOLLYA_X_), SOLLYA_LOG(SOLLYA_CONST(2))) ) ); x = SOLLYA_DIV(SOLLYA_CONST(3), SOLLYA_PI); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting 1\n\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate an expression exactly at the middle of two fp numbers but it is hard to decide that it is exact */ f = SOLLYA_ADD( SOLLYA_ADD(SOLLYA_CONST(1), SOLLYA_POW(SOLLYA_CONST(2), SOLLYA_NEG(SOLLYA_CONST(mpfr_get_prec(y))))), SOLLYA_SUB( SOLLYA_DIV(SOLLYA_LOG10(SOLLYA_X_), SOLLYA_LOG10(SOLLYA_CONST(2))), SOLLYA_DIV(SOLLYA_LOG(SOLLYA_X_), SOLLYA_LOG(SOLLYA_CONST(2))) ) ); x = SOLLYA_DIV(SOLLYA_CONST(3), SOLLYA_PI); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting 1\n\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate a constant expression */ f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_CONST(10)); x = SOLLYA_CONST(3); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting one of 858993459 * 2^(-33) or 214748365 * 2^(-31)\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_CONST(10)); x = SOLLYA_CONST(3); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 0.01, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 858993459 * 2^(-33) or 214748365 * 2^(-31)\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_CONST(10)); x = SOLLYA_CONST(3); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate the identity at 1/10 */ f = SOLLYA_X_; x = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_CONST(10)); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting one of 858993459 * 2^(-33) or 214748365 * 2^(-31)\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_X_; x = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_CONST(10)); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 0.01, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 858993459 * 2^(-33) or 214748365 * 2^(-31)\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_X_; x = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_CONST(10)); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate a string */ f = sollya_lib_string("Hello"); x = SOLLYA_CONST(3); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate an expression exactly equal to 0 */ f = SOLLYA_SUB( SOLLYA_DIV(SOLLYA_LOG10(SOLLYA_X_), SOLLYA_LOG10(SOLLYA_CONST(2))), SOLLYA_DIV(SOLLYA_LOG(SOLLYA_X_), SOLLYA_LOG(SOLLYA_CONST(2))) ); x = SOLLYA_DIV(SOLLYA_CONST(3), SOLLYA_PI); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_SUB( SOLLYA_DIV(SOLLYA_LOG10(SOLLYA_X_), SOLLYA_LOG10(SOLLYA_CONST(2))), SOLLYA_DIV(SOLLYA_LOG(SOLLYA_X_), SOLLYA_LOG(SOLLYA_CONST(2))) ); x = SOLLYA_DIV(SOLLYA_CONST(3), SOLLYA_PI); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 0.01, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate an expression */ f = SOLLYA_EXP( SOLLYA_COS(SOLLYA_X_)); x = SOLLYA_CONST(3); mpfr_set_d(y, -17, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting one of 797960855 * 2^(-31) or 99745107 * 2^(-28)\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_EXP( SOLLYA_COS(SOLLYA_X_)); x = SOLLYA_CONST(3); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 0.01, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 797960855 * 2^(-31) or 99745107 * 2^(-28)\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_EXP( SOLLYA_COS(SOLLYA_X_)); x = SOLLYA_CONST(3); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 797960855 * 2^(-31) or 99745107 * 2^(-28)\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate a very small expression */ f = SOLLYA_EXP(SOLLYA_X_); x = SOLLYA_CONST(-100); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting one of 890781225 * 2^(-174) or 445390613 * 2^(-173)\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_EXP(SOLLYA_X_); x = SOLLYA_CONST(-100); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 890781225 * 2^(-174) or 445390613 * 2^(-173)\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_EXP(SOLLYA_X_); x = SOLLYA_CONST(-100); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 890781225 * 2^(-174) or 445390613 * 2^(-173)\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate an undefined expression */ f = SOLLYA_TAN(SOLLYA_X_); x = SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2)); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_TAN(SOLLYA_X_); x = SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2)); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_TAN(SOLLYA_X_); x = SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2)); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate an expression at a point where its value is +Inf */ f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_POW(SOLLYA_X_, SOLLYA_CONST(2))); x = SOLLYA_CONST(0); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_POW(SOLLYA_X_, SOLLYA_CONST(2))); x = SOLLYA_CONST(0); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_POW(SOLLYA_X_, SOLLYA_CONST(2))); x = SOLLYA_CONST(0); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate an expression at a point where it is undefined */ f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_X_); x = SOLLYA_CONST(0); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_X_); x = SOLLYA_CONST(0); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_X_); x = SOLLYA_CONST(0); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate an expression at a point on the boundary of its domain */ f = SOLLYA_LOG(SOLLYA_X_); x = SOLLYA_CONST(0); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_LOG(SOLLYA_X_); x = SOLLYA_CONST(0); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_LOG(SOLLYA_X_); x = SOLLYA_CONST(0); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate an expression at a point outside of its domain */ f = SOLLYA_LOG(SOLLYA_X_); x = SOLLYA_CONST(-1); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_LOG(SOLLYA_X_); x = SOLLYA_CONST(-1); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_LOG(SOLLYA_X_); x = SOLLYA_CONST(-1); mpfr_set_d(y, -17, GMP_RNDN); mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate an expression at a point where it is very close to 0, but not zero */ f = sollya_lib_parse_string("sin(pi/3)-x+1b-100000"); x = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = sollya_lib_parse_string("sin(pi/3)-x+1b-100000"); x = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = sollya_lib_parse_string("sin(pi/3)-x+1b-100000"); x = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); mpfr_set_d(y, -17, GMP_RNDN); mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Evaluate tricky expressions. */ f = sollya_lib_parse_string("(sin(pi/3)-x)*1b100000+3"); x = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = sollya_lib_parse_string("(sin(pi/3)-x)*1b100000+1b60000"); x = SOLLYA_DIV(SOLLYA_SQRT(SOLLYA_CONST(3)), SOLLYA_CONST(2)); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = sollya_lib_parse_string("3+7b-31*sin(1/(280b-18000 + (sin(pi/6)-x)))"); x = SOLLYA_CONST(0.5); mpfr_set_d(y, -17, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Trying negative cutoff, infinite cutoff and NaN cutoff */ f = sollya_lib_parse_string("sin(pi/6)-x+1b-100000"); x = SOLLYA_CONST(0.5); mpfr_set_d(y, -17, GMP_RNDN); mpfr_set_d(cutoff, -4., GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = sollya_lib_parse_string("sin(pi/6)-x+1b-100000"); x = SOLLYA_CONST(0.5); mpfr_set_d(y, -17, GMP_RNDN); mpfr_set_inf(cutoff, 1); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = sollya_lib_parse_string("sin(pi/6)-x+1b-100000"); x = SOLLYA_CONST(0.5); mpfr_set_d(y, -17, GMP_RNDN); mpfr_set_nan(cutoff); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); /* Cases when the constant function argument is not a constant function */ f = SOLLYA_X_; x = SOLLYA_X_; mpfr_set_d(y, -17, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = SOLLYA_X_; x = sollya_lib_string("Hello"); mpfr_set_d(y, -17, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); f = sollya_lib_string("Hello"); x = SOLLYA_X_; mpfr_set_d(y, -17, GMP_RNDN); res = sollya_lib_evaluate_function_at_constant_expression(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %b with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); sollya_lib_clear_obj(x); mpfr_clear(y); mpfr_clear(cutoff); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tevaluate_function_at_constant_expression.reference000066400000000000000000000165721300174114700276360ustar00rootroot00000000000000Trying to faithfuly evaluate pi at 3 with cutoff NULL: returns 843314857 * 2^(-28) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 105414357 * 2^(-25) or 843314857 * 2^(-28) Trying to faithfuly evaluate pi at 3 with cutoff 1: returns 843314857 * 2^(-28) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 105414357 * 2^(-25) or 843314857 * 2^(-28) Trying to faithfuly evaluate pi at 3 with cutoff 4: returns 843314857 * 2^(-28) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 105414357 * 2^(-25) or 843314857 * 2^(-28) Trying to faithfuly evaluate exp(0) / 4 at 3 with cutoff NULL: returns 1 * 2^(-2) (status: SOLLYA_FP_PROVEN_EXACT) -- expecting 1 * 2^(-2) Trying to faithfuly evaluate 1 + log10(_x_) / log10(2) - log(_x_) / log(2) at 3 / (pi) with cutoff NULL: returns 1 (status: SOLLYA_FP_CORRECTLY_ROUNDED) -- expecting 1 Trying to faithfuly evaluate 1 + 2^(-30) + log10(_x_) / log10(2) - log(_x_) / log(2) at 3 / (pi) with cutoff NULL: returns 1 (status: SOLLYA_FP_FAITHFUL_PROVEN_INEXACT) -- expecting 1 Trying to faithfuly evaluate 1 / 10 at 3 with cutoff NULL: returns 858993459 * 2^(-33) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 858993459 * 2^(-33) or 214748365 * 2^(-31) Trying to faithfuly evaluate 1 / 10 at 3 with cutoff 687194767 * 2^(-36): returns 858993459 * 2^(-33) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 858993459 * 2^(-33) or 214748365 * 2^(-31) Trying to faithfuly evaluate 1 / 10 at 3 with cutoff 4: returns 858993459 * 2^(-33) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) Trying to faithfuly evaluate _x_ at 1 / 10 with cutoff NULL: returns 858993459 * 2^(-33) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 858993459 * 2^(-33) or 214748365 * 2^(-31) Trying to faithfuly evaluate _x_ at 1 / 10 with cutoff 687194767 * 2^(-36): returns 858993459 * 2^(-33) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 858993459 * 2^(-33) or 214748365 * 2^(-31) Trying to faithfuly evaluate _x_ at 1 / 10 with cutoff 4: returns 858993459 * 2^(-33) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) Trying to faithfuly evaluate Hello at 3 with cutoff NULL: returns NaN (status: SOLLYA_FP_OBJ_NO_FUNCTION) Trying to faithfuly evaluate log10(_x_) / log10(2) - log(_x_) / log(2) at 3 / (pi) with cutoff NULL: returns 0 (status: SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD) Trying to faithfuly evaluate log10(_x_) / log10(2) - log(_x_) / log(2) at 3 / (pi) with cutoff 687194767 * 2^(-36): returns 0 (status: SOLLYA_FP_BELOW_CUTOFF) Trying to faithfuly evaluate exp(cos(_x_)) at 3 with cutoff NULL: returns 797960855 * 2^(-31) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 797960855 * 2^(-31) or 99745107 * 2^(-28) Trying to faithfuly evaluate exp(cos(_x_)) at 3 with cutoff 687194767 * 2^(-36): returns 797960855 * 2^(-31) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 797960855 * 2^(-31) or 99745107 * 2^(-28) Trying to faithfuly evaluate exp(cos(_x_)) at 3 with cutoff 4: returns 797960855 * 2^(-31) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 797960855 * 2^(-31) or 99745107 * 2^(-28) Trying to faithfuly evaluate exp(_x_) at -100 with cutoff NULL: returns 445390613 * 2^(-173) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 890781225 * 2^(-174) or 445390613 * 2^(-173) Trying to faithfuly evaluate exp(_x_) at -100 with cutoff 502168139 * 2^(-195): returns 445390613 * 2^(-173) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 890781225 * 2^(-174) or 445390613 * 2^(-173) Trying to faithfuly evaluate exp(_x_) at -100 with cutoff 4: returns 445390613 * 2^(-173) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 890781225 * 2^(-174) or 445390613 * 2^(-173) Trying to faithfuly evaluate tan(_x_) at (pi) / 2 with cutoff NULL: returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate tan(_x_) at (pi) / 2 with cutoff 502168139 * 2^(-195): returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate tan(_x_) at (pi) / 2 with cutoff 4: returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate 1 / _x_^2 at 0 with cutoff NULL: returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate 1 / _x_^2 at 0 with cutoff 502168139 * 2^(-195): returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate 1 / _x_^2 at 0 with cutoff 4: returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate 1 / _x_ at 0 with cutoff NULL: returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate 1 / _x_ at 0 with cutoff 502168139 * 2^(-195): returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate 1 / _x_ at 0 with cutoff 4: returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate log(_x_) at 0 with cutoff NULL: returns -infty (status: SOLLYA_FP_INFINITY) Trying to faithfuly evaluate log(_x_) at 0 with cutoff 502168139 * 2^(-195): returns -infty (status: SOLLYA_FP_INFINITY) Trying to faithfuly evaluate log(_x_) at 0 with cutoff 4: returns -infty (status: SOLLYA_FP_INFINITY) Trying to faithfuly evaluate log(_x_) at -1 with cutoff NULL: returns NaN (status: SOLLYA_FP_FAILURE) Trying to faithfuly evaluate log(_x_) at -1 with cutoff 502168139 * 2^(-195): returns NaN (status: SOLLYA_FP_FAILURE) Trying to faithfuly evaluate log(_x_) at -1 with cutoff 4: returns NaN (status: SOLLYA_FP_FAILURE) Trying to faithfuly evaluate sin((pi) / 3) - x + (1 * 2^(-100000)) at sqrt(3) / 2 with cutoff NULL: returns 0 (status: SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD) Trying to faithfuly evaluate sin((pi) / 3) - x + (1 * 2^(-100000)) at sqrt(3) / 2 with cutoff 502168139 * 2^(-195): returns 0 (status: SOLLYA_FP_BELOW_CUTOFF) Trying to faithfuly evaluate sin((pi) / 3) - x + (1 * 2^(-100000)) at sqrt(3) / 2 with cutoff 4: returns 0 (status: SOLLYA_FP_BELOW_CUTOFF) Trying to faithfuly evaluate (sin((pi) / 3) - x) * (1 * 2^100000) + 3 at sqrt(3) / 2 with cutoff NULL: returns 411 * 2^57739 (status: SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_NOT_BELOW_THRESHOLD) Trying to faithfuly evaluate (sin((pi) / 3) - x) * (1 * 2^100000) + (1 * 2^60000) at sqrt(3) / 2 with cutoff NULL: returns 1 * 2^60000 (status: SOLLYA_FP_NOT_FAITHFUL_ZERO_NOT_CONTAINED) Trying to faithfuly evaluate 3 + 7 * 2^(-31) * sin(1 / (35 * 2^(-17997) + sin((pi) / 6) - x)) at 1 * 2^(-1) with cutoff NULL: returns 3 (status: SOLLYA_FP_FAITHFUL) Trying to faithfuly evaluate sin((pi) / 6) - x + (1 * 2^(-100000)) at 1 * 2^(-1) with cutoff -4: returns 0 (status: SOLLYA_FP_BELOW_CUTOFF) Trying to faithfuly evaluate sin((pi) / 6) - x + (1 * 2^(-100000)) at 1 * 2^(-1) with cutoff infty: returns 0 (status: SOLLYA_FP_BELOW_CUTOFF) Trying to faithfuly evaluate sin((pi) / 6) - x + (1 * 2^(-100000)) at 1 * 2^(-1) with cutoff NaN: returns NaN (status: SOLLYA_FP_CUTOFF_IS_NAN) Trying to faithfuly evaluate x at x with cutoff NULL: returns NaN (status: SOLLYA_FP_EXPRESSION_NOT_CONSTANT) Trying to faithfuly evaluate x at Hello with cutoff NULL: returns NaN (status: SOLLYA_FP_OBJ_NO_FUNCTION) Trying to faithfuly evaluate Hello at x with cutoff NULL: returns NaN (status: SOLLYA_FP_OBJ_NO_FUNCTION) sollya-6.0+ds/tests-lib/tevaluate_function_at_point.c000066400000000000000000000502251300174114700231340ustar00rootroot00000000000000#include #include #include const char *get_status(sollya_fp_result_t s) { switch(s) { case SOLLYA_FP_OBJ_NO_FUNCTION: return "status: SOLLYA_FP_OBJ_NO_FUNCTION"; case SOLLYA_FP_PROVEN_EXACT: return "status: SOLLYA_FP_PROVEN_EXACT"; case SOLLYA_FP_CORRECTLY_ROUNDED: return "status: SOLLYA_FP_CORRECTLY_ROUNDED"; case SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT: return "status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT"; case SOLLYA_FP_FAITHFUL_PROVEN_INEXACT: return "status: SOLLYA_FP_FAITHFUL_PROVEN_INEXACT"; case SOLLYA_FP_FAITHFUL: return "status: SOLLYA_FP_FAITHFUL"; case SOLLYA_FP_BELOW_CUTOFF: return "status: SOLLYA_FP_BELOW_CUTOFF"; case SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD: return "status: SOLLYA_SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD"; case SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_NOT_BELOW_THRESHOLD: return "status: SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_NOT_BELOW_THRESHOLD"; case SOLLYA_FP_NOT_FAITHFUL_ZERO_NOT_CONTAINED: return "status: SOLLYA_FP_NOT_FAITHFUL_ZERO_NOT_CONTAINED"; case SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED: return "status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED"; case SOLLYA_FP_INFINITY: return "status: SOLLYA_FP_INFINITY"; case SOLLYA_FP_FAILURE: return "status: SOLLYA_FP_FAILURE"; case SOLLYA_FP_CUTOFF_IS_NAN: return "status: SOLLYA_FP_CUTOFF_IS_NAN"; default: fprintf(stderr, "Unexpected case. Exiting.\n"); exit(1); } } int main(void) { sollya_fp_result_t res; sollya_obj_t f, powers; mpfr_t x,y, cutoff; mpfr_init2(y, 30); mpfr_init2(x, 30); mpfr_init2(cutoff, 30); sollya_lib_init(); powers = sollya_lib_powers(); sollya_lib_set_display(powers); sollya_lib_clear_obj(powers); /* Evaluate a 0-ary function */ f = SOLLYA_PI; mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting one of 105414357 * 2^(-25) or 843314857 * 2^(-28)\n"); sollya_lib_clear_obj(f); f = SOLLYA_PI; mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1., GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 105414357 * 2^(-25) or 843314857 * 2^(-28)\n"); sollya_lib_clear_obj(f); f = SOLLYA_PI; mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 105414357 * 2^(-25) or 843314857 * 2^(-28)\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Evaluate a simple expression */ f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_CONST(0)), SOLLYA_CONST(4)); mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting 1 * 2^(-2)\n\n"); sollya_lib_clear_obj(f); /* Evaluate an exact expression, but it is hard to decide that it is exact */ f = SOLLYA_ADD( SOLLYA_CONST(1), SOLLYA_SUB( SOLLYA_DIV(SOLLYA_LOG10(SOLLYA_X_), SOLLYA_LOG10(SOLLYA_CONST(2))), SOLLYA_DIV(SOLLYA_LOG(SOLLYA_X_), SOLLYA_LOG(SOLLYA_CONST(2))) ) ); mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting 1\n\n"); sollya_lib_clear_obj(f); /* Evaluate an expression exactly at the middle of two fp numbers but it is hard to decide that it is exact */ f = SOLLYA_ADD( SOLLYA_ADD(SOLLYA_CONST(1), SOLLYA_POW(SOLLYA_CONST(2), SOLLYA_NEG(SOLLYA_CONST(mpfr_get_prec(y))))), SOLLYA_SUB( SOLLYA_DIV(SOLLYA_LOG10(SOLLYA_X_), SOLLYA_LOG10(SOLLYA_CONST(2))), SOLLYA_DIV(SOLLYA_LOG(SOLLYA_X_), SOLLYA_LOG(SOLLYA_CONST(2))) ) ); mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting 1 or 536870913 * 2^(-29)\n\n"); sollya_lib_clear_obj(f); /* Evaluate a constant expression */ f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_CONST(10)); mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting one of 858993459 * 2^(-33) or 214748365 * 2^(-31)\n"); sollya_lib_clear_obj(f); f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_CONST(10)); mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 0.01, GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 858993459 * 2^(-33) or 214748365 * 2^(-31)\n"); sollya_lib_clear_obj(f); f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_CONST(10)); mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Evaluate a string */ f = sollya_lib_string("Hello"); mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Evaluate an expression exactly equal to 0 */ f = SOLLYA_SUB( SOLLYA_DIV(SOLLYA_LOG10(SOLLYA_X_), SOLLYA_LOG10(SOLLYA_CONST(2))), SOLLYA_DIV(SOLLYA_LOG(SOLLYA_X_), SOLLYA_LOG(SOLLYA_CONST(2))) ); mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = SOLLYA_SUB( SOLLYA_DIV(SOLLYA_LOG10(SOLLYA_X_), SOLLYA_LOG10(SOLLYA_CONST(2))), SOLLYA_DIV(SOLLYA_LOG(SOLLYA_X_), SOLLYA_LOG(SOLLYA_CONST(2))) ); mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 0.01, GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Evaluate an expression */ f = SOLLYA_EXP( SOLLYA_COS(SOLLYA_X_)); mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting one of 797960855 * 2^(-31) or 99745107 * 2^(-28)\n"); sollya_lib_clear_obj(f); f = SOLLYA_EXP( SOLLYA_COS(SOLLYA_X_)); mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 0.01, GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 797960855 * 2^(-31) or 99745107 * 2^(-28)\n"); sollya_lib_clear_obj(f); f = SOLLYA_EXP( SOLLYA_COS(SOLLYA_X_)); mpfr_set_d(x, 3, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 797960855 * 2^(-31) or 99745107 * 2^(-28)\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Evaluate a very small expression */ f = SOLLYA_EXP(SOLLYA_X_); mpfr_set_d(x, -100, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf(" -- expecting one of 890781225 * 2^(-174) or 445390613 * 2^(-173)\n"); sollya_lib_clear_obj(f); f = SOLLYA_EXP(SOLLYA_X_); mpfr_set_d(x, -100, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 890781225 * 2^(-174) or 445390613 * 2^(-173)\n"); sollya_lib_clear_obj(f); f = SOLLYA_EXP(SOLLYA_X_); mpfr_set_d(x, -100, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf(" -- expecting one of 890781225 * 2^(-174) or 445390613 * 2^(-173)\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Evaluate an undefined expression */ f = SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))); mpfr_set_d(x, -100, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))); mpfr_set_d(x, -100, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = SOLLYA_TAN(SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(2))); mpfr_set_d(x, -100, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Evaluate an expression at a point where its value is +Inf */ f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_POW(SOLLYA_X_, SOLLYA_CONST(2))); mpfr_set_d(x, 0, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_POW(SOLLYA_X_, SOLLYA_CONST(2))); mpfr_set_d(x, 0, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_POW(SOLLYA_X_, SOLLYA_CONST(2))); mpfr_set_d(x, 0, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Evaluate an expression at a point where it is undefined */ f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_X_); mpfr_set_d(x, 0, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_X_); mpfr_set_d(x, 0, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_X_); mpfr_set_d(x, 0, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Evaluate an expression at a point on the boundary of its domain */ f = SOLLYA_LOG(SOLLYA_X_); mpfr_set_d(x, 0, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = SOLLYA_LOG(SOLLYA_X_); mpfr_set_d(x, 0, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = SOLLYA_LOG(SOLLYA_X_); mpfr_set_d(x, 0, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Evaluate an expression at a point outside of its domain */ f = SOLLYA_LOG(SOLLYA_X_); mpfr_set_d(x, -1, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = SOLLYA_LOG(SOLLYA_X_); mpfr_set_d(x, -1, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = SOLLYA_LOG(SOLLYA_X_); mpfr_set_d(x, -1, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN); mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Evaluate an expression at a point where it is very close to 0, but not zero */ f = sollya_lib_parse_string("sin(pi/6)-x+1b-100000"); mpfr_set_d(x, 0.5, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("sin(pi/6)-x+1b-100000"); mpfr_set_d(x, 0.5, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; mpfr_set_d(cutoff, 1e-50, GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("sin(pi/6)-x+1b-100000"); mpfr_set_d(x, 0.5, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN); mpfr_set_d(cutoff, 4., GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Evaluate tricky expressions. */ f = sollya_lib_parse_string("(sin(pi/6)-x)*1b50000+3"); mpfr_set_d(x, 0.5, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("(sin(pi/6)-x)*1b50000+1b25000"); mpfr_set_d(x, 0.5, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN);; res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("3+7b-31*sin(1/(280b-18000 + (sin(pi/6)-x)))"); mpfr_set_d(x, 0.5, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff NULL: returns %v (%s)", f, x, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); /* Trying negative cutoff, infinite cutoff and NaN cutoff */ f = sollya_lib_parse_string("sin(pi/6)-x+1b-100000"); mpfr_set_d(x, 0.5, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN); mpfr_set_d(cutoff, -4., GMP_RNDN); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("sin(pi/6)-x+1b-100000"); mpfr_set_d(x, 0.5, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN); mpfr_set_inf(cutoff, 1); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("sin(pi/6)-x+1b-100000"); mpfr_set_d(x, 0.5, GMP_RNDN); mpfr_set_d(y, -17, GMP_RNDN); mpfr_set_nan(cutoff); res = sollya_lib_evaluate_function_at_point(y, f, x, &cutoff); sollya_lib_printf("Trying to faithfuly evaluate %b at %v with cutoff %v: returns %v (%s)", f, x, cutoff, y, get_status(res)); sollya_lib_printf("\n"); sollya_lib_clear_obj(f); mpfr_clear(x); mpfr_clear(y); mpfr_clear(cutoff); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tevaluate_function_at_point.reference000066400000000000000000000150041300174114700246440ustar00rootroot00000000000000Trying to faithfuly evaluate pi at 3 with cutoff NULL: returns 843314857 * 2^(-28) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 105414357 * 2^(-25) or 843314857 * 2^(-28) Trying to faithfuly evaluate pi at 3 with cutoff 1: returns 843314857 * 2^(-28) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 105414357 * 2^(-25) or 843314857 * 2^(-28) Trying to faithfuly evaluate pi at 3 with cutoff 4: returns 843314857 * 2^(-28) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 105414357 * 2^(-25) or 843314857 * 2^(-28) Trying to faithfuly evaluate exp(0) / 4 at 3 with cutoff NULL: returns 1 * 2^(-2) (status: SOLLYA_FP_PROVEN_EXACT) -- expecting 1 * 2^(-2) Trying to faithfuly evaluate 1 + log10(_x_) / log10(2) - log(_x_) / log(2) at 3 with cutoff NULL: returns 1 (status: SOLLYA_FP_CORRECTLY_ROUNDED) -- expecting 1 Trying to faithfuly evaluate 1 + 2^(-30) + log10(_x_) / log10(2) - log(_x_) / log(2) at 3 with cutoff NULL: returns 1 (status: SOLLYA_FP_FAITHFUL_PROVEN_INEXACT) -- expecting 1 or 536870913 * 2^(-29) Trying to faithfuly evaluate 1 / 10 at 3 with cutoff NULL: returns 858993459 * 2^(-33) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 858993459 * 2^(-33) or 214748365 * 2^(-31) Trying to faithfuly evaluate 1 / 10 at 3 with cutoff 687194767 * 2^(-36): returns 858993459 * 2^(-33) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 858993459 * 2^(-33) or 214748365 * 2^(-31) Trying to faithfuly evaluate 1 / 10 at 3 with cutoff 4: returns 858993459 * 2^(-33) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) Trying to faithfuly evaluate Hello at 3 with cutoff NULL: returns NaN (status: SOLLYA_FP_OBJ_NO_FUNCTION) Trying to faithfuly evaluate log10(_x_) / log10(2) - log(_x_) / log(2) at 3 with cutoff NULL: returns 0 (status: SOLLYA_SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD) Trying to faithfuly evaluate log10(_x_) / log10(2) - log(_x_) / log(2) at 3 with cutoff 687194767 * 2^(-36): returns 0 (status: SOLLYA_FP_BELOW_CUTOFF) Trying to faithfuly evaluate exp(cos(_x_)) at 3 with cutoff NULL: returns 797960855 * 2^(-31) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 797960855 * 2^(-31) or 99745107 * 2^(-28) Trying to faithfuly evaluate exp(cos(_x_)) at 3 with cutoff 687194767 * 2^(-36): returns 797960855 * 2^(-31) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 797960855 * 2^(-31) or 99745107 * 2^(-28) Trying to faithfuly evaluate exp(cos(_x_)) at 3 with cutoff 4: returns 797960855 * 2^(-31) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 797960855 * 2^(-31) or 99745107 * 2^(-28) Trying to faithfuly evaluate exp(_x_) at -100 with cutoff NULL: returns 445390613 * 2^(-173) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 890781225 * 2^(-174) or 445390613 * 2^(-173) Trying to faithfuly evaluate exp(_x_) at -100 with cutoff 502168139 * 2^(-195): returns 445390613 * 2^(-173) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 890781225 * 2^(-174) or 445390613 * 2^(-173) Trying to faithfuly evaluate exp(_x_) at -100 with cutoff 4: returns 445390613 * 2^(-173) (status: SOLLYA_FP_CORRECTLY_ROUNDED_PROVEN_INEXACT) -- expecting one of 890781225 * 2^(-174) or 445390613 * 2^(-173) Trying to faithfuly evaluate tan((pi) / 2) at -100 with cutoff NULL: returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate tan((pi) / 2) at -100 with cutoff 502168139 * 2^(-195): returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate tan((pi) / 2) at -100 with cutoff 4: returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate 1 / _x_^2 at 0 with cutoff NULL: returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate 1 / _x_^2 at 0 with cutoff 502168139 * 2^(-195): returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate 1 / _x_^2 at 0 with cutoff 4: returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate 1 / _x_ at 0 with cutoff NULL: returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate 1 / _x_ at 0 with cutoff 502168139 * 2^(-195): returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate 1 / _x_ at 0 with cutoff 4: returns NaN (status: SOLLYA_FP_NOT_FAITHFUL_INFINITY_CONTAINED) Trying to faithfuly evaluate log(_x_) at 0 with cutoff NULL: returns -infty (status: SOLLYA_FP_INFINITY) Trying to faithfuly evaluate log(_x_) at 0 with cutoff 502168139 * 2^(-195): returns -infty (status: SOLLYA_FP_INFINITY) Trying to faithfuly evaluate log(_x_) at 0 with cutoff 4: returns -infty (status: SOLLYA_FP_INFINITY) Trying to faithfuly evaluate log(_x_) at -1 with cutoff NULL: returns NaN (status: SOLLYA_FP_FAILURE) Trying to faithfuly evaluate log(_x_) at -1 with cutoff 502168139 * 2^(-195): returns NaN (status: SOLLYA_FP_FAILURE) Trying to faithfuly evaluate log(_x_) at -1 with cutoff 4: returns NaN (status: SOLLYA_FP_FAILURE) Trying to faithfuly evaluate sin((pi) / 6) - x + (1 * 2^(-100000)) at 1 * 2^(-1) with cutoff NULL: returns 0 (status: SOLLYA_SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_BELOW_THRESHOLD) Trying to faithfuly evaluate sin((pi) / 6) - x + (1 * 2^(-100000)) at 1 * 2^(-1) with cutoff 502168139 * 2^(-195): returns 0 (status: SOLLYA_FP_BELOW_CUTOFF) Trying to faithfuly evaluate sin((pi) / 6) - x + (1 * 2^(-100000)) at 1 * 2^(-1) with cutoff 4: returns 0 (status: SOLLYA_FP_BELOW_CUTOFF) Trying to faithfuly evaluate (sin((pi) / 6) - x) * (1 * 2^50000) + 3 at 1 * 2^(-1) with cutoff NULL: returns 1 * 2^7738 (status: SOLLYA_FP_NOT_FAITHFUL_ZERO_CONTAINED_NOT_BELOW_THRESHOLD) Trying to faithfuly evaluate (sin((pi) / 6) - x) * (1 * 2^50000) + (1 * 2^25000) at 1 * 2^(-1) with cutoff NULL: returns 1 * 2^25000 (status: SOLLYA_FP_NOT_FAITHFUL_ZERO_NOT_CONTAINED) Trying to faithfuly evaluate 3 + 7 * 2^(-31) * sin(1 / (35 * 2^(-17997) + sin((pi) / 6) - x)) at 1 * 2^(-1) with cutoff NULL: returns 3 (status: SOLLYA_FP_FAITHFUL) Trying to faithfuly evaluate sin((pi) / 6) - x + (1 * 2^(-100000)) at 1 * 2^(-1) with cutoff -4: returns 0 (status: SOLLYA_FP_BELOW_CUTOFF) Trying to faithfuly evaluate sin((pi) / 6) - x + (1 * 2^(-100000)) at 1 * 2^(-1) with cutoff infty: returns 0 (status: SOLLYA_FP_BELOW_CUTOFF) Trying to faithfuly evaluate sin((pi) / 6) - x + (1 * 2^(-100000)) at 1 * 2^(-1) with cutoff NaN: returns NaN (status: SOLLYA_FP_CUTOFF_IS_NAN) sollya-6.0+ds/tests-lib/texecute.c000066400000000000000000000027101300174114700171620ustar00rootroot00000000000000#include #include #include #include #define FILENAME_SUFFIX ".tmp" int callback(sollya_msg_t msg, void *data) { (void)msg; /* Avoiding "unused parameter" warning */ (void)data; /* Avoiding "unused parameter" warning */ return 0; } int main(int argc, char **argv) { char *tempFile; int fopenerr, fcloseerr; FILE *fd; sollya_obj_t fileObj; if (argc < 1) return 1; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); tempFile = (char *) sollya_lib_calloc(strlen(argv[0]) + strlen(FILENAME_SUFFIX) + 1, sizeof(char)); strcpy(tempFile, argv[0]); strcpy(tempFile + strlen(argv[0]), FILENAME_SUFFIX); if ((fd = fopen(tempFile, "w")) == NULL) { fopenerr = errno; fprintf(stderr, "Error opening temporary file \"%s\": \"%s\"\n", tempFile, strerror(fopenerr)); sollya_lib_free(tempFile); sollya_lib_close(); return 1; } fprintf(fd, "f = exp(x);\nf(5);\nprocedure a(f,n) {\n \"f = \", f;\n \"n = \", n;\n f(n);\n return f(n);\n};\nt = a(f + sin(x),5);\nprint(t);\n"); if (fclose(fd) != 0) { fcloseerr = errno; fprintf(stderr, "Error closing temporary file \"%s\": \"%s\"\n", tempFile, strerror(fcloseerr)); sollya_lib_free(tempFile); sollya_lib_close(); return 1; } fileObj = sollya_lib_string(tempFile); sollya_lib_free(tempFile); sollya_lib_execute(fileObj); sollya_lib_clear_obj(fileObj); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/texecute.reference000066400000000000000000000002231300174114700206730ustar00rootroot00000000000000148.41315910257660342111558004055227962348766759388 f = exp(x) + sin(x) n = 5 147.454234827913464952222425634396285650135206049916 exp(5) + sin(5) sollya-6.0+ds/tests-lib/texecute_procedure.c000066400000000000000000000040411300174114700212310ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)msg; /* Avoiding "unused parameter" warning */ (void)data; /* Avoiding "unused parameter" warning */ return 0; } int main(void) { sollya_obj_t proc1, proc2, proc3, one, two, three, proc1Res, proc1Resb, proc1Resc, proc2Res, proc3Res, proc3Resb; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); proc1 = sollya_lib_parse_string("proc (a,b) { \"a = \", a, \", b = \", b; return a + b; }"); proc2 = sollya_lib_parse_string("proc () { write(\"Coucou\\n\"); }"); proc3 = sollya_lib_parse_string("proc (l = ...) { \"l = \", l; return exp(_x_); }"); one = SOLLYA_CONST_SI64(1); two = SOLLYA_CONST_SI64(2); three = SOLLYA_CONST_SI64(3); proc1Res = sollya_lib_execute_procedure(proc1, one, two, NULL); proc1Resb = sollya_lib_execute_procedure(proc1, one, NULL); proc1Resc = sollya_lib_execute_procedure(proc1, one, two, three, NULL); proc2Res = sollya_lib_execute_procedure(proc2, NULL); proc3Res = sollya_lib_execute_procedure(proc3, one, two, three, NULL); proc3Resb = sollya_lib_execute_procedure(proc3, NULL); sollya_lib_printf("proc1 = %b, args = %b, %b: result = %b\n", proc1, one, two, proc1Res); sollya_lib_printf("proc1 = %b, args = %b: result = %b\n", proc1, one, proc1Resb); sollya_lib_printf("proc1 = %b, args = %b, %b, %b: result = %b\n", proc1, one, two, three, proc1Resc); sollya_lib_printf("proc2 = %b: result = %b\n", proc2, proc2Res); sollya_lib_printf("proc3 = %b, args = %b, %b, %b: result = %b\n", proc3, one, two, three, proc3Res); sollya_lib_printf("proc3 = %b: result = %b\n", proc3, proc3Resb); sollya_lib_clear_obj(proc3Res); sollya_lib_clear_obj(proc3Resb); sollya_lib_clear_obj(proc2Res); sollya_lib_clear_obj(proc1Res); sollya_lib_clear_obj(proc1Resb); sollya_lib_clear_obj(proc1Resc); sollya_lib_clear_obj(three); sollya_lib_clear_obj(two); sollya_lib_clear_obj(one); sollya_lib_clear_obj(proc3); sollya_lib_clear_obj(proc2); sollya_lib_clear_obj(proc1); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/texecute_procedure.reference000066400000000000000000000010531300174114700227450ustar00rootroot00000000000000a = 1, b = 2 Coucou l = [|1, 2, 3|] l = [|void|] proc1 = proc(a, b) { "a = ", a, ", b = ", b; return (a) + (b); }, args = 1, 2: result = 3 proc1 = proc(a, b) { "a = ", a, ", b = ", b; return (a) + (b); }, args = 1: result = error proc1 = proc(a, b) { "a = ", a, ", b = ", b; return (a) + (b); }, args = 1, 2, 3: result = error proc2 = proc() { write("Coucou\n"); return void; }: result = void proc3 = proc(l = ...) { "l = ", l; return exp(_x_); }, args = 1, 2, 3: result = exp(_x_) proc3 = proc(l = ...) { "l = ", l; return exp(_x_); }: result = exp(_x_) sollya-6.0+ds/tests-lib/texp.c000066400000000000000000000004141300174114700163130ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_exp(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/texp.reference000066400000000000000000000000101300174114700200170ustar00rootroot00000000000000exp(_x_)sollya-6.0+ds/tests-lib/texpand.c000066400000000000000000000021151300174114700167760ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a[7], b[7]; int i; sollya_lib_init(); a[0] = SOLLYA_POW(SOLLYA_SUB(SOLLYA_POW(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_CONST(2.0),SOLLYA_X_),SOLLYA_CONST(-3.0)),SOLLYA_CONST(3)),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(5))),SOLLYA_CONST(2.0)); /* ( (2x+(-3))^3 - x^5 )^2 = 729 - 2916*x + 4860*x^2 - 4320*x^3 + 2160*x^4 - 522*x^5 - 44*x^6 + 72*x^7 - 16*x^8 + x^10 */ a[1] = SOLLYA_EXP(SOLLYA_X_); a[2] = sollya_lib_parse_string("(x+3)^3 + sin((x+3)^3)"); a[3] = sollya_lib_parse_string("horner((x^4 + x^2 + ((x + 3)^2)/(x + 4))^3)"); a[4] = sollya_lib_parse_string("(((x + 1)/(x + 2)) * ((x + 3)/(x + 4)))/(((x + 5)/(x + 6)) * ((x + 7)/(x + 8)))"); a[5] = sollya_lib_parse_string("(((x + 1)/(x + 2)) * ((x + 3)/(x + 4)))/x"); a[6] = sollya_lib_parse_string("expand( (x+3)^3 )"); for (i=0;i<7;i++) { b[i] = sollya_lib_expand(a[i]); sollya_lib_printf("%b after a call to 'expand' becomes %b.\n",a[i],b[i]); } for (i=0;i<7;i++) { sollya_lib_clear_obj(a[i]); sollya_lib_clear_obj(b[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/texpand.reference000066400000000000000000000022411300174114700205120ustar00rootroot00000000000000((2 * x + (-3))^3 - x^5)^2 after a call to 'expand' becomes x * x * x * x * x * x * x * x * x * x + 54 * x * x * x * x * x + -108 * x * x * x * x * x * x + 72 * x * x * x * x * x * x * x + -16 * x * x * x * x * x * x * x * x + x * x * x * x * x * x * 64 + x * x * x * (-432) + 108 * x * x * x * x * 8 + -72 * x * x * x * x * x * 8 + 1296 * x * x * x * x + x * x * 1944 + 108 * x * -36 * x * x + 2916 * x * x + x * (-2916) + 729. exp(x) after a call to 'expand' becomes exp(x). (x + 3)^3 + sin((x + 3)^3) after a call to 'expand' becomes 27 + 27 * x + 9 * x * x + x * x * x + sin(27 + 27 * x + 9 * x * x + x * x * x). (x^2 * (1 + x^2) + (9 + x * (6 + x)) / (4 + x))^3 after a call to 'expand' becomes (x * x + x * x * x * x + (9 + 6 * x + x * x) / (4 + x))^3. ((x + 1) / (x + 2) * (x + 3) / (x + 4)) / ((x + 5) / (x + 6) * (x + 7) / (x + 8)) after a call to 'expand' becomes ((x + 1) / (x + 2) * (x + 3) / (x + 4)) / ((x + 5) / (x + 6) * (x + 7) / (x + 8)). ((x + 1) / (x + 2) * (x + 3) / (x + 4)) / x after a call to 'expand' becomes ((x + 1) / (x + 2) * (x + 3) / (x + 4)) / x. 27 + 27 * x + 9 * x * x + x * x * x after a call to 'expand' becomes 27 + 27 * x + x * x * 9 + x * x * x. sollya-6.0+ds/tests-lib/texpm1.c000066400000000000000000000004161300174114700165530ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_expm1(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/texpm1.reference000066400000000000000000000000121300174114700202570ustar00rootroot00000000000000expm1(_x_)sollya-6.0+ds/tests-lib/texternalprocedure.c000066400000000000000000000076451300174114700212670ustar00rootroot00000000000000#include #include #include #include #include int successor_impl(int a) { return a + 1; } int successor(int *res, void **args) { *res = successor_impl(*((int *) (args[0]))); return 1; } int successor_bis(int *res, void **args) { *res = successor_impl(*((int *) (args[0]))); return 1; } int strange_impl(char *str, int i, mpfr_t v) { sollya_lib_printf(">>>%s<<<>>>%d<<<>>>%v<<<\n", str, i, v); return (i == 17); } int strange(int *res, void **args) { *res = strange_impl(((char *) (args[0])), *((int *) (args[1])), *((mpfr_t *) (args[2]))); return 1; } int strange_bis(int *res, void **args) { *res = strange_impl(((char *) (args[0])), *((int *) (args[1])), *((mpfr_t *) (args[2]))); return 1; } int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t f[18]; sollya_externalprocedure_type_t argTypes[3]; int i; char str1[1024]; char str2[1024]; sollya_lib_init(); argTypes[0] = SOLLYA_EXTERNALPROC_TYPE_INTEGER; f[0] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_INTEGER, argTypes, 1, "succ", successor); sollya_lib_printf("%b\n", f[0]); sollya_lib_autoprint(f[0], NULL); f[1] = SOLLYA_CONST_SI64(16); f[2] = sollya_lib_apply(f[0], f[1], NULL); sollya_lib_printf("%b\n", f[2]); argTypes[0] = SOLLYA_EXTERNALPROC_TYPE_INTEGER; f[3] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_INTEGER, argTypes, 1, NULL, successor_bis); sollya_lib_sprintf(str1, "%b", f[3]); sollya_lib_sprintf(str2, "proc_%p", successor_bis); if ((strcmp(str1, str2) == 0) || (strcmp(str1, "successor_bis") == 0)) { sollya_lib_printf("The behavior when no name is suggested is conform to the semantic\n"); } else { sollya_lib_printf("FAILURE: the external procedure prints as \"%s\"\n",str1); } f[4] = SOLLYA_CONST_SI64(16); f[5] = sollya_lib_apply(f[3], f[4], NULL); sollya_lib_printf("%b\n", f[5]); argTypes[0] = SOLLYA_EXTERNALPROC_TYPE_STRING; argTypes[1] = SOLLYA_EXTERNALPROC_TYPE_INTEGER; argTypes[2] = SOLLYA_EXTERNALPROC_TYPE_CONSTANT; f[6] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_BOOLEAN, argTypes, 3, "strange_proc", strange); sollya_lib_printf("%b\n", f[6]); sollya_lib_autoprint(f[6], NULL); f[7] = sollya_lib_string("Coucou"); f[8] = SOLLYA_CONST_SI64(17); f[9] = SOLLYA_EXP(SOLLYA_CONST_SI64(1)); f[10] = sollya_lib_apply(f[6], f[7], f[8], f[9], NULL); sollya_lib_printf("%b\n", f[10]); argTypes[0] = SOLLYA_EXTERNALPROC_TYPE_STRING; argTypes[1] = SOLLYA_EXTERNALPROC_TYPE_INTEGER; argTypes[2] = SOLLYA_EXTERNALPROC_TYPE_CONSTANT; f[11] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_BOOLEAN, argTypes, 3, NULL, strange_bis); sollya_lib_sprintf(str1, "%b", f[11]); sollya_lib_sprintf(str2, "proc_%p", strange_bis); if ((strcmp(str1, str2) == 0) || (strcmp(str1, "strange_bis") == 0)) { sollya_lib_printf("The behavior when no name is suggested is conform to the semantic\n"); } else { sollya_lib_printf("FAILURE: the external procedure prints as \"%s\"\n",str1); } f[12] = sollya_lib_string("Coucou"); f[13] = SOLLYA_CONST_SI64(42); f[14] = SOLLYA_EXP(SOLLYA_CONST_SI64(1)); f[15] = sollya_lib_apply(f[11], f[12], f[13], f[14], NULL); sollya_lib_printf("%b\n", f[15]); f[16] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); sollya_lib_sprintf(str1, "%b", f[16]); sollya_lib_sprintf(str2, "proc_%p", empty_func); if ((strcmp(str1, str2) == 0) || (strcmp(str1, "empty_func") == 0)) { sollya_lib_printf("The behavior when no name is suggested is conform to the semantic\n"); } else { sollya_lib_printf("FAILURE: the external procedure prints as \"%s\"\n",str1); } f[17] = sollya_lib_apply(f[16], NULL); for(i=0;i<=17;i++) sollya_lib_clear_obj(f[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/texternalprocedure.reference000066400000000000000000000012731300174114700227720ustar00rootroot00000000000000succ succ 17 The behavior when no name is suggested is conform to the semantic 17 strange_proc strange_proc Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation to 165 bits will be used. >>>Coucou<<<>>>17<<<>>>2.7182818284590452353602874713526624977572470937<<< true The behavior when no name is suggested is conform to the semantic Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation to 165 bits will be used. >>>Coucou<<<>>>42<<<>>>2.7182818284590452353602874713526624977572470937<<< false The behavior when no name is suggested is conform to the semantic External procedure only doing a side effect sollya-6.0+ds/tests-lib/texternalprocedure_with_data.c000066400000000000000000000125711300174114700233050ustar00rootroot00000000000000#include #include #include #include #include typedef struct data_struct_t { char text[32]; int counter; } data_t; int successor_impl(int a) { return a + 1; } int successor(int *res, void **args, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; *res = successor_impl(*((int *) (args[0]))); return 1; } int successor_bis(int *res, void **args, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; *res = successor_impl(*((int *) (args[0]))); return 1; } int strange_impl(char *str, int i, mpfr_t v) { sollya_lib_printf(">>>%s<<<>>>%d<<<>>>%v<<<\n", str, i, v); return (i == 17); } int strange(int *res, void **args, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; *res = strange_impl(((char *) (args[0])), *((int *) (args[1])), *((mpfr_t *) (args[2]))); return 1; } int strange_bis(int *res, void **args, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; *res = strange_impl(((char *) (args[0])), *((int *) (args[1])), *((mpfr_t *) (args[2]))); return 1; } int empty_func(void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } void dealloc(void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf("Deallocation function called for the data pointer (%s<<<>>>%d)\n", data->text, data->counter); return; } int main(void) { sollya_obj_t f[19]; sollya_externalprocedure_type_t argTypes[3]; int i; char str1[1024]; char str2[1024]; char str3[1024]; data_t data = { "Hello world", 0 }; sollya_lib_init(); argTypes[0] = SOLLYA_EXTERNALPROC_TYPE_INTEGER; f[0] = sollya_lib_externalprocedure_with_data(SOLLYA_EXTERNALPROC_TYPE_INTEGER, argTypes, 1, "succ", successor, &data, NULL); sollya_lib_printf("%b\n", f[0]); sollya_lib_autoprint(f[0], NULL); f[1] = SOLLYA_CONST_SI64(16); f[2] = sollya_lib_apply(f[0], f[1], NULL); sollya_lib_printf("%b\n", f[2]); argTypes[0] = SOLLYA_EXTERNALPROC_TYPE_INTEGER; f[3] = sollya_lib_externalprocedure_with_data(SOLLYA_EXTERNALPROC_TYPE_INTEGER, argTypes, 1, NULL, successor_bis, &data, NULL); sollya_lib_sprintf(str1, "%b", f[3]); sollya_lib_sprintf(str2, "proc_%p_%p", successor_bis, &data); sollya_lib_sprintf(str3, "%s_%p", "successor_bis", &data); if ((strcmp(str1, str2) == 0) || (strcmp(str1, str3) == 0)) { sollya_lib_printf("The behavior when no name is suggested is conform to the semantic\n"); } else { sollya_lib_printf("FAILURE: the external procedure prints as \"%s\"\n",str1); } f[4] = SOLLYA_CONST_SI64(16); f[5] = sollya_lib_apply(f[3], f[4], NULL); sollya_lib_printf("%b\n", f[5]); argTypes[0] = SOLLYA_EXTERNALPROC_TYPE_STRING; argTypes[1] = SOLLYA_EXTERNALPROC_TYPE_INTEGER; argTypes[2] = SOLLYA_EXTERNALPROC_TYPE_CONSTANT; f[6] = sollya_lib_externalprocedure_with_data(SOLLYA_EXTERNALPROC_TYPE_BOOLEAN, argTypes, 3, "strange_proc", strange, &data, NULL); sollya_lib_printf("%b\n", f[6]); sollya_lib_autoprint(f[6], NULL); f[7] = sollya_lib_string("Coucou"); f[8] = SOLLYA_CONST_SI64(17); f[9] = SOLLYA_EXP(SOLLYA_CONST_SI64(1)); f[10] = sollya_lib_apply(f[6], f[7], f[8], f[9], NULL); sollya_lib_printf("%b\n", f[10]); argTypes[0] = SOLLYA_EXTERNALPROC_TYPE_STRING; argTypes[1] = SOLLYA_EXTERNALPROC_TYPE_INTEGER; argTypes[2] = SOLLYA_EXTERNALPROC_TYPE_CONSTANT; f[11] = sollya_lib_externalprocedure_with_data(SOLLYA_EXTERNALPROC_TYPE_BOOLEAN, argTypes, 3, NULL, strange_bis, &data, NULL); sollya_lib_sprintf(str1, "%b", f[11]); sollya_lib_sprintf(str2, "proc_%p_%p", strange_bis, &data); sollya_lib_sprintf(str3, "%s_%p", "strange_bis", &data); if ((strcmp(str1, str2) == 0) || (strcmp(str1, str3) == 0)) { sollya_lib_printf("The behavior when no name is suggested is conform to the semantic\n"); } else { sollya_lib_printf("FAILURE: the external procedure prints as \"%s\"\n",str1); } f[12] = sollya_lib_string("Coucou"); f[13] = SOLLYA_CONST_SI64(42); f[14] = SOLLYA_EXP(SOLLYA_CONST_SI64(1)); f[15] = sollya_lib_apply(f[11], f[12], f[13], f[14], NULL); sollya_lib_printf("%b\n", f[15]); f[16] = sollya_lib_externalprocedure_with_data(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func, &data, dealloc); sollya_lib_sprintf(str1, "%b", f[16]); sollya_lib_sprintf(str2, "proc_%p_%p", empty_func, &data); sollya_lib_sprintf(str3, "%s_%p", "empty_func", &data); if ((strcmp(str1, str2) == 0) || (strcmp(str1, str3) == 0)) { sollya_lib_printf("The behavior when no name is suggested is conform to the semantic\n"); } else { sollya_lib_printf("FAILURE: the external procedure prints as \"%s\"\n",str1); } f[17] = sollya_lib_apply(f[16], NULL); f[18] = sollya_lib_copy_obj(f[16]); sollya_lib_clear_obj(f[16]); sollya_lib_printf("Deallocation function must not yet have been called\n"); f[16] = SOLLYA_X_; for(i=0;i<=18;i++) sollya_lib_clear_obj(f[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/texternalprocedure_with_data.reference000066400000000000000000000017071300174114700250200ustar00rootroot00000000000000succ succ >>>>Hello world<<<<>>>>0<<<< 17 The behavior when no name is suggested is conform to the semantic >>>>Hello world<<<<>>>>1<<<< 17 strange_proc strange_proc Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation to 165 bits will be used. >>>>Hello world<<<<>>>>2<<<< >>>Coucou<<<>>>17<<<>>>2.7182818284590452353602874713526624977572470937<<< true The behavior when no name is suggested is conform to the semantic Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation to 165 bits will be used. >>>>Hello world<<<<>>>>3<<<< >>>Coucou<<<>>>42<<<>>>2.7182818284590452353602874713526624977572470937<<< false The behavior when no name is suggested is conform to the semantic >>>>Hello world<<<<>>>>4<<<< External procedure only doing a side effect Deallocation function must not yet have been called Deallocation function called for the data pointer (Hello world<<<>>>5) sollya-6.0+ds/tests-lib/tfalse.c000066400000000000000000000003051300174114700166100ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_false(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tfalse.reference000066400000000000000000000000051300174114700203210ustar00rootroot00000000000000falsesollya-6.0+ds/tests-lib/tfile.c000066400000000000000000000003041300174114700164340ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_file(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tfile.reference000066400000000000000000000000041300174114700201450ustar00rootroot00000000000000filesollya-6.0+ds/tests-lib/tfixed.c000066400000000000000000000003051300174114700166150ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_fixed(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tfixed.reference000066400000000000000000000000051300174114700203260ustar00rootroot00000000000000fixedsollya-6.0+ds/tests-lib/tfloating.c000066400000000000000000000003101300174114700173150ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_floating(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tfloating.reference000066400000000000000000000000101300174114700210260ustar00rootroot00000000000000floatingsollya-6.0+ds/tests-lib/tfloor.c000066400000000000000000000004161300174114700166420ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_floor(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tfloor.reference000066400000000000000000000000121300174114700203460ustar00rootroot00000000000000floor(_x_)sollya-6.0+ds/tests-lib/tfpminimax.c000066400000000000000000000142571300174114700175210ustar00rootroot00000000000000#include int main(void) { sollya_obj_t pstar, P, f, n, formats, I, fp, mode, constrainedpart, powers, tmp1, tmp2, P1, P2, P3; sollya_lib_init(); pstar = sollya_lib_parse_string("5846006549323611671784298104022718622318882177971b-162 + x * (37857459261849734002934198358497784854969213609141b-241 + x * (-23384026197294176595383359674367214160107584181507b-165 + x * (-38602791478525408905485501706553096127203819717855b-228 + x * (31178701574267686389540459856148935530651557981629b-169 + x * (14117092987825147270453985390332190734246695748303b-216 + x * (-16628060881742355087337911794409009456208012766191b-173))))))"); f = SOLLYA_COS(SOLLYA_X_); n = SOLLYA_CONST(6); formats = sollya_lib_parse_string("[|DD, DD, D...|]"); I = sollya_lib_parse_string("[-1b-5;1b-5]"); fp = sollya_lib_default(); mode = sollya_lib_default(); constrainedpart = sollya_lib_default(); P = sollya_lib_fpminimax(f, n, formats, I, fp, mode, constrainedpart, pstar, NULL); sollya_lib_printexpansion(P); sollya_lib_clear_obj(pstar); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(formats); sollya_lib_clear_obj(I); sollya_lib_clear_obj(fp); sollya_lib_clear_obj(mode); sollya_lib_clear_obj(constrainedpart); sollya_lib_clear_obj(P); pstar = sollya_lib_parse_string("2148263723907549819858926287983956687732819b-218 + x * (46768052394587948180729798097226792243112547550905b-165 + x * (-25507165977932281269808564943557572116806817621809b-228 + x * (-31178701565420095891159605334409136402204722409645b-167 + x * (12584781347098934684186528379166357990161007221285b-216 + x * (24941946363609599630853575496590807881363811501643b-171 + x * (-27084577193023540426845942064151570020527090561271b-208))))))"); f = SOLLYA_SIN(SOLLYA_X_); n = SOLLYA_CONST(6); formats = sollya_lib_parse_string("[|32...|]"); I = sollya_lib_parse_string("[-1b-5;1b-5]"); fp = sollya_lib_fixed(); mode = sollya_lib_absolute(); constrainedpart = sollya_lib_default(); tmp1 = sollya_lib_fpminimax(f, n, formats, I, fp, mode, constrainedpart, pstar, NULL); P = sollya_lib_horner(tmp1); sollya_lib_clear_obj(tmp1); powers = sollya_lib_powers(); sollya_lib_set_display(powers); sollya_lib_clear_obj(powers); sollya_lib_printf("%b\n",P); sollya_lib_clear_obj(pstar); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(formats); sollya_lib_clear_obj(I); sollya_lib_clear_obj(fp); sollya_lib_clear_obj(mode); sollya_lib_clear_obj(constrainedpart); sollya_lib_clear_obj(P); pstar = sollya_lib_parse_string("x^3 * (7794680717168470900797342378780962700124730873177b-165 + x * 31179902867931546748200780881663744737011812548003b-169)"); f = SOLLYA_EXP(SOLLYA_X_); n = sollya_lib_parse_string("[|3,4|]"); formats = sollya_lib_parse_string("[|D,24|]"); tmp1 = sollya_lib_off(); sollya_lib_set_roundingwarnings(tmp1); sollya_lib_clear_obj(tmp1); I = sollya_lib_parse_string("[-1/256; 1/246]"); constrainedpart = sollya_lib_parse_string("1+x+x^2/2"); fp = sollya_lib_default(); mode = sollya_lib_default(); tmp1 = sollya_lib_fpminimax(f, n, formats, I, constrainedpart, fp, mode, pstar, NULL); P = sollya_lib_horner(tmp1); sollya_lib_clear_obj(tmp1); powers = sollya_lib_powers(); sollya_lib_set_display(powers); sollya_lib_clear_obj(powers); sollya_lib_printf("%b\n",P); sollya_lib_clear_obj(pstar); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(formats); sollya_lib_clear_obj(I); sollya_lib_clear_obj(fp); sollya_lib_clear_obj(mode); sollya_lib_clear_obj(constrainedpart); sollya_lib_clear_obj(P); f = SOLLYA_COS(SOLLYA_EXP(SOLLYA_X_)); pstar = sollya_lib_parse_string("12634443274879194690170438040404782420883156872817b-164 + x * (-9838489776505477022831228470738983214292503288671b-163 + x * (-32311422838792817804696665515592631012661758648301b-165 + x * (-25268886572680378753378093437862180139058069966971b-166 + x * (15055969478386755176354565521121927285916932024465b-168 + x * 3245144072789014252966495640681210160689977302851b-164))))"); mode = sollya_lib_absolute(); n = SOLLYA_CONST(5); fp = sollya_lib_default(); constrainedpart = sollya_lib_default(); tmp1 = SOLLYA_SUB(sollya_lib_copy_obj(f), sollya_lib_copy_obj(pstar)); tmp2 = sollya_lib_parse_string("[-1b-7; 1b-7]"); I = sollya_lib_dirtyfindzeros(tmp1, tmp2); sollya_lib_clear_obj(tmp1); sollya_lib_clear_obj(tmp2); formats = sollya_lib_parse_string("[|DD...|]"); P1 = sollya_lib_fpminimax(f, n, formats, I, mode, constrainedpart, fp, pstar, NULL); sollya_lib_clear_obj(formats); formats = sollya_lib_parse_string("[|D...|]"); P2 = sollya_lib_fpminimax(f, n, formats, I, mode, constrainedpart, fp, pstar, NULL); sollya_lib_clear_obj(formats); formats = sollya_lib_parse_string("[|D, D, D, 24...|]"); P3 = sollya_lib_fpminimax(f, n, formats, I, mode, constrainedpart, fp, pstar, NULL); sollya_lib_clear_obj(formats); sollya_lib_clear_obj(I); I = sollya_lib_parse_string("[-1b-7; 1b-7]"); tmp1 = SOLLYA_SUB(sollya_lib_copy_obj(f), sollya_lib_copy_obj(pstar)); tmp2 = sollya_lib_dirtyinfnorm(tmp1, I); sollya_lib_printf("Error of pstar: %b\n", tmp2); sollya_lib_clear_obj(tmp1); sollya_lib_clear_obj(tmp2); tmp1 = SOLLYA_SUB(sollya_lib_copy_obj(f), sollya_lib_copy_obj(P1)); tmp2 = sollya_lib_dirtyinfnorm(tmp1, I); sollya_lib_printf("Error of P1: %b\n", tmp2); sollya_lib_clear_obj(tmp1); sollya_lib_clear_obj(tmp2); tmp1 = SOLLYA_SUB(sollya_lib_copy_obj(f), sollya_lib_copy_obj(P2)); tmp2 = sollya_lib_dirtyinfnorm(tmp1, I); sollya_lib_printf("Error of P2: %b\n", tmp2); sollya_lib_clear_obj(tmp1); sollya_lib_clear_obj(tmp2); tmp1 = SOLLYA_SUB(sollya_lib_copy_obj(f), sollya_lib_copy_obj(P3)); tmp2 = sollya_lib_dirtyinfnorm(tmp1, I); sollya_lib_printf("Error of P3: %b\n", tmp2); sollya_lib_clear_obj(tmp1); sollya_lib_clear_obj(tmp2); sollya_lib_clear_obj(I); sollya_lib_clear_obj(pstar); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(fp); sollya_lib_clear_obj(mode); sollya_lib_clear_obj(constrainedpart); sollya_lib_clear_obj(P1); sollya_lib_clear_obj(P2); sollya_lib_clear_obj(P3); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tfpminimax.reference000066400000000000000000000012741300174114700212300ustar00rootroot00000000000000(0x3ff0000000000000 + 0xbc09fda20235c100) + x * ((0x3b29ecd485d34781 + 0xb7c1cbc97120359a) + x * (0xbfdfffffffffff98 + x * (0xbbfa6e0b3183cb0d + x * (0x3fa5555555145337 + x * (0x3ca3540480618939 + x * 0xbf56c138142d8c3b))))) x * (1 + x^2 * (-357913941 * 2^(-31) + x^2 * (35789873 * 2^(-32)))) 1 + x * (1 + x * (1 * 2^(-1) + x * (375300225001191 * 2^(-51) + x * (5592621 * 2^(-27))))) Error of pstar: 41623862533526995219855274593333067596572580995543 * 2^(-215) Error of P1: 41623862533526995249852857301809387823617141062435 * 2^(-215) Error of P2: 43429285529967733230721931906794206008049814555029 * 2^(-215) Error of P3: 28553921171649539207471988588453621507466219169379 * 2^(-214) sollya-6.0+ds/tests-lib/tfree_variable.c000066400000000000000000000003151300174114700203050ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_free_variable(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tfree_variable.reference000066400000000000000000000000031300174114700220130ustar00rootroot00000000000000_x_sollya-6.0+ds/tests-lib/tget_autosimplify.c000066400000000000000000000003621300174114700211050ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_autosimplify(); sollya_lib_printf("Default value for autosimplify: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_autosimplify.reference000066400000000000000000000000431300174114700226150ustar00rootroot00000000000000Default value for autosimplify: on sollya-6.0+ds/tests-lib/tget_bounds_from_range.c000066400000000000000000000056221300174114700220550ustar00rootroot00000000000000#include int callback(sollya_msg_t m, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int id = sollya_lib_get_msg_id(m); switch(id) { case SOLLYA_MSG_SAFE_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST: return 0; default: printf("Unexpected warning message number %d\n", id); return 1; } } int main(void) { sollya_obj_t a; mpfr_t resleft, resright; int s; mpfr_init2(resleft, 100); mpfr_init2(resright, 120); sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a = SOLLYA_CONST(4); s = sollya_lib_get_bounds_from_range(resleft, resright, a); if (s==0) sollya_lib_printf("%b is not a range\n\n", a); else sollya_lib_printf("%b has been converted to\n[%v, %v].\n\n", a, resleft, resright); sollya_lib_clear_obj(a); /* Exact conversion */ a = sollya_lib_parse_string("[1, 3]"); s = sollya_lib_get_bounds_from_range(resleft, resright, a); if (s==0) sollya_lib_printf("%b is not a range\n\n", a); else sollya_lib_printf("%b has been converted to\n[%v, %v] (should be the same).\n\n", a, resleft, resright); sollya_lib_clear_obj(a); /* Another exact conversion */ a = SOLLYA_CONST(100); sollya_lib_set_prec_and_print(a); sollya_lib_clear_obj(a); a = sollya_lib_powers(); sollya_lib_set_display(a); sollya_lib_clear_obj(a); a = sollya_lib_parse_string("[exp(1), pi]"); s = sollya_lib_get_bounds_from_range(resleft, resright, a); if (s==0) sollya_lib_printf("%b is not a range\n\n", a); else sollya_lib_printf("%b has been converted to\n[%v, %v] (should be [430728948929449700355022696705 * 2^(-97), 995610453248924340922087778489 * 2^(-98)]).\n\n", a, resleft, resright); sollya_lib_clear_obj(a); /* Inexact conversion at one side only */ a = SOLLYA_CONST(110); sollya_lib_set_prec_and_print(a); sollya_lib_clear_obj(a); a = sollya_lib_decimal(); sollya_lib_set_display(a); sollya_lib_clear_obj(a); a = sollya_lib_parse_string("[exp(1), pi]"); s = sollya_lib_get_bounds_from_range(resleft, resright, a); if (s==0) sollya_lib_printf("%b is not a range\n\n", a); else sollya_lib_printf("%b has been converted to\n[%v, %v] (left bound of the second one should be smaller than left bound of the first one. Right bounds should be equal .\n\n", a, resleft, resright); sollya_lib_clear_obj(a); /* Inexact conversion */ a = SOLLYA_CONST(165); sollya_lib_set_prec_and_print(a); sollya_lib_clear_obj(a); a = sollya_lib_decimal(); sollya_lib_set_display(a); sollya_lib_clear_obj(a); a = sollya_lib_parse_string("[exp(1), pi]"); s = sollya_lib_get_bounds_from_range(resleft, resright, a); if (s==0) sollya_lib_printf("%b is not a range\n\n", a); else sollya_lib_printf("%b has been converted to\n[%v, %v] (the first one should be enclosed in the second one).\n\n", a, resleft, resright); sollya_lib_clear_obj(a); mpfr_clear(resleft); mpfr_clear(resright); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_bounds_from_range.reference000066400000000000000000000020451300174114700235650ustar00rootroot000000000000004 is not a range [1;3] has been converted to [1, 3] (should be the same). The precision has been set to 100 bits. [430728948929449700355022696705 * 2^(-97);995610453248924340922087778489 * 2^(-98)] has been converted to [430728948929449700355022696705 * 2^(-97), 995610453248924340922087778489 * 2^(-98)] (should be [430728948929449700355022696705 * 2^(-97), 995610453248924340922087778489 * 2^(-98)]). The precision has been set to 110 bits. [2.718281828459045235360287471352662;3.141592653589793238462643383279506] has been converted to [2.718281828459045235360287471351235, 3.141592653589793238462643383279506] (left bound of the second one should be smaller than left bound of the first one. Right bounds should be equal . The precision has been set to 165 bits. [2.7182818284590452353602874713526624977572470936999;3.1415926535897932384626433832795028841971693993752] has been converted to [2.7182818284590452353602874713512348150836420479793, 3.1415926535897932384626433832795028847477687031839] (the first one should be enclosed in the second one). sollya-6.0+ds/tests-lib/tget_canonical.c000066400000000000000000000003541300174114700203100ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_canonical(); sollya_lib_printf("Default value for canonical: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_canonical.reference000066400000000000000000000000411300174114700220150ustar00rootroot00000000000000Default value for canonical: off sollya-6.0+ds/tests-lib/tget_constant_as_double.c000066400000000000000000000171651300174114700222370ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a, prec; double res; sollya_lib_init(); prec = SOLLYA_CONST(20); sollya_lib_set_prec_and_print(prec); sollya_lib_clear_obj(prec); /* something that is obviously not a constant */ res = -17; a = sollya_lib_parse_string("[1;2]"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %e\n\n", a, res); } sollya_lib_clear_obj(a); /* something that could be interpreted as constant but that is not a */ /* constant, strictly speaking */ res = -17; a = sollya_lib_parse_string("[1;1]"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %e\n\n", a, res); } sollya_lib_clear_obj(a); /* something that is constant, but it is not obvious */ res = -17; a = sollya_lib_parse_string("3*cos(2*x)/(2*sin(x)*cos(x))"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %e\n\n", a, res); } sollya_lib_clear_obj(a); /* An obvious constant */ res = -17; a = SOLLYA_CONST(3.25); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting 0x1.ap+1)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant, but that does not fit on 20 bits */ res = -17; a = SOLLYA_CONST(7.62939453125e4); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting 0x1.2a05f2p16)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression exactly representable as a double but it cannot be decided. */ res = -17; a = sollya_lib_parse_string("(1b200+1)-1b200*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting 0x1p+0)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression very close to the middle between two doubles and it cannot be decided. */ res = -17; a = sollya_lib_parse_string("1 + 1b-400 + 1b-53*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting one of 0x1p+0 or 0x1.0000000000001p+0 -- the second one would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression very close to the middle between two doubles */ res = -17; a = sollya_lib_parse_string("1 + 1b-400 + 1b-53"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting one of 0x1p+0 or 0x1.0000000000001p+0 -- the second one would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression exactly at the middle between two doubles, but it cannot be decided. */ res = -17; a = sollya_lib_parse_string("1 - 1b-54*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting one of 0x1p+0 or 0xf.ffffffffffff8p-4 -- the first one would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* The same constant but decidable */ res = -17; a = sollya_lib_parse_string("1 - 1b-54"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting one of 0x1p+0 or 0xf.ffffffffffff8p-4 -- the first one would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* Another constant expression exactly at the middle between two doubles, but it cannot be decided. */ res = -17; a = sollya_lib_parse_string("1 + 3b-53*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting one of 0x1.0000000000001p0 or 0x1.0000000000002p0 -- the second one would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* The same constant but decidable. */ res = -17; a = sollya_lib_parse_string("1 + 3b-53"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting one of 0x1.0000000000001p0 or 0x1.0000000000002p0 -- the second one would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A transcendantal constant. */ res = -17; a = sollya_lib_parse_string("exp(pi) + log(2)"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting one of 0x1.7d57686a86509p4 or 0x1.7d57686a8650ap4 -- the first one would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant hard to evaluate because exactly zero but undecidable. */ res = -17; a = sollya_lib_parse_string("log10(2)/log10(3) - log(2)/log(3)"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting 0x0p+0).\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant very hard to evaluate (cf. tevaluate_function_at_constant_expression). */ res = -17; a = sollya_lib_parse_string("(sin((pi) / 3) - sqrt(3) / 2) * (1 * 2^(100000)) + 3"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to some number. Expecting that the above warning message states that faithtul evaluation is *NOT* possible.\n\n", a); } sollya_lib_clear_obj(a); /* Another tricky one. */ res = -17; a = sollya_lib_parse_string("(sin((pi) / 3) - sqrt(3) / 2 ) * (1 * 2^(100000)) + (1 * 2^(60000))"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to some number. Expecting that the above warning message states that faithtul evaluation is *NOT* possible.\n\n", a); } sollya_lib_clear_obj(a); /* Trying -inf */ res = -17; a = sollya_lib_parse_string("-@Inf@"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting -inf).\n\n", a, res); } sollya_lib_clear_obj(a); /* Trying -Huge */ res = -17; a = sollya_lib_parse_string("-1b2000"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting -inf with an overflow warning).\n\n", a, res); } sollya_lib_clear_obj(a); /* Trying NaN */ res = -17; a = sollya_lib_parse_string("@NaN@"); if (!sollya_lib_get_constant_as_double(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %a (expecting NaN).\n\n", a, res); } sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_constant_as_double.reference000066400000000000000000000070201300174114700237400ustar00rootroot00000000000000The precision has been set to 20 bits. [1;2] is not a constant. [1;1] is not a constant. (3 * cos(2 * x)) / (2 * sin(x) * cos(x)) is not a constant. 3.25 has been converted to 0x1.ap+1 (expecting 0x1.ap+1) 76293.9453125 has been converted to 0x1.2a05f2p+16 (expecting 0x1.2a05f2p16) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1.606938e60 + 1 - 1.606938e60 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 0x1p+0 (expecting 0x1p+0) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 3.872592e-121 + 1.110223e-16 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 0x1p+0 (expecting one of 0x1p+0 or 0x1.0000000000001p+0 -- the second one would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 3.872592e-121 + 1.110223e-16 has been converted to 0x1p+0 (expecting one of 0x1p+0 or 0x1.0000000000001p+0 -- the second one would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 - 5.55112e-17 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 0x1p+0 (expecting one of 0x1p+0 or 0xf.ffffffffffff8p-4 -- the first one would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 - 5.55112e-17 has been converted to 0x1p+0 (expecting one of 0x1p+0 or 0xf.ffffffffffff8p-4 -- the first one would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 3.33067e-16 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 0x1.0000000000002p+0 (expecting one of 0x1.0000000000001p0 or 0x1.0000000000002p0 -- the second one would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 3.33067e-16 has been converted to 0x1.0000000000002p+0 (expecting one of 0x1.0000000000001p0 or 0x1.0000000000002p0 -- the second one would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. exp(pi) + log(2) has been converted to 0x1.7d57686a86509p+4 (expecting one of 0x1.7d57686a86509p4 or 0x1.7d57686a8650ap4 -- the first one would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. log10(2) / log10(3) - log(2) / log(3) has been converted to 0x0p+0 (expecting 0x0p+0). Warning: the given expression is not a constant but an expression to evaluate and a faithful evaluation is *NOT* possible. (sin((pi) / 3) - sqrt(3) / 2) * 9.99002e30102 + 3 has been converted to some number. Expecting that the above warning message states that faithtul evaluation is *NOT* possible. Warning: the given expression is not a constant but an expression to evaluate and a faithful evaluation is *NOT* possible. (sin((pi) / 3) - sqrt(3) / 2) * 9.99002e30102 + 6.3058e18061 has been converted to some number. Expecting that the above warning message states that faithtul evaluation is *NOT* possible. -infty has been converted to -inf (expecting -inf). Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. -1.148131e602 has been converted to -inf (expecting -inf with an overflow warning). NaN has been converted to nan (expecting NaN). sollya-6.0+ds/tests-lib/tget_constant_as_int.c000066400000000000000000000223031300174114700215450ustar00rootroot00000000000000#include #include int flag = 0; int special_callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ sollya_lib_printf("Testing a tricky expression. Might return MAX_INT with an overflow message or return anything with a message stating that faithful rounding was not possible... "); if( sollya_lib_get_msg_id(msg) == SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_IS_NOT_FAITHFUL ) sollya_lib_printf("OK\n"); else if ( sollya_lib_get_msg_id(msg) == SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST ) { flag = 1; } else sollya_lib_printf("not OK.\n"); return 0; } int main(void) { sollya_obj_t a, prec; int res; int i; sollya_lib_init(); prec = SOLLYA_CONST(20); sollya_lib_set_prec_and_print(prec); sollya_lib_clear_obj(prec); /* something that is obviously not a constant */ res = -17; a = sollya_lib_parse_string("[1;2]"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d\n\n", a, res); } sollya_lib_clear_obj(a); /* something that could be interpreted as constant but that is not a */ /* constant, strictly speaking */ res = -17; a = sollya_lib_parse_string("[1;1]"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d\n\n", a, res); } sollya_lib_clear_obj(a); /* something that is constant, but it is not obvious */ res = -17; a = sollya_lib_parse_string("3*cos(2*x)/(2*sin(x)*cos(x))"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d\n\n", a, res); } sollya_lib_clear_obj(a); /* An obvious constant */ res = -17; a = SOLLYA_CONST(3); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting 3)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant, but that does not fit on 20 bits */ res = -17; a = SOLLYA_CONST(1073741824); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting 1073741824)\n\n", a, res); } sollya_lib_clear_obj(a); /* A negative constant */ res = -17; a = SOLLYA_CONST(-3); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting -3)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant close to an overflow */ res = -17; a = SOLLYA_CONST(1); for (i=1;(size_t)(i)+1<=sizeof(int)*8;i++) a = SOLLYA_MUL(a, SOLLYA_CONST(2)); a = SOLLYA_SUB(a, SOLLYA_CONST(1)); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { if (res == INT_MAX) sollya_lib_printf("%b has been converted to INT_MAX\n\n", a); else sollya_lib_printf("%b has been converted to %d (expected INT_MAX=%d)\n\n", a, res, INT_MAX); } sollya_lib_clear_obj(a); /* A constant that overflows */ res = -17; a = SOLLYA_CONST(1); for (i=1;(size_t)(i)+1<=sizeof(int)*8;i++) a = SOLLYA_MUL(a, SOLLYA_CONST(2)); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { if (res == INT_MAX) sollya_lib_printf("%b has been converted to INT_MAX (with an overflow warning expected)\n\n", a); else sollya_lib_printf("%b has been converted to %d (expected INT_MAX=%d)\n\n", a, res, INT_MAX); } sollya_lib_clear_obj(a); /* A constant expression exactly representable as an int but it cannot be decided. */ res = -17; a = sollya_lib_parse_string("(1b200+1)-1b200*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting 1)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression very close to the middle between two integers and it cannote be decided. */ res = -17; a = sollya_lib_parse_string("1 + 1b-400 + 0.5*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting either 1 or 2 -- 2 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression very close to the middle between two doubles */ res = -17; a = sollya_lib_parse_string("1 + 1b-400 + 0.5"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting either 1 or 2 -- 2 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression exactly at the middle between two doubles, but it cannot be decided. */ res = -17; a = sollya_lib_parse_string("1 - 0.5*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting either 0 or 1 -- 0 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* The same constant but decidable */ res = -17; a = sollya_lib_parse_string("1 - 0.5"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting either 0 or 1 -- 0 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* Another constant expression exactly at the middle between two doubles, but it cannot be decided. */ res = -17; a = sollya_lib_parse_string("1 + 1.5*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting either 2 or 3 -- 2 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* The same constant but decidable. */ res = -17; a = sollya_lib_parse_string("1 + 1.5"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting either 2 or 3 -- 2 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A transcendantal constant. */ res = -17; a = sollya_lib_parse_string("exp(pi) + log(2)"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting either 23 or 24 -- 24 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant hard to evaluate because exactly zero but undecidable. */ res = -17; a = sollya_lib_parse_string("log10(2)/log10(3) - log(2)/log(3)"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting 0).\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant very hard to evaluate (cf. tevaluate_function_at_constant_expression). */ res = -17; a = sollya_lib_parse_string("(sin((pi) / 3) - sqrt(3) / 2) * (1 * 2^(100000)) + 3"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to some number. Expecting that the above warning message states that faithtul evaluation is *NOT* possible.\n\n", a); } sollya_lib_clear_obj(a); /* Another tricky one. */ res = -17; sollya_lib_install_msg_callback(special_callback, NULL); a = sollya_lib_parse_string("(sin((pi) / 3) - sqrt(3) / 2 ) * (1 * 2^(100000)) + (1 * 2^(60000))"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { if(flag) { if (res != INT_MAX) sollya_lib_printf("%b has been converted to %d (expected INT_MAX=%d\n\n", a, res, INT_MAX); else { sollya_lib_printf("OK\n"); } } sollya_lib_printf("%b has been converted to some number.\n\n", a); } sollya_lib_uninstall_msg_callback(); flag = 0; sollya_lib_clear_obj(a); /* Trying -inf */ res = -17; a = sollya_lib_parse_string("-@Inf@"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { if (res == INT_MIN) sollya_lib_printf("%b has been converted to INT_MIN (with an overflow warning expected)\n\n", a); else sollya_lib_printf("%b has been converted to %d (expected INT_MIN=%d)\n\n", a, res, INT_MIN); } sollya_lib_clear_obj(a); /* Trying NaN */ res = -17; a = sollya_lib_parse_string("@NaN@"); if (!sollya_lib_get_constant_as_int(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %d (expecting 0).\n\n", a, res); } sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_constant_as_int.reference000066400000000000000000000064561300174114700232740ustar00rootroot00000000000000The precision has been set to 20 bits. [1;2] is not a constant. [1;1] is not a constant. (3 * cos(2 * x)) / (2 * sin(x) * cos(x)) is not a constant. 3 has been converted to 3 (expecting 3) 1073741824 has been converted to 1073741824 (expecting 1073741824) -3 has been converted to -3 (expecting -3) 1 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 - 1 has been converted to INT_MAX Warning: rounding occurred on retrieval of a constant. 1 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 has been converted to INT_MAX (with an overflow warning expected) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1.606938e60 + 1 - 1.606938e60 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 1 (expecting 1) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 3.872592e-121 + 0.5 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 2 (expecting either 1 or 2 -- 2 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 3.872592e-121 + 0.5 has been converted to 2 (expecting either 1 or 2 -- 2 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 - 0.5 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 0 (expecting either 0 or 1 -- 0 would be better) Warning: rounding occurred on retrieval of a constant. 0.5 has been converted to 0 (expecting either 0 or 1 -- 0 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 1.5 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 2 (expecting either 2 or 3 -- 2 would be better) Warning: rounding occurred on retrieval of a constant. 2.5 has been converted to 2 (expecting either 2 or 3 -- 2 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. exp(pi) + log(2) has been converted to 24 (expecting either 23 or 24 -- 24 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. log10(2) / log10(3) - log(2) / log(3) has been converted to 0 (expecting 0). Warning: the given expression is not a constant but an expression to evaluate and a faithful evaluation is *NOT* possible. (sin((pi) / 3) - sqrt(3) / 2) * 9.99002e30102 + 3 has been converted to some number. Expecting that the above warning message states that faithtul evaluation is *NOT* possible. Testing a tricky expression. Might return MAX_INT with an overflow message or return anything with a message stating that faithful rounding was not possible... OK (sin((pi) / 3) - sqrt(3) / 2) * 9.99002e30102 + 6.3058e18061 has been converted to some number. Warning: rounding occurred on retrieval of a constant. -infty has been converted to INT_MIN (with an overflow warning expected) Warning: a Not-A-Number value has been converted to a number upon retrieval of a constant. NaN has been converted to 0 (expecting 0). sollya-6.0+ds/tests-lib/tget_constant_as_int64.c000066400000000000000000000227021300174114700217220ustar00rootroot00000000000000#include #include int flag = 0; int special_callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ sollya_lib_printf("Testing a tricky expression. Might return INT64_MAX with an overflow message or return anything with a message stating that faithful rounding was not possible... "); if( sollya_lib_get_msg_id(msg) == SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_IS_NOT_FAITHFUL ) sollya_lib_printf("OK\n"); else if ( sollya_lib_get_msg_id(msg) == SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST ) { flag = 1; } else sollya_lib_printf("not OK.\n"); return 0; } int main(void) { sollya_obj_t a, prec; int64_t res; int i; sollya_lib_init(); prec = SOLLYA_CONST(20); sollya_lib_set_prec_and_print(prec); sollya_lib_clear_obj(prec); /* something that is obviously not a constant */ res = -17; a = sollya_lib_parse_string("[1;2]"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 "\n\n", a, res); } sollya_lib_clear_obj(a); /* something that could be interpreted as constant but that is not a */ /* constant, strictly speaking */ res = -17; a = sollya_lib_parse_string("[1;1]"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 "\n\n", a, res); } sollya_lib_clear_obj(a); /* something that is constant, but it is not obvious */ res = -17; a = sollya_lib_parse_string("3*cos(2*x)/(2*sin(x)*cos(x))"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 "\n\n", a, res); } sollya_lib_clear_obj(a); /* An obvious constant */ res = -17; a = SOLLYA_CONST(3); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting 3)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant, but that does not fit on 20 bits */ res = -17; a = SOLLYA_CONST(1073741824); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting 1073741824)\n\n", a, res); } sollya_lib_clear_obj(a); /* A negative constant */ res = -17; a = SOLLYA_CONST(-3); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting -3)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant close to an overflow */ res = -17; a = SOLLYA_CONST(1); for (i=1;(size_t)(i)+1<=sizeof(int64_t)*8;i++) a = SOLLYA_MUL(a, SOLLYA_CONST(2)); a = SOLLYA_SUB(a, SOLLYA_CONST(1)); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { if (res == INT64_MAX) sollya_lib_printf("%b has been converted to INT64_MAX\n\n", a); else sollya_lib_printf("%b has been converted to %" PRId64 " (expected INT64_MAX=%" PRId64 ")\n\n", a, res, INT64_MAX); } sollya_lib_clear_obj(a); /* A constant that overflows */ res = -17; a = SOLLYA_CONST(1); for (i=1;(size_t)(i)+1<=sizeof(int64_t)*8;i++) a = SOLLYA_MUL(a, SOLLYA_CONST(2)); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { if (res == INT64_MAX) sollya_lib_printf("%b has been converted to INT64_MAX (with an overflow warning expected)\n\n", a); else sollya_lib_printf("%b has been converted to %" PRId64 " (expected INT64_MAX=%" PRId64 ")\n\n", a, res, INT64_MAX); } sollya_lib_clear_obj(a); /* A constant expression exactly representable as an int but it cannot be decided. */ res = -17; a = sollya_lib_parse_string("(1b200+1)-1b200*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting 1)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression very close to the middle between two integers and it cannote be decided. */ res = -17; a = sollya_lib_parse_string("1 + 1b-400 + 0.5*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting either 1 or 2 -- 2 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression very close to the middle between two doubles */ res = -17; a = sollya_lib_parse_string("1 + 1b-400 + 0.5"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting either 1 or 2 -- 2 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression exactly at the middle between two doubles, but it cannot be decided. */ res = -17; a = sollya_lib_parse_string("1 - 0.5*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting either 0 or 1 -- 0 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* The same constant but decidable */ res = -17; a = sollya_lib_parse_string("1 - 0.5"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting either 0 or 1 -- 0 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* Another constant expression exactly at the middle between two doubles, but it cannot be decided. */ res = -17; a = sollya_lib_parse_string("1 + 1.5*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting either 2 or 3 -- 2 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* The same constant but decidable. */ res = -17; a = sollya_lib_parse_string("1 + 1.5"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting either 2 or 3 -- 2 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A transcendantal constant. */ res = -17; a = sollya_lib_parse_string("exp(pi) + log(2)"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting either 23 or 24 -- 24 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant hard to evaluate because exactly zero but undecidable. */ res = -17; a = sollya_lib_parse_string("log10(2)/log10(3) - log(2)/log(3)"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting 0).\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant very hard to evaluate (cf. tevaluate_function_at_constant_expression). */ res = -17; a = sollya_lib_parse_string("(sin((pi) / 3) - sqrt(3) / 2) * (1 * 2^(100000)) + 3"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to some number. Expecting that the above warning message states that faithtul evaluation is *NOT* possible.\n\n", a); } sollya_lib_clear_obj(a); /* Another tricky one. */ res = -17; sollya_lib_install_msg_callback(special_callback, NULL); a = sollya_lib_parse_string("(sin((pi) / 3) - sqrt(3) / 2 ) * (1 * 2^(100000)) + (1 * 2^(60000))"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { if (flag) { if (res != INT64_MAX) sollya_lib_printf("%b has been converted to %d (expected INT64_MAX=%" PRId64 ")\n\n", a, res, INT64_MAX); else sollya_lib_printf("OK\n"); } sollya_lib_printf("%b has been converted to some number.\n\n", a); } sollya_lib_uninstall_msg_callback(); flag = 0; sollya_lib_clear_obj(a); /* Trying -inf */ res = -17; a = sollya_lib_parse_string("-@Inf@"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { if (res == INT64_MIN) sollya_lib_printf("%b has been converted to INT64_MIN\n\n", a); else sollya_lib_printf("%b has been converted to %" PRId64 " (expected INT64_MIN=%" PRId64 ")\n\n", a, res, INT64_MIN); } sollya_lib_clear_obj(a); /* Trying NaN */ res = -17; a = sollya_lib_parse_string("@NaN@"); if (!sollya_lib_get_constant_as_int64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRId64 " (expecting 0).\n\n", a, res); } sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_constant_as_int64.reference000066400000000000000000000070221300174114700234340ustar00rootroot00000000000000The precision has been set to 20 bits. [1;2] is not a constant. [1;1] is not a constant. (3 * cos(2 * x)) / (2 * sin(x) * cos(x)) is not a constant. 3 has been converted to 3 (expecting 3) 1073741824 has been converted to 1073741824 (expecting 1073741824) -3 has been converted to -3 (expecting -3) 1 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 - 1 has been converted to INT64_MAX Warning: rounding occurred on retrieval of a constant. 1 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 has been converted to INT64_MAX (with an overflow warning expected) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1.606938e60 + 1 - 1.606938e60 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 1 (expecting 1) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 3.872592e-121 + 0.5 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 2 (expecting either 1 or 2 -- 2 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 3.872592e-121 + 0.5 has been converted to 2 (expecting either 1 or 2 -- 2 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 - 0.5 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 0 (expecting either 0 or 1 -- 0 would be better) Warning: rounding occurred on retrieval of a constant. 0.5 has been converted to 0 (expecting either 0 or 1 -- 0 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 1.5 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 2 (expecting either 2 or 3 -- 2 would be better) Warning: rounding occurred on retrieval of a constant. 2.5 has been converted to 2 (expecting either 2 or 3 -- 2 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. exp(pi) + log(2) has been converted to 24 (expecting either 23 or 24 -- 24 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. log10(2) / log10(3) - log(2) / log(3) has been converted to 0 (expecting 0). Warning: the given expression is not a constant but an expression to evaluate and a faithful evaluation is *NOT* possible. (sin((pi) / 3) - sqrt(3) / 2) * 9.99002e30102 + 3 has been converted to some number. Expecting that the above warning message states that faithtul evaluation is *NOT* possible. Testing a tricky expression. Might return INT64_MAX with an overflow message or return anything with a message stating that faithful rounding was not possible... OK (sin((pi) / 3) - sqrt(3) / 2) * 9.99002e30102 + 6.3058e18061 has been converted to some number. Warning: rounding occurred on retrieval of a constant. -infty has been converted to INT64_MIN Warning: a Not-A-Number value has been converted to a number upon retrieval of a constant. NaN has been converted to 0 (expecting 0). sollya-6.0+ds/tests-lib/tget_constant_as_mpq.c000066400000000000000000000145441300174114700215600ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a, prec; mpq_t res; sollya_lib_init(); mpq_init(res); prec = SOLLYA_CONST(20); sollya_lib_set_prec_and_print(prec); sollya_lib_clear_obj(prec); /* something that is obviously not a constant */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("[1;2]"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r\n\n", a, res); } sollya_lib_clear_obj(a); /* something that could be interpreted as constant but that is not a */ /* constant, strictly speaking */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("[1;1]"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r\n\n", a, res); } sollya_lib_clear_obj(a); /* something that is constant, but it is not obvious */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("3*cos(2*x)/(2*sin(x)*cos(x))"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r\n\n", a, res); } sollya_lib_clear_obj(a); /* An obvious constant */ mpq_set_si(res, -17, 1); a = SOLLYA_CONST(3.25); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r (expecting 13/4)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant, but that does not fit on 20 bits */ mpq_set_si(res, -17, 1); a = SOLLYA_CONST(7.62939453125e4); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r (expecting 9765625/128)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression exactly representable as a double but it cannot be decided. */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("(1b200+1)-1b200*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression very close to the middle between two doubles */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("1 + 1b-400 + 1b-53"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r (expecting 2582249878086908876343246170761950825682317705590091112401283002575788089215446117995004864340738840188222310738458312705/2582249878086908589655919172003011874329705792829223512830659356540647622016841194629645353280137831435903171972747493376)\n\n", a, res); } sollya_lib_clear_obj(a); /* Another one in the same spirit */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("1 - 1b-54"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r (expecting 18014398509481983/18014398509481984)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant rational expression. */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("6/10"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r (expecting 3/5)\n\n", a, res); } sollya_lib_clear_obj(a); /* A transcendantal constant. */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("exp(pi) + log(2)"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant hard to evaluate because exactly zero but undecidable. */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("log10(2)/log10(3) - log(2)/log(3)"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r.\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant very hard to evaluate (cf. tevaluate_function_at_constant_expression). */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("(sin((pi) / 3) - sqrt(3) / 2) * (1 * 2^(100000)) + 3"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r.\n\n", a, res); } sollya_lib_clear_obj(a); /* Trying -inf */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("-@Inf@"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r.\n\n", a, res); } sollya_lib_clear_obj(a); /* Trying -Huge */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("-1b2000"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r (expecting -114813069527425452423283320117768198402231770208869520047764273682576626139237031385665948631650626991844596463898746277344711896086305533142593135616665318539129989145312280000688779148240044871428926990063486244781615463646388363947317026040466353970904996558162398808944629605623311649536164221970332681344168908984458505602379484807914058900934776500429002716706625830522008132236281291761267883317206598995396418127021779858404042159853183251540889433902091920554957783589672039160081957216630582755380425583726015528348786419432054508915275783882625175435528800822842770817965453762184851149029376).\n\n", a, res); } sollya_lib_clear_obj(a); /* Trying NaN */ mpq_set_si(res, -17, 1); a = sollya_lib_parse_string("@NaN@"); if (!sollya_lib_get_constant_as_mpq(res, a)) sollya_lib_printf("%b is not a rational constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %r.\n\n", a, res); } sollya_lib_clear_obj(a); mpq_clear(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_constant_as_mpq.reference000066400000000000000000000051551300174114700232720ustar00rootroot00000000000000The precision has been set to 20 bits. [1;2] is not a rational constant. [1;1] is not a rational constant. (3 * cos(2 * x)) / (2 * sin(x) * cos(x)) is not a rational constant. 3.25 has been converted to 13 / 4 (expecting 13/4) 76293.9453125 has been converted to 9765625 / 128 (expecting 9765625/128) 1.606938e60 + 1 - 1.606938e60 * (log2(3) / log2(7) - log(3) / log(7) + 1) is not a rational constant. 1 + 3.872592e-121 + 1.110223e-16 has been converted to 2582249878086908876343246170761950825682317705590091112401283002575788089215446117995004864340738840188222310738458312705 / 2582249878086908589655919172003011874329705792829223512830659356540647622016841194629645353280137831435903171972747493376 (expecting 2582249878086908876343246170761950825682317705590091112401283002575788089215446117995004864340738840188222310738458312705/2582249878086908589655919172003011874329705792829223512830659356540647622016841194629645353280137831435903171972747493376) 1 - 5.55112e-17 has been converted to 18014398509481983 / 18014398509481984 (expecting 18014398509481983/18014398509481984) 6 / 10 has been converted to 3 / 5 (expecting 3/5) exp(pi) + log(2) is not a rational constant. log10(2) / log10(3) - log(2) / log(3) is not a rational constant. (sin((pi) / 3) - sqrt(3) / 2) * 9.99002e30102 + 3 is not a rational constant. -infty is not a rational constant. -1.148131e602 has been converted to -114813069527425452423283320117768198402231770208869520047764273682576626139237031385665948631650626991844596463898746277344711896086305533142593135616665318539129989145312280000688779148240044871428926990063486244781615463646388363947317026040466353970904996558162398808944629605623311649536164221970332681344168908984458505602379484807914058900934776500429002716706625830522008132236281291761267883317206598995396418127021779858404042159853183251540889433902091920554957783589672039160081957216630582755380425583726015528348786419432054508915275783882625175435528800822842770817965453762184851149029376 / 1 (expecting -114813069527425452423283320117768198402231770208869520047764273682576626139237031385665948631650626991844596463898746277344711896086305533142593135616665318539129989145312280000688779148240044871428926990063486244781615463646388363947317026040466353970904996558162398808944629605623311649536164221970332681344168908984458505602379484807914058900934776500429002716706625830522008132236281291761267883317206598995396418127021779858404042159853183251540889433902091920554957783589672039160081957216630582755380425583726015528348786419432054508915275783882625175435528800822842770817965453762184851149029376). NaN is not a rational constant. sollya-6.0+ds/tests-lib/tget_constant_as_mpz.c000066400000000000000000000207321300174114700215650ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a, prec; mpz_t res; int i; sollya_lib_init(); mpz_init(res); prec = SOLLYA_CONST(20); sollya_lib_set_prec_and_print(prec); sollya_lib_clear_obj(prec); /* something that is obviously not a constant */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("[1;2]"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf("\n\n"); } sollya_lib_clear_obj(a); /* something that could be interpreted as constant but that is not a */ /* constant, strictly speaking */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("[1;1]"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf("\n\n"); } sollya_lib_clear_obj(a); /* something that is constant, but it is not obvious */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("3*cos(2*x)/(2*sin(x)*cos(x))"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf("\n\n"); } sollya_lib_clear_obj(a); /* An obvious constant */ mpz_set_ui(res, 17); a = SOLLYA_CONST(3); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting 3)\n\n"); } sollya_lib_clear_obj(a); /* A constant, but that does not fit on 20 bits */ mpz_set_ui(res, 17); a = SOLLYA_CONST(1073741824); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting 1073741824)\n\n"); } sollya_lib_clear_obj(a); /* A negative constant */ mpz_set_ui(res, 17); a = SOLLYA_CONST(-3); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting -3)\n\n"); } sollya_lib_clear_obj(a); /* A constant that does not fit in a integer */ mpz_set_ui(res, 17); a = SOLLYA_CONST(1); for (i=1;i<=90;i++) a = SOLLYA_MUL(a, SOLLYA_CONST(2)); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expected 1237940039285380274899124224)\n\n"); } sollya_lib_clear_obj(a); /* The same, but negative */ mpz_set_ui(res, 17); a = SOLLYA_CONST(-1); for (i=1;i<=90;i++) a = SOLLYA_MUL(a, SOLLYA_CONST(2)); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expected -1237940039285380274899124224)\n\n"); } sollya_lib_clear_obj(a); /* A constant expression exactly representable as an int but it cannot be decided. */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("(1b200+1)-1b200*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting 1)\n\n"); } sollya_lib_clear_obj(a); /* A constant expression very close to the middle between two integers and it cannot be decided. */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("1 + 1b-400 + 0.5*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting either 1 or 2 -- 2 would be better)\n\n"); } sollya_lib_clear_obj(a); /* A constant expression very close to the middle between two doubles */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("1 + 1b-400 + 0.5"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting either 1 or 2 -- 2 would be better)\n\n"); } sollya_lib_clear_obj(a); /* A constant expression exactly at the middle between two doubles, but it cannot be decided. */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("1 - 0.5*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting either 0 or 1 -- 0 would be better)\n\n"); } sollya_lib_clear_obj(a); /* The same constant but decidable */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("1 - 0.5"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting either 0 or 1 -- 0 would be better)\n\n"); } sollya_lib_clear_obj(a); /* Another constant expression exactly at the middle between two doubles, but it cannot be decided. */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("1 + 1.5*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting either 2 or 3 -- 2 would be better)\n\n"); } sollya_lib_clear_obj(a); /* The same constant but decidable. */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("1 + 1.5"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting either 2 or 3 -- 2 would be better)\n\n"); } sollya_lib_clear_obj(a); /* A transcendantal constant. */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("exp(pi) + log(2)"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting either 23 or 24 -- 24 would be better)\n\n"); } sollya_lib_clear_obj(a); /* A constant hard to evaluate because exactly zero but undecidable. */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("log10(2)/log10(3) - log(2)/log(3)"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting 0).\n\n"); } sollya_lib_clear_obj(a); /* A constant very hard to evaluate (cf. tevaluate_function_at_constant_expression). */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("(sin((pi) / 3) - sqrt(3) / 2) * (1 * 2^(100000)) + 3"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to some number. Expecting that the above warning message states that faithtul evaluation is *NOT* possible.\n\n", a); } sollya_lib_clear_obj(a); /* Trying -inf */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("-@Inf@"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expected 0)\n\n"); } sollya_lib_clear_obj(a); /* Trying NaN */ mpz_set_ui(res, 17); a = sollya_lib_parse_string("@NaN@"); if (!sollya_lib_get_constant_as_mpz(res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to ", a); gmp_printf("%Zd", res); sollya_lib_printf(" (expecting 0).\n\n"); } sollya_lib_clear_obj(a); mpz_clear(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_constant_as_mpz.reference000066400000000000000000000070361300174114700233030ustar00rootroot00000000000000The precision has been set to 20 bits. [1;2] is not a constant. [1;1] is not a constant. (3 * cos(2 * x)) / (2 * sin(x) * cos(x)) is not a constant. 3 has been converted to 3 (expecting 3) 1073741824 has been converted to 1073741824 (expecting 1073741824) -3 has been converted to -3 (expecting -3) 1 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 has been converted to 1237940039285380274899124224 (expected 1237940039285380274899124224) -1 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 has been converted to -1237940039285380274899124224 (expected -1237940039285380274899124224) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1.606938e60 + 1 - 1.606938e60 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 1 (expecting 1) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 3.872592e-121 + 0.5 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 2 (expecting either 1 or 2 -- 2 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 3.872592e-121 + 0.5 has been converted to 2 (expecting either 1 or 2 -- 2 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 - 0.5 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 0 (expecting either 0 or 1 -- 0 would be better) Warning: rounding occurred on retrieval of a constant. 0.5 has been converted to 0 (expecting either 0 or 1 -- 0 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 1.5 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 2 (expecting either 2 or 3 -- 2 would be better) Warning: rounding occurred on retrieval of a constant. 2.5 has been converted to 2 (expecting either 2 or 3 -- 2 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. exp(pi) + log(2) has been converted to 24 (expecting either 23 or 24 -- 24 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. log10(2) / log10(3) - log(2) / log(3) has been converted to 0 (expecting 0). Warning: the given expression is not a constant but an expression to evaluate and a faithful evaluation is *NOT* possible. (sin((pi) / 3) - sqrt(3) / 2) * 9.99002e30102 + 3 has been converted to some number. Expecting that the above warning message states that faithtul evaluation is *NOT* possible. Warning: an infinity has been converted to a number upon retrieval of a constant. -infty has been converted to 0 (expected 0) Warning: a Not-A-Number value has been converted to a number upon retrieval of a constant. NaN has been converted to 0 (expecting 0). sollya-6.0+ds/tests-lib/tget_constant_as_uint64.c000066400000000000000000000234261300174114700221130ustar00rootroot00000000000000#include #include int flag = 0; int special_callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ sollya_lib_printf("Testing a tricky expression. Might return UINT64_MAX with an overflow message or return anything with a message stating that faithful rounding was not possible... "); if( sollya_lib_get_msg_id(msg) == SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_IS_NOT_FAITHFUL ) sollya_lib_printf("OK\n"); else if ( sollya_lib_get_msg_id(msg) == SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST ) { flag = 1; } else sollya_lib_printf("not OK.\n"); return 0; } int main(void) { sollya_obj_t a, prec; uint64_t res; int i; sollya_lib_init(); prec = SOLLYA_CONST(20); sollya_lib_set_prec_and_print(prec); sollya_lib_clear_obj(prec); /* something that is obviously not a constant */ res = -17; a = sollya_lib_parse_string("[1;2]"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 "\n\n", a, res); } sollya_lib_clear_obj(a); /* something that could be interpreted as constant but that is not a */ /* constant, strictly speaking */ res = -17; a = sollya_lib_parse_string("[1;1]"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 "\n\n", a, res); } sollya_lib_clear_obj(a); /* something that is constant, but it is not obvious */ res = -17; a = sollya_lib_parse_string("3*cos(2*x)/(2*sin(x)*cos(x))"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 "\n\n", a, res); } sollya_lib_clear_obj(a); /* An obvious constant */ res = -17; a = SOLLYA_CONST(3); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting 3)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant, but that does not fit on 20 bits */ res = -17; a = SOLLYA_CONST(1073741824); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting 1073741824)\n\n", a, res); } sollya_lib_clear_obj(a); /* A negative constant */ res = -17; a = SOLLYA_CONST(-3); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting 0)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant close to an overflow */ res = -17; a = SOLLYA_CONST(1); for (i=1;(size_t)(i)<=sizeof(int64_t)*8;i++) a = SOLLYA_MUL(a, SOLLYA_CONST(2)); a = SOLLYA_SUB(a, SOLLYA_CONST(1)); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { if (res == UINT64_MAX) sollya_lib_printf("%b has been converted to UINT64_MAX\n\n", a); else sollya_lib_printf("%b has been converted to %" PRIu64 " (expected UINT64_MAX=%" PRIu64 ")\n\n", a, res, UINT64_MAX); } sollya_lib_clear_obj(a); /* A constant that overflows */ res = -17; a = SOLLYA_CONST(1); for (i=1;(size_t)(i)<=sizeof(int64_t)*8;i++) a = SOLLYA_MUL(a, SOLLYA_CONST(2)); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { if (res == UINT64_MAX) sollya_lib_printf("%b has been converted to UINT64_MAX (with an overflow warning expected)\n\n", a); else sollya_lib_printf("%b has been converted to %" PRIu64 " (expected UINT64_MAX=%" PRIu64 ")\n\n", a, res, UINT64_MAX); } sollya_lib_clear_obj(a); /* A constant expression exactly representable as an int but it cannot be decided. */ res = -17; a = sollya_lib_parse_string("(1b200+1)-1b200*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting 1)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression very close to the middle between two integers and it cannote be decided. */ res = -17; a = sollya_lib_parse_string("1 + 1b-400 + 0.5*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting either 1 or 2 -- 2 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression very close to the middle between two doubles */ res = -17; a = sollya_lib_parse_string("1 + 1b-400 + 0.5"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting either 1 or 2 -- 2 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant expression exactly at the middle between two doubles, but it cannot be decided. */ res = -17; a = sollya_lib_parse_string("1 - 0.5*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting either 0 or 1 -- 0 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* The same constant but decidable */ res = -17; a = sollya_lib_parse_string("1 - 0.5"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting either 0 or 1 -- 0 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* Another constant expression exactly at the middle between two doubles, but it cannot be decided. */ res = -17; a = sollya_lib_parse_string("1 + 1.5*(log2(3)/log2(7) - log(3)/log(7) + 1)"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting either 2 or 3 -- 2 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* The same constant but decidable. */ res = -17; a = sollya_lib_parse_string("1 + 1.5"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting either 2 or 3 -- 2 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A transcendantal constant. */ res = -17; a = sollya_lib_parse_string("exp(pi) + log(2)"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting either 23 or 24 -- 24 would be better)\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant hard to evaluate because exactly zero but undecidable. */ res = -17; a = sollya_lib_parse_string("log10(2)/log10(3) - log(2)/log(3)"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting 0).\n\n", a, res); } sollya_lib_clear_obj(a); /* A constant very hard to evaluate (cf. tevaluate_function_at_constant_expression). */ res = -17; a = sollya_lib_parse_string("(sin((pi) / 3) - sqrt(3) / 2) * (1 * 2^(100000)) + 3"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to some number. Expecting that the above warning message states that faithtul evaluation is *NOT* possible.\n\n", a); } sollya_lib_clear_obj(a); /* Another tricky one. */ res = -17; sollya_lib_install_msg_callback(special_callback, NULL); a = sollya_lib_parse_string("(sin((pi) / 3) - sqrt(3) / 2 ) * (1 * 2^(100000)) + (1 * 2^(60000))"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { if (flag) { if (res != UINT64_MAX) sollya_lib_printf("%b has been converted to %d (expected UINT64_MAX=%" PRIu64 ")\n\n", a, res, UINT64_MAX); else sollya_lib_printf("OK\n"); } sollya_lib_printf("%b has been converted to some number.\n\n", a); } sollya_lib_uninstall_msg_callback(); flag = 0; sollya_lib_clear_obj(a); /* Trying -inf */ res = -17; a = sollya_lib_parse_string("-@Inf@"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting 0).\n\n", a, res); } sollya_lib_clear_obj(a); /* Trying +inf */ res = -17; a = sollya_lib_parse_string("@Inf@"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { if (res == UINT64_MAX) sollya_lib_printf("%b has been converted to UINT64_MAX\n\n", a); else sollya_lib_printf("%b has been converted to %" PRIu64 " (expected UINT64_MAX=%" PRIu64 ")\n\n", a, res, UINT64_MAX); } sollya_lib_clear_obj(a); /* Trying NaN */ res = -17; a = sollya_lib_parse_string("@NaN@"); if (!sollya_lib_get_constant_as_uint64(&res, a)) sollya_lib_printf("%b is not a constant.\n\n", a); else { sollya_lib_printf("%b has been converted to %" PRIu64 " (expecting 0).\n\n", a, res); } sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_constant_as_uint64.reference000066400000000000000000000072701300174114700236260ustar00rootroot00000000000000The precision has been set to 20 bits. [1;2] is not a constant. [1;1] is not a constant. (3 * cos(2 * x)) / (2 * sin(x) * cos(x)) is not a constant. 3 has been converted to 3 (expecting 3) 1073741824 has been converted to 1073741824 (expecting 1073741824) Warning: rounding occurred on retrieval of a constant. -3 has been converted to 0 (expecting 0) 1 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 - 1 has been converted to UINT64_MAX Warning: rounding occurred on retrieval of a constant. 1 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 has been converted to UINT64_MAX (with an overflow warning expected) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1.606938e60 + 1 - 1.606938e60 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 1 (expecting 1) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 3.872592e-121 + 0.5 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 2 (expecting either 1 or 2 -- 2 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 3.872592e-121 + 0.5 has been converted to 2 (expecting either 1 or 2 -- 2 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 - 0.5 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 0 (expecting either 0 or 1 -- 0 would be better) Warning: rounding occurred on retrieval of a constant. 0.5 has been converted to 0 (expecting either 0 or 1 -- 0 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. 1 + 1.5 * (log2(3) / log2(7) - log(3) / log(7) + 1) has been converted to 2 (expecting either 2 or 3 -- 2 would be better) Warning: rounding occurred on retrieval of a constant. 2.5 has been converted to 2 (expecting either 2 or 3 -- 2 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. exp(pi) + log(2) has been converted to 24 (expecting either 23 or 24 -- 24 would be better) Warning: the given expression is not a constant but an expression to evaluate. A faithful evaluation will be used. log10(2) / log10(3) - log(2) / log(3) has been converted to 0 (expecting 0). Warning: the given expression is not a constant but an expression to evaluate and a faithful evaluation is *NOT* possible. (sin((pi) / 3) - sqrt(3) / 2) * 9.99002e30102 + 3 has been converted to some number. Expecting that the above warning message states that faithtul evaluation is *NOT* possible. Testing a tricky expression. Might return UINT64_MAX with an overflow message or return anything with a message stating that faithful rounding was not possible... OK (sin((pi) / 3) - sqrt(3) / 2) * 9.99002e30102 + 6.3058e18061 has been converted to some number. Warning: rounding occurred on retrieval of a constant. -infty has been converted to 0 (expecting 0). Warning: rounding occurred on retrieval of a constant. infty has been converted to UINT64_MAX Warning: a Not-A-Number value has been converted to a number upon retrieval of a constant. NaN has been converted to 0 (expecting 0). sollya-6.0+ds/tests-lib/tget_diam.c000066400000000000000000000003421300174114700172700ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_diam(); sollya_lib_printf("Default value for diam: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_diam.reference000066400000000000000000000000611300174114700210020ustar00rootroot00000000000000Default value for diam: 1.0001659393310546875e-4 sollya-6.0+ds/tests-lib/tget_dieonerrormode.c000066400000000000000000000003661300174114700214010ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_dieonerrormode(); sollya_lib_printf("Default value for dieonerrormode: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_dieonerrormode.reference000066400000000000000000000000461300174114700231100ustar00rootroot00000000000000Default value for dieonerrormode: off sollya-6.0+ds/tests-lib/tget_display.c000066400000000000000000000003501300174114700200220ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_display(); sollya_lib_printf("Default value for display: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_display.reference000066400000000000000000000000431300174114700215350ustar00rootroot00000000000000Default value for display: decimal sollya-6.0+ds/tests-lib/tget_element_in_list.c000066400000000000000000000213571300174114700215410ustar00rootroot00000000000000#include int main(void) { sollya_obj_t listobj; sollya_obj_t a; int i; sollya_lib_init(); /* Empty list */ listobj = sollya_lib_build_list(NULL); a = NULL; i = 0; if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Success on %b : %b (i=%d)\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n", listobj, i, a); } if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Second call on %b : %b (i=%d)\n\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n\n", listobj, i, a); } sollya_lib_clear_obj(listobj); /* Negative index on a regular list */ listobj = sollya_lib_build_list(SOLLYA_CONST(3.), SOLLYA_COS(SOLLYA_X_), sollya_lib_double_obj(), NULL); a = NULL; i = -1; if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Success on %b : %b (i=%d)\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n", listobj, i, a); } if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Second call on %b : %b (i=%d)\n\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n\n", listobj, i, a); } sollya_lib_clear_obj(listobj); /* Out-of-bounds index on a regular list */ listobj = sollya_lib_build_list(SOLLYA_CONST(3.), SOLLYA_COS(SOLLYA_X_), sollya_lib_double_obj(), NULL); a = NULL; i = 3; if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Success on %b : %b (i=%d)\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n", listobj, i, a); } if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Second call on %b : %b (i=%d)\n\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n\n", listobj, i, a); } sollya_lib_clear_obj(listobj); /* First element on a regular list */ listobj = sollya_lib_build_list(SOLLYA_CONST(3.), SOLLYA_COS(SOLLYA_X_), sollya_lib_double_obj(), NULL); a = NULL; i=0; if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Success on %b : %b (i=%d)\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n", listobj, i, a); } if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Second call on %b : %b (i=%d)\n\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n\n", listobj, i, a); } sollya_lib_clear_obj(listobj); /* Last element on a regular list */ listobj = sollya_lib_build_list(SOLLYA_CONST(3.), SOLLYA_COS(SOLLYA_X_), sollya_lib_double_obj(), NULL); a = NULL; i=2; if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Success on %b : %b (i=%d)\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n", listobj, i, a); } if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Second call on %b : %b (i=%d)\n\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n\n", listobj, i, a); } sollya_lib_clear_obj(listobj); /* Negative index on an end-elliptic list */ listobj = sollya_lib_build_end_elliptic_list(SOLLYA_CONST(3.), SOLLYA_COS(SOLLYA_X_), sollya_lib_double_obj(), NULL); a = NULL; i=-1; if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Success on %b : %b (i=%d)\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n", listobj, i, a); } if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Second call on %b : %b (i=%d)\n\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n\n", listobj, i, a); } sollya_lib_clear_obj(listobj); /* index after the ellipsis on an end-elliptic list ending with a non-integer element */ listobj = sollya_lib_build_end_elliptic_list(SOLLYA_CONST(3.), SOLLYA_COS(SOLLYA_X_), sollya_lib_double_obj(), NULL); a = NULL; i=3; if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Success on %b : %b (i=%d)\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n", listobj, i, a); } if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Second call on %b : %b (i=%d)\n\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n\n", listobj, i, a); } sollya_lib_clear_obj(listobj); /* index after the ellipsis on an end-elliptic list ending with an integer element */ listobj = sollya_lib_build_end_elliptic_list(SOLLYA_PI, SOLLYA_COS(SOLLYA_X_), SOLLYA_CONST(4.), NULL); a = NULL; i=3; if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Success on %b : %b (i=%d)\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n", listobj, i, a); } if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Second call on %b : %b (i=%d)\n\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n\n", listobj, i, a); } sollya_lib_clear_obj(listobj); /* First element on an end-elliptic list */ listobj = sollya_lib_build_end_elliptic_list(SOLLYA_PI, SOLLYA_COS(SOLLYA_X_), SOLLYA_CONST(4.), NULL); a = NULL; i=0; if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Success on %b : %b (i=%d)\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n", listobj, i, a); } if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Second call on %b : %b (i=%d)\n\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n\n", listobj, i, a); } sollya_lib_clear_obj(listobj); /* Last element before the ellipsis on an end-elliptic list */ listobj = sollya_lib_build_end_elliptic_list(SOLLYA_PI, SOLLYA_COS(SOLLYA_X_), SOLLYA_CONST(4.), NULL); a = NULL; i=2; if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Success on %b : %b (i=%d)\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n", listobj, i, a); } if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Second call on %b : %b (i=%d)\n\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n\n", listobj, i, a); } sollya_lib_clear_obj(listobj); /* Not a list */ listobj = SOLLYA_COS(SOLLYA_X_); a = NULL; i=0; if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Success on %b : %b (i=%d)\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n", listobj, i, a); } if (sollya_lib_get_element_in_list(&a, listobj, i)) { sollya_lib_printf("Second call on %b : %b (i=%d)\n\n", listobj, a, i); sollya_lib_clear_obj(a); } else { sollya_lib_printf("Failure on %b (i=%d and a=%b).\n\n", listobj, i, a); } sollya_lib_clear_obj(listobj); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_element_in_list.reference000066400000000000000000000020571300174114700232510ustar00rootroot00000000000000Failure on [| |] (i=0 and a=NULL). Failure on [| |] (i=0 and a=NULL). Failure on [|3, cos(_x_), double|] (i=-1 and a=NULL). Failure on [|3, cos(_x_), double|] (i=-1 and a=NULL). Failure on [|3, cos(_x_), double|] (i=3 and a=NULL). Failure on [|3, cos(_x_), double|] (i=3 and a=NULL). Success on [|3, cos(_x_), double|] : 3 (i=0) Second call on [|3, cos(_x_), double|] : 3 (i=0) Success on [|3, cos(_x_), double|] : double (i=2) Second call on [|3, cos(_x_), double|] : double (i=2) Failure on [|3, cos(_x_), double...|] (i=-1 and a=NULL). Failure on [|3, cos(_x_), double...|] (i=-1 and a=NULL). Success on [|3, cos(_x_), double...|] : double (i=3) Second call on [|3, cos(_x_), double...|] : double (i=3) Success on [|pi, cos(_x_), 4...|] : 5 (i=3) Second call on [|pi, cos(_x_), 4...|] : 5 (i=3) Success on [|pi, cos(_x_), 4...|] : pi (i=0) Second call on [|pi, cos(_x_), 4...|] : pi (i=0) Success on [|pi, cos(_x_), 4...|] : 4 (i=2) Second call on [|pi, cos(_x_), 4...|] : 4 (i=2) Failure on cos(_x_) (i=0 and a=NULL). Failure on cos(_x_) (i=0 and a=NULL). sollya-6.0+ds/tests-lib/tget_element_in_list_timecomplexity.c000066400000000000000000000051361300174114700246720ustar00rootroot00000000000000#include #ifdef HAVE_CONFIG_H #include "config.h" #endif #if TIME_WITH_SYS_TIME #include #include #else #if HAVE_SYS_TIME_H #include #else #include #endif #endif #if defined(HAVE_GETTIMEOFDAY) && HAVE_GETTIMEOFDAY #include #define LIST_SIZE 8000 int main(void) { sollya_obj_t listobj; sollya_obj_t tab[LIST_SIZE]; sollya_obj_t a; int i, k; struct timeval t1; struct timeval t2; double length1; double length2; int64_t nb_iter; int res = 0; sollya_lib_init(); for(i=0;i #include int main(void) { sollya_obj_t a, b; sollya_obj_t ea, eb, ec, ed; int ra, rb, rc, rd; sollya_lib_init(); a = sollya_lib_parse_string("{ .a = 5; .b = exp(_x_); .c = { .d = 17; .e = sin(_x_) }}"); b = SOLLYA_EXP(SOLLYA_X_); ea = NULL; ra = sollya_lib_get_element_in_structure(&ea, "a", a); sollya_lib_printf("Does the Sollya object %b contain an element called \"a\"? %s. ",a,(ra?"Yes":"No")); if (ra) sollya_lib_printf("That element is %b.",ea); sollya_lib_printf("\n"); eb = NULL; rb = sollya_lib_get_element_in_structure(&eb, "a", b); sollya_lib_printf("Does the Sollya object %b contain an element called \"a\"? %s. ",b,(rb?"Yes":"No")); if (rb) sollya_lib_printf("That element is %b.",eb); sollya_lib_printf("\n"); ec = NULL; rc = sollya_lib_get_element_in_structure(&ec, "u", a); sollya_lib_printf("Does the Sollya object %b contain an element called \"u\"? %s. ",a,(rc?"Yes":"No")); if (rc) sollya_lib_printf("That element is %b.",ec); sollya_lib_printf("\n"); ed = NULL; rd = sollya_lib_get_element_in_structure(&ec, "d", a); sollya_lib_printf("Does the Sollya object %b contain an element called \"d\"? %s. ",a,(rd?"Yes":"No")); if (rd) sollya_lib_printf("That element is %b.",ed); sollya_lib_printf("\n"); if (ea != NULL) sollya_lib_clear_obj(ea); if (eb != NULL) sollya_lib_clear_obj(eb); if (ec != NULL) sollya_lib_clear_obj(ec); if (ed != NULL) sollya_lib_clear_obj(ed); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_element_in_structure.reference000066400000000000000000000006711300174114700243360ustar00rootroot00000000000000Does the Sollya object { .a = 5, .b = exp(_x_), .c = { .d = 17, .e = sin(_x_) } } contain an element called "a"? Yes. That element is 5. Does the Sollya object exp(_x_) contain an element called "a"? No. Does the Sollya object { .a = 5, .b = exp(_x_), .c = { .d = 17, .e = sin(_x_) } } contain an element called "u"? No. Does the Sollya object { .a = 5, .b = exp(_x_), .c = { .d = 17, .e = sin(_x_) } } contain an element called "d"? No. sollya-6.0+ds/tests-lib/tget_free_variable_name.c000066400000000000000000000012411300174114700221430ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; char *name; sollya_lib_init(); f = SOLLYA_ADD(SOLLYA_COS(SOLLYA_X_), SOLLYA_X_); name = sollya_lib_get_free_variable_name(); sollya_lib_printf("%b (variable name: %s)\n", f, name); name[0]='a'; sollya_lib_printf("%b (with local name changed: %s)\n", f, name); sollya_lib_free(name); sollya_lib_name_free_variable("foo"); name = sollya_lib_get_free_variable_name(); sollya_lib_printf("%b (variable name: %s)\n", f, name); name[0]='a'; sollya_lib_printf("%b (with local name changed: %s)\n", f, name); sollya_lib_free(name); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_free_variable_name.reference000066400000000000000000000002441300174114700236610ustar00rootroot00000000000000cos(_x_) + _x_ (variable name: _x_) cos(_x_) + _x_ (with local name changed: ax_) cos(foo) + foo (variable name: foo) cos(foo) + foo (with local name changed: aoo) sollya-6.0+ds/tests-lib/tget_function_arity.c000066400000000000000000000073061300174114700214220ustar00rootroot00000000000000#include #include #include void euler_gamma(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } int stupid1(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int main(void) { sollya_obj_t f, tmp; int n; int res; sollya_lib_init(); /* Constant */ f = SOLLYA_PI; n = -1; res = sollya_lib_get_function_arity(&n, f); if (res) sollya_lib_printf("Arity of %b: %d\n", f, n); else sollya_lib_printf("%b is not a functional expression (n=%d. Expecting -1)\n", f, n); sollya_lib_clear_obj(f); /* Another constant */ f = SOLLYA_CONST(3); n = -1; res = sollya_lib_get_function_arity(&n, f); if (res) sollya_lib_printf("Arity of %b: %d\n", f, n); else sollya_lib_printf("%b is not a functional expression (n=%d. Expecting -1)\n", f, n); sollya_lib_clear_obj(f); /* A library constant constant */ f = sollya_lib_libraryconstant("superconst", euler_gamma); n = -1; res = sollya_lib_get_function_arity(&n, f); if (res) sollya_lib_printf("Arity of %b: %d\n", f, n); else sollya_lib_printf("%b is not a functional expression (n=%d. Expecting -1)\n", f, n); sollya_lib_clear_obj(f); /* Free variable */ f = SOLLYA_X_; n = -1; res = sollya_lib_get_function_arity(&n, f); if (res) sollya_lib_printf("Arity of %b: %d\n", f, n); else sollya_lib_printf("%b is not a functional expression (n=%d. Expecting -1)\n", f, n); sollya_lib_clear_obj(f); /* Elementary function */ f = SOLLYA_EXP(SOLLYA_X_); n = -1; res = sollya_lib_get_function_arity(&n, f); if (res) sollya_lib_printf("Arity of %b: %d\n", f, n); else sollya_lib_printf("%b is not a functional expression (n=%d. Expecting -1)\n", f, n); sollya_lib_clear_obj(f); /* Procedure function */ tmp = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); tmp = sollya_lib_build_function_procedurefunction(SOLLYA_X_, tmp); f = sollya_lib_diff(tmp); n = -1; res = sollya_lib_get_function_arity(&n, f); if (res) sollya_lib_printf("Arity of %b: %d\n", f, n); else sollya_lib_printf("%b is not a functional expression (n=%d. Expecting -1)\n", f, n); sollya_lib_clear_obj(tmp); sollya_lib_clear_obj(f); /* Library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "stupid1", stupid1); n = -1; res = sollya_lib_get_function_arity(&n, f); if (res) sollya_lib_printf("Arity of %b: %d\n", f, n); else sollya_lib_printf("%b is not a functional expression (n=%d. Expecting -1)\n", f, n); sollya_lib_clear_obj(f); /* arithmetic operator */ f = SOLLYA_ADD(SOLLYA_X_, sollya_lib_build_function_libraryfunction(SOLLYA_X_, "stupid1", stupid1)); n = -1; res = sollya_lib_get_function_arity(&n, f); if (res) sollya_lib_printf("Arity of %b: %d\n", f, n); else sollya_lib_printf("%b is not a functional expression (n=%d. Expecting -1)\n", f, n); sollya_lib_clear_obj(f); /* A Sollya object that is not an expression */ f = sollya_lib_absolute(); n = -1; res = sollya_lib_get_function_arity(&n, f); if (res) sollya_lib_printf("Arity of %b: %d\n", f, n); else sollya_lib_printf("%b is not a functional expression (n=%d. Expecting -1)\n", f, n); sollya_lib_clear_obj(f); /* Another one */ f = sollya_lib_parse_string("[1,2]"); n = -1; res = sollya_lib_get_function_arity(&n, f); if (res) sollya_lib_printf("Arity of %b: %d\n", f, n); else sollya_lib_printf("%b is not a functional expression (n=%d. Expecting -1)\n", f, n); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_function_arity.reference000066400000000000000000000006041300174114700231300ustar00rootroot00000000000000Arity of pi: 0 Arity of 3: 0 Arity of superconst: 0 Arity of _x_: 1 Arity of exp(_x_): 1 Arity of diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })): 1 Arity of stupid1: 1 Arity of _x_ + stupid1: 2 absolute is not a functional expression (n=-1. Expecting -1) [1;2] is not a functional expression (n=-1. Expecting -1) sollya-6.0+ds/tests-lib/tget_head_function.c000066400000000000000000000165151300174114700211750ustar00rootroot00000000000000#include #include #include char *pretty_print(sollya_base_function_t type) { switch(type) { case SOLLYA_BASE_FUNC_ABS: return "SOLLYA_BASE_FUNC_ABS"; case SOLLYA_BASE_FUNC_ACOS: return "SOLLYA_BASE_FUNC_ACOS"; case SOLLYA_BASE_FUNC_ACOSH: return "SOLLYA_BASE_FUNC_ACOSH"; case SOLLYA_BASE_FUNC_ADD: return "SOLLYA_BASE_FUNC_ADD"; case SOLLYA_BASE_FUNC_ASIN: return "SOLLYA_BASE_FUNC_ASIN"; case SOLLYA_BASE_FUNC_ASINH: return "SOLLYA_BASE_FUNC_ASINH"; case SOLLYA_BASE_FUNC_ATAN: return "SOLLYA_BASE_FUNC_ATAN"; case SOLLYA_BASE_FUNC_ATANH: return "SOLLYA_BASE_FUNC_ATANH"; case SOLLYA_BASE_FUNC_CEIL: return "SOLLYA_BASE_FUNC_CEIL"; case SOLLYA_BASE_FUNC_CONSTANT: return "SOLLYA_BASE_FUNC_CONSTANT"; case SOLLYA_BASE_FUNC_COS: return "SOLLYA_BASE_FUNC_COS"; case SOLLYA_BASE_FUNC_COSH: return "SOLLYA_BASE_FUNC_COSH"; case SOLLYA_BASE_FUNC_DIV: return "SOLLYA_BASE_FUNC_DIV"; case SOLLYA_BASE_FUNC_DOUBLE: return "SOLLYA_BASE_FUNC_DOUBLE"; case SOLLYA_BASE_FUNC_DOUBLEDOUBLE: return "SOLLYA_BASE_FUNC_DOUBLEDOUBLE"; case SOLLYA_BASE_FUNC_DOUBLEEXTENDED: return "SOLLYA_BASE_FUNC_DOUBLEEXTENDED"; case SOLLYA_BASE_FUNC_ERF: return "SOLLYA_BASE_FUNC_ERF"; case SOLLYA_BASE_FUNC_ERFC: return "SOLLYA_BASE_FUNC_ERFC"; case SOLLYA_BASE_FUNC_EXP: return "SOLLYA_BASE_FUNC_EXP"; case SOLLYA_BASE_FUNC_EXP_M1: return "SOLLYA_BASE_FUNC_EXP_M1"; case SOLLYA_BASE_FUNC_FLOOR: return "SOLLYA_BASE_FUNC_FLOOR"; case SOLLYA_BASE_FUNC_FREE_VARIABLE: return "SOLLYA_BASE_FUNC_FREE_VARIABLE"; case SOLLYA_BASE_FUNC_HALFPRECISION: return "SOLLYA_BASE_FUNC_HALFPRECISION"; case SOLLYA_BASE_FUNC_LIBRARYCONSTANT: return "SOLLYA_BASE_FUNC_LIBRARYCONSTANT"; case SOLLYA_BASE_FUNC_LIBRARYFUNCTION: return "SOLLYA_BASE_FUNC_LIBRARYFUNCTION"; case SOLLYA_BASE_FUNC_LOG: return "SOLLYA_BASE_FUNC_LOG"; case SOLLYA_BASE_FUNC_LOG_10: return "SOLLYA_BASE_FUNC_LOG_10"; case SOLLYA_BASE_FUNC_LOG_1P: return "SOLLYA_BASE_FUNC_LOG_1P"; case SOLLYA_BASE_FUNC_LOG_2: return "SOLLYA_BASE_FUNC_LOG_2"; case SOLLYA_BASE_FUNC_MUL: return "SOLLYA_BASE_FUNC_MUL"; case SOLLYA_BASE_FUNC_NEARESTINT: return "SOLLYA_BASE_FUNC_NEARESTINT"; case SOLLYA_BASE_FUNC_NEG: return "SOLLYA_BASE_FUNC_NEG"; case SOLLYA_BASE_FUNC_PI: return "SOLLYA_BASE_FUNC_PI"; case SOLLYA_BASE_FUNC_POW: return "SOLLYA_BASE_FUNC_POW"; case SOLLYA_BASE_FUNC_PROCEDUREFUNCTION: return "SOLLYA_BASE_FUNC_PROCEDUREFUNCTION"; case SOLLYA_BASE_FUNC_QUAD: return "SOLLYA_BASE_FUNC_QUAD"; case SOLLYA_BASE_FUNC_SIN: return "SOLLYA_BASE_FUNC_SIN"; case SOLLYA_BASE_FUNC_SINGLE: return "SOLLYA_BASE_FUNC_SINGLE"; case SOLLYA_BASE_FUNC_SINH: return "SOLLYA_BASE_FUNC_SINH"; case SOLLYA_BASE_FUNC_SQRT: return "SOLLYA_BASE_FUNC_SQRT"; case SOLLYA_BASE_FUNC_SUB: return "SOLLYA_BASE_FUNC_SUB"; case SOLLYA_BASE_FUNC_TAN: return "SOLLYA_BASE_FUNC_TAN"; case SOLLYA_BASE_FUNC_TANH: return "SOLLYA_BASE_FUNC_TANH"; case SOLLYA_BASE_FUNC_TRIPLEDOUBLE: return"SOLLYA_BASE_FUNC_TRIPLEDOUBLE"; default: return "Unknown type"; } } void euler_gamma(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } int stupid1(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int main(void) { sollya_obj_t f, tmp; sollya_base_function_t type; int res; sollya_lib_init(); /* Constant */ f = SOLLYA_PI; type = (sollya_base_function_t) -1; res = sollya_lib_get_head_function(&type, f); if (res) sollya_lib_printf("Type of %b: %s\n", f, pretty_print(type)); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting -1)\n", f, pretty_print(type)); sollya_lib_clear_obj(f); /* Another constant */ f = SOLLYA_CONST(3); type = (sollya_base_function_t) -1; res = sollya_lib_get_head_function(&type, f); if (res) sollya_lib_printf("Type of %b: %s\n", f, pretty_print(type)); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting -1)\n", f, pretty_print(type)); sollya_lib_clear_obj(f); /* A library constant constant */ f = sollya_lib_libraryconstant("superconst", euler_gamma); type = (sollya_base_function_t) -1; res = sollya_lib_get_head_function(&type, f); if (res) sollya_lib_printf("Type of %b: %s\n", f, pretty_print(type)); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting -1)\n", f, pretty_print(type)); sollya_lib_clear_obj(f); /* Free variable */ f = SOLLYA_X_; type = (sollya_base_function_t) -1; res = sollya_lib_get_head_function(&type, f); if (res) sollya_lib_printf("Type of %b: %s\n", f, pretty_print(type)); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting -1)\n", f, pretty_print(type)); sollya_lib_clear_obj(f); /* Elementary function */ f = SOLLYA_EXP(SOLLYA_X_); type = (sollya_base_function_t) -1; res = sollya_lib_get_head_function(&type, f); if (res) sollya_lib_printf("Type of %b: %s\n", f, pretty_print(type)); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting -1)\n", f, pretty_print(type)); sollya_lib_clear_obj(f); /* Procedure function */ tmp = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); tmp = sollya_lib_build_function_procedurefunction(SOLLYA_X_, tmp); f = sollya_lib_diff(tmp); type = (sollya_base_function_t) -1; res = sollya_lib_get_head_function(&type, f); if (res) sollya_lib_printf("Type of %b: %s\n", f, pretty_print(type)); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting -1)\n", f, pretty_print(type)); sollya_lib_clear_obj(tmp); sollya_lib_clear_obj(f); /* Library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "stupid1", stupid1); type = (sollya_base_function_t) -1; res = sollya_lib_get_head_function(&type, f); if (res) sollya_lib_printf("Type of %b: %s\n", f, pretty_print(type)); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting -1)\n", f, pretty_print(type)); sollya_lib_clear_obj(f); /* arithmetic operator */ f = SOLLYA_ADD(SOLLYA_X_, sollya_lib_build_function_libraryfunction(SOLLYA_X_, "stupid1", stupid1)); type = (sollya_base_function_t) -1; res = sollya_lib_get_head_function(&type, f); if (res) sollya_lib_printf("Type of %b: %s\n", f, pretty_print(type)); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting -1)\n", f, pretty_print(type)); sollya_lib_clear_obj(f); /* A Sollya object that is not an expression */ f = sollya_lib_absolute(); type = (sollya_base_function_t) -1; res = sollya_lib_get_head_function(&type, f); if (res) sollya_lib_printf("Type of %b: %s\n", f, pretty_print(type)); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); /* Another one */ f = sollya_lib_parse_string("[1,2]"); type = (sollya_base_function_t) -1; res = sollya_lib_get_head_function(&type, f); if (res) sollya_lib_printf("Type of %b: %s\n", f, pretty_print(type)); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_head_function.reference000066400000000000000000000011721300174114700227020ustar00rootroot00000000000000Type of pi: SOLLYA_BASE_FUNC_PI Type of 3: SOLLYA_BASE_FUNC_CONSTANT Type of superconst: SOLLYA_BASE_FUNC_LIBRARYCONSTANT Type of _x_: SOLLYA_BASE_FUNC_FREE_VARIABLE Type of exp(_x_): SOLLYA_BASE_FUNC_EXP Type of diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })): SOLLYA_BASE_FUNC_PROCEDUREFUNCTION Type of stupid1: SOLLYA_BASE_FUNC_LIBRARYFUNCTION Type of _x_ + stupid1: SOLLYA_BASE_FUNC_ADD absolute is not a functional expression (type=Unknown type. Expecting 'Unknown type') [1;2] is not a functional expression (type=Unknown type. Expecting 'Unknown type') sollya-6.0+ds/tests-lib/tget_hopitalrecursions.c000066400000000000000000000003741300174114700221400ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Default value for hopitalrecursions: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_hopitalrecursions.reference000066400000000000000000000000471300174114700236510ustar00rootroot00000000000000Default value for hopitalrecursions: 2 sollya-6.0+ds/tests-lib/tget_interval_from_range.c000066400000000000000000000041111300174114700223770ustar00rootroot00000000000000#include int callback(sollya_msg_t m, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int id = sollya_lib_get_msg_id(m); switch(id) { case SOLLYA_MSG_SAFE_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST: return 0; default: printf("Unexpected warning message number %d\n", id); return 1; } } int main(void) { sollya_obj_t a; mpfi_t res; int s; mpfi_init2(res, 100); sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a = SOLLYA_CONST(4); s = sollya_lib_get_interval_from_range(res, a); if (s==0) sollya_lib_printf("%b is not a range\n\n", a); else sollya_lib_printf("%b has been converted to %w.\n\n", a, res); sollya_lib_clear_obj(a); /* Exact conversion */ a = sollya_lib_parse_string("[1, 3]"); s = sollya_lib_get_interval_from_range(res, a); if (s==0) sollya_lib_printf("%b is not a range\n\n", a); else sollya_lib_printf("%b has been converted to %w.\n\n", a, res); sollya_lib_clear_obj(a); /* Another exact conversion */ a = SOLLYA_CONST(100); sollya_lib_set_prec_and_print(a); sollya_lib_clear_obj(a); a = sollya_lib_powers(); sollya_lib_set_display(a); sollya_lib_clear_obj(a); a = sollya_lib_parse_string("[exp(1), pi]"); s = sollya_lib_get_interval_from_range(res, a); if (s==0) sollya_lib_printf("%b is not a range\n\n", a); else sollya_lib_printf("%b has been converted to\n%w (should be [430728948929449700355022696705 * 2^(-97), 995610453248924340922087778489 * 2^(-98)]).\n\n", a, res); sollya_lib_clear_obj(a); /* Inexact conversion */ a = SOLLYA_CONST(165); sollya_lib_set_prec_and_print(a); sollya_lib_clear_obj(a); a = sollya_lib_decimal(); sollya_lib_set_display(a); sollya_lib_clear_obj(a); a = sollya_lib_parse_string("[exp(1), pi]"); s = sollya_lib_get_interval_from_range(res, a); if (s==0) sollya_lib_printf("%b is not a range\n\n", a); else sollya_lib_printf("%b has been converted to\n%w (the first one should be enclosed in the second one).\n\n", a, res); sollya_lib_clear_obj(a); mpfi_clear(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_interval_from_range.reference000066400000000000000000000013101300174114700241110ustar00rootroot000000000000004 is not a range [1;3] has been converted to [1;3]. The precision has been set to 100 bits. [430728948929449700355022696705 * 2^(-97);995610453248924340922087778489 * 2^(-98)] has been converted to [430728948929449700355022696705 * 2^(-97);995610453248924340922087778489 * 2^(-98)] (should be [430728948929449700355022696705 * 2^(-97), 995610453248924340922087778489 * 2^(-98)]). The precision has been set to 165 bits. [2.7182818284590452353602874713526624977572470936999;3.1415926535897932384626433832795028841971693993752] has been converted to [2.7182818284590452353602874713512348150836420479793;3.1415926535897932384626433832824887592648460686039] (the first one should be enclosed in the second one). sollya-6.0+ds/tests-lib/tget_list_elements.c000066400000000000000000000101751300174114700212320ustar00rootroot00000000000000#include int main(void) { sollya_obj_t listobj; sollya_obj_t *ptr; int i, n, end_ell; sollya_lib_init(); /* Empty list */ listobj = sollya_lib_build_list(NULL); n = -1; end_ell = -1; ptr = NULL; if (sollya_lib_get_list_elements(&ptr, &n, &end_ell, listobj)) { sollya_lib_printf("Success on %b (n=%d and end_ell=%d).", listobj, n, end_ell); for(i=0;i int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_midpointmode(); sollya_lib_printf("Default value for midpointmode: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_midpointmode.reference000066400000000000000000000000441300174114700225610ustar00rootroot00000000000000Default value for midpointmode: off sollya-6.0+ds/tests-lib/tget_nth_subfunction.c000066400000000000000000000117661300174114700216020ustar00rootroot00000000000000#include #include #include void euler_gamma(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } int stupid1(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int main(void) { sollya_obj_t f, tmp, tmp2, tmp3; sollya_obj_t g; int n; int res; sollya_lib_init(); for(n=0;n<=3;n++) { /* Constant */ f = SOLLYA_PI; g = NULL; res = -1; res = sollya_lib_get_nth_subfunction(&g, f, n); if (res) sollya_lib_printf("Subfunction of %b (n=%d): %b\n", f, n, g); else sollya_lib_printf("No subfunction of %b such that n=%d\n", f, n); sollya_lib_clear_obj(f); if (g != NULL) sollya_lib_clear_obj(g); /* Another constant */ f = SOLLYA_CONST(3); g = NULL; res = -1; res = sollya_lib_get_nth_subfunction(&g, f, n); if (res) sollya_lib_printf("Subfunction of %b (n=%d): %b\n", f, n, g); else sollya_lib_printf("No subfunction of %b such that n=%d\n", f, n); sollya_lib_clear_obj(f); if (g != NULL) sollya_lib_clear_obj(g); /* A library constant constant */ f = sollya_lib_libraryconstant("superconst", euler_gamma); g = NULL; res = -1; res = sollya_lib_get_nth_subfunction(&g, f, n); if (res) sollya_lib_printf("Subfunction of %b (n=%d): %b\n", f, n, g); else sollya_lib_printf("No subfunction of %b such that n=%d\n", f, n); sollya_lib_clear_obj(f); if (g != NULL) sollya_lib_clear_obj(g); /* Free variable */ f = SOLLYA_X_; g = NULL; res = -1; res = sollya_lib_get_nth_subfunction(&g, f, n); if (res) sollya_lib_printf("Subfunction of %b (n=%d): %b\n", f, n, g); else sollya_lib_printf("No subfunction of %b such that n=%d\n", f, n); sollya_lib_clear_obj(f); if (g != NULL) sollya_lib_clear_obj(g); /* Elementary function */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); g = NULL; res = -1; res = sollya_lib_get_nth_subfunction(&g, f, n); if (res) sollya_lib_printf("Subfunction of %b (n=%d): %b\n", f, n, g); else sollya_lib_printf("No subfunction of %b such that n=%d\n", f, n); sollya_lib_clear_obj(f); if (g != NULL) sollya_lib_clear_obj(g); /* Procedure function */ tmp = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); tmp = sollya_lib_build_function_procedurefunction(SOLLYA_X_, tmp); tmp2 = sollya_lib_diff(tmp); tmp3 = SOLLYA_SIN(SOLLYA_X_); f = sollya_lib_apply(tmp2, tmp3, NULL); g = NULL; res = -1; res = sollya_lib_get_nth_subfunction(&g, f, n); if (res) sollya_lib_printf("Subfunction of %b (n=%d): %b\n", f, n, g); else sollya_lib_printf("No subfunction of %b such that n=%d\n", f, n); sollya_lib_clear_obj(f); if (g != NULL) sollya_lib_clear_obj(g); sollya_lib_clear_obj(tmp); sollya_lib_clear_obj(tmp2); sollya_lib_clear_obj(tmp3); /* Library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); g = NULL; res = -1; res = sollya_lib_get_nth_subfunction(&g, f, n); if (res) sollya_lib_printf("Subfunction of %b (n=%d): %b\n", f, n, g); else sollya_lib_printf("No subfunction of %b such that n=%d\n", f, n); sollya_lib_clear_obj(f); if (g != NULL) sollya_lib_clear_obj(g); /* arithmetic operator */ f = SOLLYA_ADD(SOLLYA_X_, sollya_lib_build_function_libraryfunction(SOLLYA_X_, "stupid1", stupid1)); g = NULL; res = -1; res = sollya_lib_get_nth_subfunction(&g, f, n); if (res) sollya_lib_printf("Subfunction of %b (n=%d): %b\n", f, n, g); else sollya_lib_printf("No subfunction of %b such that n=%d\n", f, n); sollya_lib_clear_obj(f); if (g != NULL) sollya_lib_clear_obj(g); /* A Sollya object that is not an expression */ f = sollya_lib_absolute(); g = NULL; res = -1; res = sollya_lib_get_nth_subfunction(&g, f, n); if (res) sollya_lib_printf("Subfunction of %b (n=%d): %b\n", f, n, g); else sollya_lib_printf("No subfunction of %b such that n=%d\n", f, n); sollya_lib_clear_obj(f); if (g != NULL) sollya_lib_clear_obj(g); /* Another one */ f = sollya_lib_parse_string("[1,2]"); g = NULL; res = -1; res = sollya_lib_get_nth_subfunction(&g, f, n); if (res) sollya_lib_printf("Subfunction of %b (n=%d): %b\n", f, n, g); else sollya_lib_printf("No subfunction of %b such that n=%d\n", f, n); sollya_lib_clear_obj(f); if (g != NULL) sollya_lib_clear_obj(g); /* What if f is NULL? */ f = NULL; g = NULL; res = -1; res = sollya_lib_get_nth_subfunction(&g, f, n); if (res) sollya_lib_printf("Subfunction of %b (n=%d): %b\n", f, n, g); else sollya_lib_printf("No subfunction of %b such that n=%d\n", f, n); sollya_lib_clear_obj(f); if (g != NULL) sollya_lib_clear_obj(g); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_nth_subfunction.reference000066400000000000000000000045301300174114700233050ustar00rootroot00000000000000No subfunction of pi such that n=0 No subfunction of 3 such that n=0 No subfunction of superconst such that n=0 No subfunction of _x_ such that n=0 No subfunction of exp(sin(_x_) + 17) such that n=0 No subfunction of (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(sin(_x_)) such that n=0 No subfunction of stupid1(cos(_x_)) such that n=0 No subfunction of _x_ + stupid1 such that n=0 No subfunction of absolute such that n=0 No subfunction of [1;2] such that n=0 No subfunction of NULL such that n=0 Subfunction of pi (n=1): pi Subfunction of 3 (n=1): 3 Subfunction of superconst (n=1): superconst Subfunction of _x_ (n=1): _x_ Subfunction of exp(sin(_x_) + 17) (n=1): sin(_x_) + 17 Subfunction of (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(sin(_x_)) (n=1): sin(_x_) Subfunction of stupid1(cos(_x_)) (n=1): cos(_x_) Subfunction of _x_ + stupid1 (n=1): _x_ No subfunction of absolute such that n=1 No subfunction of [1;2] such that n=1 No subfunction of NULL such that n=1 No subfunction of pi such that n=2 No subfunction of 3 such that n=2 No subfunction of superconst such that n=2 No subfunction of _x_ such that n=2 No subfunction of exp(sin(_x_) + 17) such that n=2 Subfunction of (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(sin(_x_)) (n=2): diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })) Subfunction of stupid1(cos(_x_)) (n=2): stupid1 Subfunction of _x_ + stupid1 (n=2): stupid1 No subfunction of absolute such that n=2 No subfunction of [1;2] such that n=2 No subfunction of NULL such that n=2 No subfunction of pi such that n=3 No subfunction of 3 such that n=3 No subfunction of superconst such that n=3 No subfunction of _x_ such that n=3 No subfunction of exp(sin(_x_) + 17) such that n=3 No subfunction of (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(sin(_x_)) such that n=3 No subfunction of stupid1(cos(_x_)) such that n=3 No subfunction of _x_ + stupid1 such that n=3 No subfunction of absolute such that n=3 No subfunction of [1;2] such that n=3 No subfunction of NULL such that n=3 sollya-6.0+ds/tests-lib/tget_points.c000066400000000000000000000003461300174114700176760ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_points(); sollya_lib_printf("Default value for points: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_points.reference000066400000000000000000000000361300174114700214060ustar00rootroot00000000000000Default value for points: 501 sollya-6.0+ds/tests-lib/tget_prec.c000066400000000000000000000003421300174114700173070ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_prec(); sollya_lib_printf("Default value for prec: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_prec.reference000066400000000000000000000000341300174114700210210ustar00rootroot00000000000000Default value for prec: 165 sollya-6.0+ds/tests-lib/tget_rationalmode.c000066400000000000000000000003621300174114700210360ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_rationalmode(); sollya_lib_printf("Default value for rationalmode: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_rationalmode.reference000066400000000000000000000000441300174114700225470ustar00rootroot00000000000000Default value for rationalmode: off sollya-6.0+ds/tests-lib/tget_roundingwarnings.c000066400000000000000000000003721300174114700217570ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_roundingwarnings(); sollya_lib_printf("Default value for roundingwarnings: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_roundingwarnings.reference000066400000000000000000000000471300174114700234720ustar00rootroot00000000000000Default value for roundingwarnings: on sollya-6.0+ds/tests-lib/tget_showmessagenumbers.c000066400000000000000000000003761300174114700223060ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_showmessagenumbers(); sollya_lib_printf("Default value for showmessagenumbers: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_showmessagenumbers.reference000066400000000000000000000000521300174114700240110ustar00rootroot00000000000000Default value for showmessagenumbers: off sollya-6.0+ds/tests-lib/tget_string.c000066400000000000000000000016201300174114700176640ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; char *s; sollya_lib_init(); a = sollya_lib_parse_string("\"Hello, World!\""); if(!sollya_lib_get_string(&s, a)) sollya_lib_printf("%b is not a string\n\n", a); else { sollya_lib_printf("%b has been converted to \"%s\"\n\n", a, s); sollya_lib_free(s); } sollya_lib_clear_obj(a); a = sollya_lib_parse_string("[1; 2]"); if(!sollya_lib_get_string(&s, a)) sollya_lib_printf("%b is not a string\n\n", a); else { sollya_lib_printf("%b has been converted to \"%s\"\n\n", a, s); sollya_lib_free(s); } sollya_lib_clear_obj(a); a = sollya_lib_parse_string("\"\""); if(!sollya_lib_get_string(&s, a)) sollya_lib_printf("%b is not a string\n\n", a); else { sollya_lib_printf("%b has been converted to \"%s\"\n\n", a, s); sollya_lib_free(s); } sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_string.reference000066400000000000000000000001471300174114700214030ustar00rootroot00000000000000Hello, World! has been converted to "Hello, World!" [1;2] is not a string has been converted to "" sollya-6.0+ds/tests-lib/tget_structure_elements.c000066400000000000000000000030301300174114700223070ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a, b; int ra, rb; sollya_obj_t *ea, *eb; char **ia, **ib; int na, nb; int i; sollya_lib_init(); a = sollya_lib_parse_string("{ .a = 5; .b = exp(_x_); .c = { .d = 17; .e = sin(_x_) }}"); b = SOLLYA_EXP(SOLLYA_X_); ea = NULL; ia = NULL; eb = NULL; ib = NULL; na = -1; nb = -1; ra = sollya_lib_get_structure_elements(&ia, &ea, &na, a); rb = sollya_lib_get_structure_elements(&ib, &eb, &nb, b); sollya_lib_printf("Is the Sollya object %b detected as a structure? %s. It contains %d elements, which are ", a, (ra?"Yes":"No"), na); if (ra) { for (i=0;i %b, ", ia[i], ea[i]); } else { sollya_lib_printf("None"); } sollya_lib_printf("\n"); sollya_lib_printf("Is the Sollya object %b is detected as a structure? %s. It contains %d elements, which are ", b, (rb?"Yes":"No"), nb); if (rb) { for (i=0;i %b, ", ib[i], eb[i]); } else { sollya_lib_printf("None"); } sollya_lib_printf("\n"); if (ea != NULL) { for (i=0;i 5, b -> exp(_x_), c -> { .d = 17, .e = sin(_x_) }, Is the Sollya object exp(_x_) is detected as a structure? No. It contains -1 elements, which are None sollya-6.0+ds/tests-lib/tget_subfunctions.c000066400000000000000000000244301300174114700211040ustar00rootroot00000000000000#include #include #include void euler_gamma(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } int stupid1(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int main(void) { sollya_obj_t f, tmp, tmp2, tmp3; sollya_obj_t g[3]; int n; int res; sollya_lib_init(); /* Constant */ f = SOLLYA_PI; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Another constant */ f = SOLLYA_CONST(3); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* A library constant constant */ f = sollya_lib_libraryconstant("superconst", euler_gamma); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Free variable */ f = SOLLYA_X_; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Elementary function */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Procedure function */ tmp = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); tmp = sollya_lib_build_function_procedurefunction(SOLLYA_X_, tmp); tmp2 = sollya_lib_diff(tmp); tmp3 = SOLLYA_SIN(SOLLYA_X_); f = sollya_lib_apply(tmp2, tmp3, NULL); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); sollya_lib_clear_obj(tmp); sollya_lib_clear_obj(tmp2); sollya_lib_clear_obj(tmp3); /* Library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* arithmetic operator */ f = SOLLYA_ADD(SOLLYA_X_, sollya_lib_build_function_libraryfunction(SOLLYA_X_, "stupid1", stupid1)); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* A Sollya object that is not an expression */ f = sollya_lib_absolute(); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Another one */ f = sollya_lib_parse_string("[1,2]"); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /*************************************************************/ /* Testing what happens when NULL is encountered prematurely */ /*************************************************************/ /* As second argument */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("Subfunction of %b with NULL as 2nd argument: %b and %b (n=%d)\n", f, g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As third argument */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("Subfunction of %b with NULL as 3rd argument: %b and %b (n=%d)\n", f, g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As third argument in a binary operator */ f = SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17)); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("Subfunction of %b with NULL as 3rd argument: %b and %b (n=%d)\n", f, g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fourth argument in a binary operator */ f = SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17)); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, &g[0], NULL, &g[2]); if (res) sollya_lib_printf("Subfunction of %b with NULL as 4th argument: %b and %b (n=%d)\n", f, g[0], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As third argument in a library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("Subfunction of %b with NULL as 3rd argument: %b and %b (n=%d)\n", f, g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fourth argument in a library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = sollya_lib_get_subfunctions(f, &n, &g[0], NULL, &g[2]); if (res) sollya_lib_printf("Subfunction of %b with NULL as 4th argument: %b and %b (n=%d)\n", f, g[0], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_subfunctions.reference000066400000000000000000000025611300174114700226210ustar00rootroot00000000000000Subfunction of pi: pi, NULL and NULL (n=0) Subfunction of 3: 3, NULL and NULL (n=0) Subfunction of superconst: superconst, NULL and NULL (n=0) Subfunction of _x_: _x_, NULL and NULL (n=1) Subfunction of exp(sin(_x_) + 17): sin(_x_) + 17, NULL and NULL (n=1) Subfunction of (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(sin(_x_)): sin(_x_), diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })) and NULL (n=1) Subfunction of stupid1(cos(_x_)): cos(_x_), stupid1 and NULL (n=1) Subfunction of _x_ + stupid1: _x_, stupid1 and NULL (n=2) absolute is not a functional expression (n=-1, g[0]=NULL, g[1]=NULL, g[2]=NULL. Expecting -1, NULL, NULL, NULL) [1;2] is not a functional expression (n=-1, g[0]=NULL, g[1]=NULL, g[2]=NULL. Expecting -1, NULL, NULL, NULL) Subfunction of exp(sin(_x_) + 17) with NULL as 2nd argument: sin(_x_) + 17 and NULL (n=-1) Subfunction of exp(sin(_x_) + 17) with NULL as 3rd argument: NULL and NULL (n=1) Subfunction of sin(_x_) + 17 with NULL as 3rd argument: NULL and NULL (n=2) Subfunction of sin(_x_) + 17 with NULL as 4th argument: sin(_x_) and NULL (n=2) Subfunction of stupid1(cos(_x_)) with NULL as 3rd argument: NULL and NULL (n=1) Subfunction of stupid1(cos(_x_)) with NULL as 4th argument: cos(_x_) and NULL (n=1) sollya-6.0+ds/tests-lib/tget_taylorrecursions.c000066400000000000000000000003721300174114700220100ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_taylorrecursions(); sollya_lib_printf("Default value for taylorrecursions: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_taylorrecursions.reference000066400000000000000000000000461300174114700235220ustar00rootroot00000000000000Default value for taylorrecursions: 0 sollya-6.0+ds/tests-lib/tget_timing.c000066400000000000000000000003461300174114700176510ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_timing(); sollya_lib_printf("Default value for timing: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_timing.reference000066400000000000000000000000361300174114700213610ustar00rootroot00000000000000Default value for timing: off sollya-6.0+ds/tests-lib/tget_verbosity.c000066400000000000000000000003541300174114700204070ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a; sollya_lib_init(); a = sollya_lib_get_verbosity(); sollya_lib_printf("Default value for verbosity: %b\n", a); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tget_verbosity.reference000066400000000000000000000000371300174114700221210ustar00rootroot00000000000000Default value for verbosity: 1 sollya-6.0+ds/tests-lib/thalfprecision.c000066400000000000000000000004261300174114700203500ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_halfprecision(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/thalfprecision.reference000066400000000000000000000000221300174114700220540ustar00rootroot00000000000000halfprecision(_x_)sollya-6.0+ds/tests-lib/thalfprecision_obj.c000066400000000000000000000003211300174114700211740ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_halfprecision_obj(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/thalfprecision_obj.reference000066400000000000000000000000151300174114700227100ustar00rootroot00000000000000halfprecisionsollya-6.0+ds/tests-lib/thash.c000066400000000000000000000032251300174114700164450ustar00rootroot00000000000000#include #include #include #include #include #include int main(void) { sollya_obj_t f[13]; int i, j; uint64_t h1, h2; sollya_lib_init(); f[0] = SOLLYA_CONST_SI64(17); f[1] = SOLLYA_CONST(17.0); f[2] = SOLLYA_CONST_SI64(42); f[3] = SOLLYA_CONST_SI64(25); f[4] = sollya_lib_sub(f[2],f[3]); f[5] = sollya_lib_parse_string("1 + 17 * x + 136 * x^2 + 680 * x^3 + 2380 * x^4 + 6188 * x^5 + 12376 * x^6 + 19448 * x^7 + 24310 * x^8 + 24310 * x^9 + 19448 * x^10 + 12376 * x^11 + 6188 * x^12 + 2380 * x^13 + 680 * x^14 + 136 * x^15 + 17 * x^16 + x^17"); f[6] = sollya_lib_parse_string("(1 + x)^17"); f[7] = sollya_lib_parse_string("(1 + x)^42"); f[8] = sollya_lib_degree(f[6]); f[9] = sollya_lib_parse_string("proc (a,b) { \"When I add \", b, \" to \", a, \", I get \", (a + b); return (a + b); }"); f[10] = SOLLYA_CONST_SI64(8); f[11] = SOLLYA_CONST_SI64(9); f[12] = sollya_lib_apply(f[9], f[10], f[11], NULL); sollya_lib_printf("Objects:\n"); for (i=0;i<=12;i++) { sollya_lib_printf("%02d: %b\n", i, f[i]); } sollya_lib_printf("\n"); sollya_lib_printf("Hash equality table:\n"); sollya_lib_printf("-- "); for (j=0;j<=12;j++) { sollya_lib_printf("%02d ",j); } sollya_lib_printf("\n"); for (i=0;i<=12;i++) { h1 = sollya_lib_hash(f[i]); sollya_lib_printf("%02d ", i); for (j=0;j<=12;j++) { h2 = sollya_lib_hash(f[j]); if (h1 == h2) { sollya_lib_printf(" * "); } else { sollya_lib_printf(" "); } } sollya_lib_printf("\n"); } for(i=0;i<=12;i++) sollya_lib_clear_obj(f[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/thash.reference000066400000000000000000000020511300174114700201550ustar00rootroot00000000000000When I add 9 to 8, I get 17 Objects: 00: 17 01: 17 02: 42 03: 25 04: 17 05: 1 + 17 * x + 136 * x^2 + 680 * x^3 + 2380 * x^4 + 6188 * x^5 + 12376 * x^6 + 19448 * x^7 + 24310 * x^8 + 24310 * x^9 + 19448 * x^10 + 12376 * x^11 + 6188 * x^12 + 2380 * x^13 + 680 * x^14 + 136 * x^15 + 17 * x^16 + x^17 06: (1 + x)^17 07: (1 + x)^42 08: 17 09: proc(a, b) { "When I add ", b, " to ", a, ", I get ", (a) + (b); return (a) + (b); } 10: 8 11: 9 12: 17 Hash equality table: -- 00 01 02 03 04 05 06 07 08 09 10 11 12 00 * * * * * 01 * * * * * 02 * 03 * 04 * * * * * 05 * * 06 * * 07 * 08 * * * * * 09 * 10 * 11 * 12 * * * * * sollya-6.0+ds/tests-lib/thead.c000066400000000000000000000030521300174114700164210ustar00rootroot00000000000000#include #define A_DIM 11 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The expected error message stating that the head operation on an empty list cannot be performed has been caught.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[A_DIM], b[A_DIM]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = sollya_lib_parse_string("[||]"); a[1] = sollya_lib_parse_string("[|1|]"); a[2] = sollya_lib_parse_string("[|1,2|]"); a[3] = sollya_lib_parse_string("[|1,...,17|]"); a[4] = sollya_lib_parse_string("[|1,...,17...|]"); a[5] = sollya_lib_parse_string("[|\"Hello\"|]"); a[6] = sollya_lib_parse_string("[|\"Hello\",\"World\"|]"); a[7] = sollya_lib_parse_string("[|\"land\",\"of\",\"milk\",\"and\",\"honey\"|]"); a[8] = sollya_lib_parse_string("[|\"land\",\"of\",\"milk\",\"and\",\"honey\"...|]"); a[9] = sollya_lib_parse_string("[|17...|]"); a[10] = sollya_lib_parse_string("[|\"Rudolph the red-nosed reindeer\"...|]"); for (i=0;i int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_hexadecimal(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/thexadecimal.reference000066400000000000000000000000131300174114700214720ustar00rootroot00000000000000hexadecimalsollya-6.0+ds/tests-lib/thonorcoeffprec.c000066400000000000000000000003161300174114700205220ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_honorcoeffprec(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/thonorcoeffprec.reference000066400000000000000000000000161300174114700222330ustar00rootroot00000000000000honorcoeffprecsollya-6.0+ds/tests-lib/thorner.c000066400000000000000000000015621300174114700170210ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a[5], b[5]; int i; sollya_lib_init(); a[0] = SOLLYA_POW(SOLLYA_SUB(SOLLYA_POW(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_CONST(2.0),SOLLYA_X_),SOLLYA_CONST(-3.0)),SOLLYA_CONST(3)),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(5))),SOLLYA_CONST(2.0)); /* ( (2x+(-3))^3 - x^5 )^2 = 729 - 2916*x + 4860*x^2 - 4320*x^3 + 2160*x^4 - 522*x^5 - 44*x^6 + 72*x^7 - 16*x^8 + x^10 */ a[1] = SOLLYA_EXP(SOLLYA_X_); a[2] = SOLLYA_ADD(sollya_lib_copy_obj(a[0]),SOLLYA_SIN(sollya_lib_copy_obj(a[0]))); a[3] = sollya_lib_parse_string("3*x^5 + 2*x^4 + 7*x"); a[4] = sollya_lib_horner(a[3]); for (i=0;i<5;i++) { b[i] = sollya_lib_horner(a[i]); sollya_lib_printf("The hornerized version of %b is %b.\n",a[i],b[i]); } for (i=0;i<5;i++) { sollya_lib_clear_obj(a[i]); sollya_lib_clear_obj(b[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/thorner.reference000066400000000000000000000013011300174114700205240ustar00rootroot00000000000000The hornerized version of ((2 * x + (-3))^3 - x^5)^2 is 729 + x * (-2916 + x * (4860 + x * (-4320 + x * (2160 + x * (-522 + x * (-44 + x * (72 + x * (-16 + x^2)))))))). The hornerized version of exp(x) is exp(x). The hornerized version of ((2 * x + (-3))^3 - x^5)^2 + sin(((2 * x + (-3))^3 - x^5)^2) is 729 + x * (-2916 + x * (4860 + x * (-4320 + x * (2160 + x * (-522 + x * (-44 + x * (72 + x * (-16 + x^2)))))))) + sin(729 + x * (-2916 + x * (4860 + x * (-4320 + x * (2160 + x * (-522 + x * (-44 + x * (72 + x * (-16 + x^2))))))))). The hornerized version of 3 * x^5 + 2 * x^4 + 7 * x is x * (7 + x^3 * (2 + x * 3)). The hornerized version of x * (7 + x^3 * (2 + x * 3)) is x * (7 + x^3 * (2 + x * 3)). sollya-6.0+ds/tests-lib/timplementpoly.c000066400000000000000000000163061300174114700204240ustar00rootroot00000000000000#include #include #include #include #include #include #define A_DIM 15 #define TEMP_IMPLEMENTATION_FILE "timplementpoly.implementation.c" #define TEMP_PROOF_FILE "timplementpoly.implementation.gappa" #define READBUFFERSIZE 1024 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_IMPLEMENTED_POLY_DIFFERS_FROM_ORIGINAL_ONE: sollya_lib_printf("Caught the message: the implemented polynomial is different from the original one.\n"); break; case SOLLYA_MSG_INFERED_COEFF_PREC_HIGHER_THAN_REQUIRED: sollya_lib_printf("Caught the message: the inferred precision of a coefficient is higher than what seems to be needed to meet the accuracy target.\n"); break; case SOLLYA_MSG_COEFF_NOT_TWICE_GREATER_THAN_SUBPOLY: sollya_lib_printf("Caught the message: a coefficient in a Horner scheme is not guaranteed to also be twice as large as the subpolynomial.\n"); break; case SOLLYA_MSG_ERROR_ON_DETERMINING_THE_REQUIRED_PRECISIONS: sollya_lib_printf("Caught the message: an error has occurred during the determination of the required precisions.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } void read_and_print_file(char *filename) { FILE *fd; char readBuffer[READBUFFERSIZE]; int i; size_t readChars; if ((fd = fopen(filename,"r")) == NULL) { exit(1); } while (1) { for (i=0;i; # Disable some annoying warnings: #@-Wno-dichotomy-failure # Helper definitions for decomposing the free variable xh = double(xhm); xm = xhm - xh; # Transcription of the C code p_coeff_0h = double(1.50000000000000000000000000000000000000000000000000000000000000000000000000000000e+01); p_coeff_1h = double(1.40000000000000000000000000000000000000000000000000000000000000000000000000000000e+01); p_coeff_2h = double(1.30000000000000000000000000000000000000000000000000000000000000000000000000000000e+01); p_coeff_3h = double(1.20000000000000000000000000000000000000000000000000000000000000000000000000000000e+01); p_coeff_4h = double(1.10000000000000000000000000000000000000000000000000000000000000000000000000000000e+01); p_coeff_5h = double(1.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+01); p_coeff_6h = double(9.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_7h = double(8.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_8h = double(7.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_9h = double(6.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_10h = double(5.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_11h = double(4.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_12h = double(3.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_13h = double(2.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_14h = double(1.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_t_1_0h = p_coeff_14h; p_t_2_0hm = mul_rel<102>(p_t_1_0h,xhm); p_t_2_0h = double(p_t_2_0hm); p_t_2_0m = p_t_2_0hm - p_t_2_0h; p_t_3_0hm = add_rel<102>(p_coeff_13h,p_t_2_0hm); p_t_3_0h = double(p_t_3_0hm); p_t_3_0m = p_t_3_0hm - p_t_3_0h; p_t_4_0hm = mul_rel<102>(p_t_3_0hm,xhm); p_t_4_0h = double(p_t_4_0hm); p_t_4_0m = p_t_4_0hm - p_t_4_0h; p_t_5_0hm = add_rel<102>(p_coeff_12h,p_t_4_0hm); p_t_5_0h = double(p_t_5_0hm); p_t_5_0m = p_t_5_0hm - p_t_5_0h; p_t_6_0hm = mul_rel<102>(p_t_5_0hm,xhm); p_t_6_0h = double(p_t_6_0hm); p_t_6_0m = p_t_6_0hm - p_t_6_0h; p_t_7_0hm = add_rel<102>(p_coeff_11h,p_t_6_0hm); p_t_7_0h = double(p_t_7_0hm); p_t_7_0m = p_t_7_0hm - p_t_7_0h; p_t_8_0hm = mul_rel<102>(p_t_7_0hm,xhm); p_t_8_0h = double(p_t_8_0hm); p_t_8_0m = p_t_8_0hm - p_t_8_0h; p_t_9_0hm = add_rel<102>(p_coeff_10h,p_t_8_0hm); p_t_9_0h = double(p_t_9_0hm); p_t_9_0m = p_t_9_0hm - p_t_9_0h; p_t_10_0hm = mul_rel<102>(p_t_9_0hm,xhm); p_t_10_0h = double(p_t_10_0hm); p_t_10_0m = p_t_10_0hm - p_t_10_0h; p_t_11_0hm = add_rel<102>(p_coeff_9h,p_t_10_0hm); p_t_11_0h = double(p_t_11_0hm); p_t_11_0m = p_t_11_0hm - p_t_11_0h; p_t_12_0hm = mul_rel<102>(p_t_11_0hm,xhm); p_t_12_0h = double(p_t_12_0hm); p_t_12_0m = p_t_12_0hm - p_t_12_0h; p_t_13_0hm = add_rel<102>(p_coeff_8h,p_t_12_0hm); p_t_13_0h = double(p_t_13_0hm); p_t_13_0m = p_t_13_0hm - p_t_13_0h; p_t_14_0hm = mul_rel<102>(p_t_13_0hm,xhm); p_t_14_0h = double(p_t_14_0hm); p_t_14_0m = p_t_14_0hm - p_t_14_0h; p_t_15_0hm = add_rel<102>(p_coeff_7h,p_t_14_0hm); p_t_15_0h = double(p_t_15_0hm); p_t_15_0m = p_t_15_0hm - p_t_15_0h; p_t_16_0hm = mul_rel<102>(p_t_15_0hm,xhm); p_t_16_0h = double(p_t_16_0hm); p_t_16_0m = p_t_16_0hm - p_t_16_0h; p_t_17_0hm = add_rel<102>(p_coeff_6h,p_t_16_0hm); p_t_17_0h = double(p_t_17_0hm); p_t_17_0m = p_t_17_0hm - p_t_17_0h; p_t_18_0hm = mul_rel<102>(p_t_17_0hm,xhm); p_t_18_0h = double(p_t_18_0hm); p_t_18_0m = p_t_18_0hm - p_t_18_0h; p_t_19_0hm = add_rel<102>(p_coeff_5h,p_t_18_0hm); p_t_19_0h = double(p_t_19_0hm); p_t_19_0m = p_t_19_0hm - p_t_19_0h; p_t_20_0hm = mul_rel<102>(p_t_19_0hm,xhm); p_t_20_0h = double(p_t_20_0hm); p_t_20_0m = p_t_20_0hm - p_t_20_0h; p_t_21_0hm = add_rel<102>(p_coeff_4h,p_t_20_0hm); p_t_21_0h = double(p_t_21_0hm); p_t_21_0m = p_t_21_0hm - p_t_21_0h; p_t_22_0hm = mul_rel<102>(p_t_21_0hm,xhm); p_t_22_0h = double(p_t_22_0hm); p_t_22_0m = p_t_22_0hm - p_t_22_0h; p_t_23_0hm = add_rel<102>(p_coeff_3h,p_t_22_0hm); p_t_23_0h = double(p_t_23_0hm); p_t_23_0m = p_t_23_0hm - p_t_23_0h; p_t_24_0hm = mul_rel<102>(p_t_23_0hm,xhm); p_t_24_0h = double(p_t_24_0hm); p_t_24_0m = p_t_24_0hm - p_t_24_0h; p_t_25_0hm = add_rel<102>(p_coeff_2h,p_t_24_0hm); p_t_25_0h = double(p_t_25_0hm); p_t_25_0m = p_t_25_0hm - p_t_25_0h; p_t_26_0hm = mul_rel<102>(p_t_25_0hm,xhm); p_t_26_0h = double(p_t_26_0hm); p_t_26_0m = p_t_26_0hm - p_t_26_0h; p_t_27_0hm = add_rel<102>(p_coeff_1h,p_t_26_0hm); p_t_27_0h = double(p_t_27_0hm); p_t_27_0m = p_t_27_0hm - p_t_27_0h; p_t_28_0hm = mul_rel<102>(p_t_27_0hm,xhm); p_t_28_0h = double(p_t_28_0hm); p_t_28_0m = p_t_28_0hm - p_t_28_0h; p_t_29_0hm = add_rel<102>(p_coeff_0h,p_t_28_0hm); p_t_29_0h = double(p_t_29_0hm); p_t_29_0m = p_t_29_0hm - p_t_29_0h; p_reshm = p_t_29_0hm; p_resh = p_t_29_0h; p_resm = p_t_29_0m; # Mathematical equivalents Mx = xhm; Mp_coeff_0 = p_coeff_0h; Mp_coeff_1 = p_coeff_1h; Mp_coeff_2 = p_coeff_2h; Mp_coeff_3 = p_coeff_3h; Mp_coeff_4 = p_coeff_4h; Mp_coeff_5 = p_coeff_5h; Mp_coeff_6 = p_coeff_6h; Mp_coeff_7 = p_coeff_7h; Mp_coeff_8 = p_coeff_8h; Mp_coeff_9 = p_coeff_9h; Mp_coeff_10 = p_coeff_10h; Mp_coeff_11 = p_coeff_11h; Mp_coeff_12 = p_coeff_12h; Mp_coeff_13 = p_coeff_13h; Mp_coeff_14 = p_coeff_14h; Mp_t_1_0 = Mp_coeff_14; Mp_t_2_0 = Mp_t_1_0 * Mx; Mp_t_3_0 = Mp_coeff_13 + Mp_t_2_0; Mp_t_4_0 = Mp_t_3_0 * Mx; Mp_t_5_0 = Mp_coeff_12 + Mp_t_4_0; Mp_t_6_0 = Mp_t_5_0 * Mx; Mp_t_7_0 = Mp_coeff_11 + Mp_t_6_0; Mp_t_8_0 = Mp_t_7_0 * Mx; Mp_t_9_0 = Mp_coeff_10 + Mp_t_8_0; Mp_t_10_0 = Mp_t_9_0 * Mx; Mp_t_11_0 = Mp_coeff_9 + Mp_t_10_0; Mp_t_12_0 = Mp_t_11_0 * Mx; Mp_t_13_0 = Mp_coeff_8 + Mp_t_12_0; Mp_t_14_0 = Mp_t_13_0 * Mx; Mp_t_15_0 = Mp_coeff_7 + Mp_t_14_0; Mp_t_16_0 = Mp_t_15_0 * Mx; Mp_t_17_0 = Mp_coeff_6 + Mp_t_16_0; Mp_t_18_0 = Mp_t_17_0 * Mx; Mp_t_19_0 = Mp_coeff_5 + Mp_t_18_0; Mp_t_20_0 = Mp_t_19_0 * Mx; Mp_t_21_0 = Mp_coeff_4 + Mp_t_20_0; Mp_t_22_0 = Mp_t_21_0 * Mx; Mp_t_23_0 = Mp_coeff_3 + Mp_t_22_0; Mp_t_24_0 = Mp_t_23_0 * Mx; Mp_t_25_0 = Mp_coeff_2 + Mp_t_24_0; Mp_t_26_0 = Mp_t_25_0 * Mx; Mp_t_27_0 = Mp_coeff_1 + Mp_t_26_0; Mp_t_28_0 = Mp_t_27_0 * Mx; Mp_t_29_0 = Mp_coeff_0 + Mp_t_28_0; Mp_res = Mp_t_29_0; # Definition of the relative arithmetical error epsilon = (p_reshm - Mp_res) / Mp_res; # Implication to prove {( xhm in [-1b-1,1b-1] /\ not xhm in [-1b-401,1b-401] ) -> ( epsilon in ? )} # Hints and Meta-Hints for expansion decomposition xh ~ xhm; p_t_2_0h ~ p_t_2_0hm; p_t_3_0h ~ p_t_3_0hm; p_t_4_0h ~ p_t_4_0hm; p_t_5_0h ~ p_t_5_0hm; p_t_6_0h ~ p_t_6_0hm; p_t_7_0h ~ p_t_7_0hm; p_t_8_0h ~ p_t_8_0hm; p_t_9_0h ~ p_t_9_0hm; p_t_10_0h ~ p_t_10_0hm; p_t_11_0h ~ p_t_11_0hm; p_t_12_0h ~ p_t_12_0hm; p_t_13_0h ~ p_t_13_0hm; p_t_14_0h ~ p_t_14_0hm; p_t_15_0h ~ p_t_15_0hm; p_t_16_0h ~ p_t_16_0hm; p_t_17_0h ~ p_t_17_0hm; p_t_18_0h ~ p_t_18_0hm; p_t_19_0h ~ p_t_19_0hm; p_t_20_0h ~ p_t_20_0hm; p_t_21_0h ~ p_t_21_0hm; p_t_22_0h ~ p_t_22_0hm; p_t_23_0h ~ p_t_23_0hm; p_t_24_0h ~ p_t_24_0hm; p_t_25_0h ~ p_t_25_0hm; p_t_26_0h ~ p_t_26_0hm; p_t_27_0h ~ p_t_27_0hm; p_t_28_0h ~ p_t_28_0hm; p_t_29_0h ~ p_t_29_0hm; # Meta-Hints for Horner scheme p_t_1_0h ~ Mp_t_1_0; p_t_2_0hm ~ Mp_t_2_0; p_t_3_0hm ~ Mp_t_3_0; p_t_4_0hm ~ Mp_t_4_0; p_t_5_0hm ~ Mp_t_5_0; p_t_6_0hm ~ Mp_t_6_0; p_t_7_0hm ~ Mp_t_7_0; p_t_8_0hm ~ Mp_t_8_0; p_t_9_0hm ~ Mp_t_9_0; p_t_10_0hm ~ Mp_t_10_0; p_t_11_0hm ~ Mp_t_11_0; p_t_12_0hm ~ Mp_t_12_0; p_t_13_0hm ~ Mp_t_13_0; p_t_14_0hm ~ Mp_t_14_0; p_t_15_0hm ~ Mp_t_15_0; p_t_16_0hm ~ Mp_t_16_0; p_t_17_0hm ~ Mp_t_17_0; p_t_18_0hm ~ Mp_t_18_0; p_t_19_0hm ~ Mp_t_19_0; p_t_20_0hm ~ Mp_t_20_0; p_t_21_0hm ~ Mp_t_21_0; p_t_22_0hm ~ Mp_t_22_0; p_t_23_0hm ~ Mp_t_23_0; p_t_24_0hm ~ Mp_t_24_0; p_t_25_0hm ~ Mp_t_25_0; p_t_26_0hm ~ Mp_t_26_0; p_t_27_0hm ~ Mp_t_27_0; p_t_28_0hm ~ Mp_t_28_0; p_t_29_0hm ~ Mp_t_29_0; p_reshm ~ Mp_res; # Dichotomies for triple-double decomposition # Dichotomy for the error bound epsilon $ xhm; sollya-6.0+ds/tests-lib/tinf.c000066400000000000000000000032571300174114700163030ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); if (message == SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED) sollya_lib_printf("The following test produces a typing error\n"); else sollya_lib_printf("Unexpected message\n"); return 0; } int main(void) { sollya_obj_t a, res; double nan = 0.0/0.0; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a = SOLLYA_CONST(2); res = sollya_lib_inf(a); sollya_lib_printf("inf of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_CONST(3)); res = sollya_lib_inf(a); sollya_lib_printf("inf of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_LOG(SOLLYA_NEG(SOLLYA_CONST(3))); res = sollya_lib_inf(a); sollya_lib_printf("inf of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); res = sollya_lib_inf(a); sollya_lib_printf("inf of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[1,2]"); res = sollya_lib_inf(a); sollya_lib_printf("inf of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_X_; res = sollya_lib_inf(a); sollya_lib_printf("inf of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_string("Hello"); res = sollya_lib_inf(a); sollya_lib_printf("inf of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tinf.reference000066400000000000000000000003421300174114700200070ustar00rootroot00000000000000inf of 2 is 2 inf of 1 / 3 is 1 / 3 inf of log(-3) is log(-3) inf of NaN is NaN inf of [1;2] is 1 The following test produces a typing error inf of _x_ is error The following test produces a typing error inf of Hello is error sollya-6.0+ds/tests-lib/tinit_with_custom_memory_functions.c000066400000000000000000000252051300174114700245740ustar00rootroot00000000000000#include #include #include #include #define NB_OF_TESTS 11 int myMallocUsed = 0; int myCallocUsed = 0; int myReallocUsed = 0; int myFreeUsed = 0; int myReallocWithSizeUsed = 0; int myFreeWithSizeUsed = 0; int callback(sollya_msg_t msg, void *data) { (void)msg; /* Avoiding "unused parameter" warning */ (void)data; /* Avoiding "unused parameter" warning */ return 0; } void *myMalloc(size_t size) { myMallocUsed++; return malloc(size); } void *myCalloc(size_t nmemb, size_t size) { myCallocUsed++; return calloc(nmemb,size); } void *myRealloc(void *ptr, size_t size) { myReallocUsed++; return realloc(ptr,size); } void myFree(void *ptr) { myFreeUsed++; free(ptr); } void *myReallocWithSize(void *ptr, size_t oldSize, size_t size) { (void) oldSize; myReallocWithSizeUsed++; return realloc(ptr,size); } void myFreeWithSize(void *ptr, size_t size) { (void) size; myFreeWithSizeUsed++; free(ptr); } int main(void) { int okay = 1; void *(*gmp_malloc_before)(size_t); void *(*gmp_realloc_before)(void *, size_t, size_t); void (*gmp_free_before)(void *, size_t); void *(*gmp_malloc_after)(size_t); void *(*gmp_realloc_after)(void *, size_t, size_t); void (*gmp_free_after)(void *, size_t); sollya_obj_t a[NB_OF_TESTS], b[NB_OF_TESTS], c[NB_OF_TESTS]; int i; /* Test #1 */ mp_get_memory_functions(&gmp_malloc_before, &gmp_realloc_before, &gmp_free_before); myMallocUsed = 0; myCallocUsed = 0; myReallocUsed = 0; myFreeUsed = 0; myReallocWithSizeUsed = 0; myFreeWithSizeUsed = 0; sollya_lib_init_with_custom_memory_functions(myMalloc, myCalloc, myRealloc, myFree, myReallocWithSize, myFreeWithSize); sollya_lib_install_msg_callback(callback, NULL); /* Just do some stuff to use the memory functions */ a[0] = SOLLYA_CONST(17.0); b[0] = sollya_lib_parse_string("[-1;1]"); a[1] = SOLLYA_X_; b[1] = sollya_lib_parse_string("[-1;1.5]"); a[2] = sollya_lib_parse_string("x^2 + x -1"); b[2] = sollya_lib_parse_string("[-2;1]"); a[3] = sollya_lib_parse_string("x^2 + x -1"); b[3] = sollya_lib_parse_string("[-2;2]"); a[4] = sollya_lib_parse_string("sin(17 * (x-3)) * cos(x-3) * exp(x/4)"); b[4] = sollya_lib_parse_string("[-2;2]"); a[5] = sollya_lib_parse_string("sin(-51 + x * 17) * cos(-3 + x) * exp(x * 1b-2) + 4 - (5841986838484490273226357258541178809257197853603b-160 + x * (-1657010884744388725768284702475520358103564313103b-163 + x * (1566987824830335456879991047308861887585745670967b-162 + x * (18637702919758264241676014573759486129098461080361b-165 + x * (-4691389977422298284816628406735202847317903770937b-165 + x * (-3641480240898210056437514385988871012264138539689b-165))))))"); b[5] = sollya_lib_parse_string("[-2;2]"); a[6] = sollya_lib_parse_string("exp(x)"); b[6] = sollya_lib_parse_string("[-infty;2]"); a[7] = sollya_lib_parse_string("erf(x)"); b[7] = sollya_lib_parse_string("[-infty;infty]"); a[8] = sollya_lib_parse_string("(x * (46768052394588893382517914646921013753690502283181b-165 + x * (-23842604129029764481373810400725037839108682209013b-310 + x * (-31178701596392595588345276430836652277717061563611b-167 + x * (19474296355951076471139239730950050055091215313371b-300 + x * (6235740319278519117669054529057531256595154021039b-169 + x * (-8903255600987858885078854107239112353939531067197b-291 + x * (-19004160973039296358594544346438861776255280578323b-176 + x * (13978875722788212683821368308788823202998673317847b-285 + x * (16892587531590485568360414041618499983605528356089b-182 + x * (-5509367034013013747984244537606353757286793710935b-278 + x * (-9828414563834216782252138074806120633549802775429b-188 + x * (36514821794022558047614397315048656003649092374341b-276 + x * (4032170077040468786771930826281267656340291488583b-194 + x * (-15157407289929000622398688419996925341779253679627b-271 + x * (-19661622363274627316629009823189604834794640905605b-204 + x * (9925527665865119935372490664410596660907859285007b-268 + x * 9244923258117519852493775515420083692797862150005b-211))))))))))))))))) / sin(x) - 1"); b[8] = sollya_lib_parse_string("[-1/4;1/4]"); a[9] = sollya_lib_parse_string("exp(x)"); b[9] = sollya_lib_parse_string("[2;2]"); a[10] = sollya_lib_parse_string("(-5 * x^2 + 5) * cos(x * 10000)"); b[10] = sollya_lib_parse_string("[-1;1]"); for (i=0;i #include int main(void) { sollya_int_list_t list1, iter, list2; int a, b, c, d, e; int i; sollya_lib_init(); a = 1; b = 2; c = 3; d = 4; e = 5; list1 = sollya_lib_construct_int_list(a, sollya_lib_construct_int_list(b, sollya_lib_construct_int_list(c, sollya_lib_construct_int_list(d, NULL)))); for (iter = list1, i = 0; !sollya_lib_is_empty_int_list(iter); iter = sollya_lib_get_int_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list1 before copy and modification of the copy: %d\n", i, sollya_lib_get_int_list_head(iter)); } list2 = sollya_lib_copy_int_list(list1); list2 = sollya_lib_construct_int_list(e, list2); for (iter = list1, i = 0; !sollya_lib_is_empty_int_list(iter); iter = sollya_lib_get_int_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list1 after copy and modification of the copy: %d\n", i, sollya_lib_get_int_list_head(iter)); } for (iter = list2, i = 0; !sollya_lib_is_empty_int_list(iter); iter = sollya_lib_get_int_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list2 after copy and modification of the copy: %d\n", i, sollya_lib_get_int_list_head(iter)); } sollya_lib_clear_int_list(list1); sollya_lib_clear_int_list(list2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tint_list_ops.reference000066400000000000000000000015211300174114700217410ustar00rootroot000000000000000-th element in list1 before copy and modification of the copy: 1 1-th element in list1 before copy and modification of the copy: 2 2-th element in list1 before copy and modification of the copy: 3 3-th element in list1 before copy and modification of the copy: 4 0-th element in list1 after copy and modification of the copy: 1 1-th element in list1 after copy and modification of the copy: 2 2-th element in list1 after copy and modification of the copy: 3 3-th element in list1 after copy and modification of the copy: 4 0-th element in list2 after copy and modification of the copy: 5 1-th element in list2 after copy and modification of the copy: 1 2-th element in list2 after copy and modification of the copy: 2 3-th element in list2 after copy and modification of the copy: 3 4-th element in list2 after copy and modification of the copy: 4 sollya-6.0+ds/tests-lib/tintegral.c000066400000000000000000000032341300174114700173270ustar00rootroot00000000000000#include #define NB_OF_TESTS 8 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_DOMAIN_IS_NO_CLOSED_INTERVAL_ON_THE_REALS: sollya_lib_printf("Caught the message: the given domain is not a closed subset of the reals.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[NB_OF_TESTS], b[NB_OF_TESTS], c[NB_OF_TESTS]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = SOLLYA_X_; b[0] = sollya_lib_parse_string("[1;2]"); a[1] = SOLLYA_X_; b[1] = sollya_lib_parse_string("[2;3]"); a[2] = sollya_lib_parse_string("2/sqrt(pi) * exp(-_x_^2)"); b[2] = sollya_lib_parse_string("[0;100]"); a[3] = sollya_lib_parse_string("2/sqrt(pi) * exp(-_x_^2)"); b[3] = sollya_lib_parse_string("[-5;5]"); a[4] = SOLLYA_EXP(SOLLYA_X_); b[4] = sollya_lib_parse_string("[0;1]"); a[5] = SOLLYA_EXP(SOLLYA_X_); b[5] = sollya_lib_parse_string("[-infty;1]"); a[6] = SOLLYA_EXP(SOLLYA_X_); b[6] = sollya_lib_parse_string("[1;infty]"); a[7] = sollya_lib_parse_string("1/sqrt(_x_)"); b[7] = sollya_lib_parse_string("[0;1]"); for (i=0;i #include mpfi_t *tinterval_list_ops_make_mpfi_ptr(double l, double r) { mpfi_t *res; res = (mpfi_t *) malloc(sizeof(mpfi_t)); if (res == NULL) exit(1); mpfi_init2(*res, 64); mpfi_interv_d(*res, l, r); return res; } int main(void) { sollya_interval_list_t list1, iter, list2; mpfi_t *a, *b, *c, *d, *e; int i; sollya_lib_init(); a = tinterval_list_ops_make_mpfi_ptr(0.5,0.75); b = tinterval_list_ops_make_mpfi_ptr(1.25,1.75); c = tinterval_list_ops_make_mpfi_ptr(3.75,3.75); d = tinterval_list_ops_make_mpfi_ptr(9.125,12.125); e = tinterval_list_ops_make_mpfi_ptr(17.0e17,1700000000000000256.); list1 = sollya_lib_construct_interval_list(a, sollya_lib_construct_interval_list(b, sollya_lib_construct_interval_list(c, sollya_lib_construct_interval_list(d, NULL)))); for (iter = list1, i = 0; !sollya_lib_is_empty_interval_list(iter); iter = sollya_lib_get_interval_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list1 before copy and modification of the copy: %w\n", i, *sollya_lib_get_interval_list_head(iter)); } list2 = sollya_lib_copy_interval_list(list1); list2 = sollya_lib_construct_interval_list(e, list2); for (iter = list1, i = 0; !sollya_lib_is_empty_interval_list(iter); iter = sollya_lib_get_interval_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list1 after copy and modification of the copy: %w\n", i, *sollya_lib_get_interval_list_head(iter)); } for (iter = list2, i = 0; !sollya_lib_is_empty_interval_list(iter); iter = sollya_lib_get_interval_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list2 after copy and modification of the copy: %w\n", i, *sollya_lib_get_interval_list_head(iter)); } sollya_lib_clear_interval_list(list1); sollya_lib_clear_interval_list(list2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tinterval_list_ops.reference000066400000000000000000000017671300174114700230070ustar00rootroot000000000000000-th element in list1 before copy and modification of the copy: [0.5;0.75] 1-th element in list1 before copy and modification of the copy: [1.25;1.75] 2-th element in list1 before copy and modification of the copy: [3.75;3.75] 3-th element in list1 before copy and modification of the copy: [9.125;12.125] 0-th element in list1 after copy and modification of the copy: [0.5;0.75] 1-th element in list1 after copy and modification of the copy: [1.25;1.75] 2-th element in list1 after copy and modification of the copy: [3.75;3.75] 3-th element in list1 after copy and modification of the copy: [9.125;12.125] 0-th element in list2 after copy and modification of the copy: [1700000000000000000;1700000000000000256] 1-th element in list2 after copy and modification of the copy: [0.5;0.75] 2-th element in list2 after copy and modification of the copy: [1.25;1.75] 3-th element in list2 after copy and modification of the copy: [3.75;3.75] 4-th element in list2 after copy and modification of the copy: [9.125;12.125] sollya-6.0+ds/tests-lib/tis_absolute.c000066400000000000000000000154501300174114700200360ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("absolute"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_absolute(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_absolute detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_absolute detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_absolute detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_absolute detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_absolute detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_absolute detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_absolute detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_absolute detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_absolute detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_absolute detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_absolute detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_absolute detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_absolute detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_absolute detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_absolute detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_absolute detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_absolute detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_absolute detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_absolute detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_absolute detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_absolute detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_absolute detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_absolute detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_absolute detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_absolute detects the string \"absolute\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_absolute detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_absolute detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_absolute detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_absolute detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_absolute detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_absolute detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_absolute detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_absolute detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_absolute detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_absolute detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_absolute detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_absolute detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_absolute detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_absolute detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_absolute detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_absolute detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_absolute detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_absolute detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_absolute detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_absolute detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_absolute detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_absolute detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_absolute detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_absolute detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_absolute detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_absolute detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_absolute detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_absolute detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_absolute.reference000066400000000000000000000000501300174114700215400ustar00rootroot00000000000000sollya_lib_is_absolute detects absolute sollya-6.0+ds/tests-lib/tis_binary.c000066400000000000000000000152701300174114700175040ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("binary"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_binary(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_binary detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_binary detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_binary detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_binary detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_binary detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_binary detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_binary detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_binary detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_binary detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_binary detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_binary detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_binary detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_binary detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_binary detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_binary detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_binary detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_binary detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_binary detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_binary detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_binary detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_binary detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_binary detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_binary detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_binary detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_binary detects the string \"binary\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_binary detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_binary detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_binary detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_binary detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_binary detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_binary detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_binary detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_binary detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_binary detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_binary detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_binary detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_binary detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_binary detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_binary detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_binary detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_binary detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_binary detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_binary detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_binary detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_binary detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_binary detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_binary detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_binary detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_binary detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_binary detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_binary detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_binary detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_binary detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_binary.reference000066400000000000000000000000441300174114700212110ustar00rootroot00000000000000sollya_lib_is_binary detects binary sollya-6.0+ds/tests-lib/tis_decimal.c000066400000000000000000000153601300174114700176160ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("decimal"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_decimal(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_decimal detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_decimal detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_decimal detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_decimal detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_decimal detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_decimal detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_decimal detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_decimal detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_decimal detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_decimal detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_decimal detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_decimal detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_decimal detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_decimal detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_decimal detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_decimal detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_decimal detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_decimal detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_decimal detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_decimal detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_decimal detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_decimal detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_decimal detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_decimal detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_decimal detects the string \"decimal\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_decimal detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_decimal detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_decimal detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_decimal detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_decimal detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_decimal detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_decimal detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_decimal detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_decimal detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_decimal detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_decimal detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_decimal detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_decimal detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_decimal detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_decimal detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_decimal detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_decimal detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_decimal detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_decimal detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_decimal detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_decimal detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_decimal detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_decimal detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_decimal detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_decimal detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_decimal detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_decimal detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_decimal detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_decimal.reference000066400000000000000000000000461300174114700213250ustar00rootroot00000000000000sollya_lib_is_decimal detects decimal sollya-6.0+ds/tests-lib/tis_default.c000066400000000000000000000153601300174114700176440ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("default"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_default(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_default detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_default detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_default detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_default detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_default detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_default detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_default detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_default detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_default detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_default detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_default detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_default detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_default detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_default detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_default detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_default detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_default detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_default detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_default detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_default detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_default detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_default detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_default detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_default detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_default detects the string \"default\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_default detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_default detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_default detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_default detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_default detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_default detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_default detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_default detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_default detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_default detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_default detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_default detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_default detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_default detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_default detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_default detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_default detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_default detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_default detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_default detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_default detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_default detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_default detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_default detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_default detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_default detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_default detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_default detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_default.reference000066400000000000000000000000461300174114700213530ustar00rootroot00000000000000sollya_lib_is_default detects default sollya-6.0+ds/tests-lib/tis_double_double_obj.c000066400000000000000000000164401300174114700216560ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("double_double_obj"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_double_double_obj(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_double_double_obj detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_double_double_obj detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_double_double_obj detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_double_double_obj detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_double_double_obj detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_double_double_obj detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_double_double_obj detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_double_double_obj detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_double_double_obj detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_double_double_obj detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_double_double_obj detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_double_double_obj detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_double_double_obj detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_double_double_obj detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_double_double_obj detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_double_double_obj detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_double_double_obj detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_double_double_obj detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_double_double_obj detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_double_double_obj detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_double_double_obj detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_double_double_obj detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_double_double_obj detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_double_double_obj detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_double_double_obj detects the string \"double_double_obj\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_double_double_obj detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_double_double_obj detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_double_double_obj detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_double_double_obj detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_double_double_obj detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_double_double_obj detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_double_double_obj detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_double_double_obj detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_double_double_obj detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_double_double_obj detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_double_double_obj detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_double_double_obj detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_double_double_obj detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_double_double_obj detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_double_double_obj detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_double_double_obj detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_double_double_obj detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_double_double_obj detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_double_double_obj detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_double_double_obj detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_double_double_obj detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_double_double_obj detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_double_double_obj detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_double_double_obj detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_double_double_obj detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_double_double_obj detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_double_double_obj detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_double_double_obj detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_double_double_obj.reference000066400000000000000000000000661300174114700233670ustar00rootroot00000000000000sollya_lib_is_double_double_obj detects DD as symbol. sollya-6.0+ds/tests-lib/tis_double_obj.c000066400000000000000000000156301300174114700203240ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("double_obj"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_double_obj(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_double_obj detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_double_obj detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_double_obj detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_double_obj detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_double_obj detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_double_obj detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_double_obj detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_double_obj detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_double_obj detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_double_obj detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_double_obj detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_double_obj detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_double_obj detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_double_obj detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_double_obj detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_double_obj detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_double_obj detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_double_obj detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_double_obj detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_double_obj detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_double_obj detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_double_obj detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_double_obj detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_double_obj detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_double_obj detects the string \"double_obj\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_double_obj detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_double_obj detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_double_obj detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_double_obj detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_double_obj detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_double_obj detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_double_obj detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_double_obj detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_double_obj detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_double_obj detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_double_obj detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_double_obj detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_double_obj detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_double_obj detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_double_obj detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_double_obj detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_double_obj detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_double_obj detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_double_obj detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_double_obj detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_double_obj detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_double_obj detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_double_obj detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_double_obj detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_double_obj detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_double_obj detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_double_obj detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_double_obj detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_double_obj.reference000066400000000000000000000000561300174114700220340ustar00rootroot00000000000000sollya_lib_is_double_obj detects D as symbol. sollya-6.0+ds/tests-lib/tis_doubleextended_obj.c000066400000000000000000000165301300174114700220450ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("doubleextended_obj"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_doubleextended_obj(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects the string \"doubleextended_obj\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_doubleextended_obj detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_doubleextended_obj.reference000066400000000000000000000000671300174114700235570ustar00rootroot00000000000000sollya_lib_is_doubleextended_obj detects DE as symbol. sollya-6.0+ds/tests-lib/tis_dyadic.c000066400000000000000000000152701300174114700174550ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("dyadic"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_dyadic(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_dyadic detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_dyadic detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_dyadic detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_dyadic detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_dyadic detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_dyadic detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_dyadic detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_dyadic detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_dyadic detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_dyadic detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_dyadic detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_dyadic detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_dyadic detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_dyadic detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_dyadic detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_dyadic detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_dyadic detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_dyadic detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_dyadic detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_dyadic detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_dyadic detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_dyadic detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_dyadic detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_dyadic detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_dyadic detects the string \"dyadic\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_dyadic detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_dyadic detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_dyadic detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_dyadic detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_dyadic detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_dyadic detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_dyadic detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_dyadic detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_dyadic detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_dyadic detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_dyadic detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_dyadic detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_dyadic detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_dyadic detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_dyadic detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_dyadic detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_dyadic detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_dyadic detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_dyadic detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_dyadic detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_dyadic detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_dyadic detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_dyadic detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_dyadic detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_dyadic detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_dyadic detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_dyadic detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_dyadic detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_dyadic.reference000066400000000000000000000000441300174114700211620ustar00rootroot00000000000000sollya_lib_is_dyadic detects dyadic sollya-6.0+ds/tests-lib/tis_false.c000066400000000000000000000152001300174114700173030ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("false"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_false(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_false detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_false detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_false detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_false detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_false detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_false detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_false detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_false detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_false detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_false detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_false detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_false detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_false detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_false detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_false detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_false detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_false detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_false detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_false detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_false detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_false detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_false detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_false detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_false detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_false detects the string \"false\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_false detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_false detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_false detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_false detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_false detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_false detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_false detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_false detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_false detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_false detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_false detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_false detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_false detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_false detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_false detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_false detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_false detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_false detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_false detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_false detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_false detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_false detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_false detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_false detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_false detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_false detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_false detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_false detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_false.reference000066400000000000000000000000421300174114700210150ustar00rootroot00000000000000sollya_lib_is_false detects false sollya-6.0+ds/tests-lib/tis_file.c000066400000000000000000000151101300174114700171300ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("file"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_file(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_file detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_file detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_file detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_file detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_file detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_file detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_file detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_file detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_file detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_file detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_file detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_file detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_file detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_file detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_file detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_file detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_file detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_file detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_file detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_file detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_file detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_file detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_file detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_file detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_file detects the string \"file\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_file detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_file detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_file detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_file detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_file detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_file detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_file detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_file detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_file detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_file detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_file detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_file detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_file detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_file detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_file detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_file detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_file detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_file detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_file detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_file detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_file detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_file detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_file detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_file detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_file detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_file detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_file detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_file detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_file.reference000066400000000000000000000000401300174114700206400ustar00rootroot00000000000000sollya_lib_is_file detects file sollya-6.0+ds/tests-lib/tis_fixed.c000066400000000000000000000152001300174114700173100ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("fixed"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_fixed(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_fixed detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_fixed detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_fixed detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_fixed detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_fixed detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_fixed detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_fixed detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_fixed detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_fixed detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_fixed detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_fixed detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_fixed detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_fixed detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_fixed detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_fixed detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_fixed detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_fixed detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_fixed detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_fixed detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_fixed detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_fixed detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_fixed detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_fixed detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_fixed detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_fixed detects the string \"fixed\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_fixed detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_fixed detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_fixed detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_fixed detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_fixed detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_fixed detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_fixed detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_fixed detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_fixed detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_fixed detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_fixed detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_fixed detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_fixed detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_fixed detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_fixed detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_fixed detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_fixed detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_fixed detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_fixed detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_fixed detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_fixed detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_fixed detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_fixed detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_fixed detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_fixed detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_fixed detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_fixed detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_fixed detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_fixed.reference000066400000000000000000000000421300174114700210220ustar00rootroot00000000000000sollya_lib_is_fixed detects fixed sollya-6.0+ds/tests-lib/tis_floating.c000066400000000000000000000154501300174114700200230ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("floating"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_floating(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_floating detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_floating detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_floating detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_floating detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_floating detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_floating detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_floating detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_floating detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_floating detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_floating detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_floating detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_floating detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_floating detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_floating detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_floating detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_floating detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_floating detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_floating detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_floating detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_floating detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_floating detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_floating detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_floating detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_floating detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_floating detects the string \"floating\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_floating detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_floating detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_floating detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_floating detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_floating detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_floating detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_floating detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_floating detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_floating detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_floating detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_floating detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_floating detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_floating detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_floating detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_floating detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_floating detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_floating detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_floating detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_floating detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_floating detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_floating detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_floating detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_floating detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_floating detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_floating detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_floating detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_floating detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_floating detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_floating.reference000066400000000000000000000000501300174114700215250ustar00rootroot00000000000000sollya_lib_is_floating detects floating sollya-6.0+ds/tests-lib/tis_halfprecision_obj.c000066400000000000000000000164401300174114700217000ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("halfprecision_obj"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_halfprecision_obj(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects the string \"halfprecision_obj\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_halfprecision_obj detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_halfprecision_obj.reference000066400000000000000000000000661300174114700234110ustar00rootroot00000000000000sollya_lib_is_halfprecision_obj detects HP as symbol. sollya-6.0+ds/tests-lib/tis_hexadecimal.c000066400000000000000000000157201300174114700204640ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("hexadecimal"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_hexadecimal(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_hexadecimal detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_hexadecimal detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_hexadecimal detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_hexadecimal detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_hexadecimal detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_hexadecimal detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_hexadecimal detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_hexadecimal detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_hexadecimal detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_hexadecimal detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_hexadecimal detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_hexadecimal detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_hexadecimal detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_hexadecimal detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_hexadecimal detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_hexadecimal detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_hexadecimal detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_hexadecimal detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_hexadecimal detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_hexadecimal detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_hexadecimal detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_hexadecimal detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_hexadecimal detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_hexadecimal detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_hexadecimal detects the string \"hexadecimal\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_hexadecimal detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_hexadecimal detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_hexadecimal detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_hexadecimal detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_hexadecimal detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_hexadecimal detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_hexadecimal detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_hexadecimal detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_hexadecimal detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_hexadecimal detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_hexadecimal detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_hexadecimal detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_hexadecimal detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_hexadecimal detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_hexadecimal detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_hexadecimal detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_hexadecimal detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_hexadecimal detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_hexadecimal detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_hexadecimal detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_hexadecimal detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_hexadecimal detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_hexadecimal detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_hexadecimal detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_hexadecimal detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_hexadecimal detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_hexadecimal detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_hexadecimal detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_hexadecimal.reference000066400000000000000000000000561300174114700221740ustar00rootroot00000000000000sollya_lib_is_hexadecimal detects hexadecimal sollya-6.0+ds/tests-lib/tis_honorcoeffprec.c000066400000000000000000000161701300174114700212220ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("honorcoeffprec"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_honorcoeffprec(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects the string \"honorcoeffprec\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_honorcoeffprec detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_honorcoeffprec.reference000066400000000000000000000000641300174114700227310ustar00rootroot00000000000000sollya_lib_is_honorcoeffprec detects honorcoeffprec sollya-6.0+ds/tests-lib/tis_off.c000066400000000000000000000150201300174114700167630ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("off"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_off(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_off detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_off detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_off detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_off detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_off detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_off detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_off detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_off detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_off detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_off detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_off detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_off detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_off detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_off detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_off detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_off detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_off detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_off detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_off detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_off detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_off detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_off detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_off detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_off detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_off detects the string \"off\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_off detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_off detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_off detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_off detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_off detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_off detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_off detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_off detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_off detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_off detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_off detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_off detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_off detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_off detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_off detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_off detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_off detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_off detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_off detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_off detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_off detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_off detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_off detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_off detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_off detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_off detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_off detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_off detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_off.reference000066400000000000000000000000361300174114700205000ustar00rootroot00000000000000sollya_lib_is_off detects off sollya-6.0+ds/tests-lib/tis_on.c000066400000000000000000000147301300174114700166340ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("on"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_on(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_on detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_on detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_on detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_on detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_on detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_on detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_on detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_on detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_on detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_on detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_on detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_on detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_on detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_on detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_on detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_on detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_on detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_on detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_on detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_on detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_on detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_on detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_on detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_on detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_on detects the string \"on\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_on detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_on detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_on detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_on detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_on detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_on detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_on detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_on detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_on detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_on detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_on detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_on detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_on detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_on detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_on detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_on detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_on detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_on detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_on detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_on detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_on detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_on detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_on detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_on detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_on detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_on detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_on detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_on detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_on.reference000066400000000000000000000000341300174114700203400ustar00rootroot00000000000000sollya_lib_is_on detects on sollya-6.0+ds/tests-lib/tis_perturb.c000066400000000000000000000153601300174114700177030ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("perturb"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_perturb(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_perturb detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_perturb detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_perturb detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_perturb detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_perturb detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_perturb detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_perturb detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_perturb detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_perturb detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_perturb detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_perturb detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_perturb detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_perturb detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_perturb detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_perturb detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_perturb detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_perturb detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_perturb detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_perturb detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_perturb detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_perturb detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_perturb detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_perturb detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_perturb detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_perturb detects the string \"perturb\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_perturb detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_perturb detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_perturb detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_perturb detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_perturb detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_perturb detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_perturb detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_perturb detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_perturb detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_perturb detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_perturb detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_perturb detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_perturb detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_perturb detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_perturb detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_perturb detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_perturb detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_perturb detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_perturb detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_perturb detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_perturb detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_perturb detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_perturb detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_perturb detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_perturb detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_perturb detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_perturb detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_perturb detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_perturb.reference000066400000000000000000000000461300174114700214120ustar00rootroot00000000000000sollya_lib_is_perturb detects perturb sollya-6.0+ds/tests-lib/tis_pi.c000066400000000000000000000147301300174114700166300ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("pi"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_pi(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_pi detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_pi detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_pi detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_pi detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_pi detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_pi detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_pi detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_pi detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_pi detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_pi detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_pi detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_pi detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_pi detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_pi detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_pi detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_pi detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_pi detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_pi detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_pi detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_pi detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_pi detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_pi detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_pi detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_pi detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_pi detects the string \"pi\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_pi detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_pi detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_pi detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_pi detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_pi detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_pi detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_pi detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_pi detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_pi detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_pi detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_pi detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_pi detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_pi detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_pi detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_pi detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_pi detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_pi detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_pi detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_pi detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_pi detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_pi detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_pi detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_pi detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_pi detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_pi detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_pi detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_pi detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_pi detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_pi.reference000066400000000000000000000000341300174114700203340ustar00rootroot00000000000000sollya_lib_is_pi detects pi sollya-6.0+ds/tests-lib/tis_postscript.c000066400000000000000000000156301300174114700204320ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("postscript"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_postscript(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_postscript detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_postscript detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_postscript detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_postscript detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_postscript detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_postscript detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_postscript detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_postscript detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_postscript detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_postscript detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_postscript detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_postscript detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_postscript detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_postscript detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_postscript detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_postscript detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_postscript detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_postscript detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_postscript detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_postscript detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_postscript detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_postscript detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_postscript detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_postscript detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_postscript detects the string \"postscript\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_postscript detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_postscript detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_postscript detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_postscript detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_postscript detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_postscript detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_postscript detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_postscript detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_postscript detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_postscript detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_postscript detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_postscript detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_postscript detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_postscript detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_postscript detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_postscript detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_postscript detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_postscript detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_postscript detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_postscript detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_postscript detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_postscript detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_postscript detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_postscript detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_postscript detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_postscript detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_postscript detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_postscript detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_postscript.reference000066400000000000000000000000541300174114700221400ustar00rootroot00000000000000sollya_lib_is_postscript detects postscript sollya-6.0+ds/tests-lib/tis_postscriptfile.c000066400000000000000000000161701300174114700212720ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("postscriptfile"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_postscriptfile(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_postscriptfile detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_postscriptfile detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_postscriptfile detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_postscriptfile detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_postscriptfile detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_postscriptfile detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_postscriptfile detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_postscriptfile detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_postscriptfile detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_postscriptfile detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_postscriptfile detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_postscriptfile detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_postscriptfile detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_postscriptfile detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_postscriptfile detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_postscriptfile detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_postscriptfile detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_postscriptfile detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_postscriptfile detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_postscriptfile detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_postscriptfile detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_postscriptfile detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_postscriptfile detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_postscriptfile detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_postscriptfile detects the string \"postscriptfile\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_postscriptfile detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_postscriptfile detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_postscriptfile detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_postscriptfile detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_postscriptfile detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_postscriptfile detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_postscriptfile detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_postscriptfile detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_postscriptfile detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_postscriptfile detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_postscriptfile detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_postscriptfile detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_postscriptfile detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_postscriptfile detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_postscriptfile detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_postscriptfile detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_postscriptfile detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_postscriptfile detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_postscriptfile detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_postscriptfile detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_postscriptfile detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_postscriptfile detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_postscriptfile detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_postscriptfile detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_postscriptfile detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_postscriptfile detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_postscriptfile detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_postscriptfile detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_postscriptfile.reference000066400000000000000000000000641300174114700230010ustar00rootroot00000000000000sollya_lib_is_postscriptfile detects postscriptfile sollya-6.0+ds/tests-lib/tis_powers.c000066400000000000000000000152701300174114700175370ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("powers"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_powers(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_powers detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_powers detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_powers detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_powers detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_powers detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_powers detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_powers detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_powers detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_powers detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_powers detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_powers detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_powers detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_powers detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_powers detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_powers detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_powers detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_powers detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_powers detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_powers detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_powers detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_powers detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_powers detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_powers detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_powers detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_powers detects the string \"powers\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_powers detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_powers detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_powers detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_powers detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_powers detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_powers detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_powers detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_powers detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_powers detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_powers detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_powers detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_powers detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_powers detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_powers detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_powers detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_powers detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_powers detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_powers detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_powers detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_powers detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_powers detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_powers detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_powers detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_powers detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_powers detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_powers detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_powers detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_powers detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_powers.reference000066400000000000000000000000441300174114700212440ustar00rootroot00000000000000sollya_lib_is_powers detects powers sollya-6.0+ds/tests-lib/tis_quad_obj.c000066400000000000000000000154501300174114700200040ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("quad_obj"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_quad_obj(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_quad_obj detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_quad_obj detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_quad_obj detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_quad_obj detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_quad_obj detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_quad_obj detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_quad_obj detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_quad_obj detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_quad_obj detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_quad_obj detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_quad_obj detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_quad_obj detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_quad_obj detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_quad_obj detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_quad_obj detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_quad_obj detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_quad_obj detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_quad_obj detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_quad_obj detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_quad_obj detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_quad_obj detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_quad_obj detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_quad_obj detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_quad_obj detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_quad_obj detects the string \"quad_obj\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_quad_obj detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_quad_obj detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_quad_obj detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_quad_obj detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_quad_obj detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_quad_obj detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_quad_obj detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_quad_obj detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_quad_obj detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_quad_obj detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_quad_obj detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_quad_obj detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_quad_obj detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_quad_obj detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_quad_obj detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_quad_obj detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_quad_obj detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_quad_obj detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_quad_obj detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_quad_obj detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_quad_obj detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_quad_obj detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_quad_obj detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_quad_obj detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_quad_obj detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_quad_obj detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_quad_obj detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_quad_obj detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_quad_obj.reference000066400000000000000000000000551300174114700215130ustar00rootroot00000000000000sollya_lib_is_quad_obj detects QD as symbol. sollya-6.0+ds/tests-lib/tis_relative.c000066400000000000000000000154501300174114700200330ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("relative"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_relative(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_relative detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_relative detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_relative detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_relative detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_relative detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_relative detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_relative detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_relative detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_relative detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_relative detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_relative detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_relative detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_relative detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_relative detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_relative detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_relative detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_relative detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_relative detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_relative detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_relative detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_relative detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_relative detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_relative detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_relative detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_relative detects the string \"relative\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_relative detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_relative detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_relative detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_relative detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_relative detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_relative detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_relative detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_relative detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_relative detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_relative detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_relative detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_relative detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_relative detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_relative detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_relative detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_relative detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_relative detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_relative detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_relative detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_relative detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_relative detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_relative detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_relative detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_relative detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_relative detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_relative detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_relative detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_relative detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_relative.reference000066400000000000000000000000501300174114700215350ustar00rootroot00000000000000sollya_lib_is_relative detects relative sollya-6.0+ds/tests-lib/tis_round_down.c000066400000000000000000000156301300174114700203760ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("round_down"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_round_down(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_round_down detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_round_down detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_round_down detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_round_down detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_round_down detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_round_down detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_round_down detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_round_down detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_round_down detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_round_down detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_round_down detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_round_down detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_round_down detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_round_down detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_round_down detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_round_down detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_round_down detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_round_down detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_round_down detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_round_down detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_round_down detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_round_down detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_round_down detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_round_down detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_round_down detects the string \"round_down\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_round_down detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_round_down detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_round_down detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_round_down detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_round_down detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_round_down detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_round_down detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_round_down detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_round_down detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_round_down detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_round_down detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_round_down detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_round_down detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_round_down detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_round_down detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_round_down detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_round_down detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_round_down detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_round_down detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_round_down detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_round_down detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_round_down detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_round_down detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_round_down detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_round_down detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_round_down detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_round_down detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_round_down detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_round_down.reference000066400000000000000000000000451300174114700221040ustar00rootroot00000000000000sollya_lib_is_round_down detects RD. sollya-6.0+ds/tests-lib/tis_round_to_nearest.c000066400000000000000000000163501300174114700215720ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("round_to_nearest"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_round_to_nearest(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects the string \"round_to_nearest\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_round_to_nearest detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_round_to_nearest.reference000066400000000000000000000000531300174114700232770ustar00rootroot00000000000000sollya_lib_is_round_to_nearest detects RN. sollya-6.0+ds/tests-lib/tis_round_towards_zero.c000066400000000000000000000165301300174114700221510ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("round_towards_zero"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_round_towards_zero(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects the string \"round_towards_zero\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_round_towards_zero detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_round_towards_zero.reference000066400000000000000000000000551300174114700236600ustar00rootroot00000000000000sollya_lib_is_round_towards_zero detects RZ. sollya-6.0+ds/tests-lib/tis_round_up.c000066400000000000000000000154501300174114700200530ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("round_up"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_round_up(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_round_up detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_round_up detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_round_up detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_round_up detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_round_up detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_round_up detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_round_up detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_round_up detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_round_up detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_round_up detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_round_up detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_round_up detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_round_up detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_round_up detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_round_up detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_round_up detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_round_up detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_round_up detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_round_up detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_round_up detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_round_up detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_round_up detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_round_up detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_round_up detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_round_up detects the string \"round_up\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_round_up detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_round_up detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_round_up detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_round_up detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_round_up detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_round_up detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_round_up detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_round_up detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_round_up detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_round_up detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_round_up detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_round_up detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_round_up detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_round_up detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_round_up detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_round_up detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_round_up detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_round_up detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_round_up detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_round_up detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_round_up detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_round_up detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_round_up detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_round_up detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_round_up detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_round_up detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_round_up detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_round_up detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_round_up.reference000066400000000000000000000000431300174114700215570ustar00rootroot00000000000000sollya_lib_is_round_up detects RU. sollya-6.0+ds/tests-lib/tis_single_obj.c000066400000000000000000000156301300174114700203330ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("single_obj"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_single_obj(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_single_obj detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_single_obj detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_single_obj detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_single_obj detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_single_obj detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_single_obj detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_single_obj detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_single_obj detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_single_obj detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_single_obj detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_single_obj detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_single_obj detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_single_obj detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_single_obj detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_single_obj detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_single_obj detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_single_obj detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_single_obj detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_single_obj detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_single_obj detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_single_obj detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_single_obj detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_single_obj detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_single_obj detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_single_obj detects the string \"single_obj\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_single_obj detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_single_obj detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_single_obj detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_single_obj detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_single_obj detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_single_obj detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_single_obj detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_single_obj detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_single_obj detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_single_obj detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_single_obj detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_single_obj detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_single_obj detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_single_obj detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_single_obj detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_single_obj detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_single_obj detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_single_obj detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_single_obj detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_single_obj detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_single_obj detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_single_obj detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_single_obj detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_single_obj detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_single_obj detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_single_obj detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_single_obj detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_single_obj detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_single_obj.reference000066400000000000000000000000561300174114700220430ustar00rootroot00000000000000sollya_lib_is_single_obj detects S as symbol. sollya-6.0+ds/tests-lib/tis_triple_double_obj.c000066400000000000000000000164401300174114700217030ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("triple_double_obj"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_triple_double_obj(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects the string \"triple_double_obj\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_triple_double_obj detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_triple_double_obj.reference000066400000000000000000000000661300174114700234140ustar00rootroot00000000000000sollya_lib_is_triple_double_obj detects TD as symbol. sollya-6.0+ds/tests-lib/tis_true.c000066400000000000000000000151101300174114700171700ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("true"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_true(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_true detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_true detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_true detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_true detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_true detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_true detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_true detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_true detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_true detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_true detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_true detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_true detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_true detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_true detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_true detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_true detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_true detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_true detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_true detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_true detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_true detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_true detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_true detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_true detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_true detects the string \"true\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_true detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_true detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_true detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_true detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_true detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_true detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_true detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_true detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_true detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_true detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_true detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_true detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_true detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_true detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_true detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_true detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_true detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_true detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_true detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_true detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_true detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_true detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_true detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_true detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_true detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_true detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_true detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_true detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_true.reference000066400000000000000000000000401300174114700207000ustar00rootroot00000000000000sollya_lib_is_true detects true sollya-6.0+ds/tests-lib/tis_void.c000066400000000000000000000151101300174114700171520ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("void"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_is_void(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_is_void detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_is_void detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_is_void detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_is_void detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_is_void detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_is_void detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_is_void detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_is_void detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_is_void detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_is_void detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_is_void detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_is_void detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_is_void detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_is_void detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_is_void detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_is_void detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_is_void detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_is_void detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_is_void detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_is_void detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_is_void detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_is_void detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_is_void detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_is_void detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_is_void detects the string \"void\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_is_void detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_is_void detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_is_void detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_is_void detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_is_void detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_is_void detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_is_void detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_is_void detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_is_void detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_is_void detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_is_void detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_is_void detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_is_void detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_is_void detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_is_void detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_is_void detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_is_void detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_is_void detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_is_void detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_is_void detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_is_void detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_is_void detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_is_void detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_is_void detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_is_void detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_is_void detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_is_void detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_is_void detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tis_void.reference000066400000000000000000000000401300174114700206620ustar00rootroot00000000000000sollya_lib_is_void detects void sollya-6.0+ds/tests-lib/tlength.c000066400000000000000000000026171300174114700170070ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); if (message == SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED) sollya_lib_printf("The following test is not correctly typed\n"); else sollya_lib_printf("Unexpected warning\n"); return 0; } int main(void) { sollya_obj_t a, res; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a = sollya_lib_string("Hello world!"); res = sollya_lib_length(a); sollya_lib_printf("length of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[|1,2,3,4,5|]"); res = sollya_lib_length(a); sollya_lib_printf("length of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[||]"); res = sollya_lib_length(a); sollya_lib_printf("length of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[|1,2...|]"); res = sollya_lib_length(a); sollya_lib_printf("length of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[1,2]"); res = sollya_lib_length(a); sollya_lib_printf("length of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tlength.reference000066400000000000000000000002651300174114700205200ustar00rootroot00000000000000length of Hello world! is 12 length of [|1, 2, 3, 4, 5|] is 5 length of [| |] is 0 length of [|1, 2...|] is infty The following test is not correctly typed length of [1;2] is error sollya-6.0+ds/tests-lib/tlibraryconstant.c000066400000000000000000000136611300174114700207450ustar00rootroot00000000000000#include #include #include #include void euler_gamma(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } void stupid1(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid2(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid3(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid4(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid5(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid6(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } void stupid7(mpfr_t res, mp_prec_t prec) { (void)prec; /* Avoiding "unused parameter" warning */ mpfr_set_ui(res, 0, GMP_RNDN); return; } int main(void) { sollya_obj_t f[15]; int i; void *ptr; char str[256]; char str2[256]; mpfr_t x,y; sollya_lib_init(); /* Normal use */ f[0] = sollya_lib_libraryconstant("superconst", euler_gamma); sollya_lib_printf("%b (expecting superconst)\n", f[0]); mpfr_init2(x, 30); mpfr_init2(y, 50); mpfr_set_ui(x, 0, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f[0], x, NULL); sollya_lib_printf("%v (expecting: 0.5772...)\n", y); sollya_lib_clear_obj(f[0]); f[0] = sollya_lib_parse_string("superconst"); sollya_lib_evaluate_function_at_point(y, f[0], x, NULL); sollya_lib_printf("%v (expecting: 0.5772...)\n", y); /* Trying to rebind a constant already bounded */ f[1] = sollya_lib_libraryconstant("*]%", euler_gamma); sollya_lib_printf("%b (expecting superconst)\n", f[1]); f[2] = sollya_lib_libraryconstant("superconst", euler_gamma); sollya_lib_printf("%b (expecting superconst)\n", f[2]); f[3] = sollya_lib_libraryconstant("foo", euler_gamma); sollya_lib_printf("%b (expecting superconst)\n", f[3]); f[4] = sollya_lib_libraryconstant(NULL, euler_gamma); sollya_lib_printf("%b (expecting superconst)\n", f[4]); f[5] = sollya_lib_libraryconstant("pi", euler_gamma); sollya_lib_printf("%b (expecting superconst)\n", f[5]); for(i=1;i<=5;i++) { f[6] = sollya_lib_cmp_equal(f[0], f[i]); sollya_lib_printf("%b (expecting true)\n", f[6]); sollya_lib_clear_obj(f[6]); } /* Trying to bind a function to an already assigned name */ f[6] = sollya_lib_libraryconstant("superconst", stupid1); sollya_lib_printf("%b (expecting superconst_0)\n", f[6]); /* Leaving NULL as first argument */ f[7] = sollya_lib_libraryconstant(NULL, stupid2); sollya_lib_sprintf(str, "%b", f[7]); sollya_lib_sprintf(str2, "const_%p", stupid2); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the first argument is NULL is conform to the semantic.\n"); else { strcpy(str2, "stupid2"); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the first argument is NULL is conform to the semantic.\n"); else sollya_lib_printf("The behavior when the first argument is *NOT* conform to the semantic.\n"); } /* Unauthorized names */ f[8] = sollya_lib_libraryconstant("e]xp", stupid3); sollya_lib_printf("%b (expecting exp_0)\n", f[8]); f[9] = sollya_lib_libraryconstant("]0", stupid4); sollya_lib_sprintf(str, "%b", f[9]); sollya_lib_sprintf(str2, "const_%p", stupid4); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the first argument is NULL is conform to the semantic.\n"); else { strcpy(str2, "stupid4"); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the first argument is NULL is conform to the semantic.\n"); else sollya_lib_printf("The behavior when the first argument is *NOT* conform to the semantic.\n"); } f[10] = sollya_lib_libraryconstant("0]a", stupid5); sollya_lib_printf("%b (expecting a)\n", f[10]); /* Pointer to non-valid functions, together with NULL/illicit as second argument */ f[11] = sollya_lib_libraryconstant(NULL, (void (*)(mpfr_t, mp_prec_t)) (((char *) stupid6)+((int) 17))); sollya_lib_sprintf(str, "%b", f[11]); sollya_lib_sprintf(str2, "const_%p", (void (*)(mpfr_t, mp_prec_t)) (((char *) stupid6)+((int) 17))); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[11], str2); f[12] = sollya_lib_libraryconstant(NULL, (void (*)(mpfr_t, mp_prec_t)) (((char *) stupid7)-((int) 17))); sollya_lib_sprintf(str, "%b", f[12]); sollya_lib_sprintf(str2, "const_%p", (void (*)(mpfr_t, mp_prec_t)) (((char *) stupid7)-((int) 17))); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[12], str2); f[13] = sollya_lib_libraryconstant("", (void (*)(mpfr_t, mp_prec_t))(&x)); sollya_lib_sprintf(str, "%b", f[13]); sollya_lib_sprintf(str2, "const_%p", &x); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[13], str2); ptr = malloc(1); f[14] = sollya_lib_libraryconstant("*]%", (void (*)(mpfr_t, mp_prec_t))(ptr)); sollya_lib_sprintf(str, "%b", f[14]); sollya_lib_sprintf(str2, "const_%p", ptr); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[14], str2); for(i=0;i<=14;i++) sollya_lib_clear_obj(f[i]); free(ptr); mpfr_clear(x); mpfr_clear(y); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tlibraryconstant.reference000066400000000000000000000015261300174114700224560ustar00rootroot00000000000000superconst (expecting superconst) 0.57721566490153275452712477999739348888397216796875 (expecting: 0.5772...) 0.57721566490153275452712477999739348888397216796875 (expecting: 0.5772...) superconst (expecting superconst) superconst (expecting superconst) superconst (expecting superconst) superconst (expecting superconst) superconst (expecting superconst) true (expecting true) true (expecting true) true (expecting true) true (expecting true) true (expecting true) superconst_0 (expecting superconst_0) The behavior when the first argument is NULL is conform to the semantic. exp_0 (expecting exp_0) The behavior when the first argument is NULL is conform to the semantic. a (expecting a) Testing NULL/invalid ptr combination: OK Testing NULL/invalid ptr combination: OK Testing NULL/invalid ptr combination: OK Testing NULL/invalid ptr combination: OK sollya-6.0+ds/tests-lib/tlibraryconstant_with_data.c000066400000000000000000000042011300174114700227570ustar00rootroot00000000000000#include #include #include #include #include typedef struct data_struct_t { char text[32]; int counter; } data_t; void euler_gamma(mpfr_t res, mp_prec_t prec, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } void euler_gamma2(mpfr_t res, mp_prec_t prec, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } void dealloc(void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf("Deallocation function called for the data pointer (%s<<<>>>%d)\n", data->text, data->counter); return; } int main(void) { sollya_obj_t f,g; mpfr_t x,y; data_t data = { "Hello world", 0 }; sollya_lib_init(); f = sollya_lib_libraryconstant_with_data("superconst", euler_gamma, &data, NULL); sollya_lib_printf("%b (expecting: superconst)\n", f); mpfr_init2(x, 30); mpfr_init2(y, 50); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: 0.5772...)\n", y); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("superconst"); sollya_lib_printf("%b (expecting: superconst)\n", f); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: 0.5772...)\n", y); sollya_lib_clear_obj(f); f = sollya_lib_libraryconstant_with_data("superconst2", euler_gamma2, &data, dealloc); g = SOLLYA_ADD(SOLLYA_CONST(2), sollya_lib_copy_obj(f)); sollya_lib_printf("%b (expecting: superconst2)\n", f); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: 0.5772...)\n", y); sollya_lib_clear_obj(f); sollya_lib_printf("Deallocation function must not yet have been called\n"); sollya_lib_clear_obj(g); mpfr_clear(x); mpfr_clear(y); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tlibraryconstant_with_data.reference000066400000000000000000000010411300174114700244720ustar00rootroot00000000000000superconst (expecting: superconst) >>>>Hello world<<<<>>>>0<<<< 0.57721566490153275452712477999739348888397216796875 (expecting: 0.5772...) superconst (expecting: superconst) >>>>Hello world<<<<>>>>1<<<< 0.57721566490153275452712477999739348888397216796875 (expecting: 0.5772...) superconst2 (expecting: superconst2) >>>>Hello world<<<<>>>>2<<<< 0.57721566490153275452712477999739348888397216796875 (expecting: 0.5772...) Deallocation function must not yet have been called Deallocation function called for the data pointer (Hello world<<<>>>3) sollya-6.0+ds/tests-lib/tlibraryfunction.c000066400000000000000000000206251300174114700207370ustar00rootroot00000000000000#include #include #include #include #include int myownlog(mpfi_t result, mpfi_t x, int n) { if(n==0) { /* Implementation of the neperian logarithm */ if(mpfi_nan_p(x)) { mpfr_t a; mpfr_init2(a,mpfi_get_prec(result)); mpfi_interv_fr(result,a,a); mpfr_clear(a); return 0; } if(mpfi_has_zero(x)) { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } else { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfi_get_left(a,x); mpfr_log(a,a, GMP_RNDD); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } } if(n==1) { /* Implementation of 1/x */ mpfi_inv(result,x); return 0; } if(n==2) { /* Implementation of -1/x^2 */ mpfi_t temp; mpfi_init2(temp, mpfi_get_prec(result)); mpfi_sqr(temp, x); mpfi_inv(temp, temp); mpfi_neg(result, temp); mpfi_clear(temp); return 0; } /* else */ mpfr_t a,b; mpfr_init2(a, mpfi_get_prec(result)); mpfr_init2(b, mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfr_set_inf(b, 1); mpfi_interv_fr(result,a,b); mpfr_clear(a); mpfr_clear(b); return 0; } int stupid1(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid2(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid3(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid4(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid5(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid6(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid7(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int stupid8(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 3); return 0; } int main(void) { sollya_obj_t f[18]; mpfr_t x,y; int i; void *ptr; char str[256]; char str2[256]; sollya_lib_init(); f[0] = sollya_lib_free_variable(); /* Testing normal use */ f[1] = sollya_lib_libraryfunction(f[0], "superfunc", myownlog); sollya_lib_printf("%b (expecting: superfunc)\n", f[1]); mpfr_init2(x, 30); mpfr_init2(y, 50); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f[1], x, NULL); sollya_lib_printf("%v (expecting: approximate value of log(2))\n", y); sollya_lib_clear_obj(f[1]); f[1] = sollya_lib_parse_string("diff(superfunc(sin(_x_)))"); sollya_lib_printf("%b (expecting: (diff(superfunc))(sin(_x_)) * cos(_x_))\n", f[1]); sollya_lib_clear_obj(f[1]); f[1] = sollya_lib_parse_string("diff(superfunc(_x_))"); sollya_lib_printf("%b (expecting: diff(superfunc))\n", f[1]); sollya_lib_clear_obj(f[1]); f[1] = sollya_lib_parse_string("superfunc"); /* Trying to rebind a function already bounded */ f[2] = sollya_lib_libraryfunction(f[0], "superfunc", myownlog); sollya_lib_printf("%b (expecting superfunc)\n", f[2]); f[3] = sollya_lib_libraryfunction(f[0], "foo", myownlog); sollya_lib_printf("%b (expecting superfunc)\n", f[3]); f[4] = sollya_lib_libraryfunction(f[0], NULL, myownlog); sollya_lib_printf("%b (expecting superfunc)\n", f[4]); f[5] = sollya_lib_libraryfunction(f[0], "exp", myownlog); sollya_lib_printf("%b (expecting superfunc)\n", f[5]); for(i=2;i<=5;i++) { f[6] = sollya_lib_cmp_equal(f[1], f[i]); sollya_lib_printf("%b (expecting true)\n", f[6]); sollya_lib_clear_obj(f[6]); } /* Trying to bind a function to an already assigned name */ f[6] = sollya_lib_libraryfunction(f[0], "superfunc", stupid1); sollya_lib_printf("%b (expecting superfunc_0)\n", f[6]); /* Leaving NULL as second argument */ f[7] = sollya_lib_libraryfunction(f[0], NULL, stupid2); sollya_lib_sprintf(str, "%b", f[7]); sollya_lib_sprintf(str2, "func_%p", stupid2); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the second argument is NULL is conform to the semantic.\n"); else { strcpy(str2, "stupid2"); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the second argument is NULL is conform to the semantic.\n"); else sollya_lib_printf("The behavior when the second argument is *NOT* conform to the semantic.\n"); } /* Unauthorized names */ f[8] = sollya_lib_libraryfunction(f[0], "e]xp", stupid3); sollya_lib_printf("%b (expecting exp_0)\n", f[8]); f[9] = sollya_lib_libraryfunction(f[0], "]0", stupid4); sollya_lib_sprintf(str, "%b", f[9]); sollya_lib_sprintf(str2, "func_%p", stupid4); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the second argument is NULL is conform to the semantic.\n"); else { strcpy(str2, "stupid4"); if (strcmp(str, str2)==0) sollya_lib_printf("The behavior when the second argument is NULL is conform to the semantic.\n"); else sollya_lib_printf("The behavior when the second argument is *NOT* conform to the semantic.\n"); } f[10] = sollya_lib_libraryfunction(f[0], "0]a", stupid5); sollya_lib_printf("%b (expecting a)\n", f[10]); /* Pointer to non-valid functions, together with NULL/illicit as second argument */ f[11] = sollya_lib_libraryfunction(f[0], NULL, (int (*)(mpfi_t, mpfi_t, int)) (((char *) stupid6)+((int) 17))); sollya_lib_sprintf(str, "%b", f[11]); sollya_lib_sprintf(str2, "func_%p", (int (*)(mpfi_t, mpfi_t, int)) (((char *) stupid6)+((int) 17))); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[11], str2); f[12] = sollya_lib_libraryfunction(f[0], NULL, (int (*)(mpfi_t, mpfi_t, int)) (((char *) stupid7)-((int) 17))); sollya_lib_sprintf(str, "%b", f[12]); sollya_lib_sprintf(str2, "func_%p", (int (*)(mpfi_t, mpfi_t, int)) (((char *) stupid7)-((int) 17))); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[12], str2); f[13] = sollya_lib_libraryfunction(f[0], "", (int (*)(mpfi_t, mpfi_t, int))(&x)); sollya_lib_sprintf(str, "%b", f[13]); sollya_lib_sprintf(str2, "func_%p", &x); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[13], str2); ptr = malloc(1); f[14] = sollya_lib_libraryfunction(f[0], "*]%", (int (*)(mpfi_t, mpfi_t, int))(ptr)); sollya_lib_sprintf(str, "%b", f[14]); sollya_lib_sprintf(str2, "func_%p", ptr); if (strcmp(str, str2)==0) sollya_lib_printf("Testing NULL/invalid ptr combination: OK\n"); else sollya_lib_printf("Testing NULL/invalid ptr combination: *NOT* OK: %b versus %s\n", f[14], str2); /* Called on an interval, should return the interval, and the function should still being alive */ f[15] = sollya_lib_parse_string("[1,2]"); f[16] = sollya_lib_libraryfunction(f[15], "foo", stupid8); sollya_lib_printf("%b (expecting [3;3])\n", f[16]); f[17] = sollya_lib_parse_string("diff(foo(sin(_x_)))"); sollya_lib_printf("%b (expecting (diff(foo))(sin(_x_)) * cos(_x_))\n", f[17]); for(i=0;i<=17;i++) sollya_lib_clear_obj(f[i]); mpfr_clear(x); mpfr_clear(y); free(ptr); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tlibraryfunction.reference000066400000000000000000000017101300174114700224450ustar00rootroot00000000000000superfunc (expecting: superfunc) 0.6931471805599453972490664455108344554901123046875 (expecting: approximate value of log(2)) (diff(superfunc))(sin(_x_)) * cos(_x_) (expecting: (diff(superfunc))(sin(_x_)) * cos(_x_)) diff(superfunc) (expecting: diff(superfunc)) superfunc (expecting superfunc) superfunc (expecting superfunc) superfunc (expecting superfunc) superfunc (expecting superfunc) true (expecting true) true (expecting true) true (expecting true) true (expecting true) superfunc_0 (expecting superfunc_0) The behavior when the second argument is NULL is conform to the semantic. exp_0 (expecting exp_0) The behavior when the second argument is NULL is conform to the semantic. a (expecting a) Testing NULL/invalid ptr combination: OK Testing NULL/invalid ptr combination: OK Testing NULL/invalid ptr combination: OK Testing NULL/invalid ptr combination: OK [3;3] (expecting [3;3]) (diff(foo))(sin(_x_)) * cos(_x_) (expecting (diff(foo))(sin(_x_)) * cos(_x_)) sollya-6.0+ds/tests-lib/tlibraryfunction_with_data.c000066400000000000000000000122171300174114700227610ustar00rootroot00000000000000#include #include #include #include #include typedef struct data_struct_t { char text[32]; int counter; } data_t; int myownlog(mpfi_t result, mpfi_t x, int n, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; if(n==0) { /* Implementation of the neperian logarithm */ if(mpfi_nan_p(x)) { mpfr_t a; mpfr_init2(a,mpfi_get_prec(result)); mpfi_interv_fr(result,a,a); mpfr_clear(a); return 0; } if(mpfi_has_zero(x)) { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } else { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfi_get_left(a,x); mpfr_log(a,a, GMP_RNDD); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } } if(n==1) { /* Implementation of 1/x */ mpfi_inv(result,x); return 0; } if(n==2) { /* Implementation of -1/x^2 */ mpfi_t temp; mpfi_init2(temp, mpfi_get_prec(result)); mpfi_sqr(temp, x); mpfi_inv(temp, temp); mpfi_neg(result, temp); mpfi_clear(temp); return 0; } /* else */ mpfr_t a,b; mpfr_init2(a, mpfi_get_prec(result)); mpfr_init2(b, mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfr_set_inf(b, 1); mpfi_interv_fr(result,a,b); mpfr_clear(a); mpfr_clear(b); return 0; } int myownlog2(mpfi_t result, mpfi_t x, int n, void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf(">>>>%s<<<<>>>>%d<<<<\n", data->text, data->counter); (data->counter)++; if(n==0) { /* Implementation of the neperian logarithm */ if(mpfi_nan_p(x)) { mpfr_t a; mpfr_init2(a,mpfi_get_prec(result)); mpfi_interv_fr(result,a,a); mpfr_clear(a); return 0; } if(mpfi_has_zero(x)) { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } else { mpfr_t a,b; mpfr_init2(a,mpfi_get_prec(result)); mpfr_init2(b,mpfi_get_prec(result)); mpfi_get_left(a,x); mpfr_log(a,a, GMP_RNDD); mpfi_get_right(b,x); mpfr_log(b,b,GMP_RNDU); mpfi_interv_fr(result, a, b); mpfr_clear(a); mpfr_clear(b); return 0; } } if(n==1) { /* Implementation of 1/x */ mpfi_inv(result,x); return 0; } if(n==2) { /* Implementation of -1/x^2 */ mpfi_t temp; mpfi_init2(temp, mpfi_get_prec(result)); mpfi_sqr(temp, x); mpfi_inv(temp, temp); mpfi_neg(result, temp); mpfi_clear(temp); return 0; } /* else */ mpfr_t a,b; mpfr_init2(a, mpfi_get_prec(result)); mpfr_init2(b, mpfi_get_prec(result)); mpfr_set_inf(a,-1); mpfr_set_inf(b, 1); mpfi_interv_fr(result,a,b); mpfr_clear(a); mpfr_clear(b); return 0; } void dealloc(void *ptr) { data_t *data; data = (data_t *) ptr; sollya_lib_printf("Deallocation function called for the data pointer (%s<<<>>>%d)\n", data->text, data->counter); return; } int main(void) { sollya_obj_t X, f, g; mpfr_t x,y; data_t data = { "Hello world", 0 }; sollya_lib_init(); X = sollya_lib_free_variable(); f = sollya_lib_libraryfunction_with_data(X, "superfunc", myownlog, &data, NULL); sollya_lib_printf("%b (expecting: superfunc)\n", f); mpfr_init2(x, 30); mpfr_init2(y, 50); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: approximate value of log(2))\n", y); sollya_lib_clear_obj(f); sollya_lib_clear_obj(X); f = sollya_lib_parse_string("diff(superfunc(sin(_x_)))"); sollya_lib_printf("%b (expecting: (diff(superfunc))(sin(_x_)) * cos(_x_))\n", f); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("diff(superfunc(_x_))"); sollya_lib_printf("%b (expecting: diff(superfunc))\n", f); mpfr_set_ui(x, 4, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: approximate value of 1/4)\n", y); sollya_lib_clear_obj(f); X = sollya_lib_free_variable(); f = sollya_lib_libraryfunction_with_data(X, "superfunc2", myownlog2, &data, dealloc); g = SOLLYA_ADD(SOLLYA_CONST(3), sollya_lib_copy_obj(f)); sollya_lib_printf("%b (expecting: superfunc2)\n", f); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, f, x, NULL); sollya_lib_printf("%v (expecting: approximate value of log(2))\n", y); sollya_lib_clear_obj(f); sollya_lib_printf("Deallocation function must not yet have been called\n"); sollya_lib_clear_obj(X); sollya_lib_clear_obj(g); mpfr_clear(x); mpfr_clear(y); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tlibraryfunction_with_data.reference000066400000000000000000000012031300174114700244660ustar00rootroot00000000000000superfunc (expecting: superfunc) >>>>Hello world<<<<>>>>0<<<< 0.6931471805599453972490664455108344554901123046875 (expecting: approximate value of log(2)) (diff(superfunc))(sin(_x_)) * cos(_x_) (expecting: (diff(superfunc))(sin(_x_)) * cos(_x_)) diff(superfunc) (expecting: diff(superfunc)) >>>>Hello world<<<<>>>>1<<<< 0.25 (expecting: approximate value of 1/4) superfunc2 (expecting: superfunc2) >>>>Hello world<<<<>>>>2<<<< 0.6931471805599453972490664455108344554901123046875 (expecting: approximate value of log(2)) Deallocation function must not yet have been called Deallocation function called for the data pointer (Hello world<<<>>>3) sollya-6.0+ds/tests-lib/tlist.c000066400000000000000000000022051300174114700164720ustar00rootroot00000000000000#include int main(void) { sollya_obj_t L[3]; void *ptr; sollya_obj_t listobj; sollya_lib_init(); /* Empty list from nothing */ listobj = sollya_lib_list(NULL, 0); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); L[0] = SOLLYA_COS(SOLLYA_X_); L[1] = SOLLYA_CONST(3.); L[2] = sollya_lib_double_obj(); /* Empty list from an invalid pointer */ ptr = (void *) 17; listobj = sollya_lib_list((sollya_obj_t *)ptr, 0); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* Empty list from a valid pointer */ listobj = sollya_lib_list(L, 0); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* List with one element, out of an array of more elements */ listobj = sollya_lib_list(L, 1); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* List from an array with all the elements of the array */ listobj = sollya_lib_list(L, 3); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); sollya_lib_clear_obj(L[0]); sollya_lib_clear_obj(L[1]); sollya_lib_clear_obj(L[2]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tlist.reference000066400000000000000000000000671300174114700202120ustar00rootroot00000000000000[| |] [| |] [| |] [|cos(_x_)|] [|cos(_x_), 3, double|] sollya-6.0+ds/tests-lib/tlog.c000066400000000000000000000004141300174114700163000ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_log(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tlog.reference000066400000000000000000000000101300174114700200040ustar00rootroot00000000000000log(_x_)sollya-6.0+ds/tests-lib/tlog10.c000066400000000000000000000004161300174114700164430ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_log10(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tlog10.reference000066400000000000000000000000121300174114700201470ustar00rootroot00000000000000log10(_x_)sollya-6.0+ds/tests-lib/tlog1p.c000066400000000000000000000004161300174114700165430ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_log1p(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tlog1p.reference000066400000000000000000000000121300174114700202470ustar00rootroot00000000000000log1p(_x_)sollya-6.0+ds/tests-lib/tlog2.c000066400000000000000000000004151300174114700163630ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_log2(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tlog2.reference000066400000000000000000000000111300174114700200670ustar00rootroot00000000000000log2(_x_)sollya-6.0+ds/tests-lib/tmacros_build_function.c000066400000000000000000000214611300174114700220740ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); if (message==SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT) sollya_lib_printf("Caught the message about the fact that faithful rounding has occurred.\n"); else sollya_lib_printf("Unexpected message caught.\n"); return 0; } int main(void) { sollya_obj_t a,b; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a = SOLLYA_SQRT(SOLLYA_X_); b = sollya_lib_build_function_sqrt(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_EXP(SOLLYA_X_); b = sollya_lib_build_function_exp(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_LOG(SOLLYA_X_); b = sollya_lib_build_function_log(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_LOG2(SOLLYA_X_); b = sollya_lib_build_function_log2(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_LOG10(SOLLYA_X_); b = sollya_lib_build_function_log10(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_SIN(SOLLYA_X_); b = sollya_lib_build_function_sin(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_COS(SOLLYA_X_); b = sollya_lib_build_function_cos(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_TAN(SOLLYA_X_); b = sollya_lib_build_function_tan(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_ASIN(SOLLYA_X_); b = sollya_lib_build_function_asin(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_ACOS(SOLLYA_X_); b = sollya_lib_build_function_acos(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_ATAN(SOLLYA_X_); b = sollya_lib_build_function_atan(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_NEG(SOLLYA_X_); b = sollya_lib_build_function_neg(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_ABS(SOLLYA_X_); b = sollya_lib_build_function_abs(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_D(SOLLYA_X_); b = sollya_lib_build_function_double(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_SG(SOLLYA_X_); b = sollya_lib_build_function_single(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_QD(SOLLYA_X_); b = sollya_lib_build_function_quad(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_HP(SOLLYA_X_); b = sollya_lib_build_function_halfprecision(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_DD(SOLLYA_X_); b = sollya_lib_build_function_double_double(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_TD(SOLLYA_X_); b = sollya_lib_build_function_triple_double(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_ERF(SOLLYA_X_); b = sollya_lib_build_function_erf(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_ERFC(SOLLYA_X_); b = sollya_lib_build_function_erfc(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_LOG1P(SOLLYA_X_); b = sollya_lib_build_function_log1p(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_EXPM1(SOLLYA_X_); b = sollya_lib_build_function_expm1(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_DE(SOLLYA_X_); b = sollya_lib_build_function_doubleextended(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_CEIL(SOLLYA_X_); b = sollya_lib_build_function_ceil(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_FLOOR(SOLLYA_X_); b = sollya_lib_build_function_floor(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_NEARESTINT(SOLLYA_X_); b = sollya_lib_build_function_nearestint(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_SINH(SOLLYA_X_); b = sollya_lib_build_function_sinh(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_COSH(SOLLYA_X_); b = sollya_lib_build_function_cosh(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_TANH(SOLLYA_X_); b = sollya_lib_build_function_tanh(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_ASINH(SOLLYA_X_); b = sollya_lib_build_function_asinh(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_ACOSH(SOLLYA_X_); b = sollya_lib_build_function_acosh(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_ATANH(SOLLYA_X_); b = sollya_lib_build_function_atanh(SOLLYA_X_); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_ADD(SOLLYA_X_, sollya_lib_constant_from_int(1)); b = sollya_lib_build_function_add((SOLLYA_X_), sollya_lib_constant_from_int(1)); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_SUB(SOLLYA_X_, sollya_lib_constant_from_int(1)); b = sollya_lib_build_function_sub((SOLLYA_X_), ( sollya_lib_constant_from_int(1))); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_MUL(SOLLYA_X_, sollya_lib_constant_from_int(2)); b = sollya_lib_build_function_mul((SOLLYA_X_), ( sollya_lib_constant_from_int(2))); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_DIV(SOLLYA_X_, sollya_lib_constant_from_int(2)); b = sollya_lib_build_function_div((SOLLYA_X_), ( sollya_lib_constant_from_int(2))); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_POW(SOLLYA_X_, sollya_lib_constant_from_int(2)); b = sollya_lib_build_function_pow((SOLLYA_X_), ( sollya_lib_constant_from_int(2))); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_PI; b = sollya_lib_build_function_pi(); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_CONST(43); b = sollya_lib_constant_from_int(43); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_CONST(43.); b = sollya_lib_constant_from_int(43); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_CONST(1180591620717411303424.); b = sollya_lib_constant_from_double(1180591620717411303424.); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_CONST(0.1); b = sollya_lib_parse_string("0.1"); sollya_lib_printf("%b is not %b (and it is expected)\n",a,b); sollya_lib_clear_obj(b); b = sollya_lib_parse_string("D(1/10)"); sollya_lib_printf("... but %b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_CONST_UI64(UINT64_C(281474976710656)); b = sollya_lib_constant_from_double(281474976710656.); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_CONST_UI64(UINT64_C(-281474976710656)); b = sollya_lib_constant_from_uint64(UINT64_C(-281474976710656)); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = SOLLYA_CONST_SI64(INT64_C(-281474976710656)); b = sollya_lib_constant_from_double(-281474976710656.); sollya_lib_printf("%b is %b\n",a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tmacros_build_function.reference000066400000000000000000000025671300174114700236160ustar00rootroot00000000000000sqrt(_x_) is sqrt(_x_) exp(_x_) is exp(_x_) log(_x_) is log(_x_) log2(_x_) is log2(_x_) log10(_x_) is log10(_x_) sin(_x_) is sin(_x_) cos(_x_) is cos(_x_) tan(_x_) is tan(_x_) asin(_x_) is asin(_x_) acos(_x_) is acos(_x_) atan(_x_) is atan(_x_) -_x_ is -_x_ abs(_x_) is abs(_x_) double(_x_) is double(_x_) single(_x_) is single(_x_) quad(_x_) is quad(_x_) halfprecision(_x_) is halfprecision(_x_) doubledouble(_x_) is doubledouble(_x_) tripledouble(_x_) is tripledouble(_x_) erf(_x_) is erf(_x_) erfc(_x_) is erfc(_x_) log1p(_x_) is log1p(_x_) expm1(_x_) is expm1(_x_) doubleextended(_x_) is doubleextended(_x_) ceil(_x_) is ceil(_x_) floor(_x_) is floor(_x_) nearestint(_x_) is nearestint(_x_) sinh(_x_) is sinh(_x_) cosh(_x_) is cosh(_x_) tanh(_x_) is tanh(_x_) asinh(_x_) is asinh(_x_) acosh(_x_) is acosh(_x_) atanh(_x_) is atanh(_x_) _x_ + 1 is _x_ + 1 _x_ - 1 is _x_ - 1 _x_ * 2 is _x_ * 2 _x_ / 2 is _x_ / 2 _x_^2 is _x_^2 pi is pi 43 is 43 43 is 43 1180591620717411303424 is 1180591620717411303424 Caught the message about the fact that faithful rounding has occurred. 0.100000000000000005551115123125782702118158340454102 is not 0.1 (and it is expected) ... but 0.100000000000000005551115123125782702118158340454102 is 0.100000000000000005551115123125782702118158340454102 281474976710656 is 281474976710656 18446462598732840960 is 18446462598732840960 -281474976710656 is -281474976710656 sollya-6.0+ds/tests-lib/tmantissa_and_exponent.c000066400000000000000000000045541300174114700221110ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST: sollya_lib_printf("An expression should have been a constant but it is just a constant expression.\n"); break; default: sollya_lib_printf("Unexpected warning %d\n", message); } return 0; } int main(void) { sollya_obj_t a[8]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = SOLLYA_PI; a[1] = SOLLYA_CONST(20.0); a[2] = sollya_lib_round_to_nearest(); a[3] = sollya_lib_round(a[0],a[1],a[2]); a[4] = sollya_lib_exponent(a[3]); a[5] = sollya_lib_mantissa(a[3]); a[6] = SOLLYA_SUB(sollya_lib_copy_obj(a[3]),SOLLYA_MUL(sollya_lib_copy_obj(a[5]),SOLLYA_POW(SOLLYA_CONST(2.0),sollya_lib_copy_obj(a[4])))); a[7] = sollya_lib_simplify(a[6]); sollya_lib_printf("val = %b, mantissa = %b, exponent = %b, val - mantissa * 2^exponent = %b\n", a[3], a[5], a[4], a[7]); for (i=0;i<8;i++) { sollya_lib_clear_obj(a[i]); } a[0] = SOLLYA_NEG(SOLLYA_PI); a[1] = SOLLYA_CONST(20.0); a[2] = sollya_lib_round_to_nearest(); a[3] = sollya_lib_round(a[0],a[1],a[2]); a[4] = sollya_lib_exponent(a[3]); a[5] = sollya_lib_mantissa(a[3]); a[6] = SOLLYA_SUB(sollya_lib_copy_obj(a[3]),SOLLYA_MUL(sollya_lib_copy_obj(a[5]),SOLLYA_POW(SOLLYA_CONST(2.0),sollya_lib_copy_obj(a[4])))); a[7] = sollya_lib_simplify(a[6]); sollya_lib_printf("val = %b, mantissa = %b, exponent = %b, val - mantissa * 2^exponent = %b\n", a[3], a[5], a[4], a[7]); for (i=0;i<8;i++) { sollya_lib_clear_obj(a[i]); } a[0] = SOLLYA_ADD(SOLLYA_CONST(1.0),SOLLYA_POW(SOLLYA_CONST(2.0),SOLLYA_CONST(-17.0))); a[1] = SOLLYA_CONST(40.0); a[2] = sollya_lib_round_to_nearest(); a[3] = sollya_lib_round(a[0],a[1],a[2]); a[4] = sollya_lib_exponent(a[3]); a[5] = sollya_lib_mantissa(a[3]); a[6] = SOLLYA_SUB(sollya_lib_copy_obj(a[3]),SOLLYA_MUL(sollya_lib_copy_obj(a[5]),SOLLYA_POW(SOLLYA_CONST(2.0),sollya_lib_copy_obj(a[4])))); a[7] = sollya_lib_simplify(a[6]); sollya_lib_printf("val = %b, mantissa = %b, exponent = %b, val - mantissa * 2^exponent = %b\n", a[3], a[5], a[4], a[7]); for (i=0;i<8;i++) { sollya_lib_clear_obj(a[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tmantissa_and_exponent.reference000066400000000000000000000004341300174114700236160ustar00rootroot00000000000000val = 3.14159393310546875, mantissa = 411775, exponent = -17, val - mantissa * 2^exponent = 0 val = -3.14159393310546875, mantissa = -411775, exponent = -17, val - mantissa * 2^exponent = 0 val = 1.00000762939453125, mantissa = 131073, exponent = -17, val - mantissa * 2^exponent = 0 sollya-6.0+ds/tests-lib/tmax.c000066400000000000000000000206441300174114700163130ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: sollya_lib_printf("The following test is not certified (probably because the max is reached by two equal values).\n"); break; case SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: sollya_lib_printf("The test will rely on pure FP evaluation (probably because 0 is the maximum but it is hard to prove it).\n"); break; case SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL: sollya_lib_printf("Warning: the following test involves a NaN\n"); break; case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The following expression is not correctly typed.\n"); break; default: sollya_lib_printf("Unexpected warning %d\n", message); } return 0; } int main(void) { sollya_obj_t a[4]; sollya_obj_t b,c; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* Tests a simple maximum */ a[0] = sollya_lib_constant_from_int(4); a[1] = sollya_lib_constant_from_int(5); a[2] = sollya_lib_constant_from_int(1); a[3] = sollya_lib_constant_from_int(3); b = sollya_lib_max(a[0], a[1], a[2], a[3], NULL); sollya_lib_printf("max(4,5,1,3) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 4); b = sollya_lib_max(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); for(i=0;i<4;i++) sollya_lib_clear_obj(a[i]); /* Tests a tricky case where the maximum is impossible to detect */ a[0] = sollya_lib_parse_string("17 + log2(13)/log2(9)"); a[1] = sollya_lib_parse_string("17 + log(13)/log(9)"); b = sollya_lib_max(a[0], a[1], NULL); sollya_lib_printf("max of 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 2); b = sollya_lib_max(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); /* Tests a tricky case when the maximum is possible to detect, but at some point of the algorithm it was impossible to detect it for sure */ a[0] = sollya_lib_parse_string("17 + log2(13)/log2(9)"); a[1] = sollya_lib_parse_string("17 + log(13)/log(9)"); a[2] = SOLLYA_CONST(100); b = sollya_lib_max(a[0], a[1], a[2], NULL); sollya_lib_printf("max of 17 + log2(13)/log2(9), 17 + log(13)/log(9), 100 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_max(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* The same but in reversed order */ a[0] = SOLLYA_CONST(100); a[1] = sollya_lib_parse_string("17 + log2(13)/log2(9)"); a[2] = sollya_lib_parse_string("17 + log(13)/log(9)"); b = sollya_lib_max(a[0], a[1], a[2], NULL); sollya_lib_printf("max of 100, 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_max(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* Tests another tricky case where the maximum is impossible to detect */ a[0] = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); a[1] = sollya_lib_parse_string("0"); b = sollya_lib_max(a[0], a[1], NULL); sollya_lib_printf("max of sin(pi/3)-sqrt(3)/2 and 0 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 2); b = sollya_lib_max(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); /* Tests another tricky case where the maximum is possible to detect, but the list contains elements that are hard to evaluate */ a[0] = SOLLYA_CONST(0); a[1] = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); a[2] = sollya_lib_parse_string("1"); b = sollya_lib_max(a[0], a[1], a[2], NULL); sollya_lib_printf("max of 0, sin(pi/3)-sqrt(3)/2 and 1 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_max(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* The same, but in reversed order */ a[0] = sollya_lib_parse_string("1"); a[1] = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); a[2] = SOLLYA_CONST(0); b = sollya_lib_max(a[0], a[1], a[2], NULL); sollya_lib_printf("max of 1 and sin(pi/3)-sqrt(3)/2 and 0 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_max(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* Tests what happens when a NaN is in the list */ a[0] = sollya_lib_constant_from_int(2); a[1] = sollya_lib_parse_string("NaN"); a[2] = sollya_lib_constant_from_int(1); b = sollya_lib_max(a[0], a[1], a[2], NULL); sollya_lib_printf("max(2,NaN,1) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_max(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); a[0] = sollya_lib_constant_from_int(2); a[1] = SOLLYA_LOG(SOLLYA_CONST(-17)); a[2] = sollya_lib_constant_from_int(1); b = sollya_lib_max(a[0], a[1], a[2], NULL); sollya_lib_printf("max(2,log(-17),1) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_max(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); a[0] = sollya_lib_parse_string("NaN"); a[1] = sollya_lib_constant_from_int(1); a[2] = sollya_lib_constant_from_int(2); b = sollya_lib_max(a[0], a[1], a[2], NULL); sollya_lib_printf("max(NaN,1,2) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_max(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); a[0] = SOLLYA_LOG(SOLLYA_CONST(-17)); a[1] = sollya_lib_constant_from_int(1); a[2] = sollya_lib_constant_from_int(2); b = sollya_lib_max(a[0], a[1], a[2], NULL); sollya_lib_printf("max(log(-17),1,2) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_max(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* Tests maximum of only one element */ a[0] = sollya_lib_constant_from_int(17); b = sollya_lib_max(a[0], NULL); sollya_lib_printf("max of 17 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 1); b = sollya_lib_max(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); /* Tests maximum of an empty list */ c = sollya_lib_list(NULL, 0); b = sollya_lib_max(c, NULL); sollya_lib_printf("max of an empty list returns %b\n\n", b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); /* Tests what happens if a list is given, followed by a constant */ a[0] = sollya_lib_constant_from_int(4); a[1] = sollya_lib_constant_from_int(1); a[2] = sollya_lib_constant_from_int(3); a[3] = sollya_lib_constant_from_int(5); c = sollya_lib_list(a, 3); b = sollya_lib_max(c, a[3], NULL); sollya_lib_printf("max(%b, 5) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); for(i=0;i<4;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tmax.reference000066400000000000000000000034571300174114700200320ustar00rootroot00000000000000max(4,5,1,3) returns 5 max([|4, 5, 1, 3|]) returns 5 The following test is not certified (probably because the max is reached by two equal values). max of 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns 17 + log2(13) / log2(9) The following test is not certified (probably because the max is reached by two equal values). max([|17 + log2(13) / log2(9), 17 + log(13) / log(9)|]) returns 17 + log2(13) / log2(9) max of 17 + log2(13)/log2(9), 17 + log(13)/log(9), 100 returns 100 max([|17 + log2(13) / log2(9), 17 + log(13) / log(9), 100|]) returns 100 max of 100, 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns 100 max([|100, 17 + log2(13) / log2(9), 17 + log(13) / log(9)|]) returns 100 The test will rely on pure FP evaluation (probably because 0 is the maximum but it is hard to prove it). max of sin(pi/3)-sqrt(3)/2 and 0 returns sin((pi) / 3) - sqrt(3) / 2 The test will rely on pure FP evaluation (probably because 0 is the maximum but it is hard to prove it). max([|sin((pi) / 3) - sqrt(3) / 2, 0|]) returns sin((pi) / 3) - sqrt(3) / 2 max of 0, sin(pi/3)-sqrt(3)/2 and 1 returns 1 max([|0, sin((pi) / 3) - sqrt(3) / 2, 1|]) returns 1 max of 1 and sin(pi/3)-sqrt(3)/2 and 0 returns 1 max([|1, sin((pi) / 3) - sqrt(3) / 2, 0|]) returns 1 max(2,NaN,1) returns 2 max([|2, NaN, 1|]) returns 2 Warning: the following test involves a NaN max(2,log(-17),1) returns 2 Warning: the following test involves a NaN max([|2, log(-17), 1|]) returns 2 max(NaN,1,2) returns 2 max([|NaN, 1, 2|]) returns 2 Warning: the following test involves a NaN max(log(-17),1,2) returns 2 Warning: the following test involves a NaN max([|log(-17), 1, 2|]) returns 2 max of 17 returns 17 max([|17|]) returns 17 The following expression is not correctly typed. max of an empty list returns error max([|4, 1, 3|], 5) returns 4 sollya-6.0+ds/tests-lib/tmid.c000066400000000000000000000050761300174114700163010ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); if (message == SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED) sollya_lib_printf("The following test produces a typing error\n"); else sollya_lib_printf("Unexpected message\n"); return 0; } int main(void) { sollya_obj_t a, res; double nan = 0.0/0.0; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a = SOLLYA_CONST(2); res = sollya_lib_mid(a); sollya_lib_printf("mid of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_CONST(3)); res = sollya_lib_mid(a); sollya_lib_printf("mid of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_LOG(SOLLYA_NEG(SOLLYA_CONST(3))); res = sollya_lib_mid(a); sollya_lib_printf("mid of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); res = sollya_lib_mid(a); sollya_lib_printf("mid of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[1,2]"); res = sollya_lib_mid(a); sollya_lib_printf("mid of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[@Inf@, @Inf@]"); res = sollya_lib_mid(a); sollya_lib_printf("mid of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[1, @Inf@]"); res = sollya_lib_mid(a); sollya_lib_printf("mid of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[-@Inf@, @Inf@]"); res = sollya_lib_mid(a); sollya_lib_printf("mid of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[-@Inf@, 1]"); res = sollya_lib_mid(a); sollya_lib_printf("mid of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[-@Inf@, -@Inf@]"); res = sollya_lib_mid(a); sollya_lib_printf("mid of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_X_; res = sollya_lib_mid(a); sollya_lib_printf("mid of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_string("Hello"); res = sollya_lib_mid(a); sollya_lib_printf("mid of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tmid.reference000066400000000000000000000006721300174114700200120ustar00rootroot00000000000000mid of 2 is 2 mid of 1 / 3 is 1 / 3 mid of log(-3) is log(-3) mid of NaN is NaN mid of [1;2] is 1.5 mid of [infty;infty] is (infty + infty) / 2 mid of [1;infty] is (1 + infty) / 2 mid of [-infty;infty] is (-infty + infty) / 2 mid of [-infty;1] is (-infty + 1) / 2 mid of [-infty;-infty] is (-infty + (-infty)) / 2 The following test produces a typing error mid of _x_ is error The following test produces a typing error mid of Hello is error sollya-6.0+ds/tests-lib/tmin.c000066400000000000000000000206401300174114700163050ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: sollya_lib_printf("The following test is not certified (probably because the min is reached by two equal values).\n"); break; case SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: sollya_lib_printf("The test will rely on pure FP evaluation (probably because 0 is the minimum but it is hard to prove it).\n"); break; case SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL: sollya_lib_printf("Warning: the following test involves a NaN\n"); break; case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The following expression is not correctly typed.\n"); break; default: sollya_lib_printf("Unexpected warning %d\n", message); } return 0; } int main(void) { sollya_obj_t a[4]; sollya_obj_t b,c; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* Tests a simple minimum */ a[0] = sollya_lib_constant_from_int(4); a[1] = sollya_lib_constant_from_int(5); a[2] = sollya_lib_constant_from_int(1); a[3] = sollya_lib_constant_from_int(3); b = sollya_lib_min(a[0], a[1], a[2], a[3], NULL); sollya_lib_printf("min(4,5,1,3) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 4); b = sollya_lib_min(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); for(i=0;i<4;i++) sollya_lib_clear_obj(a[i]); /* Tests a tricky case where the minimum is impossible to detect */ a[0] = sollya_lib_parse_string("17 + log2(13)/log2(9)"); a[1] = sollya_lib_parse_string("17 + log(13)/log(9)"); b = sollya_lib_min(a[0], a[1], NULL); sollya_lib_printf("min of 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 2); b = sollya_lib_min(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); /* Tests a tricky case when the minimum is possible to detect, but at some point of the algorithm it was impossible to detect it for sure */ a[0] = sollya_lib_parse_string("17 + log2(13)/log2(9)"); a[1] = sollya_lib_parse_string("17 + log(13)/log(9)"); a[2] = SOLLYA_CONST(1); b = sollya_lib_min(a[0], a[1], a[2], NULL); sollya_lib_printf("min of 17 + log2(13)/log2(9), 17 + log(13)/log(9), 1 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_min(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* The same but in reversed order */ a[0] = SOLLYA_CONST(1); a[1] = sollya_lib_parse_string("17 + log2(13)/log2(9)"); a[2] = sollya_lib_parse_string("17 + log(13)/log(9)"); b = sollya_lib_min(a[0], a[1], a[2], NULL); sollya_lib_printf("min of 1, 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_min(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* Tests another tricky case where the minimum is impossible to detect */ a[0] = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); a[1] = sollya_lib_parse_string("0"); b = sollya_lib_min(a[0], a[1], NULL); sollya_lib_printf("min of sin(pi/3)-sqrt(3)/2 and 0 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 2); b = sollya_lib_min(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); /* Tests another tricky case where the minimum is possible to detect, but the list contains elements that are hard to evaluate */ a[0] = SOLLYA_CONST(0); a[1] = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); a[2] = sollya_lib_parse_string("-1"); b = sollya_lib_min(a[0], a[1], a[2], NULL); sollya_lib_printf("min of 0, sin(pi/3)-sqrt(3)/2 and -1 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_min(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* The same, but in reversed order */ a[0] = sollya_lib_parse_string("-1"); a[1] = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); a[2] = SOLLYA_CONST(0); b = sollya_lib_min(a[0], a[1], a[2], NULL); sollya_lib_printf("min of -1 and sin(pi/3)-sqrt(3)/2 and 0 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_min(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* Tests what happens when a NaN is in the list */ a[0] = sollya_lib_constant_from_int(2); a[1] = sollya_lib_parse_string("NaN"); a[2] = sollya_lib_constant_from_int(1); b = sollya_lib_min(a[0], a[1], a[2], NULL); sollya_lib_printf("min(2,NaN,1) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_min(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); a[0] = sollya_lib_constant_from_int(2); a[1] = SOLLYA_LOG(SOLLYA_CONST(-17)); a[2] = sollya_lib_constant_from_int(1); b = sollya_lib_min(a[0], a[1], a[2], NULL); sollya_lib_printf("min(2,log(-17),1) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_min(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); a[0] = sollya_lib_parse_string("NaN"); a[1] = sollya_lib_constant_from_int(1); a[2] = sollya_lib_constant_from_int(2); b = sollya_lib_min(a[0], a[1], a[2], NULL); sollya_lib_printf("min(NaN,1,2) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_min(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); a[0] = SOLLYA_LOG(SOLLYA_CONST(-17)); a[1] = sollya_lib_constant_from_int(1); a[2] = sollya_lib_constant_from_int(2); b = sollya_lib_min(a[0], a[1], a[2], NULL); sollya_lib_printf("min(log(-17),1,2) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = sollya_lib_min(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* Tests minimum of only one element */ a[0] = sollya_lib_constant_from_int(17); b = sollya_lib_min(a[0], NULL); sollya_lib_printf("min of 17 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 1); b = sollya_lib_min(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); /* Tests minimum of an empty list */ c = sollya_lib_list(NULL, 0); b = sollya_lib_min(c, NULL); sollya_lib_printf("min of an empty list returns %b\n\n", b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); /* Tests what happens if a list is given, followed by a constant */ a[0] = sollya_lib_constant_from_int(4); a[1] = sollya_lib_constant_from_int(1); a[2] = sollya_lib_constant_from_int(3); a[3] = sollya_lib_constant_from_int(5); c = sollya_lib_list(a, 3); b = sollya_lib_min(c, a[3], NULL); sollya_lib_printf("min(%b, 5) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); for(i=0;i<4;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tmin.reference000066400000000000000000000033571300174114700200270ustar00rootroot00000000000000min(4,5,1,3) returns 1 min([|4, 5, 1, 3|]) returns 1 The following test is not certified (probably because the min is reached by two equal values). min of 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns 17 + log(13) / log(9) The following test is not certified (probably because the min is reached by two equal values). min([|17 + log2(13) / log2(9), 17 + log(13) / log(9)|]) returns 17 + log(13) / log(9) min of 17 + log2(13)/log2(9), 17 + log(13)/log(9), 1 returns 1 min([|17 + log2(13) / log2(9), 17 + log(13) / log(9), 1|]) returns 1 min of 1, 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns 1 min([|1, 17 + log2(13) / log2(9), 17 + log(13) / log(9)|]) returns 1 The test will rely on pure FP evaluation (probably because 0 is the minimum but it is hard to prove it). min of sin(pi/3)-sqrt(3)/2 and 0 returns 0 The test will rely on pure FP evaluation (probably because 0 is the minimum but it is hard to prove it). min([|sin((pi) / 3) - sqrt(3) / 2, 0|]) returns 0 min of 0, sin(pi/3)-sqrt(3)/2 and -1 returns -1 min([|0, sin((pi) / 3) - sqrt(3) / 2, -1|]) returns -1 min of -1 and sin(pi/3)-sqrt(3)/2 and 0 returns -1 min([|-1, sin((pi) / 3) - sqrt(3) / 2, 0|]) returns -1 min(2,NaN,1) returns 1 min([|2, NaN, 1|]) returns 1 Warning: the following test involves a NaN min(2,log(-17),1) returns 1 Warning: the following test involves a NaN min([|2, log(-17), 1|]) returns 1 min(NaN,1,2) returns 1 min([|NaN, 1, 2|]) returns 1 Warning: the following test involves a NaN min(log(-17),1,2) returns 1 Warning: the following test involves a NaN min([|log(-17), 1, 2|]) returns 1 min of 17 returns 17 min([|17|]) returns 17 The following expression is not correctly typed. min of an empty list returns error min([|4, 1, 3|], 5) returns 1 sollya-6.0+ds/tests-lib/tmsg_callback_functions.c000066400000000000000000000231351300174114700222160ustar00rootroot00000000000000#include int hide_everything(sollya_msg_t msg, void *data) { if (data != NULL) printf("Callback hide_everything receives a non-NULL data set.\n"); (void)msg; return 0; } int keep_comparison_warnings(sollya_msg_t msg, void *data) { (void)data; switch(sollya_lib_get_msg_id(msg)) { case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT: case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: case SOLLYA_MSG_TEST_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL: return 1; default: return 0; } } int flag_double_rounding = 0; int set_flag_on_problem(sollya_msg_t msg, void *data) { (void)data; char *s; switch(sollya_lib_get_msg_id(msg)) { case SOLLYA_MSG_ROUNDING_OCCURRED_WHILE_READING_A_CONSTANT: flag_double_rounding = 1; s = sollya_lib_msg_to_text(msg); printf("Generic message: %s\n", s); sollya_lib_free(s); printf("Specific message:\n"); } return 1; } #define SIZE 10 struct callback_data_struct { int counter; char *tab[SIZE]; }; typedef struct callback_data_struct callback_data; int remember_history(sollya_msg_t msg, void *data) { callback_data *data_ptr = (callback_data *)(data); if (data==NULL) { printf("rember_history callback is called with NULL as data argument.\n"); return 0; } if (data_ptr->counter < SIZE) { data_ptr->tab[data_ptr->counter] = sollya_lib_msg_to_text(msg); data_ptr->counter++; } return 0; } int main(void) { sollya_obj_t a, b, c; int (*old_callback)(sollya_msg_t, void *); void *old_data; callback_data calls; int i; calls.counter = 0; sollya_lib_init(); /* Display a warning */ a = SOLLYA_PI; b = sollya_lib_default(); c = sollya_lib_add(a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); /* Callback that stops all messages. Tests the effect of the value returned by the callback when it is called */ printf("\n"); if (!sollya_lib_install_msg_callback(hide_everything, NULL)) printf("An error happened when installing the message callback\n"); printf("Nothing should be displayed between now and "); a = SOLLYA_PI; b = sollya_lib_default(); c = sollya_lib_add(a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); printf("now.\n"); /* Callback that stops some messages but not all. Tests that the variable msg is correctly passed to the callback */ printf("\n"); if (!sollya_lib_install_msg_callback(keep_comparison_warnings, NULL)) printf("An error happened when installing the message callback\n"); printf("Nothing should be displayed between now and "); a = SOLLYA_PI; b = sollya_lib_default(); c = sollya_lib_add(a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); printf("now.\n"); a = SOLLYA_DIV(SOLLYA_LOG(SOLLYA_CONST(17)), SOLLYA_LOG(SOLLYA_CONST(2))); b = SOLLYA_LOG2(SOLLYA_CONST(17)); c = sollya_lib_cmp_less(a, b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); /* Check that uninstalling a callback works and that callbacks do not stack */ /* A warning should be displayed */ printf("\n"); if (!sollya_lib_uninstall_msg_callback()) printf("An error happened when removing the message callback\n"); a = SOLLYA_PI; b = sollya_lib_default(); c = sollya_lib_add(a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); /* Callback with side effect */ printf("\n"); if (!sollya_lib_install_msg_callback(set_flag_on_problem, NULL)) printf("An error happened when installing the message callback\n"); printf("Value of the flag: %d\n", flag_double_rounding); a = SOLLYA_PI; b = sollya_lib_default(); c = sollya_lib_add(a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); printf("Value of the flag: %d\n", flag_double_rounding); a = sollya_lib_parse_string("0.1"); sollya_lib_clear_obj(a); printf("Value of the flag: %d\n", flag_double_rounding); a = SOLLYA_PI; b = sollya_lib_default(); c = sollya_lib_add(a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); printf("Value of the flag: %d\n", flag_double_rounding); /* Testing get_msg_callback, when no callback is installed */ sollya_lib_uninstall_msg_callback(); sollya_lib_get_msg_callback(&old_callback, &old_data); if ( (old_callback != NULL) || (old_data != NULL) ) printf("sollya_lib_get_msg_callback returned a non-NULL couple of pointers (%p, %p) while no callback is installed.\n", old_callback, old_data); /* Testing get_msg_callback, when a callback actually is installed */ printf("\n"); if (!sollya_lib_install_msg_callback(keep_comparison_warnings, NULL)) printf("An error happened when installing the message callback\n"); printf("Nothing should be displayed between now and "); a = SOLLYA_PI; b = sollya_lib_default(); c = sollya_lib_add(a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); printf("now.\n"); a = SOLLYA_DIV(SOLLYA_LOG(SOLLYA_CONST(17)), SOLLYA_LOG(SOLLYA_CONST(2))); b = SOLLYA_LOG2(SOLLYA_CONST(17)); c = sollya_lib_cmp_less(a, b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_get_msg_callback(&old_callback, NULL); if (!sollya_lib_install_msg_callback(hide_everything, NULL)) printf("An error happened when installing the message callback\n"); printf("Nothing should be displayed between now and "); a = SOLLYA_DIV(SOLLYA_LOG(SOLLYA_CONST(17)), SOLLYA_LOG(SOLLYA_CONST(2))); b = SOLLYA_LOG2(SOLLYA_CONST(17)); c = sollya_lib_cmp_less(a, b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); printf("now.\n"); if (old_callback != keep_comparison_warnings) printf("sollya_lib_get_msg_callback returned a pointer different from the intended callback.\n"); if (old_callback) { if (!sollya_lib_install_msg_callback(old_callback, NULL)) printf("An error happened when installing the message callback\n"); } printf("Nothing should be displayed between now and "); a = SOLLYA_PI; b = sollya_lib_default(); c = sollya_lib_add(a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); printf("now.\n"); a = SOLLYA_DIV(SOLLYA_LOG(SOLLYA_CONST(17)), SOLLYA_LOG(SOLLYA_CONST(2))); b = SOLLYA_LOG2(SOLLYA_CONST(17)); c = sollya_lib_cmp_less(a, b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); /* Testing the mechanism of data passed to callbacks */ printf("\n"); if (!sollya_lib_install_msg_callback(remember_history, &calls)) printf("An error happened when installing the message callback\n"); printf("Nothing should be displayed between now and "); a = SOLLYA_PI; b = sollya_lib_default(); c = sollya_lib_add(a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); a = SOLLYA_DIV(SOLLYA_LOG(SOLLYA_CONST(17)), SOLLYA_LOG(SOLLYA_CONST(2))); b = SOLLYA_LOG2(SOLLYA_CONST(17)); c = sollya_lib_cmp_less(a, b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); printf("now.\n"); printf("Recorded messages:\n"); for(i=0;i= SIZE) printf(" [Other messages discarded]\n"); /* Testing get_msg_callback when a callback using data is installed */ printf("\n"); sollya_lib_get_msg_callback(&old_callback, &old_data); if (old_callback != remember_history) printf("sollya_lib_get_msg_callback returned a pointer different from the intended callback.\n"); if (old_data != &calls) printf("sollya_lib_get_msg_callback returned a data pointer different from the intended data object.\n"); if (!sollya_lib_install_msg_callback(hide_everything, NULL)) printf("An error happened when installing the message callback\n"); printf("Nothing should be displayed between now and "); a = SOLLYA_DIV(SOLLYA_LOG(SOLLYA_CONST(17)), SOLLYA_LOG(SOLLYA_CONST(2))); b = SOLLYA_LOG2(SOLLYA_CONST(17)); c = sollya_lib_cmp_less(a, b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); printf("now.\n"); printf("Recorded messages:\n"); for(i=0;i= SIZE) printf(" [Other messages discarded]\n"); if (old_callback) { if (!sollya_lib_install_msg_callback(old_callback, old_data)) printf("An error happened when installing the message callback\n"); } printf("Nothing should be displayed between now and "); a = SOLLYA_PI; b = sollya_lib_default(); c = sollya_lib_add(a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); printf("now.\n"); printf("Recorded messages:\n"); for(i=0;i= SIZE) printf(" [Other messages discarded]\n"); old_data = NULL; sollya_lib_get_msg_callback(NULL, &old_data); if (old_data != &calls) printf("sollya_lib_get_msg_callback returned a data pointer different from the intended data object.\n"); if (!sollya_lib_install_msg_callback(old_callback, NULL)) printf("An error happened when installing the message callback\n"); printf("Expecting a warning about NULL passed as data argument to the callback:\n"); a = SOLLYA_PI; b = sollya_lib_default(); c = sollya_lib_add(a,b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); printf("Recorded messages:\n"); for(i=0;i= SIZE) printf(" [Other messages discarded]\n"); for(i=0;i int main(void) { sollya_obj_t f1, f2, f; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_constant_from_double(2.0); f = sollya_lib_mul(f1, f2); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tmul.reference000066400000000000000000000000071300174114700200260ustar00rootroot00000000000000_x_ * 2sollya-6.0+ds/tests-lib/tname_free_variable.c000066400000000000000000000004511300174114700213060ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = SOLLYA_ADD(SOLLYA_COS(SOLLYA_X_), SOLLYA_X_); sollya_lib_printf("%b\n", f); sollya_lib_name_free_variable("foo"); sollya_lib_printf("%b\n", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tname_free_variable.reference000066400000000000000000000000361300174114700230210ustar00rootroot00000000000000cos(_x_) + _x_ cos(foo) + foo sollya-6.0+ds/tests-lib/tnearestint.c000066400000000000000000000004231300174114700176730ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_nearestint(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tnearestint.reference000066400000000000000000000000171300174114700214060ustar00rootroot00000000000000nearestint(_x_)sollya-6.0+ds/tests-lib/tneg.c000066400000000000000000000004141300174114700162700ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_neg(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tneg.reference000066400000000000000000000000041300174114700177770ustar00rootroot00000000000000-_x_sollya-6.0+ds/tests-lib/tnegate.c000066400000000000000000000022371300174114700167670ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); if (message == SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED) sollya_lib_printf("The following test produces a typing error\n"); else sollya_lib_printf("Unexpected message\n"); return 0; } int main(void) { sollya_obj_t true, false, a, res; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); true = sollya_lib_true(); false = sollya_lib_false(); a = sollya_lib_copy_obj(true); res = sollya_lib_negate(a); sollya_lib_printf("the negation of %b gives %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_copy_obj(false); res = sollya_lib_negate(a); sollya_lib_printf("the negation of %b gives %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_CONST(17); res = sollya_lib_negate(a); sollya_lib_printf("the negation of %b gives %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); sollya_lib_clear_obj(true); sollya_lib_clear_obj(false); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tnegate.reference000066400000000000000000000002141300174114700204740ustar00rootroot00000000000000the negation of true gives false the negation of false gives true The following test produces a typing error the negation of 17 gives error sollya-6.0+ds/tests-lib/tnumberroots.c000066400000000000000000000064361300174114700201100ustar00rootroot00000000000000#include #define NB_OF_TESTS 12 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_STURM_COEFF_NOT_CONSTANT_NOR_RATIONAL_ROUNDING: sollya_lib_printf("Caught the message that a certain polynomial coefficient is neither a constant nor a rational expression and that it got rounded.\n"); break; case SOLLYA_MSG_STURM_USING_SLOWER_ALGORITHM_ON_RATIONALS: sollya_lib_printf("Caught the message that a slower version of the Sturm algorithm, using rational arithmetic is used.\n"); break; case SOLLYA_MSG_GIVEN_FUNCTION_IS_NO_POLYNOMIAL: sollya_lib_printf("Caught the message that a given function is no polynomial.\n"); break; case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("Caught the message that a given expression is not correctly typed.\n"); break; case SOLLYA_MSG_STURM_INTERVAL_A_CERTAIN_PREC_HAS_BEEN_CHOSEN: sollya_lib_printf("Caught the message that a certain working precision has been chosen.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[NB_OF_TESTS], b[NB_OF_TESTS], c[NB_OF_TESTS]; sollya_obj_t temp; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = SOLLYA_X_; b[0] = sollya_lib_parse_string("[-1;1]"); a[1] = SOLLYA_X_; b[1] = sollya_lib_parse_string("[-1/1024;1]"); a[2] = SOLLYA_X_; b[2] = sollya_lib_parse_string("[0;1]"); a[3] = SOLLYA_X_; b[3] = sollya_lib_parse_string("[1/1024;1]"); a[4] = sollya_lib_parse_string("x^2 - 1/1024"); b[4] = sollya_lib_parse_string("[-1;1]"); a[5] = sollya_lib_parse_string("x^2 + 1/1024"); b[5] = sollya_lib_parse_string("[-1;1]"); a[6] = sollya_lib_parse_string("x^2"); b[6] = sollya_lib_parse_string("[-1;1]"); a[7] = sollya_lib_parse_string("x^2 - 1b-2000"); b[7] = sollya_lib_parse_string("[-1;1]"); a[8] = sollya_lib_parse_string("exp(1) * x^2 - 2.5"); b[8] = sollya_lib_parse_string("[-1;1]"); a[9] = sollya_lib_parse_string("106/39 * x^2 - 2.5"); b[9] = sollya_lib_parse_string("[-1;1]"); a[10] = sollya_lib_parse_string("498433858766847607572119674832101659036346057980888594722531428147165925512023745865901769 / 4046269353306249636975402911371420403218250121568610417645180644958487760262349813894609b6 + x * (-524133224017035031109281522782898592169355668835836355206157 / 28642971806507469479740749646041579549850744218111183188997b2 + x * 551157654494325100219720823521 / 202759569932735203392750534601)"); b[10] = sollya_lib_parse_string("[-2;2]"); a[11] = sollya_lib_parse_string("exp(x)"); b[11] = sollya_lib_parse_string("[-1;1]"); temp = SOLLYA_CONST_SI64(2); sollya_lib_set_verbosity(temp); sollya_lib_clear_obj(temp); for (i=0;i int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch (message) { case SOLLYA_MSG_EXPR_IS_NO_FRACTION: sollya_lib_printf("The following object is not a fraction.\n"); break; default: sollya_lib_printf("Unexpected message caught.\n"); } return 0; } int main(void) { sollya_obj_t a[4], b[4]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = SOLLYA_DIV(SOLLYA_CONST(17.0),SOLLYA_CONST(1001.0)); a[1] = SOLLYA_DIV(SOLLYA_ADD(SOLLYA_X_,SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0))), SOLLYA_ADD(SOLLYA_ADD(SOLLYA_X_,SOLLYA_MUL(SOLLYA_CONST(2.0),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)))),SOLLYA_CONST(1.0))); a[2] = sollya_lib_parse_string("((x + 1)/(x + 2)) * ((x + 3)/(x + 4))"); a[3] = SOLLYA_EXP(SOLLYA_DIV(SOLLYA_X_, SOLLYA_CONST(4))); for (i=0;i<4;i++) { b[i] = sollya_lib_numerator(a[i]); sollya_lib_printf("The numerator of %b is %b.\n",a[i],b[i]); } for (i=0;i<4;i++) { sollya_lib_clear_obj(a[i]); sollya_lib_clear_obj(b[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tnumerator.reference000066400000000000000000000004711300174114700212520ustar00rootroot00000000000000The numerator of 17 / 1001 is 17. The numerator of (x + x^2) / (x + 2 * x^2 + 1) is x + x^2. The following object is not a fraction. The numerator of (x + 1) / (x + 2) * (x + 3) / (x + 4) is (x + 1) / (x + 2) * (x + 3) / (x + 4). The following object is not a fraction. The numerator of exp(x / 4) is exp(x / 4). sollya-6.0+ds/tests-lib/tobj_is_end_elliptic_list.c000066400000000000000000000167701300174114700225460ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("end_elliptic_list"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_obj_is_end_elliptic_list(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects the string \"end_elliptic_list\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_obj_is_end_elliptic_list detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tobj_is_end_elliptic_list.reference000066400000000000000000000002071300174114700242460ustar00rootroot00000000000000sollya_lib_obj_is_end_elliptic_list detects the empty list. sollya_lib_obj_is_end_elliptic_list detects a non empty end-elliptic list. sollya-6.0+ds/tests-lib/tobj_is_error.c000066400000000000000000000155301300174114700202020ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("error"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_obj_is_error(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_obj_is_error detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_obj_is_error detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_obj_is_error detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_obj_is_error detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_obj_is_error detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_obj_is_error detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_obj_is_error detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_obj_is_error detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_obj_is_error detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_obj_is_error detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_obj_is_error detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_obj_is_error detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_obj_is_error detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_obj_is_error detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_obj_is_error detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_obj_is_error detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_obj_is_error detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_obj_is_error detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_obj_is_error detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_obj_is_error detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_obj_is_error detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_obj_is_error detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_obj_is_error detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_obj_is_error detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_obj_is_error detects the string \"error\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_obj_is_error detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_obj_is_error detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_obj_is_error detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_obj_is_error detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_obj_is_error detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_obj_is_error detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_obj_is_error detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_obj_is_error detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_obj_is_error detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_obj_is_error detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_obj_is_error detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_obj_is_error detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_obj_is_error detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_obj_is_error detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_obj_is_error detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_obj_is_error detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_obj_is_error detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_obj_is_error detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_obj_is_error detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_obj_is_error detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_obj_is_error detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_obj_is_error detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_obj_is_error detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_obj_is_error detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_obj_is_error detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_obj_is_error detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_obj_is_error detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_obj_is_error detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tobj_is_error.reference000066400000000000000000000001421300174114700217070ustar00rootroot00000000000000sollya_lib_obj_is_error detects error sollya_lib_obj_is_error detects an empty end-elliptic list. sollya-6.0+ds/tests-lib/tobj_is_externalprocedure.c000066400000000000000000000167401300174114700226100ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("range"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_obj_is_externalprocedure(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects the string \"range\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_obj_is_externalprocedure detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tobj_is_externalprocedure.reference000066400000000000000000000001241300174114700243110ustar00rootroot00000000000000sollya_lib_obj_is_externalprocedure detects external procedure based on empty_func. sollya-6.0+ds/tests-lib/tobj_is_function.c000066400000000000000000000160001300174114700206670ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("function"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_obj_is_function(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_obj_is_function detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_obj_is_function detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_obj_is_function detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_obj_is_function detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_obj_is_function detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_obj_is_function detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_obj_is_function detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_obj_is_function detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_obj_is_function detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_obj_is_function detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_obj_is_function detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_obj_is_function detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_obj_is_function detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_obj_is_function detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_obj_is_function detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_obj_is_function detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_obj_is_function detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_obj_is_function detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_obj_is_function detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_obj_is_function detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_obj_is_function detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_obj_is_function detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_obj_is_function detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_obj_is_function detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_obj_is_function detects the string \"function\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_obj_is_function detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_obj_is_function detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_obj_is_function detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_obj_is_function detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_obj_is_function detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_obj_is_function detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_obj_is_function detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_obj_is_function detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_obj_is_function detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_obj_is_function detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_obj_is_function detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_obj_is_function detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_obj_is_function detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_obj_is_function detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_obj_is_function detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_obj_is_function detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_obj_is_function detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_obj_is_function detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_obj_is_function detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_obj_is_function detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_obj_is_function detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_obj_is_function detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_obj_is_function detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_obj_is_function detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_obj_is_function detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_obj_is_function detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_obj_is_function detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_obj_is_function detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tobj_is_function.reference000066400000000000000000000007611300174114700224120ustar00rootroot00000000000000sollya_lib_obj_is_function detects pi sollya_lib_obj_is_function detects a constant sollya_lib_obj_is_function detects free_variable sollya_lib_obj_is_function detects D(_x_). sollya_lib_obj_is_function detects S(_x_). sollya_lib_obj_is_function detects QD(_x_). sollya_lib_obj_is_function detects HP(_x_). sollya_lib_obj_is_function detects DE(_x_). sollya_lib_obj_is_function detects DD(_x_). sollya_lib_obj_is_function detects TD(_x_). sollya_lib_obj_is_function detects a constant expression. sollya-6.0+ds/tests-lib/tobj_is_list.c000066400000000000000000000154401300174114700200240ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("list"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_obj_is_list(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_obj_is_list detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_obj_is_list detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_obj_is_list detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_obj_is_list detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_obj_is_list detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_obj_is_list detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_obj_is_list detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_obj_is_list detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_obj_is_list detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_obj_is_list detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_obj_is_list detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_obj_is_list detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_obj_is_list detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_obj_is_list detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_obj_is_list detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_obj_is_list detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_obj_is_list detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_obj_is_list detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_obj_is_list detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_obj_is_list detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_obj_is_list detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_obj_is_list detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_obj_is_list detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_obj_is_list detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_obj_is_list detects the string \"list\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_obj_is_list detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_obj_is_list detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_obj_is_list detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_obj_is_list detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_obj_is_list detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_obj_is_list detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_obj_is_list detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_obj_is_list detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_obj_is_list detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_obj_is_list detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_obj_is_list detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_obj_is_list detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_obj_is_list detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_obj_is_list detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_obj_is_list detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_obj_is_list detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_obj_is_list detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_obj_is_list detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_obj_is_list detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_obj_is_list detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_obj_is_list detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_obj_is_list detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_obj_is_list detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_obj_is_list detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_obj_is_list detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_obj_is_list detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_obj_is_list detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_obj_is_list detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tobj_is_list.reference000066400000000000000000000001401300174114700215270ustar00rootroot00000000000000sollya_lib_obj_is_list detects the empty list. sollya_lib_obj_is_list detects a non empty list. sollya-6.0+ds/tests-lib/tobj_is_procedure.c000066400000000000000000000160601300174114700210400ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("range"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_obj_is_procedure(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_obj_is_procedure detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_obj_is_procedure detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_obj_is_procedure detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_obj_is_procedure detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_obj_is_procedure detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_obj_is_procedure detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_obj_is_procedure detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_obj_is_procedure detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_obj_is_procedure detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_obj_is_procedure detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_obj_is_procedure detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_obj_is_procedure detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_obj_is_procedure detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_obj_is_procedure detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_obj_is_procedure detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_obj_is_procedure detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_obj_is_procedure detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_obj_is_procedure detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_obj_is_procedure detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_obj_is_procedure detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_obj_is_procedure detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_obj_is_procedure detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_obj_is_procedure detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_obj_is_procedure detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_obj_is_procedure detects the string \"range\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_obj_is_procedure detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_obj_is_procedure detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_obj_is_procedure detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_obj_is_procedure detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_obj_is_procedure detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_obj_is_procedure detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_obj_is_procedure detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_obj_is_procedure detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_obj_is_procedure detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_obj_is_procedure detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_obj_is_procedure detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_obj_is_procedure detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_obj_is_procedure detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_obj_is_procedure detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_obj_is_procedure detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_obj_is_procedure detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_obj_is_procedure detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_obj_is_procedure detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_obj_is_procedure detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_obj_is_procedure detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_obj_is_procedure detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_obj_is_procedure detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_obj_is_procedure detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_obj_is_procedure detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_obj_is_procedure detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_obj_is_procedure detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_obj_is_procedure detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_obj_is_procedure detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tobj_is_procedure.reference000066400000000000000000000001071300174114700225470ustar00rootroot00000000000000sollya_lib_obj_is_procedure detects procedure proc(a) { return a+1; }. sollya-6.0+ds/tests-lib/tobj_is_range.c000066400000000000000000000155301300174114700201450ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("range"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_obj_is_range(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_obj_is_range detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_obj_is_range detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_obj_is_range detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_obj_is_range detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_obj_is_range detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_obj_is_range detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_obj_is_range detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_obj_is_range detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_obj_is_range detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_obj_is_range detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_obj_is_range detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_obj_is_range detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_obj_is_range detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_obj_is_range detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_obj_is_range detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_obj_is_range detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_obj_is_range detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_obj_is_range detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_obj_is_range detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_obj_is_range detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_obj_is_range detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_obj_is_range detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_obj_is_range detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_obj_is_range detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_obj_is_range detects the string \"range\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_obj_is_range detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_obj_is_range detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_obj_is_range detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_obj_is_range detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_obj_is_range detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_obj_is_range detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_obj_is_range detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_obj_is_range detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_obj_is_range detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_obj_is_range detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_obj_is_range detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_obj_is_range detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_obj_is_range detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_obj_is_range detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_obj_is_range detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_obj_is_range detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_obj_is_range detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_obj_is_range detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_obj_is_range detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_obj_is_range detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_obj_is_range detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_obj_is_range detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_obj_is_range detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_obj_is_range detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_obj_is_range detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_obj_is_range detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_obj_is_range detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_obj_is_range detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tobj_is_range.reference000066400000000000000000000000511300174114700216510ustar00rootroot00000000000000sollya_lib_obj_is_range detects a range. sollya-6.0+ds/tests-lib/tobj_is_string.c000066400000000000000000000156201300174114700203570ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("string"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_obj_is_string(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_obj_is_string detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_obj_is_string detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_obj_is_string detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_obj_is_string detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_obj_is_string detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_obj_is_string detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_obj_is_string detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_obj_is_string detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_obj_is_string detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_obj_is_string detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_obj_is_string detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_obj_is_string detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_obj_is_string detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_obj_is_string detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_obj_is_string detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_obj_is_string detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_obj_is_string detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_obj_is_string detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_obj_is_string detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_obj_is_string detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_obj_is_string detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_obj_is_string detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_obj_is_string detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_obj_is_string detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_obj_is_string detects the string \"string\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_obj_is_string detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_obj_is_string detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_obj_is_string detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_obj_is_string detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_obj_is_string detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_obj_is_string detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_obj_is_string detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_obj_is_string detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_obj_is_string detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_obj_is_string detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_obj_is_string detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_obj_is_string detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_obj_is_string detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_obj_is_string detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_obj_is_string detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_obj_is_string detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_obj_is_string detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_obj_is_string detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_obj_is_string detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_obj_is_string detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_obj_is_string detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_obj_is_string detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_obj_is_string detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_obj_is_string detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_obj_is_string detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_obj_is_string detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_obj_is_string detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_obj_is_string detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tobj_is_string.reference000066400000000000000000000001501300174114700220630ustar00rootroot00000000000000sollya_lib_obj_is_string detects the string "string" sollya_lib_obj_is_string detects the empty string. sollya-6.0+ds/tests-lib/tobj_is_structure.c000066400000000000000000000160721300174114700211130ustar00rootroot00000000000000#include int empty_func(void **args) { (void)(args); /* Compiler happiness */ sollya_lib_printf("External procedure only doing a side effect\n"); return 1; } int main(void) { sollya_obj_t a[53]; int t[53]; int i; sollya_lib_init(); a[0] = sollya_lib_absolute(); a[1] = sollya_lib_binary(); a[2] = sollya_lib_decimal(); a[3] = sollya_lib_default(); a[4] = sollya_lib_dyadic(); a[5] = sollya_lib_error(); a[6] = sollya_lib_false(); a[7] = sollya_lib_file(); a[8] = sollya_lib_fixed(); a[9] = sollya_lib_floating(); a[10] = sollya_lib_hexadecimal(); a[11] = sollya_lib_honorcoeffprec(); a[12] = sollya_lib_off(); a[13] = sollya_lib_on(); a[14] = sollya_lib_perturb(); a[15] = sollya_lib_pi(); a[16] = sollya_lib_postscript(); a[17] = sollya_lib_postscriptfile(); a[18] = sollya_lib_powers(); a[19] = sollya_lib_relative(); a[20] = sollya_lib_true(); a[21] = sollya_lib_void(); a[22] = sollya_lib_constant_from_double(1.0); a[23] = sollya_lib_free_variable(); a[24] = sollya_lib_string("single_obj"); a[25] = sollya_lib_string(""); a[26] = sollya_lib_list(NULL, 0); a[27] = sollya_lib_list(a, 2); a[28] = sollya_lib_end_elliptic_list(a, 2); a[29] = sollya_lib_parse_string("[1, 2]"); a[30] = sollya_lib_round_down(); a[31] = sollya_lib_round_up(); a[32] = sollya_lib_round_towards_zero(); a[33] = sollya_lib_round_to_nearest(); a[34] = sollya_lib_double_obj(); a[35] = sollya_lib_build_function_double(sollya_lib_free_variable()); a[36] = sollya_lib_single_obj(); a[37] = sollya_lib_build_function_single(sollya_lib_free_variable()); a[38] = sollya_lib_quad_obj(); a[39] = sollya_lib_build_function_quad(sollya_lib_free_variable()); a[40] = sollya_lib_halfprecision_obj(); a[41] = sollya_lib_build_function_halfprecision(sollya_lib_free_variable()); a[42] = sollya_lib_doubleextended_obj(); a[43] = sollya_lib_build_function_doubleextended(sollya_lib_free_variable()); a[44] = sollya_lib_double_double_obj(); a[45] = sollya_lib_build_function_double_double(sollya_lib_free_variable()); a[46] = sollya_lib_triple_double_obj(); a[47] = sollya_lib_build_function_triple_double(sollya_lib_free_variable()); a[48] = sollya_lib_build_function_cos(sollya_lib_constant_from_int(5)); a[49] = sollya_lib_end_elliptic_list(NULL, 0); a[50] = sollya_lib_parse_string("{.a = 5; .b = exp(_x_)}"); a[51] = sollya_lib_parse_string("proc (a) { return a+1; }"); a[52] = sollya_lib_externalprocedure(SOLLYA_EXTERNALPROC_TYPE_VOID, NULL, 0, NULL, empty_func); for(i=0;i<53;i++) t[i] = sollya_lib_obj_is_structure(a[i]); if (t[0]) sollya_lib_printf("sollya_lib_obj_is_structure detects absolute\n"); if (t[1]) sollya_lib_printf("sollya_lib_obj_is_structure detects binary\n"); if (t[2]) sollya_lib_printf("sollya_lib_obj_is_structure detects decimal\n"); if (t[3]) sollya_lib_printf("sollya_lib_obj_is_structure detects default\n"); if (t[4]) sollya_lib_printf("sollya_lib_obj_is_structure detects dyadic\n"); if (t[5]) sollya_lib_printf("sollya_lib_obj_is_structure detects error\n"); if (t[6]) sollya_lib_printf("sollya_lib_obj_is_structure detects false\n"); if (t[7]) sollya_lib_printf("sollya_lib_obj_is_structure detects file\n"); if (t[8]) sollya_lib_printf("sollya_lib_obj_is_structure detects fixed\n"); if (t[9]) sollya_lib_printf("sollya_lib_obj_is_structure detects floating\n"); if (t[10]) sollya_lib_printf("sollya_lib_obj_is_structure detects hexadecimal\n"); if (t[11]) sollya_lib_printf("sollya_lib_obj_is_structure detects honorcoeffprec\n"); if (t[12]) sollya_lib_printf("sollya_lib_obj_is_structure detects off\n"); if (t[13]) sollya_lib_printf("sollya_lib_obj_is_structure detects on\n"); if (t[14]) sollya_lib_printf("sollya_lib_obj_is_structure detects perturb\n"); if (t[15]) sollya_lib_printf("sollya_lib_obj_is_structure detects pi\n"); if (t[16]) sollya_lib_printf("sollya_lib_obj_is_structure detects postscript\n"); if (t[17]) sollya_lib_printf("sollya_lib_obj_is_structure detects postscriptfile\n"); if (t[18]) sollya_lib_printf("sollya_lib_obj_is_structure detects powers\n"); if (t[19]) sollya_lib_printf("sollya_lib_obj_is_structure detects relative\n"); if (t[20]) sollya_lib_printf("sollya_lib_obj_is_structure detects true\n"); if (t[21]) sollya_lib_printf("sollya_lib_obj_is_structure detects void\n"); if (t[22]) sollya_lib_printf("sollya_lib_obj_is_structure detects a constant\n"); if (t[23]) sollya_lib_printf("sollya_lib_obj_is_structure detects free_variable\n"); if (t[24]) sollya_lib_printf("sollya_lib_obj_is_structure detects the string \"single_obj\"\n"); if (t[25]) sollya_lib_printf("sollya_lib_obj_is_structure detects the empty string.\n"); if (t[26]) sollya_lib_printf("sollya_lib_obj_is_structure detects the empty list.\n"); if (t[27]) sollya_lib_printf("sollya_lib_obj_is_structure detects a non empty list.\n"); if (t[28]) sollya_lib_printf("sollya_lib_obj_is_structure detects a non empty end-elliptic list.\n"); if (t[29]) sollya_lib_printf("sollya_lib_obj_is_structure detects a range.\n"); if (t[30]) sollya_lib_printf("sollya_lib_obj_is_structure detects RD.\n"); if (t[31]) sollya_lib_printf("sollya_lib_obj_is_structure detects RU.\n"); if (t[32]) sollya_lib_printf("sollya_lib_obj_is_structure detects RZ.\n"); if (t[33]) sollya_lib_printf("sollya_lib_obj_is_structure detects RN.\n"); if (t[34]) sollya_lib_printf("sollya_lib_obj_is_structure detects D as symbol.\n"); if (t[35]) sollya_lib_printf("sollya_lib_obj_is_structure detects D(_x_).\n"); if (t[36]) sollya_lib_printf("sollya_lib_obj_is_structure detects S as symbol.\n"); if (t[37]) sollya_lib_printf("sollya_lib_obj_is_structure detects S(_x_).\n"); if (t[38]) sollya_lib_printf("sollya_lib_obj_is_structure detects QD as symbol.\n"); if (t[39]) sollya_lib_printf("sollya_lib_obj_is_structure detects QD(_x_).\n"); if (t[40]) sollya_lib_printf("sollya_lib_obj_is_structure detects HP as symbol.\n"); if (t[41]) sollya_lib_printf("sollya_lib_obj_is_structure detects HP(_x_).\n"); if (t[42]) sollya_lib_printf("sollya_lib_obj_is_structure detects DE as symbol.\n"); if (t[43]) sollya_lib_printf("sollya_lib_obj_is_structure detects DE(_x_).\n"); if (t[44]) sollya_lib_printf("sollya_lib_obj_is_structure detects DD as symbol.\n"); if (t[45]) sollya_lib_printf("sollya_lib_obj_is_structure detects DD(_x_).\n"); if (t[46]) sollya_lib_printf("sollya_lib_obj_is_structure detects TD as symbol.\n"); if (t[47]) sollya_lib_printf("sollya_lib_obj_is_structure detects TD(_x_).\n"); if (t[48]) sollya_lib_printf("sollya_lib_obj_is_structure detects a constant expression.\n"); if (t[49]) sollya_lib_printf("sollya_lib_obj_is_structure detects an empty end-elliptic list.\n"); if (t[50]) sollya_lib_printf("sollya_lib_obj_is_structure detects structure { .a = 5; .b = exp(_x_)}.\n"); if (t[51]) sollya_lib_printf("sollya_lib_obj_is_structure detects procedure proc(a) { return a+1; }.\n"); if (t[52]) sollya_lib_printf("sollya_lib_obj_is_structure detects external procedure based on empty_func.\n"); for(i=0;i<53;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tobj_is_structure.reference000066400000000000000000000001101300174114700226110ustar00rootroot00000000000000sollya_lib_obj_is_structure detects structure { .a = 5; .b = exp(_x_)}. sollya-6.0+ds/tests-lib/tobject_list_ops.c000066400000000000000000000027551300174114700207130ustar00rootroot00000000000000#include int main(void) { sollya_obj_list_t list1, iter, list2; sollya_obj_t a, b, c, d, e; int i; sollya_lib_init(); a = SOLLYA_EXP(SOLLYA_ASIN(SOLLYA_X_)); b = sollya_lib_parse_string("\"Hello\""); c = sollya_lib_on(); d = sollya_lib_parse_string("[| 1, ..., 17... |]"); e = sollya_lib_parse_string("1 + x"); list1 = sollya_lib_construct_object_list(a, sollya_lib_construct_object_list(b, sollya_lib_construct_object_list(c, sollya_lib_construct_object_list(d, NULL)))); for (iter = list1, i = 0; !sollya_lib_is_empty_object_list(iter); iter = sollya_lib_get_object_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list1 before copy and modification of the copy: %b\n", i, sollya_lib_get_object_list_head(iter)); } list2 = sollya_lib_copy_object_list(list1); list2 = sollya_lib_construct_object_list(e, list2); for (iter = list1, i = 0; !sollya_lib_is_empty_object_list(iter); iter = sollya_lib_get_object_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list1 after copy and modification of the copy: %b\n", i, sollya_lib_get_object_list_head(iter)); } for (iter = list2, i = 0; !sollya_lib_is_empty_object_list(iter); iter = sollya_lib_get_object_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list2 after copy and modification of the copy: %b\n", i, sollya_lib_get_object_list_head(iter)); } sollya_lib_clear_object_list(list1); sollya_lib_clear_object_list(list2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tobject_list_ops.reference000066400000000000000000000021021300174114700224110ustar00rootroot000000000000000-th element in list1 before copy and modification of the copy: exp(asin(x)) 1-th element in list1 before copy and modification of the copy: Hello 2-th element in list1 before copy and modification of the copy: on 3-th element in list1 before copy and modification of the copy: [|1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17...|] 0-th element in list1 after copy and modification of the copy: exp(asin(x)) 1-th element in list1 after copy and modification of the copy: Hello 2-th element in list1 after copy and modification of the copy: on 3-th element in list1 after copy and modification of the copy: [|1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17...|] 0-th element in list2 after copy and modification of the copy: 1 + x 1-th element in list2 after copy and modification of the copy: exp(asin(x)) 2-th element in list2 after copy and modification of the copy: Hello 3-th element in list2 after copy and modification of the copy: on 4-th element in list2 after copy and modification of the copy: [|1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17...|] sollya-6.0+ds/tests-lib/toff.c000066400000000000000000000003031300174114700162660ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_off(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/toff.reference000066400000000000000000000000031300174114700177770ustar00rootroot00000000000000offsollya-6.0+ds/tests-lib/ton.c000066400000000000000000000003021300174114700161270ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_on(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/ton.reference000066400000000000000000000000021300174114700176400ustar00rootroot00000000000000onsollya-6.0+ds/tests-lib/tor.c000066400000000000000000000034261300174114700161450ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); if (message == SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED) sollya_lib_printf("The following test produces a typing error\n"); else sollya_lib_printf("Unexpected message\n"); return 0; } int main(void) { sollya_obj_t true, false, a, b, res; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); true = sollya_lib_true(); false = sollya_lib_false(); a = sollya_lib_copy_obj(true); b = sollya_lib_copy_obj(true); res = sollya_lib_or(a, b); sollya_lib_printf("%b or %b gives %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_copy_obj(true); b = sollya_lib_copy_obj(false); res = sollya_lib_or(a, b); sollya_lib_printf("%b or %b gives %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_copy_obj(false); b = sollya_lib_copy_obj(true); res = sollya_lib_or(a, b); sollya_lib_printf("%b or %b gives %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = sollya_lib_copy_obj(false); b = sollya_lib_copy_obj(false); res = sollya_lib_or(a, b); sollya_lib_printf("%b or %b gives %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); a = SOLLYA_CONST(17); b = sollya_lib_string("Hello"); res = sollya_lib_or(a, b); sollya_lib_printf("%b or %b gives %b\n", a, b, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); sollya_lib_clear_obj(res); sollya_lib_clear_obj(true); sollya_lib_clear_obj(false); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tor.reference000066400000000000000000000002501300174114700176510ustar00rootroot00000000000000true or true gives true true or false gives true false or true gives true false or false gives false The following test produces a typing error 17 or Hello gives error sollya-6.0+ds/tests-lib/tperturb.c000066400000000000000000000003071300174114700172030ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_perturb(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tperturb.reference000066400000000000000000000000071300174114700207140ustar00rootroot00000000000000perturbsollya-6.0+ds/tests-lib/tpi.c000066400000000000000000000003021300174114700161230ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_pi(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tpi.reference000066400000000000000000000000021300174114700176340ustar00rootroot00000000000000pisollya-6.0+ds/tests-lib/tpostscript.c000066400000000000000000000003121300174114700177260ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_postscript(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tpostscript.reference000066400000000000000000000000121300174114700214370ustar00rootroot00000000000000postscriptsollya-6.0+ds/tests-lib/tpostscriptfile.c000066400000000000000000000003161300174114700205720ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_postscriptfile(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tpostscriptfile.reference000066400000000000000000000000161300174114700223030ustar00rootroot00000000000000postscriptfilesollya-6.0+ds/tests-lib/tpow.c000066400000000000000000000005311300174114700163240ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2, f; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_constant_from_double(2.0); f = sollya_lib_pow(f1, f2); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tpow.reference000066400000000000000000000000051300174114700200340ustar00rootroot00000000000000_x_^2sollya-6.0+ds/tests-lib/tpowers.c000066400000000000000000000003061300174114700170360ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_powers(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tpowers.reference000066400000000000000000000000061300174114700205470ustar00rootroot00000000000000powerssollya-6.0+ds/tests-lib/tprecision.c000066400000000000000000000026631300174114700175220ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST: sollya_lib_printf("An expression should have been a constant but it is just a constant expression.\n"); break; default: sollya_lib_printf("Unexpected warning %d\n", message); } return 0; } #define A_DIM 8 int main(void) { sollya_obj_t a[A_DIM], b[A_DIM]; int i; sollya_obj_t temp; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); sollya_lib_set_display(temp = sollya_lib_dyadic()); sollya_lib_clear_obj(temp); a[0] = sollya_lib_parse_string("0"); a[1] = sollya_lib_parse_string("NaN"); a[2] = sollya_lib_parse_string("infty"); a[3] = sollya_lib_parse_string("1"); a[4] = sollya_lib_parse_string("1 + 2^(-5)"); a[5] = sollya_lib_parse_string("1 + 2^(-100)"); a[6] = sollya_lib_parse_string("1 + 2^(-500)"); a[7] = sollya_lib_parse_string("pi"); for (i=0;i #define A_DIM 9 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("Caught the message that a certain expression is not correctly typed.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[A_DIM], b[A_DIM * A_DIM]; int i, j; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = sollya_lib_parse_string("[||]"); a[1] = sollya_lib_parse_string("[|1|]"); a[2] = sollya_lib_parse_string("[|1,2|]"); a[3] = sollya_lib_parse_string("[|1,...,17...|]"); a[4] = sollya_lib_parse_string("[|\"Hello\"|]"); a[5] = sollya_lib_parse_string("[|\"Hello\",\"World\"|]"); a[6] = sollya_lib_parse_string("[|\"land\",\"of\",\"milk\",\"and\",\"honey\"|]"); a[7] = sollya_lib_string("Hello "); a[8] = SOLLYA_CONST(19.25); for (i=0;i int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch (message) { case SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST: case SOLLYA_MSG_ROUNDING_DOWN_BEFORE_PRINTING_DOUBLE: case SOLLYA_MSG_ROUNDING_UP_BEFORE_PRINTING_DOUBLE: sollya_lib_printf("One of the expected warning messages has been caught.\n"); break; default: sollya_lib_printf("Unexpected message caught.\n"); } return 0; } int main(void) { sollya_obj_t a[6]; int i; double huge = 1e300; volatile double infval, nanval; union { uint64_t valint; double valdouble; } specialval; specialval.valint = 0x3ff6a09e667f3bcdull; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = sollya_lib_constant_from_double(1.); infval = huge * huge; nanval = infval - infval; a[1] = sollya_lib_constant_from_double(infval); a[2] = sollya_lib_constant_from_double(-infval); a[3] = sollya_lib_constant_from_double(nanval); a[4] = sollya_lib_constant_from_double(specialval.valdouble); a[5] = SOLLYA_EXP(SOLLYA_ASIN(sollya_lib_copy_obj(a[0]))); for (i=0;i<6;i++) { sollya_lib_printdouble(a[i]); } for (i=0;i<6;i++) { sollya_lib_clear_obj(a[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tprintdouble.reference000066400000000000000000000003361300174114700215650ustar00rootroot000000000000000x3ff0000000000000 0x7ff0000000000000 0xfff0000000000000 0x7ff800007ff80000 0x3ff6a09e667f3bcd One of the expected warning messages has been caught. One of the expected warning messages has been caught. 0x40133dedc855935f sollya-6.0+ds/tests-lib/tprintexpansion.c000066400000000000000000000034201300174114700206000ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch (message) { case SOLLYA_MSG_ERROR_POLY_COEFF_GETS_ROUNDED: case SOLLYA_MSG_ROUNDING_WHILE_PRINTING: sollya_lib_printf("One of the expected warning messages has been caught.\n"); break; default: sollya_lib_printf("Unexpected message caught.\n"); } return 0; } int main(void) { sollya_obj_t a[4]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = sollya_lib_parse_string("roundcoefficients(taylor(exp(x),5,0),[|DD...|])"); a[1] = sollya_lib_parse_string("11692536319630510474283968587625525849426869787677b-163 + x * (23384922893552793741208186896732057180708286140565b-164 + x * (46692941277611593554424973690517694800554713844979b-166 + x * (3891678517537147456387754739468835779118224484425b-164 + x * (1024072943597638219514404758611859127188920401873b-164 + x * 26154763285557255659575812244171511366994513699585b-171))))"); a[2] = SOLLYA_PI; a[3] = sollya_lib_parse_string("fpminimax(cos(x),6,[|DD, DD, D...|],[-1b-5;1b-5],default,default,default,5846006549323611671784298104022718622318882177971b-162 + x * (37857459261849734002934198358497784854969213609141b-241 + x * (-23384026197294176595383359674367214160107584181507b-165 + x * (-38602791478525408905485501706553096127203819717855b-228 + x * (31178701574267686389540459856148935530651557981629b-169 + x * (14117092987825147270453985390332190734246695748303b-216 + x * (-16628060881742355087337911794409009456208012766191b-173)))))))"); for (i=0;i<4;i++) { sollya_lib_printexpansion(a[i]); } for (i=0;i<4;i++) { sollya_lib_clear_obj(a[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tprintexpansion.reference000066400000000000000000000023111300174114700223120ustar00rootroot00000000000000One of the expected warning messages has been caught. One of the expected warning messages has been caught. One of the expected warning messages has been caught. 0x3ff0000000000000 + x * (0x3ff0000000000000 + x * (0x3fe0000000000000 + x * ((0x3fc5555555555555 + 0x3c65555555555555) + x * ((0x3fa5555555555555 + 0x3c45555555555555) + x * (0x3f81111111111111 + 0x3c01111111111111))))) (0x3ff0002eec908ce9 + 0xbc7df99eb225af5b + 0xb8d55834b08b1f18) + x * ((0x3ff0002835917719 + 0x3c6d82c073b25ebf + 0xb902cf062b54b7b6 + 0x35b0000000000000) + x * ((0x3fdff2d7e6a9c5e9 + 0xbc7b09a95b0d520f + 0xb915b639add55731 + 0x35a8000000000000) + x * ((0x3fc54d67338ba09f + 0x3c4867596d0631cf + 0xb8ef0756bdb4af6e) + x * ((0x3fa66c209b825167 + 0x3c45ec5b6655b076 + 0xb8d8c125286400bc) + x * (0x3f81e55425e72ab4 + 0x3c263b25a1bf597b + 0xb8c843e0401dadd0 + 0x3540000000000000))))) (0x400921fb54442d18 + 0x3ca1a62633145c07 + 0xb92f1976b7ed8fbc + 0x35c0000000000000)One of the expected warning messages has been caught. (0x3ff0000000000000 + 0xbc09fda20235c100) + x * ((0x3b29ecd485d34781 + 0xb7c1cbc97120359a) + x * (0xbfdfffffffffff98 + x * (0xbbfa6e0b3183cb0d + x * (0x3fa5555555145337 + x * (0x3ca3540480618939 + x * 0xbf56c138142d8c3b))))) sollya-6.0+ds/tests-lib/tprintf.c000066400000000000000000001107651300174114700170340ustar00rootroot00000000000000#define _BSD_SOURCE #define _DEFAULT_SOURCE #include #include #include #include #include #include #include #ifdef HAVE_CONFIG_H #include "config.h" #endif #ifdef SYSTEM_DOES_NOT_ALLOW_COMPLETE_PRINTF int main(void) { return 77; } #else #define SIZE 32 #define BUFSIZE 256 typedef signed char hh_t; typedef unsigned char hhu_t; typedef short int h_t; typedef unsigned short int hu_t; typedef long int l_t; typedef unsigned long int lu_t; typedef long long int ll_t; typedef unsigned long long int llu_t; typedef intmax_t j_t; typedef intmax_t ju_t; typedef size_t z_t; typedef ssize_t zu_t; typedef ptrdiff_t t_t; int counter = 0; size_t my_strnlen(const char *s, size_t lngmax) { int i; for(i=0;(size_t)(i) int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch (message) { case SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST: case SOLLYA_MSG_ROUNDING_DOWN_BEFORE_PRINTING_SINGLE: case SOLLYA_MSG_ROUNDING_UP_BEFORE_PRINTING_SINGLE: sollya_lib_printf("One of the expected warning messages has been caught.\n"); break; default: sollya_lib_printf("Unexpected message caught.\n"); } return 0; } int main(void) { sollya_obj_t a[24]; sollya_obj_t temp; int i; float huge = 1e38f; volatile float infval, nanval; union { uint32_t valint; float valfloat; } specialval; specialval.valint = 0x3fb504f3u; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = sollya_lib_constant_from_double(1.); infval = huge * huge; nanval = infval - infval; a[1] = sollya_lib_constant_from_double((double) (infval)); a[2] = sollya_lib_constant_from_double((double) (-infval)); a[3] = sollya_lib_constant_from_double((double) nanval); a[4] = sollya_lib_constant_from_double((double)(specialval.valfloat)); a[5] = SOLLYA_EXP(SOLLYA_ASIN(sollya_lib_copy_obj(a[0]))); sollya_lib_set_prec(temp = sollya_lib_constant_from_double(1000.0)); sollya_lib_clear_obj(temp); a[6] = sollya_lib_parse_string("1b128 - 1b103 - 1b-500"); a[7] = sollya_lib_parse_string("1b128 - 1b103 - 1b-74"); a[8] = sollya_lib_parse_string("1b128 - 1b103 - 1b-75"); a[9] = sollya_lib_parse_string("1b128 - 1b103"); a[10] = sollya_lib_parse_string("1b128 - 1b103 + 1b-500"); a[11] = sollya_lib_parse_string("1b128 - 1b103 + 1b-74"); a[12] = sollya_lib_parse_string("1b128 - 1b103 + 1b-75"); a[13] = sollya_lib_parse_string("1.0000000010111111111111111000001_2 * 2^(-140)"); a[14] = sollya_lib_parse_string("-1.0000000010111111111111111000001_2 * 2^(-140)"); a[15] = sollya_lib_parse_string("1b-1000"); a[16] = sollya_lib_parse_string("-1b-1000"); a[17] = sollya_lib_parse_string("0"); a[18] = sollya_lib_parse_string("-0"); a[19] = sollya_lib_parse_string("1b-150"); a[20] = sollya_lib_parse_string("1b-150 + 1b-1000"); a[21] = sollya_lib_parse_string("1b-150 - 1b-1000"); a[22] = sollya_lib_parse_string("-1b-150 + 1b-1000"); a[23] = sollya_lib_parse_string("-1b-150 - 1b-1000"); for (i=0;i<24;i++) { sollya_lib_printsingle(a[i]); } for (i=0;i<24;i++) { sollya_lib_clear_obj(a[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tprintsingle.reference000066400000000000000000000023241300174114700215730ustar00rootroot000000000000000x3f800000 0x7f800000 0xff800000 0x7fc00003 0x3fb504f3 One of the expected warning messages has been caught. One of the expected warning messages has been caught. 0x4099ef6e One of the expected warning messages has been caught. 0x7f7fffff One of the expected warning messages has been caught. 0x7f7fffff One of the expected warning messages has been caught. 0x7f7fffff One of the expected warning messages has been caught. 0x7f800000 One of the expected warning messages has been caught. 0x7f800000 One of the expected warning messages has been caught. 0x7f800000 One of the expected warning messages has been caught. 0x7f800000 One of the expected warning messages has been caught. 0x00000201 One of the expected warning messages has been caught. 0x80000201 One of the expected warning messages has been caught. 0x00000000 One of the expected warning messages has been caught. 0x80000000 0x00000000 0x80000000 One of the expected warning messages has been caught. 0x00000000 One of the expected warning messages has been caught. 0x00000001 One of the expected warning messages has been caught. 0x00000000 One of the expected warning messages has been caught. 0x80000000 One of the expected warning messages has been caught. 0x80000001 sollya-6.0+ds/tests-lib/tprocedurefunction.c000066400000000000000000000027221300174114700212610ustar00rootroot00000000000000#include #include int main(void) { sollya_obj_t f[11]; mpfr_t x,y; int i; sollya_lib_init(); /* Simple definition and evaluation */ f[0] = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); f[1] = SOLLYA_X_; f[2] = sollya_lib_procedurefunction(f[1], f[0]); sollya_lib_printf("%b\n", f[2]); mpfr_init2(x, 30); mpfr_init2(y, 50); mpfr_set_ui(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y,f[2], x, NULL); sollya_lib_printf("%v (expecting approximate value of exp(2))\n", y); /* Trying to differentiate and display */ f[3] = SOLLYA_SIN(SOLLYA_X_); f[4] = sollya_lib_apply(f[2], f[3], NULL); f[5] = sollya_lib_diff(f[4]); sollya_lib_printf("%b (expecting: (diff(function(proc(X, n, p) {...})))(sin(_x_)) * cos(_x_))\n", f[5]); f[6] = SOLLYA_X_; f[7] = sollya_lib_apply(f[2], f[6], NULL); f[8] = sollya_lib_diff(f[7]); sollya_lib_printf("%b (expecting: diff(function(proc(X, n, p) {...})))\n", f[8]); /* Applying a procedure function to an interval. */ f[9] = sollya_lib_parse_string("[1,2]"); f[10] = sollya_lib_procedurefunction(f[9], f[0]); sollya_lib_printf("%b (expecting: [2.71828182845904523536028747135266249775724709369989, 7.3890560989306502272304274605750078131803155705518])\n", f[10]); for(i=0;i<=10;i++) { sollya_lib_clear_obj(f[i]); } mpfr_clear(x); mpfr_clear(y); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tprocedurefunction.reference000066400000000000000000000014641300174114700227770ustar00rootroot00000000000000function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; }) 7.3890560989306521832986618392169475555419921875 (expecting approximate value of exp(2)) (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(sin(_x_)) * cos(_x_) (expecting: (diff(function(proc(X, n, p) {...})))(sin(_x_)) * cos(_x_)) diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })) (expecting: diff(function(proc(X, n, p) {...}))) [2.7182818284590452353602874713526624977572470936999;7.3890560989306502272304274605750078131803155705519] (expecting: [2.71828182845904523536028747135266249775724709369989, 7.3890560989306502272304274605750078131803155705518]) sollya-6.0+ds/tests-lib/tquad.c000066400000000000000000000004151300174114700164520ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_quad(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tquad.reference000066400000000000000000000000111300174114700201560ustar00rootroot00000000000000quad(_x_)sollya-6.0+ds/tests-lib/tquad_obj.c000066400000000000000000000003101300174114700172760ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_quad_obj(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tquad_obj.reference000066400000000000000000000000041300174114700210120ustar00rootroot00000000000000quadsollya-6.0+ds/tests-lib/trange_from_bounds.c000066400000000000000000000041031300174114700212070ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); if (message==SOLLYA_MSG_RANGE_BOUNDS_IN_INVERSE_ORDER) sollya_lib_printf("Caught the message about bounds in inverse order.\n"); else if (message==SOLLYA_MSG_ONLY_ONE_ENDPOINT_OF_RANGE_IS_NAN) sollya_lib_printf("Caught the message indicating that only one bound is NaN.\n"); else sollya_lib_printf("Unexpected message caught.\n"); return 0; } int main(void) { sollya_obj_t a, prec, tmp, left, right; mpfr_t b1, b2; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); tmp = sollya_lib_binary(); sollya_lib_set_display(tmp); sollya_lib_clear_obj(tmp); mpfr_init2(b1, 40); mpfr_init2(b2, 40); mpfr_set_d(b1, 0.1, GMP_RNDD); mpfr_set_d(b2, 0.2, GMP_RNDU); a = sollya_lib_range_from_bounds(b1, b2); left = sollya_lib_parse_string("round(D(1/10), 40, RD)"); right = sollya_lib_parse_string("round(D(2/10), 40, RU)"); sollya_lib_printf("%b\n[%b;%b] (should be the same as above)\n", a, left, right); sollya_lib_clear_obj(left); sollya_lib_clear_obj(right); sollya_lib_clear_obj(a); prec = sollya_lib_constant_from_int(20); sollya_lib_set_prec(prec); sollya_lib_clear_obj(prec); a = sollya_lib_range_from_bounds(b1, b2); sollya_lib_printf("%b (should be the same as above)\n", a); sollya_lib_clear_obj(a); a = sollya_lib_range_from_bounds(b2, b1); sollya_lib_printf("%b (should be the same as above)\n", a); sollya_lib_clear_obj(a); mpfr_set_nan(b1); mpfr_set_nan(b2); a = sollya_lib_range_from_bounds(b1, b2); sollya_lib_printf("%b (should be [NaN, NaN])\n", a); sollya_lib_clear_obj(a); mpfr_set_d(b1, 1., GMP_RNDN); a = sollya_lib_range_from_bounds(b1, b2); sollya_lib_printf("%b (should be [NaN, NaN])\n", a); sollya_lib_clear_obj(a); a = sollya_lib_range_from_bounds(b2, b1); sollya_lib_printf("%b (should be [NaN, NaN])\n", a); sollya_lib_clear_obj(a); mpfr_clear(b1); mpfr_clear(b2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/trange_from_bounds.reference000066400000000000000000000014131300174114700227240ustar00rootroot00000000000000[1.1001100110011001100110011001100110011_2 * 2^(-4);1.100110011001100110011001100110011001101_2 * 2^(-3)] [1.1001100110011001100110011001100110011_2 * 2^(-4);1.100110011001100110011001100110011001101_2 * 2^(-3)] (should be the same as above) [1.1001100110011001100110011001100110011_2 * 2^(-4);1.100110011001100110011001100110011001101_2 * 2^(-3)] (should be the same as above) Caught the message about bounds in inverse order. [1.1001100110011001100110011001100110011_2 * 2^(-4);1.100110011001100110011001100110011001101_2 * 2^(-3)] (should be the same as above) [NaN;NaN] (should be [NaN, NaN]) Caught the message indicating that only one bound is NaN. [NaN;NaN] (should be [NaN, NaN]) Caught the message indicating that only one bound is NaN. [NaN;NaN] (should be [NaN, NaN]) sollya-6.0+ds/tests-lib/trange_from_interval.c000066400000000000000000000047671300174114700215610ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); if (message==SOLLYA_MSG_RANGE_BOUNDS_IN_INVERSE_ORDER) sollya_lib_printf("Caught the message about bounds in inverse order.\n"); else if (message==SOLLYA_MSG_ONLY_ONE_ENDPOINT_OF_RANGE_IS_NAN) sollya_lib_printf("Caught the message indicating that only one bound is NaN.\n"); else sollya_lib_printf("Unexpected message caught.\n"); return 0; } int main(void) { sollya_obj_t a, prec, tmp, left, right; mpfi_t b; double nan; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); tmp = sollya_lib_binary(); sollya_lib_set_display(tmp); sollya_lib_clear_obj(tmp); mpfi_init2(b, 40); mpfi_interv_d(b, 0.1, 0.2); a = sollya_lib_range_from_interval(b); left = sollya_lib_parse_string("round(D(1/10), 40, RD)"); right = sollya_lib_parse_string("round(D(2/10), 40, RU)"); sollya_lib_printf("%b\n[%b;%b] (should be the same as above)\n", a, left, right); sollya_lib_clear_obj(left); sollya_lib_clear_obj(right); sollya_lib_clear_obj(a); prec = sollya_lib_constant_from_int(20); sollya_lib_set_prec(prec); sollya_lib_clear_obj(prec); a = sollya_lib_range_from_interval(b); sollya_lib_printf("%b (should be the same as above)\n", a); sollya_lib_clear_obj(a); mpfi_interv_d(b, 0.2, 0.1); a = sollya_lib_range_from_interval(b); sollya_lib_printf("%b (should be the same as above)\n", a); sollya_lib_clear_obj(a); mpfi_clear(b); mpfi_init2(b, 40); /* Should put NaN into b according to the doc */ a = sollya_lib_range_from_interval(b); sollya_lib_printf("%b (should be [NaN, NaN])\n", a); sollya_lib_clear_obj(a); nan = 0./0.; mpfi_interv_d(b, 1, nan); a = sollya_lib_range_from_interval(b); sollya_lib_printf("%b (should be [NaN, NaN])\n", a); sollya_lib_clear_obj(a); mpfi_interv_d(b, nan, 1); a = sollya_lib_range_from_interval(b); sollya_lib_printf("%b (should be [NaN, NaN])\n", a); sollya_lib_clear_obj(a); /* Note: the following code uses knowledge about internal implementation of MPFI. Could be broken in future release of MPFI, but needs to be tested anyway, because users could try it. */ mpfr_set_d(&(b->left), 1., GMP_RNDN); mpfr_set_d(&(b->right), -1., GMP_RNDN); a = sollya_lib_range_from_interval(b); sollya_lib_printf("%b (should be [-1, 1])\n", a); sollya_lib_clear_obj(a); mpfi_clear(b); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/trange_from_interval.reference000066400000000000000000000014521300174114700232610ustar00rootroot00000000000000[1.1001100110011001100110011001100110011_2 * 2^(-4);1.100110011001100110011001100110011001101_2 * 2^(-3)] [1.1001100110011001100110011001100110011_2 * 2^(-4);1.100110011001100110011001100110011001101_2 * 2^(-3)] (should be the same as above) [1.1001100110011001100110011001100110011_2 * 2^(-4);1.100110011001100110011001100110011001101_2 * 2^(-3)] (should be the same as above) [1.1001100110011001100110011001100110011_2 * 2^(-4);1.100110011001100110011001100110011001101_2 * 2^(-3)] (should be the same as above) [NaN;NaN] (should be [NaN, NaN]) Caught the message indicating that only one bound is NaN. [NaN;NaN] (should be [NaN, NaN]) Caught the message indicating that only one bound is NaN. [NaN;NaN] (should be [NaN, NaN]) Caught the message about bounds in inverse order. [-1_2;1_2] (should be [-1, 1]) sollya-6.0+ds/tests-lib/trationalapprox.c000066400000000000000000000066071300174114700205740ustar00rootroot00000000000000#include #define A_DIM 14 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST: sollya_lib_printf("Caught a message stating that a constant expression was given instead of a constant.\n"); break; case SOLLYA_MSG_RATIONALAPPROX_SECOND_ARG_MUST_BE_GREATER_THAN_ONE: sollya_lib_printf("Caught a message stating that the precision is not large enough.\n"); break; case SOLLYA_MSG_EXPR_OR_COMMAND_COULD_NOT_BE_HANDLED: sollya_lib_printf("Caught a message stating that the command cannot be handeled.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int checkrationalapprox(sollya_obj_t num, sollya_obj_t bits, sollya_obj_t res) { sollya_obj_t zero, temp, eps, bound; int numIsZero, resIsZero, okay; if (sollya_lib_obj_is_error(res)) return 1; zero = SOLLYA_CONST(0.0); temp = sollya_lib_cmp_equal(num, zero); numIsZero = sollya_lib_is_true(temp); sollya_lib_clear_obj(temp); temp = sollya_lib_cmp_equal(res, zero); resIsZero = sollya_lib_is_true(temp); sollya_lib_clear_obj(temp); sollya_lib_clear_obj(zero); if (numIsZero) { return resIsZero; } eps = SOLLYA_ABS(SOLLYA_SUB(SOLLYA_DIV(sollya_lib_copy_obj(res), sollya_lib_copy_obj(num)), SOLLYA_CONST(1.0))); bound = SOLLYA_POW(SOLLYA_CONST(2.0), SOLLYA_NEG(sollya_lib_copy_obj(bits))); temp = sollya_lib_cmp_less_equal(eps, bound); okay = sollya_lib_is_true(temp); sollya_lib_clear_obj(temp); sollya_lib_clear_obj(eps); sollya_lib_clear_obj(bound); return okay; } int main(void) { sollya_obj_t a[A_DIM], b[A_DIM], c[A_DIM]; int i, okay, check; okay = 1; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = SOLLYA_CONST(17.0); b[0] = SOLLYA_CONST(2.0); a[1] = SOLLYA_CONST(17.0); b[1] = SOLLYA_CONST(15.0); a[2] = SOLLYA_D(SOLLYA_PI); b[2] = SOLLYA_CONST(15.0); a[3] = SOLLYA_TD(SOLLYA_PI); b[3] = SOLLYA_CONST(150.0); a[4] = SOLLYA_D(SOLLYA_PI); b[4] = SOLLYA_CONST(1.0); a[5] = SOLLYA_D(SOLLYA_PI); b[5] = SOLLYA_CONST(0.0); a[6] = SOLLYA_D(SOLLYA_PI); b[6] = SOLLYA_CONST(2.0); a[7] = SOLLYA_D(SOLLYA_PI); b[7] = SOLLYA_CONST(-2.0); a[8] = SOLLYA_CONST(0.1); b[8] = SOLLYA_CONST(10.0); a[9] = SOLLYA_CONST(0.1); b[9] = SOLLYA_CONST(100.0); a[10] = SOLLYA_TD(SOLLYA_DIV(SOLLYA_CONST(1329.0),SOLLYA_CONST(5971.0))); b[10] = SOLLYA_CONST(20.0); a[11] = SOLLYA_CONST(0.0); b[11] = SOLLYA_CONST(17.0); a[12] = SOLLYA_MUL(SOLLYA_CONST(10), SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(59))); b[12] = SOLLYA_CONST(6.0); a[13] = SOLLYA_SIN(SOLLYA_MUL(SOLLYA_CONST(10), SOLLYA_DIV(SOLLYA_PI, SOLLYA_CONST(59)))); b[13] = SOLLYA_CONST(7.0); for (i=0;i int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_relative(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/trelative.reference000066400000000000000000000000101300174114700210360ustar00rootroot00000000000000relativesollya-6.0+ds/tests-lib/tremez.c000066400000000000000000003715501300174114700166550ustar00rootroot00000000000000#include int boolean_not_eq(sollya_obj_t a, sollya_obj_t b) { sollya_obj_t tmp; int res; tmp = sollya_lib_cmp_not_equal(a,b); res = sollya_lib_is_true(tmp); sollya_lib_clear_obj(tmp); return res; } int callback(sollya_msg_t msg, void *data) { (void)msg; /* Avoiding "unused parameter" warning */ (void)data; /* Avoiding "unused parameter" warning */ return 0; } int main(void) { sollya_obj_t f, n, I, w, quality, p, res, pold32, pold64, psvn, prec; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* This set of tests the problem mentioned in the commit message of revision 1270 */ sollya_lib_printf("=============== Check remez #1 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[-1,1]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("11692536319630510474283968587625525849426869787677b-163 + x * (11692461446776396870604093448366028590354143070281b-163 + x * (11673235319402898388606243422629423700138678461245b-164 + x * (31133428140297179651102037915750686232945795875449b-167 + x * (16385167097562211512230476137789746035022726429977b-168 + x * 3269345410694656957446976530521438920874314212397b-168))))"); pold64 = sollya_lib_parse_string("11692536319630510474283968587625525849426869787677b-163 + x * (11692461446776396870604093448366028590354143070281b-163 + x * (11673235319402898388606243422629423700138678461245b-164 + x * (31133428140297179651102037915750686232945795875449b-167 + x * (16385167097562211512230476137789746035022726429977b-168 + x * 3269345410694656957446976530521438920874314212397b-168))))"); psvn = sollya_lib_parse_string("5846268159844744362743250522846987862429367629517b-162 + x * (11692461446497641124271694526853099581211451868505b-163 + x * (46692941277687010312354789479617646356383574093505b-166 + x * (31133428154210205207475891032719442864509304264413b-167 + x * (32770334189338630118937388326942173859103583586297b-169 + x * 26154763134310317818688286279981231602507327130357b-171))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #2 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_SIN(SOLLYA_X_); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[8602502489799048500699352110124879245308378241707b-164;7945546686039470376946513431105230628758836096031b-161]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("2214847272544331422982959495339200583251295560623b-168 + x * (22570554785080561636146441606989328655486420601777b-164 + x * (14059659517842917521277573489957716260107438465453b-167 + x * (-45540662462117273602262338480450403246420473478025b-167 + x * 28992086169774180186447811867835608633187677753845b-169)))"); pold64 = sollya_lib_parse_string("2214847272544331422982959495339200583251295560623b-168 + x * (22570554785080561636146441606989328655486420601777b-164 + x * (14059659517842917521277573489957716260107438465453b-167 + x * (-45540662462117273602262338480450403246420473478025b-167 + x * 28992086169774180186447811867835608633187677753845b-169)))"); psvn = sollya_lib_parse_string("35437554945294880980632330593543073201088752576427b-172 + x * (45141109621726235334917783839125819818331107328775b-165 + x * (7029829603586427223675545515975596612915570331385b-166 + x * (-11385165569957834689007715202379973379744083428327b-165 + x * 14496043012911941041556939044573938262006021182555b-168)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #3 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[-1,1]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("127320445892597569233192084573816508818883486078679099554120447022081703359819068009205547b-296 + x * (1018557044797143666503767416322855867839491631117818135205555253332674508098291366773725959b-299 + x * (508441106512784560521103888523310670303733435407883686814016285688113354381980961005656571b-299 + x * (1356052046777263815902350693610623816222104351491496878169889792980744642403155011929747871b-302 + x * (1427349359299711414482673569219142091501984527550101477773398194525418017639951550600094011b-304 + x * 142400076760410063419384360841976625466855068476814073302706323729266395387747260369551141b-303))))"); pold64 = sollya_lib_parse_string("23385072639206744003725553236226897950127307962451b-164 + x * (365389420211574099793611713376448329829065556119b-158 + x * (46692941283719626881488690119204107293177946206343b-166 + x * (31133428132962382466270199289173155642175257945163b-167 + x * (32770334150519966250277800665629495916849322658691b-169 + x * 13077381702228291991132998535625300995139355424413b-170))))"); psvn = sollya_lib_parse_string("1018563567135987915012032258711626357126926844785584405249158988500045361779294524522137609b-299 + x * (63659815291914294289514095925732401040544551614636617651518742466446015741886727574488441b-295 + x * (2033764425613398113005508465663637496484258379622733425468204193164419557706436715536867277b-301 + x * (1356052049838784195049149578638111221779213254032530089671765628325726082534242762143843701b-302 + x * (713674681588234494371962064568899835020713913740079267560613729649927766384468681112736739b-303 + x * 142400072661608631070456694965201033405098147932863694799040634951915614775231369251933923b-303))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #4 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_SIN(SOLLYA_X_); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[374691828310027073697551143672108152896494840720292515058859891294604926811223524123212345b-299;346077367399210202326012086853215365101795134298550595521910142083912300379007927274911891b-296]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("771761635395839434377129531728754385222063722650731773025337381349894526273800455320994827b-306 + x * (491543155523301332510096977904466770120443466902627277040602137207242486357322286394764839b-298 + x * (306192269961748776289513828518754452203023757960747199912707501846371742102754825130961253b-301 + x * (-991787802459613064655442347525062928740559494434023642211380691777391678934404916892326387b-301 + x * 1262783450062636101159847119423691169466818338834735686194803407195747225125865497190175227b-304)))"); pold64 = sollya_lib_parse_string("4429694543892476662758950169267086222983904426445b-169 + x * (705329837039797126620403885467797756064876572665b-159 + x * (14059659515839393799760722484884113456401859506117b-167 + x * (-22770331230580585570448475640636477599253588269445b-166 + x * 14496043084575263078863254256762631012805774503031b-168)))"); psvn = sollya_lib_parse_string("771761604782391317266041851785945726969630324975846680133806343191685414408397696546623025b-306 + x * (983086312139836775818762885502129911710245659966259444915127631295702907925608027660771709b-299 + x * (1224769054074531902982422536607908492630645593827460997931865849686410542941640013242217675b-303 + x * (-1983575597502081965714353024113746965208457974615584377507146126565280394079564572724184361b-302 + x * 1262783444340237354442532109902524854573062009580400181046879466613800524190097257252128189b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #5 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_SUB(SOLLYA_POW(SOLLYA_CONST(2), SOLLYA_X_), SOLLYA_CONST(1)),SOLLYA_X_); n = SOLLYA_CONST(9); I = sollya_lib_parse_string("[-1/16, 1/16]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("32417143657589090276342392320386542212634719195519b-165 + x * (22469851728064591059583753980795080887258113935177b-166 + x * (10383276248605324150931761963547736824435408824845b-167 + x * (28788554626783304799277995343333212138822726194415b-171 + x * (31927528755121801828772085911906676930045165407763b-174 + x * (29507302051812361584763105995068885830047872617559b-177 + x * (46749493035990890820236833700755803008100799330757b-181 + x * (4050534911275574634871329395893993407613062655611b-181 + x * (39932254070374564388452160149914943140225571249661b-188 + x * 44286286888723497574154492217999447288717640509613b-192))))))))"); pold64 = sollya_lib_parse_string("32417143657589090276342392320386542212634719195519b-165 + x * (22469851728064591059583753980795080887258113935177b-166 + x * (10383276248605324150931761963547736824435408824845b-167 + x * (28788554626783304799277995343333212138822726194415b-171 + x * (31927528755121801828772085911906676930045165407763b-174 + x * (29507302051812361584763105995068885830047872617559b-177 + x * (46749493035990890820236833700755803008100799330757b-181 + x * (4050534911275574634871329395893993407613062655611b-181 + x * (39932254070374564388452160149914943140225571249661b-188 + x * 44286286888723497574154492217999447288717640509613b-192))))))))"); psvn = sollya_lib_parse_string("16208571828794545138171196160198665353392027726519b-164 + x * (1404365733004036941223984624239966955522849707087b-162 + x * (20766552497210648301863523826884866697474843319139b-168 + x * (28788554626783304799277546456383385755588541941189b-171 + x * (7981882188780450457193021387137975228227525851703b-172 + x * (29507302051812361607733914252846404885311057946759b-177 + x * (23374746517995445671169652317254474972656939309419b-180 + x * (16202139645101822893887622168399062673636756653911b-183 + x * (19966127035178946160378341872570680908647845093767b-187 + x * 22143143457750640206904485509370313176196151922715b-191))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #6 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[0, 1]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("11691999891702459232513188345837804387460473133465b-163 + x * (23385884215836431320692282794470362044234264759653b-164 + x * (23341752494481389797661158971731272634607100367573b-165 + x * (31877473745927764039755782208650650896265284145499b-167 + x * (13020439476544364685564705598260199073785811131065b-168 + x * 10404004557414297823136671010327185596581741545881b-169))))"); pold64 = sollya_lib_parse_string("11691999891702459232513188345837804387460473133465b-163 + x * (23385884215836431320692282794470362044234264759653b-164 + x * (23341752494481389797661158971731272634607100367573b-165 + x * (31877473745927764039755782208650650896265284145499b-167 + x * (13020439476544364685564705598260199073785811131065b-168 + x * 10404004557414297823136671010327185596581741545881b-169))))"); psvn = sollya_lib_parse_string("46767999566809558881308044468442218032103592655757b-165 + x * (11692942107914186071032289323545495195098625849317b-163 + x * (1458859530921322116893682516178375390461742133049b-161 + x * (15938736871253002006918388195626326961019565596185b-166 + x * (26040878969624894003265505832639851578483944977057b-169 + x * 41616018202667367394235807063903500749064273666975b-171))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #7 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_COS(SOLLYA_EXP(SOLLYA_X_)); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[-1b-7, 1b-7]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("25268886549758389380340876080809564841766313745633b-165 + x * (-19676979553010954045662456941477966428585006577331b-164 + x * (-1009731963712275556396770797362269719145679957307b-160 + x * (-25268886572680378753378093437862180139058073796075b-166 + x * (30111938956773510352709131042243854571830406972593b-169 + x * 12980576291156057011865982562724840642811102794567b-166))))"); pold64 = sollya_lib_parse_string("25268886549758389380340876080809564841766313745633b-165 + x * (-19676979553010954045662456941477966428585006577331b-164 + x * (-1009731963712275556396770797362269719145679957307b-160 + x * (-25268886572680378753378093437862180139058073796075b-166 + x * (30111938956773510352709131042243854571830406972593b-169 + x * 12980576291156057011865982562724840642811102794567b-166))))"); psvn = sollya_lib_parse_string("25268886549758389380340964094845911511083285927847b-165 + x * (-39353959106021908091317784228352609542993628947795b-165 + x * (-8077855709698204451264858061909024193753897104777b-163 + x * (-25268886572680378560233411601948682207329758068657b-166 + x * (30111938956773161130666968507397664953869736937191b-169 + x * 12980576291149064825229651770061989288082684342499b-166))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #8 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); n = sollya_lib_build_list(SOLLYA_CONST(0), SOLLYA_CONST(2), SOLLYA_CONST(4), SOLLYA_CONST(6), SOLLYA_CONST(8), NULL); I = sollya_lib_parse_string("[0;18365771228192875685539220798973244513816620097673b-164]"); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_COS(SOLLYA_X_)); res = sollya_lib_remez(f,n,I,w, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("46768052391966959108624215231152264196631503496533b-165 + x^2 * (-46768051993840437443783072518668792259606171959491b-166 + x^2 * (31178661612951199203931279724159830154661317721883b-169 + x^2 * (-16625815622415464147749762639614753800875397430565b-173 + x^2 * 37351022179333407291017870331792433578970727797399b-180)))"); pold64 = sollya_lib_parse_string("46768052391966959108624215231152264196631503496533b-165 + x^2 * (-46768051993840437443783072518668792259606171959491b-166 + x^2 * (31178661612951199203931279724159830154661317721883b-169 + x^2 * (-16625815622415464147749762639614753800875397430565b-173 + x^2 * 37351022179333407291017870331792433578970727797399b-180)))"); psvn = sollya_lib_parse_string("23384026195983475555764083291413192636174326996971b-164 + x^2 * (-5846006499229983362883814289569946057071030537265b-163 + x^2 * (31178661612930653056505238164343085429561431777217b-169 + x^2 * (-33251631243914015813578984958842684370701439463593b-174 + x^2 * 37351022158050956678139896134233747310006229285203b-180)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #9 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[0, 1]"); w = sollya_lib_default(); quality = sollya_lib_parse_string("1e-5"); res = sollya_lib_remez(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("11691999891702459232513188345837804387460473133465b-163 + x * (23385884215836431320692282794470362044234264759653b-164 + x * (23341752494481389797661158971731272634607100367573b-165 + x * (31877473745927764039755782208650650896265284145499b-167 + x * (13020439476544364685564705598260199073785811131065b-168 + x * 10404004557414297823136671010327185596581741545881b-169))))"); pold64 = sollya_lib_parse_string("11691999891702459232513188345837804387460473133465b-163 + x * (23385884215836431320692282794470362044234264759653b-164 + x * (23341752494481389797661158971731272634607100367573b-165 + x * (31877473745927764039755782208650650896265284145499b-167 + x * (13020439476544364685564705598260199073785811131065b-168 + x * 10404004557414297823136671010327185596581741545881b-169))))"); psvn = sollya_lib_parse_string("46767999566809558881308044468442218032103592655757b-165 + x * (11692942107914186071032289323545495195098625849317b-163 + x * (1458859530921322116893682516178375390461742133049b-161 + x * (15938736871253002006918388195626326961019565596185b-166 + x * (26040878969624894003265505832639851578483944977057b-169 + x * 41616018202667367394235807063903500749064273666975b-171))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[0, 1]"); w = sollya_lib_default(); quality = sollya_lib_parse_string("1e-10"); res = sollya_lib_remez(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("11691999891702299312469444817572169311673890781507b-163 + x * (5846471053959190028880485661894891163596000435605b-162 + x * (2917719061827678043813769415697570710862370049051b-162 + x * (31877473743673721131764284633492051013566249115055b-167 + x * (26040878964869758854248710691789107998476450084373b-169 + x * 20808009104796731383700609709219405830023419999013b-170))))"); pold64 = sollya_lib_parse_string("11691999891702299312469444817572169311673890781507b-163 + x * (5846471053959190028880485661894891163596000435605b-162 + x * (2917719061827678043813769415697570710862370049051b-162 + x * (31877473743673721131764284633492051013566249115055b-167 + x * (26040878964869758854248710691789107998476450084373b-169 + x * 20808009104796731383700609709219405830023419999013b-170))))"); psvn = sollya_lib_parse_string("5845999945851149656234435605422211132352886535717b-162 + x * (23385884215836760115545970932838216522984359588165b-164 + x * (5835438123655356087555656737495441519792436822103b-163 + x * (31877473743673721133327937242850399199174475687415b-167 + x * (6510219741217439713495165031525459507010189269817b-167 + x * 10404004552398365689695293864167514071470455315299b-169))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[0, 1]"); w = sollya_lib_default(); quality = sollya_lib_parse_string("1e-15"); res = sollya_lib_remez(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("11691999891702299312469444817572169311673890781507b-163 + x * (5846471053959190028880485661894891163596000435605b-162 + x * (2917719061827678043813769415697570710862370049051b-162 + x * (31877473743673721131764284633492051013566249115055b-167 + x * (26040878964869758854248710691789107998476450084373b-169 + x * 20808009104796731383700609709219405830023419999013b-170))))"); pold64 = sollya_lib_parse_string("11691999891702299312469444817572169311673890781507b-163 + x * (5846471053959190028880485661894891163596000435605b-162 + x * (2917719061827678043813769415697570710862370049051b-162 + x * (31877473743673721131764284633492051013566249115055b-167 + x * (26040878964869758854248710691789107998476450084373b-169 + x * 20808009104796731383700609709219405830023419999013b-170))))"); psvn = sollya_lib_parse_string("5845999945851149656234435605422211132352886535717b-162 + x * (23385884215836760115545970932838216522984359588165b-164 + x * (5835438123655356087555656737495441519792436822103b-163 + x * (31877473743673721133327937242850399199174475687415b-167 + x * (6510219741217439713495165031525459507010189269817b-167 + x * 10404004552398365689695293864167514071470455315299b-169))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #10 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_ATAN(SOLLYA_X_); n = SOLLYA_CONST(10); I = sollya_lib_parse_string("[-1, 1]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("38372544245022954071593576343710401499b-180 + x * (23380900442023710590629720276282789164224450528167b-164 + x * (-33609089175829249495416553130562627902380011341963b-215 + x * (-7723855757337398739828398738169459706253746872539b-164 + x * (14798371425256328739831059603503168717188731259649b-211 + x * (33702797323732429414901179632614772732191491283097b-167 + x * (-20026589901676225916120391461096241995653144141359b-210 + x * (-7965193355045203212490647632529296700704259316517b-166 + x * (11492309484232489173482584564890302837739876433267b-209 + x * (31196332541693159565915304978636341240498090752081b-170 + x * (-18696265896642848807310482596711689481317128284659b-211))))))))))"); pold64 = sollya_lib_parse_string("38372544245022954071593576343710401499b-180 + x * (23380900442023710590629720276282789164224450528167b-164 + x * (-33609089175829249495416553130562627902380011341963b-215 + x * (-7723855757337398739828398738169459706253746872539b-164 + x * (14798371425256328739831059603503168717188731259649b-211 + x * (33702797323732429414901179632614772732191491283097b-167 + x * (-20026589901676225916120391461096241995653144141359b-210 + x * (-7965193355045203212490647632529296700704259316517b-166 + x * (11492309484232489173482584564890302837739876433267b-209 + x * (31196332541693159565915304978636341240498090752081b-170 + x * (-18696265896642848807310482596711689481317128284659b-211))))))))))"); psvn = sollya_lib_parse_string("-299518546557879520665255352509681884284993b-181 + x * (46761800881643993210141123783443178910382594686091b-165 + x * (15626932760797014273458339403729579988713039201177b-197 + x * (-30895422984424026393941474369915254415267721041803b-166 + x * (-37843049683583409517658396527903377324449648118839b-195 + x * (33702797050918309664309509947748141237482896518641b-167 + x * (14340405569685532672251459301997641076318498173369b-192 + x * (-31860772758098094375292352991903847201619947720321b-168 + x * (-34116843989195391948704554536758220176631032690829b-193 + x * (974885357098662804386862783336303497880652218429b-165 + x * 13921338801137066666041733737929563262809760263031b-193)))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #11 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(3); I = sollya_lib_parse_string("[0, 1]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("46742573553811911796274412764391966160112581418361b-165 + x * (185720745566008984665440218961959381728519963271b-157 + x * (2465278576003452056620348681425508255554707916727b-162 + x * 26187910218233432242621629490193931328425524460129b-166))"); pold64 = sollya_lib_parse_string("46742573553811911796274412764391966160112581418361b-165 + x * (185720745566008984665440218961959381728519963271b-157 + x * (2465278576003452056620348681425508255554707916727b-162 + x * 26187910218233432242621629490193931328425524460129b-166))"); psvn = sollya_lib_parse_string("5842821694226678901701403157817208990903244674607b-162 + x * (11886127716219130633708414511730040683306080916975b-163 + x * (19722228608052746177156080281278926582286515128695b-165 + x * 26187910218226727873273123845127088231281394729319b-166))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #12 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_SIN(SOLLYA_X_); n = SOLLYA_CONST(10); I = sollya_lib_parse_string("[-1, 1]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("-1678574854834777132325060817371809361210735b-195 + x * (5846006547781923868641738892908189653030528304081b-162 + x * (5186811493742158415982843490921456281458058504887b-212 + x * (-31178700608529053074795655135118567830794991320849b-167 + x * (-17684054797287521526384201972347004604281755888439b-211 + x * (24942872635780650464194733939244297067048845011387b-171 + x * (22016393755287390814121400437369894118518307246709b-210 + x * (-4749415908268213847793669454772779765296429152301b-174 + x * (-45380107924050076762231472980106618449214871580875b-211 + x * (32950198265521156768718284738219033131726498607409b-183 + x * 33095953091156378813051015035960771162990683757215b-212)))))))))"); pold64 = sollya_lib_parse_string("-1678574854834777132325060817371809361210735b-195 + x * (5846006547781923868641738892908189653030528304081b-162 + x * (5186811493742158415982843490921456281458058504887b-212 + x * (-31178700608529053074795655135118567830794991320849b-167 + x * (-17684054797287521526384201972347004604281755888439b-211 + x * (24942872635780650464194733939244297067048845011387b-171 + x * (22016393755287390814121400437369894118518307246709b-210 + x * (-4749415908268213847793669454772779765296429152301b-174 + x * (-45380107924050076762231472980106618449214871580875b-211 + x * (32950198265521156768718284738219033131726498607409b-183 + x * 33095953091156378813051015035960771162990683757215b-212)))))))))"); psvn = sollya_lib_parse_string("-501469618235094668449707646317635919279433b-200 + x * (11692013095563848406205506363824123741381520090139b-163 + x * (35620680907110926409952304136880869962315563985327b-221 + x * (-31178700608529090497338468003375391002953276015721b-167 + x * (-1128778635011195860269996678779233379792952318519b-213 + x * (24942872635784374822466512879970305036022055002917b-171 + x * (11978333137537591148120847557596099349826247948291b-215 + x * (-9498831816665181898799354229729984976210026113385b-175 + x * (-25536101833773061591914574416528636823559165769255b-216 + x * (32950198285237698762568735027923570972010884588359b-183 + x * 19058765346681769783426726535203697116534992847419b-217)))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #13 ================\n"); prec = SOLLYA_CONST(400); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_EXP(SOLLYA_X_)); n = SOLLYA_CONST(25); I = sollya_lib_parse_string("[-1/8, 1/8]"); quality = sollya_lib_parse_string("1e-40"); res = sollya_lib_remez(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("161390617380431786853494948250188242145606612051826469551955379941434960076203657512239965672175150832369427924571327933b-396 + x * (2582249878086908589655919172003011874329705792829223512815518586697713929528373906645973178921345938870139944690922674719b-400 + x * (2582249878086908589655919172003011874329705792829223485685832626402974434496485981425174368061267812180286898481509725671b-401 + x * (1721499918724605726437279448002007916219803861886149410406732804556694110264268799366882772800656159764861209972164484205b-402 + x * (430374979681151431609319862000501979054950965471732012462885573145148550524342099381399012383180900245523589700170524133b-402 + x * (1377199934979684581149823558401606332975843089496293355610634191387301345954222763890552010541004557848043938741178151699b-406 + x * (918133289986456387433215705601070888650562042107828893577378984985802017340780034420418039342184959156809188297142744975b-408 + x * (2098590377111900314133064469945304888344142586006558021664462294500550566006715853849729548334078513627267405790955317995b-412 + x * (2098590377111900314133064469945304888345787506900621321180727067543258071161052823401917796984757736187655589072408299063b-415 + x * (466353417135977847585125437765623308514931894662593265387822335180764499496513126666357989921279120928715711788963003853b-416 + x * (1492330934835129112272401400849994541401556850483751940809697007101719533588456093085148424645368218472711086153465369745b-421 + x * (542665794485501495371782327581816454357534185948580690447803027072292049780254099877219461967508882519283166690502899997b-423 + x * (723554392647335327162376436776575188728320134851889625237160943201761614313054851000351657881568088833377803218059300269b-427 + x * (1781056966516517728399695844345844215372471556174952462382582280718355455253866004121406344397890554175851263316922607569b-432 + x * (508873419004719350971341650169098890399521214954235811771143731737284929667556652712937386546656949766148389278605087449b-434 + x * (2171193254420135897477725344179594326124834570679287455570164950528675466483358002551258133738010625366840419395002970151b-440 + x * (542798313605033974370075337706401928002793026768980861612649913973919428294315062471434161634783741775104301987170180913b-442 + x * (2043476004160127903487494000509588015818708867395743746978714423885089063524101669876222772309992862092677104256708028515b-448 + x * (454105778702250630730985753828746431279635370264398739548474403059075817085065739554350706233574401054757346846349616091b-450 + x * (1529619465102318290396191335466982351668824576419822769979570691541195457819322839083484971691416193070080717307820096573b-456 + x * (19120243313792727007427770378223565295754614486585379700107158437774929323650748483979182572831002782497789306950108115b-454 + x * (1864678966975461754778135403670357609027436049075542111503616505395034722356341051966639526803224699875841442314088899867b-465 + x * (678065070284798591971107193700619246254693193913266466079001229674269542931115396375932917051666799806461803260495692375b-468 + x * (1886789853182169718590609346799899921135706970254622139162469534096421624662899054210479361093776718465635395892988821967b-474 + x * (2516112710027923243369908368888976324181415757063417914592398528680717333744550145476637666909737722020354051992072953817b-479 + x * 50307115488146658682733933302724747268538227244369668577358664240031360337093741929589647579922106753044861061577239247b-478))))))))))))))))))))))))"); pold64 = sollya_lib_parse_string("40347654345107946713373737062547060536401653012956617387988844985358740019050914378059991418043787708092356981303897685b-394 + x * (2582249878086908589655919172003011874329705792829223512815518586697713929528373906645973178921345938870139926226572530419b-400 + x * (2582249878086908589655919172003011874329705792829223485685832626402974434496485981425174368061267812180282125000422255911b-401 + x * (860749959362302863218639724001003958109901930943074705203366402278347055132134399683441386400328079882648031171242699173b-401 + x * (860749959362302863218639724001003958109901930943464024925771146290297101048684198762798024766361800519426800804325423261b-403 + x * (2689843623007196447558249137503137369093443534172447960177019905053322941316841335723734395587899493844083791919392107b-397 + x * (1836266579972912774866431411202141777301124084215657787154757969971604034681560068840836078684369856252482870680526569565b-409 + x * (524647594277975078533266117486326222086035646501639505416115573625137641501678963462432387083804078551349852471424366881b-410 + x * (2098590377111900314133064469945304888345787506900621321180727067543258071161052823401917796924550191857500025280407601681b-415 + x * (932706834271955695170250875531246617029863789325186530775644670361528998993026253332715959587593584168853466498978493359b-417 + x * (746165467417564556136200700424997270700778425241875970404848503550859766794228046542575476250648530710852883838050956953b-420 + x * (2170663177942005981487129310327265817430136743794322761791212108289168199121016399510605899167723492392769350299425793467b-425 + x * (361777196323667663581188218388287594364160067425944812618580471600880807156527425474829065505737939544865331259422833885b-426 + x * (1781056966516517728399695844345844215372471556174952462382582280718355455253865956950153988746212242282738289838998624873b-432 + x * (1017746838009438701942683300338197780799042429908471623542287463474569859335115708752954312779336577592615316744664682969b-435 + x * (2171193254420135897477725344179594326124834570679287455570164950528675466485064591832988938624819005420325820282167690501b-440 + x * (542798313605033974370075337706401928002793026768980861612649913973919428258372130710028952129061378622338285405291189611b-442 + x * (2043476004160127903487494000509588015818708867395743746978714423885089022119822083619278399482467899458468117240299862735b-448 + x * (1816423114809002522923943015314985725118541481057594958193897612236306014723991503049169276327319997307976033324504731927b-452 + x * (1529619465102318290396191335466982351668824576419822769979570691541861911335333959863748886364482689496284252774938835763b-456 + x * (611847786041367264237688652103154089464147663570732150403429069992530290695438702459754703049302351095233153303462760107b-459 + x * (116542435435966359673633462729397350564214753067221381968976030733466566923737898464146533011998759208748515650262757833b-461 + x * (678065070284798591971107193700619246254693193913266466079001447615324869593187070765855363583452756240464620094460862779b-468 + x * (943394926591084859295304673399949960567853485127311069581315469253949592743326197255792712101563256946658640743668942465b-473 + x * (1258056355013961621684954184444488162090707878531708957293674068630135446803760583617837399906318732340257693807559576789b-478 + x * 804913847810346538923742932843595956296611635909914696819171177188150929320002028022779677696622256806586637731183250781b-482))))))))))))))))))))))))"); psvn = sollya_lib_parse_string("322781234760863573706989896500376484291213224103652939103910759882869920152407315024479931344350301664738855877716953233b-397 + x * (2582249878086908589655919172003011874329705792829223512815518586697713929528373906645973178921345938870139917496983436547b-400 + x * (322781234760863573706989896500376484291213224103652935710729078300371804312060747678146796007658476522534400639048326257b-398 + x * (215187489840575715804659931000250989527475482735768676300841600569586763783033599920860346600082019970677345421220989365b-399 + x * (215187489840575715804659931000250989527475482735866006231442786572574275262171049690699506191590450147611339571114332875b-401 + x * (86074995936230286321863972400100395810990193093518334725664636961706334122138922743159500658812783583670405968683128629b-402 + x * (229533322496614096858303926400267722162640510526957223394344746246450504335195008605104509835545644409092901087604544675b-406 + x * (524647594277975078533266117486326222086035646501639505416115573625137641501678963462432387083862534640861338611109593713b-410 + x * (1049295188555950157066532234972652444172893753450310660590363533771629035580526411700958898544937412080047978435348712663b-414 + x * (932706834271955695170250875531246617029863789325186530775644670361528998993026253332715955100711707168416780337610877655b-417 + x * (1492330934835129112272401400849994541401556850483751940809697007101719533588456093085147444937191584321384263876383340095b-421 + x * (2170663177942005981487129310327265817430136743794322761791212108289168199121016399511022765792218903652988214513312856103b-425 + x * (1447108785294670654324752873553150377456640269703779250474321886403523228626109701995372192338698312632456211997150128931b-428 + x * (55658030203641179012490495135807631730389736130467264449455696272448607976683310769804731474744691911992680097598424237b-427 + x * (2035493676018877403885366600676395561598084859816943247084574926949139718670227902558813571256713100640996854633281035007b-436 + x * (2171193254420135897477725344179594326124834570679287455570164950528675466485542447945601193415112392184189585676454336315b-440 + x * (542798313605033974370075337706401928002793026768980861612649913973919428280091492437959294874814210466569463784562330835b-442 + x * (2043476004160127903487494000509588015818708867395743746978714423885089009799059654815955419940954308858052258556151366221b-448 + x * (1816423114809002522923943015314985725118541481057594958193897612236304581434438367655186328396155237501320381759356490615b-452 + x * (1529619465102318290396191335466982351668824576419822769979570691542070957164975815069679148246384821231067099343136098321b-456 + x * (2447391144165469056950754608412616357856590654282928601613716280000378390117407187338735367488534615108410922687299482825b-461 + x * (932339483487730877389067701835178804513718024537771055751808243625667767026354230066961864474108971019815002730940286519b-464 + x * (169516267571199647992776798425154811563673298478316616519750338800836477027932354552473274172640840616069899166552838595b-466 + x * (471697463295542429647652336699974980283926742563655534790671511774808513886873528374826427763415526242932575396729201841b-472 + x * (2516112710027923243369908368888976324181415757063417914589335963128256773414910370734693737723384103402834997935138370453b-479 + x * 1609827695620693077847485865687191912593223271819829393342670614997429234517774491398970587717345702913258027881874277425b-483))))))))))))))))))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #14 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(10); I = sollya_lib_parse_string("[0, 1]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("23384026197294909850223840992809340481141545456185b-164 + x * (23384026197183194624978796257378849130918970768719b-164 + x * (11692013103063455329995041984738330602777159874659b-164 + x * (31178701049749408969300159772616151147056225354243b-167 + x * (31178718928032908530740508502853005869373615788143b-169 + x * (24942641274774123930888945415406111016671104869359b-171 + x * (33264627827944578300293076057231916380765491375043b-174 + x * (18950258324398416999410271318831779761843002307777b-176 + x * (39016347215689526123052797965843565732733417180009b-180 + x * (14014192292950540150415375020363290646996307648069b-182 + x * 2802308148667058909292393693969468428746054200227b-182)))))))))"); pold64 = sollya_lib_parse_string("23384026197294909850223840992809340481141545456185b-164 + x * (23384026197183194624978796257378849130918970768719b-164 + x * (11692013103063455329995041984738330602777159874659b-164 + x * (31178701049749408969300159772616151147056225354243b-167 + x * (31178718928032908530740508502853005869373615788143b-169 + x * (24942641274774123930888945415406111016671104869359b-171 + x * (33264627827944578300293076057231916380765491375043b-174 + x * (18950258324398416999410271318831779761843002307777b-176 + x * (39016347215689526123052797965843565732733417180009b-180 + x * (14014192292950540150415375020363290646996307648069b-182 + x * 2802308148667058909292393693969468428746054200227b-182)))))))))"); psvn = sollya_lib_parse_string("11692013098647454925479766594890768402020389016685b-163 + x * (2923003274647899314022989689912663654170960733739b-161 + x * (23384026206126916717621326407453992440024639124631b-165 + x * (3897337631218641563117791179495583256345586131443b-164 + x * (31178718928039669757532735707023766163548760260885b-169 + x * (24942641274676881997211624204256299106764248859825b-171 + x * (33264627829661543681005336437047562199181910619221b-174 + x * (1184391144687711538704423090650991631165709423125b-172 + x * (4877043417471098209911175115217626323630091258985b-177 + x * (28028384133527983626040751345914065460389879764863b-183 + x * 44836931077334323181376267238444603759641933172525b-186)))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #15 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_COS(SOLLYA_X_)); n = SOLLYA_CONST(15); I = sollya_lib_parse_string("[-1/2, 1/4]"); quality = sollya_lib_parse_string("1e-40"); res = sollya_lib_remez(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("2037035976334486086268445369435520635669474321562577451975655157097896464243257676249067023b-300 + x * (-147022966028724218954630457508230947486371372871749025252274007219232544034284648139415787b-373 + x * (-2037035976334486086267813534277772106898100862459457575607571406931639199411180914730434671b-301 + x * (1644629116256985976487964471064420022272893859535101909440375675266852682766040066939757477b-368 + x * (1358023984222990723447194731402895074478493689559655697573367338981199184886376418609600393b-304 + x * (-1410502123645648389482990176064909235877375828877296670824273606862592472726771255810394497b-361 + x * (-1448558916504522421008699188242670201543249049661405841998293770230912599051296200711718225b-309 + x * (539099188072322128769712711403419973541337473075122764966536485997508305218365952629146421b-354 + x * (827747952288080278806805188627854434960592102720762386536796656170780754344747602124202003b-314 + x * (-797047321997901203825499478107502791492353540573826383432166459902911767841610788036548779b-350 + x * (-1177241534201309254225497658165796336282985949571010147067884030194722915344294071302142951b-321 + x * (2000920995024742776650603097530534335966489792343502135715895342850001531040565868127767b-338 + x * (1141573461565483381928707239907860736890956525739802194008371659491759020811660632918762481b-328 + x * (-1569482484524507248868121030716379419120450572564469525806037183646653943119665927925997873b-347 + x * (-1614534504445457486506762534809318663084383593349434912234239957430267008365062703268491847b-336 + x * (-428026523256046596374630313117538331924801089558422800532774851557691869752368542107371539b-341)))))))))))))))"); pold64 = sollya_lib_parse_string("23384026197294446691258953661820219905513142999997b-164 + x * (-27003854063734750849884821333808741158467473742595b-241 + x * (-23384026197294446691251700549919982557379607705321b-165 + x * (37758832721834729315051124292478278364221823357325b-233 + x * (1948668849774537223221542671047764362309720717625b-165 + x * (-32383540589224596878145415657450161861333033785079b-226 + x * (-33257281702818745252782110178958829782540667558185b-174 + x * (6188555176873990055241491435716663097447123323431b-218 + x * (38008321946068544570195875158242165410103806748873b-180 + x * (-36598618138537720042729778331398363620481658419391b-216 + x * (-3378517512224125484327326252982467949824603981687b-183 + x * (23520713260932955827973162823434838850936138699919b-212 + x * (13104620655457709642089971023765909010985616378681b-192 + x * (-36033550669396221651928873829838168286171617182909b-212 + x * (-9266973579996565980194798904182086061308550848519b-199 + x * (-39308028131999003166237923968395842357350102726509b-208)))))))))))))))"); psvn = sollya_lib_parse_string("2037035976334486086268445369435520635669474321562577451975655157097896464243257671397097913b-300 + x * (-1176183728229793751637043660065847579890970982973992202010414015204696627262467139379764029b-376 + x * (-254629497041810760783476691784721513362262607807432196950946425866454899926397153399607781b-298 + x * (1644629116256985976487964471064420022272893859535101909434031953675864992648891286038789435b-368 + x * (1358023984222990723447194731402895074478493689559655697573367338981199184883856076285964445b-304 + x * (-705251061822824194741495088032454617938687914438648335410722373975668856478821775383473093b-360 + x * (-724279458252261210504349594121335100771624524830702920999146885115456297982352023632567717b-308 + x * (539099188072322128769712711403419973541337473075122764966008962096033302633773492746513937b-354 + x * (413873976144040139403402594313927217480296051360381193268398328085389343770403986416032953b-313 + x * (-778366525388575394360839334089358194816751504466627327570123773750386092643938586073693b-340 + x * (-1177241534201309254225497658165796336282985949571010147067884030191605631226200688044978549b-321 + x * (512235774726334150822554392967816790007421386839936546743185078349352360000905812636728755b-346 + x * (1141573461565483381928707239907860736890956525739802194008371657122260546600652960078317033b-328 + x * (-784741242262253624434060515358189709560225286282234762903248657515610266886473073544093209b-346 + x * (-201816813055682185813345316851164832885547949168679364029279847737577066398917512602560307b-333 + x * (-1712106093024186385498521252470153327699204358233691202130959727264412424137740563374441917b-343)))))))))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #16 ================\n"); prec = SOLLYA_CONST(200); sollya_lib_set_prec(prec); f = SOLLYA_SIN(SOLLYA_X_); w = SOLLYA_CONST(1); n = SOLLYA_CONST(9); I = sollya_lib_parse_string("[-1/2, 1/2]"); quality = sollya_lib_parse_string("1e-40"); res = sollya_lib_remez(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("-86947901283126667b-244 + x * (1606938044258570093798407961449753679676162673259975802224191b-200 + x * (13636820948132726187694106438306066516729639249701307318935b-373 + x * (-1071292029371495160966220394362561448878316413905740061801861b-202 + x * (-111990244421936242081011350812209431978491985227156656276615b-371 + x * (857033575383108922734866118457470597964184028156001905494615b-206 + x * (549321510198610685060667636750153381459576297857810582292629b-370 + x * (-652963883135120024306270284879808076963840233212115246631809b-211 + x * (-1596641875356444035698494903347006028859398613195275802297331b-370 + x * 1153615303801817099389035339506468998354123628680403050940707b-218))))))))"); pold64 = sollya_lib_parse_string("1101702397987b-245 + x * (1606938044258570093798407961449753679676162673259975802192261b-200 + x * (-1391143701206469558761975841650146109945844716683463572892595b-394 + x * (-1071292029371495160966220394362561448878316413905740060751103b-202 + x * (1099410985292744598667779066844465641116416435838202025648363b-390 + x * (857033575383108922734866118457470597964184028156004135919475b-206 + x * (-1161799305280053672790319311141790392778132728191469440939649b-388 + x * (-1305927766270240048612540569759616153927680466426312867749207b-212 + x * (95785462876615352149535634672062757573412322268306607987879b-384 + x * 576807651900908549694517669753234499177061814565628571151813b-217))))))))"); psvn = sollya_lib_parse_string("5119600653300209b-246 + x * (803469022129285046899203980724876839838081336629987901096367b-199 + x * (-201900659293567833992865902103684434843931295566368931355751b-383 + x * (-1071292029371495160966220394362561448878316413905740060766587b-202 + x * (825124598372502403051371387459200482219416407231744562965875b-380 + x * (428516787691554461367433059228735298982092014078002051962743b-205 + x * (-1009147081261682703749474816682212409401787097671013031504583b-377 + x * (-326481941567560012153135142439904038481920116606570763522007b-210 + x * (366558600702259702423292890113706752781180393271089391738525b-374 + x * 576807651900908549694517669753234499177061814562399320345937b-217))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #17 ================\n"); prec = SOLLYA_CONST(200); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_EXP(SOLLYA_ADD(SOLLYA_POW(SOLLYA_COS(SOLLYA_X_), SOLLYA_CONST(2)), SOLLYA_CONST(1)))); n = SOLLYA_CONST(15); I = sollya_lib_parse_string("[1,2]"); quality = sollya_lib_parse_string("1e-40"); res = sollya_lib_remez(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1429129772344635854127522980319603763315581962207637816481495b-197 + x * (1258278747211590164438565899307058663065266450700796107832479b-198 + x * (-1202878917246296858587934180920738608442450055679313080135115b-195 + x * (336837707566227764251712761526301661125280453907774843967313b-192 + x * (-1411317735908160715166251154609539762583930751245877998128451b-193 + x * (1180739419570963338745592334849712845368799300827296718761131b-192 + x * (-1400829552020409071501690715419925186599874201865469197848967b-192 + x * (73774156815960633806864131107864831639587911807241292641453b-188 + x * (-720401733120572588026235911018525487050411202136172115523201b-192 + x * (80348824392035439630284753878261997158325598597726556408827b-190 + x * (-416085524045616662367389437501662300792235411427007456053439b-194 + x * (1516396334943608786362280214735888311251638266120825634313019b-198 + x * (-906020503784862624475910695302721150708070846898444362431877b-200 + x * (1187929837442894851249315789697675967541152927109058015663159b-204 + x * (-1304662018163848750887736589024039856901512670169419818894241b-210 + x * (-729069044992515022585488029954641599182740016769331847317347b-212)))))))))))))))"); pold64 = sollya_lib_parse_string("714564886172317927063761490159801881657790981010465303668201b-196 + x * (1258278747211590164438565899307058663065266454696322711478861b-198 + x * (-18794983081973388415436471576886540756913282158790900538475b-189 + x * (1347350830264911057006851046105206644501121819436710187690425b-194 + x * (-1411317735908160715166251154609539762583930755266304814879647b-193 + x * (590369709785481669372796167424856422684399651964417662529631b-191 + x * (-700414776010204535750845357709962593299937102737693735725465b-191 + x * (1180386509055370140909826097725837306233406592143442790143967b-192 + x * (-720401733120572588026235911018525487050411204371202279457173b-192 + x * (1285581190272567034084556062052191954533209582358572230577769b-194 + x * (-832171048091233324734778875003324601584470826805302456706021b-195 + x * (379099083735902196590570053683972077812909568986721325878589b-196 + x * (-906020503784862624475910695302721150708070855821307509854977b-200 + x * (1187929837442894851249315789697675967541152949455838970639555b-204 + x * (-163082752270481093860967073628004982112689101024071081715501b-207 + x * (-1458138089985030045170976059909283198365479984009101751117121b-213)))))))))))))))"); psvn = sollya_lib_parse_string("714564886172317927063761490159801881657790980941038093582955b-196 + x * (157284843401448770554820737413382332883158307209856051503421b-195 + x * (-601439458623148429293967090460369304221225030011602564440427b-194 + x * (1347350830264911057006851046105206644501121822298593252104795b-194 + x * (-1411317735908160715166251154609539762583930758300920035042625b-193 + x * (295184854892740834686398083712428211342199826569628293662483b-190 + x * (-350207388005102267875422678854981296649968552055066361959517b-190 + x * (1180386509055370140909826097725837306233406594606596965076293b-192 + x * (-180100433280143147006558977754631371762602801520776769328315b-190 + x * (1285581190272567034084556062052191954533209586044565215103713b-194 + x * (-832171048091233324734778875003324601584470829853727191930371b-195 + x * (758198167471804393181140107367944155625819141777467611978757b-197 + x * (-906020503784862624475910695302721150708070862754694236638027b-200 + x * (148491229680361856406164473712209495942644120860204666721477b-201 + x * (-1304662018163848750887736589024039856901512916200236511645811b-210 + x * (-1458138089985030045170976059909283198365479945115367833194563b-213)))))))))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #18 ================\n"); prec = SOLLYA_CONST(200); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_TAN(SOLLYA_X_)); n = SOLLYA_CONST(10); I = sollya_lib_parse_string("[1/4,1/2]"); quality = sollya_lib_parse_string("1e-40"); res = sollya_lib_remez(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1094653698906394439537746354636570119587248281854588161151645b-219 + x * (803437057336964936961730558645726525457791801950137635572287b-199 + x * (902021694368808954079103247381093078629104460444437390593653b-210 + x * (1056889635883223009274070235439924443715342210868409313160023b-201 + x * (1239694968725463472760134669503154963255295977288145886845797b-205 + x * (282532854374805521596477948893958861358073979772606588154531b-202 + x * (745643752889790461146602566612321479694038184243781141844107b-201 + x * (-1171551728340426070339628381549725358789127811584844764092781b-201 + x * (813974777057437275620501698223620379521525143974703084506525b-200 + x * (-573353867651326030295462629700963357884059020692651314615537b-200 + x * 909290520151942024628769491295084023281483044413698733753071b-202)))))))))"); pold64 = sollya_lib_parse_string("1094653698906394439537746354636570119587248281853335503513195b-219 + x * (100429632167120617120216319830715815682223975243767208610777b-196 + x * (112752711796101119259887905922636634828638057555448406782225b-207 + x * (528444817941611504637035117719962221857671105434210743859435b-200 + x * (1239694968725463472760134669503154963255295977287215108448943b-205 + x * (282532854374805521596477948893958861358073979772985177962475b-202 + x * (372821876444895230573301283306160739847019092121678155896023b-200 + x * (-146443966042553258792453547693715669848640976448024424165389b-198 + x * (813974777057437275620501698223620379521525143974379564626113b-200 + x * (-1146707735302652060590925259401926715768118041384923094249915b-201 + x * 113661315018992753078596186411885502910185380551687459548631b-199)))))))))"); psvn = sollya_lib_parse_string("547326849453197219768873177318285059793624140926213615540933b-218 + x * (803437057336964936961730558645726525457791801950137694214707b-199 + x * (902021694368808954079103247381093078629104460442909284056059b-210 + x * (1056889635883223009274070235439924443715342210868431674482813b-201 + x * (1239694968725463472760134669503154963255295977286397777664587b-205 + x * (141266427187402760798238974446979430679036989886667072346625b-201 + x * (372821876444895230573301283306160739847019092121472590934753b-200 + x * (-1171551728340426070339628381549725358789127811583535484887981b-201 + x * (406987388528718637810250849111810189760762571987017133695939b-199 + x * (-573353867651326030295462629700963357884059020692248788608963b-200 + x * 909290520151942024628769491295084023281483044413265206466819b-202)))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #19 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_POW(SOLLYA_X_, SOLLYA_CONST(2.5))); n = SOLLYA_CONST(7); I = sollya_lib_parse_string("[1,2]"); quality = sollya_lib_parse_string("1e-40"); res = sollya_lib_remez(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("30384532462332540461916109637629717389849715629829b-171 + x * (-3988089244372918017948764449242449608854351178857b-165 + x * (12811690968338316880563803186322867131597579395639b-164 + x * (7556488996758112745826292894088723697015390350955b-163 + x * (-28279885329592063848877875417848304249497177042921b-167 + x * (28332008519536597633619239409928869027803601428177b-169 + x * (-581679350863052459602370172446562830505796444253b-166 + x * 22636516313646583057384577954643601031050496316849b-175))))))"); pold64 = sollya_lib_parse_string("30384532462332540461916109637629717389849715629829b-171 + x * (-3988089244372918017948764449242449608854351178857b-165 + x * (12811690968338316880563803186322867131597579395639b-164 + x * (7556488996758112745826292894088723697015390350955b-163 + x * (-28279885329592063848877875417848304249497177042921b-167 + x * (28332008519536597633619239409928869027803601428177b-169 + x * (-581679350863052459602370172446562830505796444253b-166 + x * 22636516313646583057384577954643601031050496316849b-175))))))"); psvn = sollya_lib_parse_string("30384532462332540461916109637629717389849717946267b-171 + x * (-7976178488745836035897528898484899217708702741833b-166 + x * (12811690968338316880563803186322867131597579611375b-164 + x * (30225955987032450983305171576354894788061560871829b-165 + x * (-28279885329592063848877875417848304249497175487639b-167 + x * (14166004259768298816809619704964434513901799366283b-168 + x * (-4653434806904419676818961379572502644046370912779b-169 + x * 45273032627293166114769155909287202062100984362831b-176))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #20 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[1;32769b-15]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519116931250074582514616920029812964033041191732166366208315683368591845444321107391435481b-299 + x * (461432969284079015555143407908324792312068012734235836652935285714259885748478589922847529b-299 + x * (346082648236258546966032322765771598479520265273144739387947665823565730921236322003050251b-299 + x * (-1845774007687049558287217203353987444440450373590070022669568374961280228727054054051744831b-318 + x * 1845774123550678624355073867555708750724188033665817979913979575189149376462087383277483735b-304)))"); pold64 = sollya_lib_parse_string("519116931250074582514616920029812964033041191732166366208315683368591845444321107391435481b-299 + x * (461432969284079015555143407908324792312068012734235836652935285714259885748478589922847529b-299 + x * (346082648236258546966032322765771598479520265273144739387947665823565730921236322003050251b-299 + x * (-1845774007687049558287217203353987444440450373590070022669568374961280228727054054051744831b-318 + x * 1845774123550678624355073867555708750724188033665817979913979575189149376462087383277483735b-304)))"); psvn = sollya_lib_parse_string("1038233862500138128475875956868800306632428862675682390630488920717334717811797516870946673b-300 + x * (1845731877136404353345197824363965360441000443429813536018330496370929583427539223063362555b-301 + x * (1384330592944901753130528148077906569022099276087325621882837928258673245249321784698887013b-301 + x * (-1845773996114896639580051046710666959523710035868209257249170813067311098077820745452470793b-318 + x * 461443530887625512479768353802665452066045555725266067356194961948251810773107744094813571b-302)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #21 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32769b-15;16385b-14]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038237383518400955977367009839350382183594881758703803206614495107092340077049399411473967b-300 + x * (115356481865619084755480970440415065182680519289900564187797650531309907130834307553810629b-297 + x * (346093210646321553188501224312760439606720851854109105733752355133531620668552095227966953b-299 + x * (-1384372810757865863246870774013473664314069086622551199217497615222312154655846982330854047b-316 + x * 922915226483104741726827502416104539849150495728611277321715440071753905846249319975793783b-303)))"); pold64 = sollya_lib_parse_string("1038237383518400955977367009839350382183594881758703803206614495107092340077049399411473967b-300 + x * (115356481865619084755480970440415065182680519289900564187797650531309907130834307553810629b-297 + x * (346093210646321553188501224312760439606720851854109105733752355133531620668552095227966953b-299 + x * (-1384372810757865863246870774013473664314069086622551199217497615222312154655846982330854047b-316 + x * 922915226483104741726827502416104539849150495728611277321715440071753905846249319975793783b-303)))"); psvn = sollya_lib_parse_string("519118691759194958869938336993917153759287839591458508418456567188501184298624872726100021b-299 + x * (922851854924996828995230076840742652224275493891088804975529618856025119380957142467717349b-300 + x * (1384372842585153765895329298580219550625999434847837181868479524834573737784352062675124987b-301 + x * (-21630825122885172715474116247404241411834884929307264625155299577493640947606454518049021b-310 + x * 461457613241508225907237045562485154919767748953769588607075164270235967889768812953893733b-302)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #22 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[16385b-14;32771b-15]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038240905073938809564185146674779242326355205294558935393649861808689793476646895917998267b-300 + x * (1845675539125013381333631624704875717580705390911799805070033763505954280685015813184580603b-301 + x * (346103774023416837754962784984162191045292920130593796757336225574631447590348180153720899b-299 + x * (-576839612789582407852511079083681823850070896509088950771773952643899923582045367370743271b-314 + x * 1845886784100803912445798173029574729693497483658677219270101727506998653158623117662166741b-304)))"); pold64 = sollya_lib_parse_string("1038240905073938809564185146674779242326355205294558935393649861808689793476646895917998267b-300 + x * (1845675539125013381333631624704875717580705390911799805070033763505954280685015813184580603b-301 + x * (346103774023416837754962784984162191045292920130593796757336225574631447590348180153720899b-299 + x * (-576839612789582407852511079083681823850070896509088950771773952643899923582045367370743271b-314 + x * 1845886784100803912445798173029574729693497483658677219270101727506998653158623117662166741b-304)))"); psvn = sollya_lib_parse_string("519120452536963884821173244848899789501807316772478296222446759249397538745336823375809823b-299 + x * (1845675539125101694015605706461280777337860878884343298135109298542343529268042667699390915b-301 + x * (1384415096093534892035237675001300304985047505891202043397431733335781664070540161603927133b-301 + x * (-72104951508279319815327385157588544245642023780291058217791044568868088235988999943887227b-311 + x * 922943392050313663616110263716550440504329578501301689158501826794379977010195644488727179b-303)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #23 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32771b-15;8193b-13]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("259561106791707898293039710633779037559822312544256220625440469079039924536763394805587147b-298 + x * (922823682480649549181635253331914708804520679107862064077300309229451099522323876193792447b-300 + x * (692228676735226522485987916737252642808432088179842657020342965630357539103964428753876415b-300 + x * (-1615200212850920429100564708444107526276999411623835378169119182171976132997095979778353947b-315 + x * 1845943116954514373788808938428499536418675482610443460189101910631877163996812552600989749b-304)))"); pold64 = sollya_lib_parse_string("259561106791707898293039710633779037559822312544256220625440469079039924536763394805587147b-298 + x * (922823682480649549181635253331914708804520679107862064077300309229451099522323876193792447b-300 + x * (692228676735226522485987916737252642808432088179842657020342965630357539103964428753876415b-300 + x * (-1615200212850920429100564708444107526276999411623835378169119182171976132997095979778353947b-315 + x * 1845943116954514373788808938428499536418675482610443460189101910631877163996812552600989749b-304)))"); psvn = sollya_lib_parse_string("1038244427166820551565755973067147360355241963809994452142709091116644179810577841611351723b-300 + x * (1845647364961387421825523150084311418659650045680119146295042340946491798656971546590638849b-301 + x * (1384457353470320573860561042760847856837132747863114232386055905953473938377168004599301501b-301 + x * (-1615200211404136432467443495420435952306923966226610031809054827327191469221677447918295401b-315 + x * 922971558477168891593098006011029689206256949520522791428989183983865797157679647198709371b-303)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #24 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[8193b-13;32773b-15]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519123974898574090744797403189736402875820343090487170676158955496764340486780611707469221b-299 + x * (922809593679210720180621035369069149157607579947128535502043286129863499054654321549929891b-300 + x * (692249807357959376265836253883008438741613503989811188430199387556659219846343306612461139b-300 + x * (-129796835530224738633653365732089398163841549341692837949460264183292272644176377903552073b-311 + x * 922999725763696665770522218372845778462978965972769992666437562934620922571048924718626613b-303)))"); pold64 = sollya_lib_parse_string("519123974898574090744797403189736402875820343090487170676158955496764340486780611707469221b-299 + x * (922809593679210720180621035369069149157607579947128535502043286129863499054654321549929891b-300 + x * (692249807357959376265836253883008438741613503989811188430199387556659219846343306612461139b-300 + x * (-129796835530224738633653365732089398163841549341692837949460264183292272644176377903552073b-311 + x * 922999725763696665770522218372845778462978965972769992666437562934620922571048924718626613b-303)))"); psvn = sollya_lib_parse_string("1038247949797137138198411810152236042027150025677663036108739190315224689959792247512160749b-300 + x * (1845619187358509774604842467695937623435744055179726882540505213863424591596696213891671669b-301 + x * (346124903678946567323148220705739125716697802928868252801660951027451205747159679274351253b-299 + x * (-129796835439795219968125879277623388697425667763867935773182028537886821315832571839139797b-311 + x * 461499862881804183887307941678648489033912962903390891925428506090593169530838666607860305b-302)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #25 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32773b-15;16387b-14]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519125736482478728255637096057110002668939858540359785187786624133365569476475713671526253b-299 + x * (1845591006316039313290133964477145081689851856783638624326715045513173982902030827577833881b-301 + x * (173067734978792493403998750245008224483827818145325564230859424100484935217540396100814837b-298 + x * (-1269163346883319747703475308401267430788360043492450542435418710232211881459685542953257601b-314 + x * 923027893909746625680981117047890403034071303800802551819413990779907053305630158715234517b-303)))"); pold64 = sollya_lib_parse_string("519125736482478728255637096057110002668939858540359785187786624133365569476475713671526253b-299 + x * (1845591006316039313290133964477145081689851856783638624326715045513173982902030827577833881b-301 + x * (173067734978792493403998750245008224483827818145325564230859424100484935217540396100814837b-298 + x * (-1269163346883319747703475308401267430788360043492450542435418710232211881459685542953257601b-314 + x * 923027893909746625680981117047890403034071303800802551819413990779907053305630158715234517b-303)))"); psvn = sollya_lib_parse_string("129781434120618301441886891494335257230404040267358123905067326858051091215008648316707077b-297 + x * (1845591006316127658316151392181817495790692827365561158476937662377994536076814765442483925b-301 + x * (1384541879830207451864381985396784724052974165647827955280948849702069351845888573147632721b-301 + x * (-1269163346159839445350523220045430584331992463269364606309266712655742118702639730565130127b-314 + x * 230756973477414581247598169075781406036468241818904491493725969017677964460473556657443327b-301)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #26 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[16387b-14;32775b-15]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("129781874583791038442386371655888238747214651568295499870462632615589784132048754166817559b-297 + x * (1845562821833811595888707917735803085968761361790239982389832893025681836759066641151458825b-301 + x * (1384584148813992118218502092824141150820996752581358234459863858555017483845838529217963523b-301 + x * (-1499966094994776220877820593486293830101759281321418876570529901431945302547470745474971957b-314 + x * 923056062915433300256084594722183984064011594047292071874020456477159231091344608769404751b-303)))"); pold64 = sollya_lib_parse_string("129781874583791038442386371655888238747214651568295499870462632615589784132048754166817559b-297 + x * (1845562821833811595888707917735803085968761361790239982389832893025681836759066641151458825b-301 + x * (1384584148813992118218502092824141150820996752581358234459863858555017483845838529217963523b-301 + x * (-1499966094994776220877820593486293830101759281321418876570529901431945302547470745474971957b-314 + x * 923056062915433300256084594722183984064011594047292071874020456477159231091344608769404751b-303)))"); psvn = sollya_lib_parse_string("519127498335158630438849944537739003235788144925780928440246986880208839775007090726675597b-299 + x * (1845562821833899951698211738738811196398297128357832936381554474912053986902403755733150637b-301 + x * (1384584148813859610721502078307685229594954837084035891935610394605149725267561036620748249b-301 + x * (-749983047135625881737490579257942200594490085861072813969764878125190845156216961172183267b-313 + x * 1846112125830689993741463623643395385818060771384246846684899278004784835999453500264629919b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #27 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32775b-15;4097b-12]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038258520913329631182690364241114017060837400037458356533335658790054537690003841798971393b-300 + x * (1845534633911397139670115973835376772897004392321237091077394093224806285780259610993209833b-301 + x * (692313210833575385125038578893698920052248173732735304293505140886091558303904658423931033b-300 + x * (-1730782929220944054148482567938745159575983219937856205356812931349500903196307292525312495b-314 + x * 923084232780782923926735159276129795162580209945750248756228435482593334497531568751473455b-303)))"); pold64 = sollya_lib_parse_string("1038258520913329631182690364241114017060837400037458356533335658790054537690003841798971393b-300 + x * (1845534633911397139670115973835376772897004392321237091077394093224806285780259610993209833b-301 + x * (692313210833575385125038578893698920052248173732735304293505140886091558303904658423931033b-300 + x * (-1730782929220944054148482567938745159575983219937856205356812931349500903196307292525312495b-314 + x * 923084232780782923926735159276129795162580209945750248756228435482593334497531568751473455b-303)))"); psvn = sollya_lib_parse_string("1038258520913318582835871273068850476933856497077008462622245762799976468802191980219453751b-300 + x * (230691829238935688283021954504460225955832164377297712195680683883387600919481882172279827b-298 + x * (1384626421667018250622821490040263781999764206537059040333196049055481337520408035865245597b-301 + x * (-1730782928497375439674518395023876303183168123788598217714567069661455459900593836351181579b-314 + x * 461542116390347308923267897641860796326923886221496814784474481383857636583464998032289687b-302)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #28 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[4097b-12;32777b-15]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038262045694030331360107288571033481310845936055396192569911648051621914710101903264082523b-300 + x * (1845506442548454768920116619308727687991614007806277523964786136086245050686512829575540843b-301 + x * (173083587298761427962455984082138996639756712278337144683760477571124473370811720671440019b-298 + x * (-1961613850206626209203908481303935475641262125973990140990420781913512806725438551266796249b-314 + x * 28847262609556929122639338428295863535850904646269632285682528473324343941472711236120323b-298)))"); pold64 = sollya_lib_parse_string("1038262045694030331360107288571033481310845936055396192569911648051621914710101903264082523b-300 + x * (1845506442548454768920116619308727687991614007806277523964786136086245050686512829575540843b-301 + x * (173083587298761427962455984082138996639756712278337144683760477571124473370811720671440019b-298 + x * (-1961613850206626209203908481303935475641262125973990140990420781913512806725438551266796249b-314 + x * 28847262609556929122639338428295863535850904646269632285682528473324343941472711236120323b-298)))"); psvn = sollya_lib_parse_string("1038262045694019281327644184498830223124624538903533316526000381856241934726227296243277141b-300 + x * (461376610637135786574950413989595397954553370890732717751691452128820892831594675084109125b-299 + x * (692334349194979445970636423727417256143496794350725629890609626014440059141562269050675299b-300 + x * (-980806924741506717818749967271003360851474142455928734971270525619689801236608458317349921b-313 + x * 461556201752866711574665321587582831953372202433881041376295584330220815148852534671601019b-302)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #29 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32777b-15;16389b-14]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519132785506249659649202446742857299970401223489329249721092671862612630646516898175534471b-299 + x * (922739123872321640347645406112487210240542424232485865309181772337452142304813401978565157b-300 + x * (1384710978983089614554980944010000553236544926984416074420180493723390468154027020533019691b-301 + x * (-274057357324581485608201308026878795188066463784519077329794224330771414587511991256451199b-311 + x * 923140575090575960281429569584646159509857496569850532443973947641407848668443675573329097b-303)))"); pold64 = sollya_lib_parse_string("519132785506249659649202446742857299970401223489329249721092671862612630646516898175534471b-299 + x * (922739123872321640347645406112487210240542424232485865309181772337452142304813401978565157b-300 + x * (1384710978983089614554980944010000553236544926984416074420180493723390468154027020533019691b-301 + x * (-274057357324581485608201308026878795188066463784519077329794224330771414587511991256451199b-311 + x * 923140575090575960281429569584646159509857496569850532443973947641407848668443675573329097b-303)))"); psvn = sollya_lib_parse_string("1038265571012488267580081747701507502552864186319462514593895218257388262663254136335223063b-300 + x * (1845478247744731668861670841934712268962889917703749792296961594361126466257897183888722895b-301 + x * (1384710978982957070664622808178739493641569277585846232694551334615901588430012311059927601b-301 + x * (-548114714468248737546338914998330532715841724616354653209882304138110057649247627183294433b-312 + x * 1846281150180975297622580633121261037106757793781048506247239550278406622496601732122485233b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #30 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[16389b-14;32779b-15]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519134548434402756767156555739491223749783992943450543735006853556479254975332814832586831b-299 + x * (1845450049499621444821257909088314960970174514175996642815635808483444745999950335490924487b-301 + x * (692376631723210447209723438129936623162107424838590538473236247198461508299268646645182651b-300 + x * (-1211658977517938259044519799457477565612229358925289453861820187775265473657297948543474075b-313 + x * 1846337495070143691660987442551713494094189875111533870425503384713134072129251923138744189b-304)))"); pold64 = sollya_lib_parse_string("519134548434402756767156555739491223749783992943450543735006853556479254975332814832586831b-299 + x * (1845450049499621444821257909088314960970174514175996642815635808483444745999950335490924487b-301 + x * (692376631723210447209723438129936623162107424838590538473236247198461508299268646645182651b-300 + x * (-1211658977517938259044519799457477565612229358925289453861820187775265473657297948543474075b-313 + x * 1846337495070143691660987442551713494094189875111533870425503384713134072129251923138744189b-304)))"); psvn = sollya_lib_parse_string("519134548434397230064956936127972782382520850925244827929853218836000799005904648968273143b-299 + x * (230681256187463730471925329479143461564111131822598486908688243409777897014209001777846291b-298 + x * (1384753263446288338396241827674000401222192703237048413873503052479299741967864085811668019b-301 + x * (-1211658977156087710136727201386554177595012980707457086826797163585841616876353357638132717b-313 + x * 1846337495069967063330522310584765768262905119753111305766662117014275030040591328883128009b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #31 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32779b-15;8195b-13]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("129784077907877229989358408559022727015506092336158554639793545988337383876342394802174983b-297 + x * (1845421847813048003890891490305799586237781940993530060924167527705002243397401652292399469b-301 + x * (346198887945090207628197443350771030623367818935766056578607553395243263683162740596574271b-299 + x * (-1327095570084590892482248321617848024550507093692816293544367981215387497436366034675858795b-313 + x * 923196920839335626205194440883751587784554165940231967259873678081231946926685373213603605b-303)))"); pold64 = sollya_lib_parse_string("129784077907877229989358408559022727015506092336158554639793545988337383876342394802174983b-297 + x * (1845421847813048003890891490305799586237781940993530060924167527705002243397401652292399469b-301 + x * (346198887945090207628197443350771030623367818935766056578607553395243263683162740596574271b-299 + x * (-1327095570084590892482248321617848024550507093692816293544367981215387497436366034675858795b-313 + x * 923196920839335626205194440883751587784554165940231967259873678081231946926685373213603605b-303)))"); psvn = sollya_lib_parse_string("129784077907875848103021982645840680645591515169750492797657603107699291758590525037607837b-297 + x * (1845421847813136413633870703430607052046900605464424242657808159061539467274966216924228471b-301 + x * (346198887945057065588968490245692536303137108974197916838210212886896320833374986466764927b-299 + x * (-331773892430679565249001833341009611065841487884530153968475059201120001178518278702171029b-311 + x * 1846393841678494618689572625930147418834828664945174741628459702119652349640192118655305321b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #32 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[8195b-13;32781b-15]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038276150195205231598046738711326787177258175938486395650936392494584531982139206239184115b-300 + x * (1845393642684581673262535084218842151923675663720046624798283948403833291890563117846027567b-301 + x * (692418921992592502835948587721625658789940441742669912865045829664790944938388346827005581b-300 + x * (-90158700457546112553689981541875410522556478042701804576870900283483380686066639012347575b-309 + x * 1846450190006787079679592267911737638039999300863927226721933815878236131218424338147248637b-304)))"); pold64 = sollya_lib_parse_string("1038276150195205231598046738711326787177258175938486395650936392494584531982139206239184115b-300 + x * (1845393642684581673262535084218842151923675663720046624798283948403833291890563117846027567b-301 + x * (692418921992592502835948587721625658789940441742669912865045829664790944938388346827005581b-300 + x * (-90158700457546112553689981541875410522556478042701804576870900283483380686066639012347575b-309 + x * 1846450190006787079679592267911737638039999300863927226721933815878236131218424338147248637b-304)))"); psvn = sollya_lib_parse_string("259569037548798543705211766440273847552185791158218877274658712831809194210870713833745673b-298 + x * (1845393642684670093795418658443966483959499499111436368344376226006811395102256883883741195b-301 + x * (86552365249065776586275418697003276474007004222425941606188960245812786516813868977909749b-297 + x * (-721269603479421542891763001724490699127240426599723243259503557550901344348923138863739103b-312 + x * 230806273750826305071032548154040822033001931080469550661156849783960847391861039573187439b-301)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #33 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32781b-15;16391b-14]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("259569919416359157263353411595457107631487782846370515248264225272015360527824594363826399b-298 + x * (115335339632117571316138611855828589074790000759090941028960355593604439013749368475305519b-297 + x * (173110017507646127293946241187089077523281184437658863294068384210744593210320374774470417b-298 + x * (-389497472387211515714083349816328582000148764030707683808210862949049454218666003932452401b-311 + x * 923253270027271825969308891928787425004862776651570518692548000594247064900609481273701205b-303)))"); pold64 = sollya_lib_parse_string("259569919416359157263353411595457107631487782846370515248264225272015360527824594363826399b-298 + x * (115335339632117571316138611855828589074790000759090941028960355593604439013749368475305519b-297 + x * (173110017507646127293946241187089077523281184437658863294068384210744593210320374774470417b-298 + x * (-389497472387211515714083349816328582000148764030707683808210862949049454218666003932452401b-311 + x * 923253270027271825969308891928787425004862776651570518692548000594247064900609481273701205b-303)))"); psvn = sollya_lib_parse_string("519139838832712785294744793651849205116744861032104915377745580281528028175234451240326511b-299 + x * (922682717056984786191037842560048361064150737445945643745434647385992378443837872514948331b-300 + x * (346220035015259106481160210084789300105860147286960056577337502664764130028140026088559053b-299 + x * (-778994944593464631590340766081149572734753525688109985050433618675051212447864257923529627b-312 + x * 923253270027183503718302883172076158284093998622393550288930910988039761075871500306073869b-303)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #34 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[16391b-14;32783b-15]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("32446350177305655626960987935742946812325170002522767312791157638567102933964497546634605b-295 + x * (1845337222100605068161869797262611840822189092245241589797562358357269406524276475910977639b-301 + x * (86557652500536780164080755973761565595940061827114833473856294034809846659646798323076743b-297 + x * (-836723808545697939112234873358000218526157193537343518615496583468179871302592432518607973b-312 + x * 923281445910996724629512929320034672478053969908467355594159490598884955120472381156840557b-303)))"); pold64 = sollya_lib_parse_string("32446350177305655626960987935742946812325170002522767312791157638567102933964497546634605b-295 + x * (1845337222100605068161869797262611840822189092245241589797562358357269406524276475910977639b-301 + x * (86557652500536780164080755973761565595940061827114833473856294034809846659646798323076743b-297 + x * (-836723808545697939112234873358000218526157193537343518615496583468179871302592432518607973b-312 + x * 923281445910996724629512929320034672478053969908467355594159490598884955120472381156840557b-303)))"); psvn = sollya_lib_parse_string("1038283205673769919911887025331851626448194016385847841894509031764122005422656005340735635b-300 + x * (1845337222100693510277772059379214171997026956522498276381252238605922803714852220093772511b-301 + x * (1384922440008455878062060395599360175063199452216836309401558676876383623276463266751524873b-301 + x * (-1673447616729456992937773129116785790977599349155587035126314461539364498038188339220166517b-313 + x * 923281445910908399683084596640108535366700793165165294325102396864118622171225970267733811b-303)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #35 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32783b-15;2049b-11]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038286734220307239720704557190733547822740233150419403919615053957098975441209633569686853b-300 + x * (461327251661103022054384452204918703840591591979662598242558653096653916764392844993155701b-299 + x * (173120592978464878523250110885262068594635284888249060190772989330683453346211323951145019b-298 + x * (-894456195135440284141609327212459558817515685541830444876237823904741453274093716964232117b-312 + x * 1846619245309188953313966043331537677921113939942277956355175799511092774945261000205458275b-304)))"); pold64 = sollya_lib_parse_string("1038286734220307239720704557190733547822740233150419403919615053957098975441209633569686853b-300 + x * (461327251661103022054384452204918703840591591979662598242558653096653916764392844993155701b-299 + x * (173120592978464878523250110885262068594635284888249060190772989330683453346211323951145019b-298 + x * (-894456195135440284141609327212459558817515685541830444876237823904741453274093716964232117b-312 + x * 1846619245309188953313966043331537677921113939942277956355175799511092774945261000205458275b-304)))"); psvn = sollya_lib_parse_string("259571683555074044470670818178587812230825000699277365821145378951477594615160521312012945b-298 + x * (461327251661125135281638642126583135701747950391370487202780401118873146425858441195315429b-299 + x * (1384964743827586411485602529357234366644873145451430649939007038090334979300009801889793807b-301 + x * (-1788912389908919596374529568446813066503320970901186502380149207073680919363378497109230273b-313 + x * 461654811327253074507525053023055519156890774698540669390486172381238009591314241263639607b-302)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #36 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[2049b-11;32785b-15]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519145131652542185217707763517530853629482604390562710940905508700387992755729079147518445b-299 + x * (922640393872480403813800177925378752771650649922883158877492845194018341940238359134743875b-300 + x * (692503525759418150173428322959528988817757243557271875472398578625935986248675832975195243b-300 + x * (-1904384209409806576422326601306777292609996776581303101650200507548917112622001929760874319b-313 + x * 461668900129045661844556472102129996706923997672351301852902828249902414108550958025784073b-302)))"); pold64 = sollya_lib_parse_string("519145131652542185217707763517530853629482604390562710940905508700387992755729079147518445b-299 + x * (922640393872480403813800177925378752771650649922883158877492845194018341940238359134743875b-300 + x * (692503525759418150173428322959528988817757243557271875472398578625935986248675832975195243b-300 + x * (-1904384209409806576422326601306777292609996776581303101650200507548917112622001929760874319b-313 + x * 461668900129045661844556472102129996706923997672351301852902828249902414108550958025784073b-302)))"); psvn = sollya_lib_parse_string("1038290263305073306910021357436777192703295793131639015679471380799055303888403647377259899b-300 + x * (1845280787745049271330801829385601924012697162885023235578234014713148345855702891268450563b-301 + x * (692503525759351835754213767281560999066059958340277525211195856674418520000763995276439531b-300 + x * (-1904384209047823516880656194229500482163654355185846454456001023003869726586038172925283849b-313 + x * 1846675600516005986703186368235938935641456969689551398906012084701101900989550520438953497b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #37 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32785b-15;16393b-14]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519146896464090670964582799011339625361876312484969902057815620146269565557712154432556743b-299 + x * (922626282700954902775491508103862824059066665916649646534456723782791265130430024881922389b-300 + x * (1385049363082215960042012852378943648217286866499398277925205949319793323173306680123576807b-301 + x * (-2019863074830693468602081973853455808051455628892417786481781217095389893397674055267503279b-313 + x * 1846731957443027016328279822610383179119522193788621019425224466359106076002887389125705337b-304)))"); pold64 = sollya_lib_parse_string("519146896464090670964582799011339625361876312484969902057815620146269565557712154432556743b-299 + x * (922626282700954902775491508103862824059066665916649646534456723782791265130430024881922389b-300 + x * (1385049363082215960042012852378943648217286866499398277925205949319793323173306680123576807b-301 + x * (-2019863074830693468602081973853455808051455628892417786481781217095389893397674055267503279b-313 + x * 1846731957443027016328279822610383179119522193788621019425224466359106076002887389125705337b-304)))"); psvn = sollya_lib_parse_string("129786724116021284589522791389533938685366914467921888591421991207973332630177941352280335b-297 + x * (922626282700999140024719752636160971604564766039702962600835043546126010405661939156175315b-300 + x * (1385049363082083319064688842536214923187066318823787115934850164088246633478542653277439281b-301 + x * (-2019863074468688320416400256549979086423852482583986753156892163967545423708598910926249469b-313 + x * 923365978721425175130951042714906397326260406560816810752882959071052073486538252895994867b-303)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #38 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[16393b-14;32787b-15]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038297323089667131239012803580298341305713834793419452962509467851074752565013307757925211b-300 + x * (461306084903729408475343382353118217458409264416593990336519465374065385491184797547928089b-299 + x * (692545839259066841913693084826024353050072653235181386446947448934842309391203558978010225b-300 + x * (-133459311678504620865868670843504381990951036478161257103477502586783643932650946540974923b-309 + x * 923394158044887273321169016644805632854020760156510314516944026455765523834141879892028803b-303)))"); pold64 = sollya_lib_parse_string("1038297323089667131239012803580298341305713834793419452962509467851074752565013307757925211b-300 + x * (461306084903729408475343382353118217458409264416593990336519465374065385491184797547928089b-299 + x * (692545839259066841913693084826024353050072653235181386446947448934842309391203558978010225b-300 + x * (-133459311678504620865868670843504381990951036478161257103477502586783643932650946540974923b-309 + x * 923394158044887273321169016644805632854020760156510314516944026455765523834141879892028803b-303)))"); psvn = sollya_lib_parse_string("519148661544828032169112102124382491302320248973389841878107879960509083336343313940712093b-299 + x * (922612169807503059598077710548707697089552788794835145315237686434928383156922308443824261b-300 + x * (1385091678518001030710303067495711898717493641565016862821034871695097707892835720800233351b-301 + x * (-1067674493247023348006567289431697340072623351320326378673614505309301324650879612282858339b-312 + x * 923394158044798937592228773002626337647906422756899856455862690345226526602596370564158317b-303)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #39 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32787b-15;8197b-13]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038300853789610722717431117998072253672745354894008819884081084657820842766590196380279323b-300 + x * (922598055191821408672718405244320303689195084515518394521613676725148488667342591269985053b-300 + x * (692566998913432581940713261525895859800522806638943732672249466782620232752379964505934067b-300 + x * (-1125420972904246892390459207958219498521812206768675803782281061308773968546984562494103223b-312 + x * 1846844676456477726400395348253828365600567546020264505003689125703323360661624398778675999b-304)))"); pold64 = sollya_lib_parse_string("1038300853789610722717431117998072253672745354894008819884081084657820842766590196380279323b-300 + x * (922598055191821408672718405244320303689195084515518394521613676725148488667342591269985053b-300 + x * (692566998913432581940713261525895859800522806638943732672249466782620232752379964505934067b-300 + x * (-1125420972904246892390459207958219498521812206768675803782281061308773968546984562494103223b-312 + x * 1846844676456477726400395348253828365600567546020264505003689125703323360661624398778675999b-304)))"); psvn = sollya_lib_parse_string("1038300853789599654128620928191626403462648427765647651718303542069532121112884285723288433b-300 + x * (57662378449491603544925455540598389841828254930253970683478709975367784588910161998384317b-296 + x * (173141749728341562327965010722690133162605762229874074625618492074160663896377606365502051b-298 + x * (-1125420972723222228136979778653159546641743330995910397970803424610079692501283999601450839b-312 + x * 230855584557037631193855946593581809239481891779533705777169923044462180995976007328272449b-301)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #40 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[8197b-13;32789b-15]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038304385028081108032949485150642166821786168174196617731484907518431023000345463323466159b-300 + x * (1845167877707743853301029862315370528448617293542570314524618753478073554077018916083953161b-301 + x * (1385176321008686108005887213926430898412220922469336951557518747806594802627115704254710467b-301 + x * (-295792744001313994757328807870081597724043138056186589579893810117232836871800794189163391b-310 + x * 57715657454474657665133753721862497061635908198782446418079866976955603901528724645894937b-299)))"); pold64 = sollya_lib_parse_string("1038304385028081108032949485150642166821786168174196617731484907518431023000345463323466159b-300 + x * (1845167877707743853301029862315370528448617293542570314524618753478073554077018916083953161b-301 + x * (1385176321008686108005887213926430898412220922469336951557518747806594802627115704254710467b-301 + x * (-295792744001313994757328807870081597724043138056186589579893810117232836871800794189163391b-310 + x * 57715657454474657665133753721862497061635908198782446418079866976955603901528724645894937b-299)))"); psvn = sollya_lib_parse_string("129788048128508754719487677985588652217030582751023707667272355799437698858583880493596255b-297 + x * (922583938853916180095837031088441763457759698847839528028476278601053096850981462009406181b-300 + x * (1385176321008553430606693149765976057091289953765215499825608320368344363306656509825322385b-301 + x * (-147896371978027533617145218288141306016409404459395846496000360299907460107780973037514293b-309 + x * 1846901038543012363042900512235202156962321012189403619311425629162308800009952703983856039b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #41 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_SUB(SOLLYA_CONST(1), SOLLYA_DIV(SOLLYA_X_, SOLLYA_SIN(SOLLYA_X_))); n = sollya_lib_build_list(SOLLYA_CONST(3), SOLLYA_CONST(5), NULL); I = sollya_lib_parse_string("[-1/8; 1/8]"); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_SIN(SOLLYA_X_)); res = sollya_lib_remez(f,n,I,w, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("x^3 * (-31178697691997280151363863339059689087420918752665b-167 + x^2 * 24930042264710159851265878394398318040604898615191b-171)"); pold64 = sollya_lib_parse_string("x^3 * (-31178697691997280151363863339059689087420918752665b-167 + x^2 * 24930042264710159851265878394398318040604898615191b-171)"); psvn = sollya_lib_parse_string("x^3 * (-15589348845998640053441772179009544391934198160575b-166 + x^2 * 3116255283088763354828944887199725512210848109683b-168)"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #42 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); n = SOLLYA_CONST(6); I = sollya_lib_parse_string("[-1b-5; 1b-5]"); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_COS(SOLLYA_X_)); res = sollya_lib_remez(f,n,I,w, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("5846006549323611671784298104022718622318882177971b-162 + x * (37857459261849734002934198358497784854969213609141b-241 + x * (-23384026197294176595383359674367214160107584181507b-165 + x * (-9650697869631352226371375426638274030332473125873b-226 + x * (31178701574267686389540459856148935530651557981629b-169 + x * (28234185975650294540907970780664381466140252467453b-217 + x * (-33256121763484710174675823588818018912416025532385b-174))))))"); pold64 = sollya_lib_parse_string("5846006549323611671784298104022718622318882177971b-162 + x * (37857459261849734002934198358497784854969213609141b-241 + x * (-23384026197294176595383359674367214160107584181507b-165 + x * (-9650697869631352226371375426638274030332473125873b-226 + x * (31178701574267686389540459856148935530651557981629b-169 + x * (28234185975650294540907970780664381466140252467453b-217 + x * (-33256121763484710174675823588818018912416025532385b-174))))))"); psvn = sollya_lib_parse_string("46768052394588893374274383349804429530193101540037b-165 + x * (37828133831966473044668513721851715408518819224469b-244 + x * (-46768052394588353190751917165222241452885446611429b-166 + x * (-25427705009315713179984612760631972436763477326811b-230 + x * (1948668848391730452279130065687865733407030940519b-165 + x * (19097661627829399791264180875000091942897986598809b-219 + x * (-33256121763550137230701412675274816909367928737119b-174))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #43 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_SIN(SOLLYA_X_); n = SOLLYA_CONST(6); I = sollya_lib_parse_string("[-1b-5; 1b-5]"); res = sollya_lib_remez(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("2148263723907549819858926287983956687732819b-218 + x * (46768052394587948180729798097226792243112547550905b-165 + x * (-25507165977932281269808564943557481990277558638851b-228 + x * (-31178701565420095891159605334409136402204722409641b-167 + x * (25169562694197869368373056758332575493933394803211b-217 + x * (24941946363609599630853575496590807881363811448161b-171 + x * (-13542288596511770213422971032075701040404674585399b-207))))))"); pold64 = sollya_lib_parse_string("2148263723907549819858926287983956687732819b-218 + x * (46768052394587948180729798097226792243112547550905b-165 + x * (-25507165977932281269808564943557481990277558638851b-228 + x * (-31178701565420095891159605334409136402204722409641b-167 + x * (25169562694197869368373056758332575493933394803211b-217 + x * (24941946363609599630853575496590807881363811448161b-171 + x * (-13542288596511770213422971032075701040404674585399b-207))))))"); psvn = sollya_lib_parse_string("-31657351710771318264480101926512972684047b-216 + x * (11692013098646987045182253340122523086369332160129b-163 + x * (45142061063915304495253236000306896279355752461095b-232 + x * (-15589350782710047985431039322670567918156898471475b-166 + x * (-32638902245554706260123356836597206211247789846683b-220 + x * (12470973181805555448555253907066439009244525141935b-170 + x * 43769018414430920138875951265888862687962052230975b-211)))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #44 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = sollya_lib_parse_string("1-(1+x+x^2/2)/exp(x)"); n = sollya_lib_build_list(SOLLYA_CONST(3), SOLLYA_CONST(4), NULL); I = sollya_lib_parse_string("[-1b-8;12167298183958086083256693241475396846566462796809b-171]"); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_EXP(SOLLYA_X_)); res = sollya_lib_remez(f,n,I,w, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("x^3 * (7794680717168470900797342378780962700124730873177b-165 + x * 31179902867931546748200780881663744737011812548003b-169)"); pold64 = sollya_lib_parse_string("x^3 * (7794680717168470900797342378780962700124730873177b-165 + x * 31179902867931546748200780881663744737011812548003b-169)"); psvn = sollya_lib_parse_string("x^3 * (31178722868673883627864298068285024212112392034985b-167 + x * 7794975716982886342439431644725264558026848337299b-167)"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(prec); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tremez.reference000066400000000000000000000167631300174114700203730ustar00rootroot00000000000000=============== Check remez #1 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #2 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #3 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #4 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #5 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #6 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #7 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #8 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #9 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #10 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #11 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #12 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #13 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #14 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #15 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #16 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #17 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #18 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #19 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #20 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #21 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #22 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #23 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #24 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #25 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #26 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #27 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #28 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #29 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #30 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #31 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #32 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #33 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #34 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #35 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #36 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #37 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #38 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #39 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #40 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #41 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #42 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #43 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #44 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK sollya-6.0+ds/tests-lib/trevert.c000066400000000000000000000030671300174114700170350ustar00rootroot00000000000000#include #define A_DIM 11 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The expected error message stating that the revert operation cannot be performed on final-elliptic lists has been caught.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[A_DIM], b[A_DIM]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = sollya_lib_parse_string("[||]"); a[1] = sollya_lib_parse_string("[|1|]"); a[2] = sollya_lib_parse_string("[|1,2|]"); a[3] = sollya_lib_parse_string("[|1,...,17|]"); a[4] = sollya_lib_parse_string("[|1,...,17...|]"); a[5] = sollya_lib_parse_string("[|\"Hello\"|]"); a[6] = sollya_lib_parse_string("[|\"Hello\",\"World\"|]"); a[7] = sollya_lib_parse_string("[|\"land\",\"of\",\"milk\",\"and\",\"honey\"|]"); a[8] = sollya_lib_parse_string("[|\"land\",\"of\",\"milk\",\"and\",\"honey\"...|]"); a[9] = sollya_lib_parse_string("[|17...|]"); a[10] = sollya_lib_parse_string("[|\"Rudolph the red-nosed reindeer\"...|]"); for (i=0;i int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_round_down(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tround_down.reference000066400000000000000000000000021300174114700214020ustar00rootroot00000000000000RDsollya-6.0+ds/tests-lib/tround_to_nearest.c000066400000000000000000000003201300174114700210650ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_round_to_nearest(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tround_to_nearest.reference000066400000000000000000000000021300174114700225760ustar00rootroot00000000000000RNsollya-6.0+ds/tests-lib/tround_towards_zero.c000066400000000000000000000003221300174114700214460ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_round_towards_zero(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tround_towards_zero.reference000066400000000000000000000000021300174114700231550ustar00rootroot00000000000000RZsollya-6.0+ds/tests-lib/tround_up.c000066400000000000000000000003101300174114700173450ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_round_up(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tround_up.reference000066400000000000000000000000021300174114700210570ustar00rootroot00000000000000RUsollya-6.0+ds/tests-lib/troundcoefficients.c000066400000000000000000000064231300174114700212360ustar00rootroot00000000000000#include #define A_DIM 4 #define B_DIM 5 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_GIVEN_FUNCTION_IS_NO_POLYNOMIAL: sollya_lib_printf("The message \"The given function is not a polynomial\" has been caught.\n"); break; case SOLLYA_MSG_ERROR_POLY_COEFF_GETS_ROUNDED: sollya_lib_printf("The message \"A coefficient of a polynomial gets rounded twice\" has been caught.\n"); break; case SOLLYA_MSG_NUM_OF_FORMATS_DOES_NOT_CORRESPOND_TO_DEGREE: sollya_lib_printf("The message \"The number of formats does not correspond to the degree of the polynomial\" has been caught.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[A_DIM], b[B_DIM], c[A_DIM * B_DIM]; int i, j; sollya_obj_t temp; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_PI,SOLLYA_X_),SOLLYA_SIN(SOLLYA_CONST(9.0)))); a[1] = SOLLYA_ADD(SOLLYA_MUL(SOLLYA_PI,SOLLYA_X_),SOLLYA_SIN(SOLLYA_CONST(9.0))); a[2] = sollya_lib_parse_string("1 + x * (1 + x * (0.5 + x * (1 / 6 + x * (1 / 24 + x * (1 / 120 + x * (1 / 720 + x * (1 / 5040 + x * (1 / 40320 + x * (1 / 362880 + x * (1 / 3628800 + x * (1 / 39916800 + x * (1 / 479001600 + x * (1 / 6227020800 + x * (1 / 87178291200 + x / 1307674368000))))))))))))))"); a[3] = sollya_lib_parse_string("1 + x * (1 + x * (1b-1 + x * (1948668849774537224271579776955044026207910057301b-163 + x * (1948668849774537224271579776955044026207910057301b-165 + x * (24942961277114076470676221145024563535461248733457b-171 + x * (2078580106426173039223018428752046961288437394455b-170 + x * (1187760060814956022413153387858312549307678511117b-172 + x * (1187760060814956022413153387858312549307678511117b-175 + x * (527893360362202676628068172381472244136746004941b-177 + x * (1689258753159048565209818151620711181237587215811b-182 + x * (4914207281917232189701289168351159799963890082359b-187 + x * (3276138187944821459800859445567439866642593388239b-190 + x * (504021259683818686123209145471913825637322059729b-191 + x * (4608194374252056558840769330028926405826944546095b-198 + x * 19661629330142107984387282474790085998194963396671b-204))))))))))))))"); b[0] = sollya_lib_parse_string("[| D, DD, DD, D |]"); b[1] = sollya_lib_parse_string("[| D, DD, DD, D... |]"); b[2] = sollya_lib_parse_string("[| D, D, D, HP, SG, D, DE, DD, TD, QD |]"); b[3] = sollya_lib_parse_string("[| D, D, D, HP, SG, D, DE, DD, TD, QD... |]"); b[4] = sollya_lib_parse_string("[| D, D, D, HP, SG, D, DE, DD, TD, QD, D, D, D, D, D, D, D |]"); sollya_lib_set_display(temp = sollya_lib_dyadic()); sollya_lib_clear_obj(temp); for (i=0;i #define A_DIM 15 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[A_DIM]; sollya_obj_t res; sollya_obj_t *resElements; int resElementsNum, endElliptic; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* searchgal(log(x),2,53,15,DD,1b-112); */ for (i=0;i int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_off(); sollya_lib_set_autosimplify(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_autosimplify.reference000066400000000000000000000012551300174114700226370ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = off showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_autosimplify_and_print.c000066400000000000000000000034001300174114700231530ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_off(); sollya_lib_set_autosimplify_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_autosimplify_and_print.reference000066400000000000000000000013461300174114700246760ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Automatic pure tree simplification has been deactivated. Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = off showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_canonical.c000066400000000000000000000033621300174114700203260ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_on(); sollya_lib_set_canonical(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_canonical.reference000066400000000000000000000012531300174114700220370ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = on autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_canonical_and_print.c000066400000000000000000000033741300174114700223670ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_on(); sollya_lib_set_canonical_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_canonical_and_print.reference000066400000000000000000000013431300174114700240750ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Canonical automatic printing output has been activated. Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = on autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_diam.c000066400000000000000000000034041300174114700173060ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_constant_from_double(1e-10); sollya_lib_set_diam(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_diam.reference000066400000000000000000000013141300174114700210200ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 501 diam = 1.00000000000000003643219731549774157916554706559964e-10 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_diam_and_print.c000066400000000000000000000034161300174114700213470ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_constant_from_double(1e-10); sollya_lib_set_diam_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_diam_and_print.reference000066400000000000000000000014421300174114700230600ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 The diameter has been set to 1.00000000000000003643219731549774157916554706559964e-10 Current state of the tool: prec = 165 points = 501 diam = 1.00000000000000003643219731549774157916554706559964e-10 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_dieonerrormode.c000066400000000000000000000033671300174114700214210ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_on(); sollya_lib_set_dieonerrormode(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_dieonerrormode.reference000066400000000000000000000012531300174114700231250ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = on rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_dieonerrormode_and_print.c000066400000000000000000000034011300174114700234440ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_on(); sollya_lib_set_dieonerrormode_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_dieonerrormode_and_print.reference000066400000000000000000000013211300174114700251570ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Die-on-error mode has been activated. Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = on rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_display.c000066400000000000000000000033641300174114700200460ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_binary(); sollya_lib_set_display(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_display.reference000066400000000000000000000013271300174114700215570ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 1.0100101_2 * 2^(7) points = 1.11110101_2 * 2^(8) diam = 1.101000111_2 * 2^(-14) display = binary verbosity = 1_2 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 1_2 * 2^(1) sollya-6.0+ds/tests-lib/tset_display_and_print.c000066400000000000000000000033761300174114700221070ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_binary(); sollya_lib_set_display_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_display_and_print.reference000066400000000000000000000013671300174114700236210ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Display mode is binary numbers. Current state of the tool: prec = 1.0100101_2 * 2^(7) points = 1.11110101_2 * 2^(8) diam = 1.101000111_2 * 2^(-14) display = binary verbosity = 1_2 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 1_2 * 2^(1) sollya-6.0+ds/tests-lib/tset_hopitalrecursions.c000066400000000000000000000034131300174114700221510ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_constant_from_int(10); sollya_lib_set_hopitalrecursions(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_hopitalrecursions.reference000066400000000000000000000012551300174114700236670ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 10 sollya-6.0+ds/tests-lib/tset_hopitalrecursions_and_print.c000066400000000000000000000034251300174114700242120ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_constant_from_int(10); sollya_lib_set_hopitalrecursions_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_hopitalrecursions_and_print.reference000066400000000000000000000013551300174114700257260ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 The number of recursions for Hopital's rule has been set to 10. Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 10 sollya-6.0+ds/tests-lib/tset_midpointmode.c000066400000000000000000000033651300174114700210720ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_on(); sollya_lib_set_midpointmode(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_midpointmode.reference000066400000000000000000000012531300174114700226000ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = on dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_midpointmode_and_print.c000066400000000000000000000033771300174114700231330ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_on(); sollya_lib_set_midpointmode_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_midpointmode_and_print.reference000066400000000000000000000013151300174114700246350ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Midpoint mode has been activated. Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = on dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_points.c000066400000000000000000000034011300174114700177050ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_constant_from_int(201); sollya_lib_set_points(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_points.reference000066400000000000000000000012541300174114700214250ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 201 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_points_and_print.c000066400000000000000000000034131300174114700217460ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_constant_from_int(201); sollya_lib_set_points_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_points_and_print.reference000066400000000000000000000013261300174114700234630ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 The number of points has been set to 201. Current state of the tool: prec = 165 points = 201 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_prec.c000066400000000000000000000033771300174114700173360ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_constant_from_int(200); sollya_lib_set_prec(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_prec.reference000066400000000000000000000012541300174114700210420ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 200 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_prec_and_print.c000066400000000000000000000034111300174114700213610ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_constant_from_int(200); sollya_lib_set_prec_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_prec_and_print.reference000066400000000000000000000013241300174114700230760ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 The precision has been set to 200 bits. Current state of the tool: prec = 200 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_rationalmode.c000066400000000000000000000033651300174114700210600ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_on(); sollya_lib_set_rationalmode(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_rationalmode.reference000066400000000000000000000012531300174114700225660ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = on roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_rationalmode_and_print.c000066400000000000000000000033771300174114700231210ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_on(); sollya_lib_set_rationalmode_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_rationalmode_and_print.reference000066400000000000000000000013151300174114700246230ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Rational mode has been activated. Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = on roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_roundingwarnings.c000066400000000000000000000033721300174114700217760ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_off(); sollya_lib_set_roundingwarnings(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_roundingwarnings.reference000066400000000000000000000012551300174114700235100ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = off hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_roundingwarnings_and_print.c000066400000000000000000000034041300174114700240300ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_off(); sollya_lib_set_roundingwarnings_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_roundingwarnings_and_print.reference000066400000000000000000000013311300174114700255410ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Rounding warning mode has been deactivated. Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = off hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_showmessagenumbers.c000066400000000000000000000033731300174114700223220ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_on(); sollya_lib_set_showmessagenumbers(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_showmessagenumbers.reference000066400000000000000000000012531300174114700240310ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = on taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_showmessagenumbers_and_print.c000066400000000000000000000034051300174114700243540ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_on(); sollya_lib_set_showmessagenumbers_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_showmessagenumbers_and_print.reference000066400000000000000000000013351300174114700260700ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Displaying of message numbers has been activated. Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = on taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_taylorrecursions.c000066400000000000000000000034111300174114700220210ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_constant_from_int(4); sollya_lib_set_taylorrecursions(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_taylorrecursions.reference000066400000000000000000000012541300174114700235400ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 4 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_taylorrecursions_and_print.c000066400000000000000000000034231300174114700240620ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_constant_from_int(4); sollya_lib_set_taylorrecursions_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_taylorrecursions_and_print.reference000066400000000000000000000013561300174114700256010ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 The number of recursions for Taylor evaluation has been set to 4. Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 4 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_timing.c000066400000000000000000000033571300174114700176720ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_on(); sollya_lib_set_timing(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_timing.reference000066400000000000000000000012531300174114700213770ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = on midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_timing_and_print.c000066400000000000000000000033711300174114700217240ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_on(); sollya_lib_set_timing_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_timing_and_print.reference000066400000000000000000000013061300174114700234340ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Timing has been activated. Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = on midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_verbosity.c000066400000000000000000000034031300174114700204210ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_constant_from_int(10); sollya_lib_set_verbosity(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_verbosity.reference000066400000000000000000000012551300174114700221400ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 10 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tset_verbosity_and_print.c000066400000000000000000000034151300174114700224620ustar00rootroot00000000000000#include int state_of_the_tool(void) { sollya_obj_t a[15]; int i; a[0] = sollya_lib_get_prec(); a[1] = sollya_lib_get_points(); a[2] = sollya_lib_get_diam(); a[3] = sollya_lib_get_display(); a[4] = sollya_lib_get_verbosity(); a[5] = sollya_lib_get_canonical(); a[6] = sollya_lib_get_autosimplify(); a[7] = sollya_lib_get_showmessagenumbers(); a[8] = sollya_lib_get_taylorrecursions(); a[9] = sollya_lib_get_timing(); a[10] = sollya_lib_get_midpointmode(); a[11] = sollya_lib_get_dieonerrormode(); a[12] = sollya_lib_get_rationalmode(); a[13] = sollya_lib_get_roundingwarnings(); a[14] = sollya_lib_get_hopitalrecursions(); sollya_lib_printf("Current state of the tool:\n"); sollya_lib_printf(" prec = %b\n", a[0]); sollya_lib_printf(" points = %b\n", a[1]); sollya_lib_printf(" diam = %b\n", a[2]); sollya_lib_printf(" display = %b\n", a[3]); sollya_lib_printf(" verbosity = %b\n", a[4]); sollya_lib_printf(" canonical = %b\n", a[5]); sollya_lib_printf(" autosimplify = %b\n", a[6]); sollya_lib_printf(" showmessagenumbers = %b\n", a[7]); sollya_lib_printf(" taylorrecursions = %b\n", a[8]); sollya_lib_printf(" timing = %b\n", a[9]); sollya_lib_printf(" midpointmode = %b\n", a[10]); sollya_lib_printf(" dieonerrormode = %b\n", a[11]); sollya_lib_printf(" rationalmode = %b\n", a[12]); sollya_lib_printf(" roundingwarnings = %b\n", a[13]); sollya_lib_printf(" hopitalrecursions = %b\n\n", a[14]); for(i=0;i<15;i++) sollya_lib_clear_obj(a[i]); return 0; } int main(void) { sollya_obj_t a; sollya_lib_init(); state_of_the_tool(); a = sollya_lib_constant_from_int(10); sollya_lib_set_verbosity_and_print(a); state_of_the_tool();; sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tset_verbosity_and_print.reference000066400000000000000000000013251300174114700241740ustar00rootroot00000000000000Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 1 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 The verbosity level has been set to 10. Current state of the tool: prec = 165 points = 501 diam = 1.0001659393310546875e-4 display = decimal verbosity = 10 canonical = off autosimplify = on showmessagenumbers = off taylorrecursions = 0 timing = off midpointmode = off dieonerrormode = off rationalmode = off roundingwarnings = on hopitalrecursions = 2 sollya-6.0+ds/tests-lib/tsimplify.c000066400000000000000000000014201300174114700173510ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a[4], b[4]; int i; sollya_lib_init(); a[0] = SOLLYA_SUB(SOLLYA_ADD(SOLLYA_X_,SOLLYA_CONST(2.0)),SOLLYA_ADD(SOLLYA_X_,SOLLYA_CONST(2.0))); a[1] = SOLLYA_ASIN(SOLLYA_EXP(SOLLYA_SUB(SOLLYA_ADD(SOLLYA_X_,SOLLYA_CONST(2.0)),SOLLYA_ADD(SOLLYA_X_,SOLLYA_CONST(2.0))))); a[2] = SOLLYA_SUB(sollya_lib_parse_string("exp(x) - 1"), sollya_lib_parse_string("expm1(x)")); a[3] = SOLLYA_ADD(SOLLYA_CONST(1.0),SOLLYA_CONST(1e-300)); for (i=0;i<4;i++) { b[i] = sollya_lib_simplify(a[i]); } for (i=0;i<4;i++) { sollya_lib_printf("%b can be safely simplified to %b.\n",a[i],b[i]); } for (i=0;i<4;i++) { sollya_lib_clear_obj(a[i]); sollya_lib_clear_obj(b[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tsimplify.reference000066400000000000000000000004721300174114700210730ustar00rootroot00000000000000x + 2 - (x + 2) can be safely simplified to 0. asin(exp(x + 2 - (x + 2))) can be safely simplified to (pi) / 2. expm1(x) - expm1(x) can be safely simplified to 0. 1 + 1.0000000000000000250590918352087596856961468077037e-300 can be safely simplified to 1 + 1.0000000000000000250590918352087596856961468077037e-300. sollya-6.0+ds/tests-lib/tsin.c000066400000000000000000000004141300174114700163100ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_sin(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tsin.reference000066400000000000000000000000101300174114700200140ustar00rootroot00000000000000sin(_x_)sollya-6.0+ds/tests-lib/tsingle.c000066400000000000000000000004171300174114700170030ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_single(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tsingle.reference000066400000000000000000000000131300174114700205070ustar00rootroot00000000000000single(_x_)sollya-6.0+ds/tests-lib/tsingle_obj.c000066400000000000000000000003121300174114700176270ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_single_obj(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tsingle_obj.reference000066400000000000000000000000061300174114700213430ustar00rootroot00000000000000singlesollya-6.0+ds/tests-lib/tsinh.c000066400000000000000000000004151300174114700164610ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_sinh(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tsinh.reference000066400000000000000000000000111300174114700201650ustar00rootroot00000000000000sinh(_x_)sollya-6.0+ds/tests-lib/tsort.c000066400000000000000000000041371300174114700165140ustar00rootroot00000000000000#include #define A_DIM 8 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_EXPR_SHOULD_BE_CONSTANT_AND_IS_NOT_FAITHFUL: sollya_lib_printf("The expected error message stating that the a certain expression should have been a constant and that faithful evaluation is not possible has been caught.\n"); break; case SOLLYA_MSG_FAITHFUL_ROUNDING_FOR_EXPR_THAT_SHOULD_BE_CONST: sollya_lib_printf("The expected error message stating that the a certain expression should have been a constant and that faithful evaluation is possible has been caught.\n"); break; case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The expected error message stating that the sort operation cannot be performed on list containing other objects but constant expressions or that are final-elliptic has been caught.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[A_DIM], b[A_DIM]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = sollya_lib_parse_string("[||]"); a[1] = sollya_lib_parse_string("[|1|]"); a[2] = sollya_lib_parse_string("[|1...|]"); a[3] = sollya_lib_parse_string("[|2, 3, 9, 17, 0, 19, -190, 1664|]"); a[4] = sollya_lib_parse_string("[|sin(pi/3) - sqrt(3)/2, -1, 0, log2(15)/log2(13) - log(15)/log(13), 17 + sin(pi/3) - sqrt(3)/2, 17 + log2(15)/log2(13) - log(15)/log(13)|]"); a[5] = sollya_lib_parse_string("[|2, 3, 9, 17, 0, 19, -190, 1664 ...|]"); a[6] = sollya_lib_parse_string("[|\"land\",\"of\",\"milk\",\"and\",\"honey\"|]"); a[7] = sollya_lib_parse_string("[|\"land\",\"of\",\"milk\",\"and\",\"honey\"...|]"); for (i=0;i int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_sqrt(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tsqrt.reference000066400000000000000000000000111300174114700202150ustar00rootroot00000000000000sqrt(_x_)sollya-6.0+ds/tests-lib/tstring.c000066400000000000000000000013621300174114700170300ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a, b; sollya_lib_init(); a = sollya_lib_string(""); sollya_lib_printf("An empty string: A%bA\n", a); sollya_lib_clear_obj(a); a = sollya_lib_string("foobar"); sollya_lib_printf("A non-empty string: A%bA\n", a); sollya_lib_clear_obj(a); a = sollya_lib_string("cos(_x_)"); b = SOLLYA_COS(SOLLYA_X_); sollya_lib_printf("%b must not be mistaken for %b\n", a, b); sollya_lib_clear_obj(a); sollya_lib_clear_obj(b); a = sollya_lib_build_list(sollya_lib_string("cos(_x_)"), SOLLYA_COS(SOLLYA_X_), NULL); sollya_lib_printf("A list of strings: %b\n", a, b); sollya_lib_clear_obj(a); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tstring.reference000066400000000000000000000002101300174114700205330ustar00rootroot00000000000000An empty string: AA A non-empty string: AfoobarA cos(_x_) must not be mistaken for cos(_x_) A list of strings: [|"cos(_x_)", cos(_x_)|] sollya-6.0+ds/tests-lib/tstring_list_ops.c000066400000000000000000000033671300174114700207530ustar00rootroot00000000000000#include #include #include char *tstring_list_ops_make_char_ptr(char *x) { char *res; res = (char *) calloc(strlen(x) + 1, sizeof(char)); if (res == NULL) exit(1); strcpy(res, x); return res; } int main(void) { sollya_string_list_t list1, iter, list2; char *a, *b, *c, *d, *e; int i; sollya_lib_init(); a = tstring_list_ops_make_char_ptr("of"); b = tstring_list_ops_make_char_ptr("milk"); c = tstring_list_ops_make_char_ptr("and"); d = tstring_list_ops_make_char_ptr("honey"); e = tstring_list_ops_make_char_ptr("land"); list1 = sollya_lib_construct_string_list(a, sollya_lib_construct_string_list(b, sollya_lib_construct_string_list(c, sollya_lib_construct_string_list(d, NULL)))); for (iter = list1, i = 0; !sollya_lib_is_empty_string_list(iter); iter = sollya_lib_get_string_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list1 before copy and modification of the copy: \"%s\"\n", i, sollya_lib_get_string_list_head(iter)); } list2 = sollya_lib_copy_string_list(list1); list2 = sollya_lib_construct_string_list(e, list2); for (iter = list1, i = 0; !sollya_lib_is_empty_string_list(iter); iter = sollya_lib_get_string_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list1 after copy and modification of the copy: \"%s\"\n", i, sollya_lib_get_string_list_head(iter)); } for (iter = list2, i = 0; !sollya_lib_is_empty_string_list(iter); iter = sollya_lib_get_string_list_tail(iter), i++) { sollya_lib_printf("%d-th element in list2 after copy and modification of the copy: \"%s\"\n", i, sollya_lib_get_string_list_head(iter)); } sollya_lib_clear_string_list(list1); sollya_lib_clear_string_list(list2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tstring_list_ops.reference000066400000000000000000000016141300174114700224600ustar00rootroot000000000000000-th element in list1 before copy and modification of the copy: "of" 1-th element in list1 before copy and modification of the copy: "milk" 2-th element in list1 before copy and modification of the copy: "and" 3-th element in list1 before copy and modification of the copy: "honey" 0-th element in list1 after copy and modification of the copy: "of" 1-th element in list1 after copy and modification of the copy: "milk" 2-th element in list1 after copy and modification of the copy: "and" 3-th element in list1 after copy and modification of the copy: "honey" 0-th element in list2 after copy and modification of the copy: "land" 1-th element in list2 after copy and modification of the copy: "of" 2-th element in list2 after copy and modification of the copy: "milk" 3-th element in list2 after copy and modification of the copy: "and" 4-th element in list2 after copy and modification of the copy: "honey" sollya-6.0+ds/tests-lib/tsub.c000066400000000000000000000005311300174114700163100ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2, f; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_constant_from_double(1.0); f = sollya_lib_sub(f1, f2); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tsub.reference000066400000000000000000000000071300174114700200220ustar00rootroot00000000000000_x_ - 1sollya-6.0+ds/tests-lib/tsubpoly.c000066400000000000000000000036461300174114700172260ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a[8], b[5], c[8 * 5]; int i, j; sollya_lib_init(); a[0] = SOLLYA_ADD(SOLLYA_X_, SOLLYA_ADD(SOLLYA_CONST(1.0),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)))); a[1] = SOLLYA_ADD(SOLLYA_MUL(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_CONST(5.0),SOLLYA_X_),SOLLYA_CONST(7.0)),SOLLYA_X_),SOLLYA_CONST(9.0)); a[2] = SOLLYA_ADD(SOLLYA_ADD(SOLLYA_X_, SOLLYA_ADD(SOLLYA_CONST(1.0),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)))), SOLLYA_ADD(SOLLYA_MUL(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_CONST(5.0),SOLLYA_X_),SOLLYA_CONST(7.0)),SOLLYA_X_),SOLLYA_CONST(9.0))); a[3] = SOLLYA_ADD(SOLLYA_X_, SOLLYA_ADD(SOLLYA_EXP(SOLLYA_CONST(1.0)),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)))); a[4] = SOLLYA_ADD(SOLLYA_MUL(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_LOG(SOLLYA_CONST(5.0)),SOLLYA_X_),SOLLYA_ATAN(SOLLYA_CONST(7.0))),SOLLYA_X_),SOLLYA_ERFC(SOLLYA_CONST(9.0))); a[5] = SOLLYA_ADD(SOLLYA_ADD(SOLLYA_X_, SOLLYA_ADD(SOLLYA_EXP(SOLLYA_CONST(1.0)),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)))), SOLLYA_ADD(SOLLYA_MUL(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_LOG(SOLLYA_CONST(5.0)),SOLLYA_X_),SOLLYA_ATAN(SOLLYA_CONST(7.0))),SOLLYA_X_),SOLLYA_ERFC(SOLLYA_CONST(9.0)))); a[6] = SOLLYA_EXP(SOLLYA_X_); a[7] = SOLLYA_POW(SOLLYA_ADD(SOLLYA_X_,SOLLYA_CONST(1.0)),SOLLYA_CONST(15)); b[0] = sollya_lib_parse_string("[|1|]"); b[1] = sollya_lib_parse_string("[|1,3,5|]"); b[2] = sollya_lib_parse_string("[|0,2,7,11...|]"); b[3] = sollya_lib_parse_string("[|1,3,5,17|]"); b[4] = sollya_lib_parse_string("[|0...|]"); for (i=0;i<8;i++) { for (j=0;j<5;j++) { c[i * 5 + j] = sollya_lib_subpoly(a[i],b[j]); sollya_lib_printf("The subpolynomial with monomials %b taken out of %b is %b\n",b[j],a[i],c[i * 5 + j]); } } for (i=0;i<8;i++) { sollya_lib_clear_obj(a[i]); } for (i=0;i<5;i++) { sollya_lib_clear_obj(b[i]); } for (i=0;i<8*5;i++) { sollya_lib_clear_obj(c[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tsubpoly.reference000066400000000000000000000106321300174114700207330ustar00rootroot00000000000000The subpolynomial with monomials [|1|] taken out of _x_ + 1 + _x_^2 is _x_ The subpolynomial with monomials [|1, 3, 5|] taken out of _x_ + 1 + _x_^2 is _x_ The subpolynomial with monomials [|0, 2, 7, 11...|] taken out of _x_ + 1 + _x_^2 is 1 + _x_^2 The subpolynomial with monomials [|1, 3, 5, 17|] taken out of _x_ + 1 + _x_^2 is _x_ The subpolynomial with monomials [|0...|] taken out of _x_ + 1 + _x_^2 is 1 + _x_ * (1 + _x_) The subpolynomial with monomials [|1|] taken out of (5 * _x_ + 7) * _x_ + 9 is 7 * _x_ The subpolynomial with monomials [|1, 3, 5|] taken out of (5 * _x_ + 7) * _x_ + 9 is 7 * _x_ The subpolynomial with monomials [|0, 2, 7, 11...|] taken out of (5 * _x_ + 7) * _x_ + 9 is 9 + _x_^2 * 5 The subpolynomial with monomials [|1, 3, 5, 17|] taken out of (5 * _x_ + 7) * _x_ + 9 is 7 * _x_ The subpolynomial with monomials [|0...|] taken out of (5 * _x_ + 7) * _x_ + 9 is 9 + _x_ * (7 + _x_ * 5) The subpolynomial with monomials [|1|] taken out of _x_ + 1 + _x_^2 + (5 * _x_ + 7) * _x_ + 9 is 8 * _x_ The subpolynomial with monomials [|1, 3, 5|] taken out of _x_ + 1 + _x_^2 + (5 * _x_ + 7) * _x_ + 9 is 8 * _x_ The subpolynomial with monomials [|0, 2, 7, 11...|] taken out of _x_ + 1 + _x_^2 + (5 * _x_ + 7) * _x_ + 9 is 10 + _x_^2 * 6 The subpolynomial with monomials [|1, 3, 5, 17|] taken out of _x_ + 1 + _x_^2 + (5 * _x_ + 7) * _x_ + 9 is 8 * _x_ The subpolynomial with monomials [|0...|] taken out of _x_ + 1 + _x_^2 + (5 * _x_ + 7) * _x_ + 9 is 10 + _x_ * (8 + _x_ * 6) The subpolynomial with monomials [|1|] taken out of _x_ + exp(1) + _x_^2 is _x_ The subpolynomial with monomials [|1, 3, 5|] taken out of _x_ + exp(1) + _x_^2 is _x_ The subpolynomial with monomials [|0, 2, 7, 11...|] taken out of _x_ + exp(1) + _x_^2 is exp(1) + _x_^2 The subpolynomial with monomials [|1, 3, 5, 17|] taken out of _x_ + exp(1) + _x_^2 is _x_ The subpolynomial with monomials [|0...|] taken out of _x_ + exp(1) + _x_^2 is exp(1) + _x_ * (1 + _x_) The subpolynomial with monomials [|1|] taken out of (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is atan(7) * _x_ The subpolynomial with monomials [|1, 3, 5|] taken out of (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is atan(7) * _x_ The subpolynomial with monomials [|0, 2, 7, 11...|] taken out of (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is erfc(9) + _x_^2 * log(5) The subpolynomial with monomials [|1, 3, 5, 17|] taken out of (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is atan(7) * _x_ The subpolynomial with monomials [|0...|] taken out of (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is erfc(9) + _x_ * (atan(7) + _x_ * log(5)) The subpolynomial with monomials [|1|] taken out of _x_ + exp(1) + _x_^2 + (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is (1 + atan(7)) * _x_ The subpolynomial with monomials [|1, 3, 5|] taken out of _x_ + exp(1) + _x_^2 + (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is (1 + atan(7)) * _x_ The subpolynomial with monomials [|0, 2, 7, 11...|] taken out of _x_ + exp(1) + _x_^2 + (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is exp(1) + erfc(9) + _x_^2 * (1 + log(5)) The subpolynomial with monomials [|1, 3, 5, 17|] taken out of _x_ + exp(1) + _x_^2 + (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is (1 + atan(7)) * _x_ The subpolynomial with monomials [|0...|] taken out of _x_ + exp(1) + _x_^2 + (log(5) * _x_ + atan(7)) * _x_ + erfc(9) is exp(1) + erfc(9) + _x_ * (1 + atan(7) + _x_ * (1 + log(5))) The subpolynomial with monomials [|1|] taken out of exp(_x_) is 0 The subpolynomial with monomials [|1, 3, 5|] taken out of exp(_x_) is 0 The subpolynomial with monomials [|0, 2, 7, 11...|] taken out of exp(_x_) is 0 The subpolynomial with monomials [|1, 3, 5, 17|] taken out of exp(_x_) is 0 The subpolynomial with monomials [|0...|] taken out of exp(_x_) is 0 The subpolynomial with monomials [|1|] taken out of (_x_ + 1)^15 is 15 * _x_ The subpolynomial with monomials [|1, 3, 5|] taken out of (_x_ + 1)^15 is _x_ * (15 + _x_^2 * (455 + _x_^2 * 3003)) The subpolynomial with monomials [|0, 2, 7, 11...|] taken out of (_x_ + 1)^15 is 1 + _x_^2 * (105 + _x_^5 * (6435 + _x_^4 * (1365 + _x_ * (455 + _x_ * (105 + _x_ * (15 + _x_)))))) The subpolynomial with monomials [|1, 3, 5, 17|] taken out of (_x_ + 1)^15 is _x_ * (15 + _x_^2 * (455 + _x_^2 * 3003)) The subpolynomial with monomials [|0...|] taken out of (_x_ + 1)^15 is 1 + _x_ * (15 + _x_ * (105 + _x_ * (455 + _x_ * (1365 + _x_ * (3003 + _x_ * (5005 + _x_ * (6435 + _x_ * (6435 + _x_ * (5005 + _x_ * (3003 + _x_ * (1365 + _x_ * (455 + _x_ * (105 + _x_ * (15 + _x_)))))))))))))) sollya-6.0+ds/tests-lib/tsubstitute.c000066400000000000000000000044221300174114700177350ustar00rootroot00000000000000#include int main(void) { sollya_obj_t a[5], b[5], c[5 * 5]; sollya_obj_t t; int i, j; sollya_lib_init(); /* First run with autosimplify = on */ sollya_lib_printf("First run with autosimplify = on\n\n"); t = sollya_lib_on(); sollya_lib_set_autosimplify(t); sollya_lib_clear_obj(t); a[0] = SOLLYA_ADD(SOLLYA_X_, SOLLYA_ADD(SOLLYA_CONST(1.0),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)))); a[1] = SOLLYA_LOG(SOLLYA_X_); a[2] = SOLLYA_CONST(17.0); a[3] = SOLLYA_DIV(SOLLYA_X_,SOLLYA_CONST(13.0)); a[4] = SOLLYA_DIV(SOLLYA_CONST(13.0),SOLLYA_X_); b[0] = SOLLYA_CONST(13.0); b[1] = SOLLYA_EXP(SOLLYA_X_); b[2] = SOLLYA_ADD(SOLLYA_MUL(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_CONST(5.0),SOLLYA_X_),SOLLYA_CONST(7.0)),SOLLYA_X_),SOLLYA_CONST(9.0)); b[3] = SOLLYA_SQRT(SOLLYA_X_); b[4] = SOLLYA_CONST(1001.0); for (i=0;i<5;i++) { for (j=0;j<5;j++) { c[i * 5 + j] = sollya_lib_substitute(a[i],b[j]); sollya_lib_printf("Substituting _x_ in %b with %b yields %b\n",a[i],b[j],c[i * 5 + j]); } } for (i=0;i<5;i++) { sollya_lib_clear_obj(a[i]); sollya_lib_clear_obj(b[i]); } for (i=0;i<5*5;i++) { sollya_lib_clear_obj(c[i]); } /* Second run with autosimplify = off */ sollya_lib_printf("\n\nSecond run with autosimplify = off\n\n"); t = sollya_lib_off(); sollya_lib_set_autosimplify(t); sollya_lib_clear_obj(t); a[0] = SOLLYA_ADD(SOLLYA_X_, SOLLYA_ADD(SOLLYA_CONST(1.0),SOLLYA_POW(SOLLYA_X_,SOLLYA_CONST(2.0)))); a[1] = SOLLYA_LOG(SOLLYA_X_); a[2] = SOLLYA_CONST(17.0); a[3] = SOLLYA_DIV(SOLLYA_X_,SOLLYA_CONST(13.0)); a[4] = SOLLYA_DIV(SOLLYA_CONST(13.0),SOLLYA_X_); b[0] = SOLLYA_CONST(13.0); b[1] = SOLLYA_EXP(SOLLYA_X_); b[2] = SOLLYA_ADD(SOLLYA_MUL(SOLLYA_ADD(SOLLYA_MUL(SOLLYA_CONST(5.0),SOLLYA_X_),SOLLYA_CONST(7.0)),SOLLYA_X_),SOLLYA_CONST(9.0)); b[3] = SOLLYA_SQRT(SOLLYA_X_); b[4] = SOLLYA_CONST(1001.0); for (i=0;i<5;i++) { for (j=0;j<5;j++) { c[i * 5 + j] = sollya_lib_substitute(a[i],b[j]); sollya_lib_printf("Substituting _x_ in %b with %b yields %b\n",a[i],b[j],c[i * 5 + j]); } } for (i=0;i<5;i++) { sollya_lib_clear_obj(a[i]); sollya_lib_clear_obj(b[i]); } for (i=0;i<5*5;i++) { sollya_lib_clear_obj(c[i]); } sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tsubstitute.reference000066400000000000000000000064021300174114700214510ustar00rootroot00000000000000First run with autosimplify = on Substituting _x_ in _x_ + 1 + _x_^2 with 13 yields 183 Substituting _x_ in _x_ + 1 + _x_^2 with exp(_x_) yields exp(_x_) + 1 + exp(_x_)^2 Substituting _x_ in _x_ + 1 + _x_^2 with (5 * _x_ + 7) * _x_ + 9 yields 91 + _x_ * (133 + _x_ * (144 + _x_ * (70 + _x_ * 25))) Substituting _x_ in _x_ + 1 + _x_^2 with sqrt(_x_) yields sqrt(_x_) + 1 + _x_ Substituting _x_ in _x_ + 1 + _x_^2 with 1001 yields 1003003 Substituting _x_ in log(_x_) with 13 yields log(13) Substituting _x_ in log(_x_) with exp(_x_) yields _x_ Substituting _x_ in log(_x_) with (5 * _x_ + 7) * _x_ + 9 yields log(9 + _x_ * (7 + _x_ * 5)) Substituting _x_ in log(_x_) with sqrt(_x_) yields log(sqrt(_x_)) Substituting _x_ in log(_x_) with 1001 yields log(1001) Substituting _x_ in 17 with 13 yields 17 Substituting _x_ in 17 with exp(_x_) yields 17 Substituting _x_ in 17 with (5 * _x_ + 7) * _x_ + 9 yields 17 Substituting _x_ in 17 with sqrt(_x_) yields 17 Substituting _x_ in 17 with 1001 yields 17 Substituting _x_ in _x_ / 13 with 13 yields 1 Substituting _x_ in _x_ / 13 with exp(_x_) yields exp(_x_) / 13 Substituting _x_ in _x_ / 13 with (5 * _x_ + 7) * _x_ + 9 yields 9 / 13 + _x_ * (7 / 13 + _x_ * 5 / 13) Substituting _x_ in _x_ / 13 with sqrt(_x_) yields sqrt(_x_) / 13 Substituting _x_ in _x_ / 13 with 1001 yields 77 Substituting _x_ in 13 / _x_ with 13 yields 1 Substituting _x_ in 13 / _x_ with exp(_x_) yields 13 / exp(_x_) Substituting _x_ in 13 / _x_ with (5 * _x_ + 7) * _x_ + 9 yields 13 / (9 + _x_ * (7 + _x_ * 5)) Substituting _x_ in 13 / _x_ with sqrt(_x_) yields 13 / sqrt(_x_) Substituting _x_ in 13 / _x_ with 1001 yields 13 / 1001 Second run with autosimplify = off Substituting _x_ in _x_ + 1 + _x_^2 with 13 yields 183 Substituting _x_ in _x_ + 1 + _x_^2 with exp(_x_) yields exp(_x_) + 1 + exp(_x_)^2 Substituting _x_ in _x_ + 1 + _x_^2 with (5 * _x_ + 7) * _x_ + 9 yields 91 + _x_ * (133 + _x_ * (144 + _x_ * (70 + _x_ * 25))) Substituting _x_ in _x_ + 1 + _x_^2 with sqrt(_x_) yields sqrt(_x_) + 1 + sqrt(_x_)^2 Substituting _x_ in _x_ + 1 + _x_^2 with 1001 yields 1003003 Substituting _x_ in log(_x_) with 13 yields log(13) Substituting _x_ in log(_x_) with exp(_x_) yields log(exp(_x_)) Substituting _x_ in log(_x_) with (5 * _x_ + 7) * _x_ + 9 yields log((5 * _x_ + 7) * _x_ + 9) Substituting _x_ in log(_x_) with sqrt(_x_) yields log(sqrt(_x_)) Substituting _x_ in log(_x_) with 1001 yields log(1001) Substituting _x_ in 17 with 13 yields 17 Substituting _x_ in 17 with exp(_x_) yields 17 Substituting _x_ in 17 with (5 * _x_ + 7) * _x_ + 9 yields 17 Substituting _x_ in 17 with sqrt(_x_) yields 17 Substituting _x_ in 17 with 1001 yields 17 Substituting _x_ in _x_ / 13 with 13 yields 1 Substituting _x_ in _x_ / 13 with exp(_x_) yields exp(_x_) / 13 Substituting _x_ in _x_ / 13 with (5 * _x_ + 7) * _x_ + 9 yields ((5 * _x_ + 7) * _x_ + 9) / 13 Substituting _x_ in _x_ / 13 with sqrt(_x_) yields sqrt(_x_) / 13 Substituting _x_ in _x_ / 13 with 1001 yields 77 Substituting _x_ in 13 / _x_ with 13 yields 1 Substituting _x_ in 13 / _x_ with exp(_x_) yields 13 / exp(_x_) Substituting _x_ in 13 / _x_ with (5 * _x_ + 7) * _x_ + 9 yields 13 / ((5 * _x_ + 7) * _x_ + 9) Substituting _x_ in 13 / _x_ with sqrt(_x_) yields 13 / sqrt(_x_) Substituting _x_ in 13 / _x_ with 1001 yields 13 / 1001 sollya-6.0+ds/tests-lib/tsup.c000066400000000000000000000032571300174114700163360ustar00rootroot00000000000000#include int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); if (message == SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED) sollya_lib_printf("The following test produces a typing error\n"); else sollya_lib_printf("Unexpected message\n"); return 0; } int main(void) { sollya_obj_t a, res; double nan = 0.0/0.0; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a = SOLLYA_CONST(2); res = sollya_lib_sup(a); sollya_lib_printf("sup of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_CONST(3)); res = sollya_lib_sup(a); sollya_lib_printf("sup of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_LOG(SOLLYA_NEG(SOLLYA_CONST(3))); res = sollya_lib_sup(a); sollya_lib_printf("sup of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_CONST(nan); res = sollya_lib_sup(a); sollya_lib_printf("sup of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_parse_string("[1,2]"); res = sollya_lib_sup(a); sollya_lib_printf("sup of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = SOLLYA_X_; res = sollya_lib_sup(a); sollya_lib_printf("sup of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); a = sollya_lib_string("Hello"); res = sollya_lib_sup(a); sollya_lib_printf("sup of %b is %b\n", a, res); sollya_lib_clear_obj(a); sollya_lib_clear_obj(res); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tsup.reference000066400000000000000000000003421300174114700200420ustar00rootroot00000000000000sup of 2 is 2 sup of 1 / 3 is 1 / 3 sup of log(-3) is log(-3) sup of NaN is NaN sup of [1;2] is 2 The following test produces a typing error sup of _x_ is error The following test produces a typing error sup of Hello is error sollya-6.0+ds/tests-lib/ttail.c000066400000000000000000000030521300174114700164510ustar00rootroot00000000000000#include #define A_DIM 11 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The expected error message stating that the tail operation on an empty list cannot be performed has been caught.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } int main(void) { sollya_obj_t a[A_DIM], b[A_DIM]; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); a[0] = sollya_lib_parse_string("[||]"); a[1] = sollya_lib_parse_string("[|1|]"); a[2] = sollya_lib_parse_string("[|1,2|]"); a[3] = sollya_lib_parse_string("[|1,...,17|]"); a[4] = sollya_lib_parse_string("[|1,...,17...|]"); a[5] = sollya_lib_parse_string("[|\"Hello\"|]"); a[6] = sollya_lib_parse_string("[|\"Hello\",\"World\"|]"); a[7] = sollya_lib_parse_string("[|\"land\",\"of\",\"milk\",\"and\",\"honey\"|]"); a[8] = sollya_lib_parse_string("[|\"land\",\"of\",\"milk\",\"and\",\"honey\"...|]"); a[9] = sollya_lib_parse_string("[|17...|]"); a[10] = sollya_lib_parse_string("[|\"Rudolph the red-nosed reindeer\"...|]"); for (i=0;i int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_tan(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/ttan.reference000066400000000000000000000000101300174114700200050ustar00rootroot00000000000000tan(_x_)sollya-6.0+ds/tests-lib/ttanh.c000066400000000000000000000004151300174114700164520ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_tanh(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/ttanh.reference000066400000000000000000000000111300174114700201560ustar00rootroot00000000000000tanh(_x_)sollya-6.0+ds/tests-lib/ttriple_double.c000066400000000000000000000004261300174114700203530ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f1, f2; sollya_lib_init(); f1 = sollya_lib_free_variable(); f2 = sollya_lib_triple_double(f1); sollya_lib_printf("%b", f2); sollya_lib_clear_obj(f1); sollya_lib_clear_obj(f2); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/ttriple_double.reference000066400000000000000000000000211300174114700220560ustar00rootroot00000000000000tripledouble(_x_)sollya-6.0+ds/tests-lib/ttriple_double_obj.c000066400000000000000000000003211300174114700211770ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_triple_double_obj(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/ttriple_double_obj.reference000066400000000000000000000000141300174114700227120ustar00rootroot00000000000000tripledoublesollya-6.0+ds/tests-lib/ttrue.c000066400000000000000000000003041300174114700164740ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_true(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/ttrue.reference000066400000000000000000000000041300174114700202050ustar00rootroot00000000000000truesollya-6.0+ds/tests-lib/tv_annotatefunction.c000066400000000000000000000027141300174114700214300ustar00rootroot00000000000000#include sollya_obj_t stupid_wrapper(sollya_obj_t arg1, sollya_obj_t arg2, sollya_obj_t arg3, sollya_obj_t arg4, ...) { va_list va; sollya_obj_t a; va_start(va, arg4); a = sollya_lib_v_annotatefunction(arg1, arg2, arg3, arg4, va); va_end(va); return a; } int main(void) { sollya_obj_t f, g, h, dom, delta; mpfr_t x, y; sollya_lib_init(); f = sollya_lib_parse_string("exp(_x_)"); g = sollya_lib_parse_string("function(proc(X,n,p) { var res, oldPrec;\n" " oldPrec = prec;\n" " prec = p!;\n" " \"Using procedure function exponential\";\n" " res = exp(X);\n" " prec = oldPrec!;\n" " return res;\n" " })"); dom = sollya_lib_parse_string("[-5;5]"); delta = sollya_lib_parse_string("[0]"); h = stupid_wrapper(f, g, dom, delta, NULL); mpfr_init2(x, 24); mpfr_init2(y, 24); mpfr_set_si(x, 2, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, h, x, NULL); mpfr_set_si(x, 6, GMP_RNDN); sollya_lib_evaluate_function_at_point(y, h, x, NULL); mpfr_clear(y); mpfr_clear(x); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g); sollya_lib_clear_obj(dom); sollya_lib_clear_obj(delta); sollya_lib_clear_obj(h); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tv_annotatefunction.reference000066400000000000000000000000001300174114700231260ustar00rootroot00000000000000sollya-6.0+ds/tests-lib/tv_build_end_elliptic_list.c000066400000000000000000000050561300174114700227200ustar00rootroot00000000000000#include #include sollya_obj_t stupid_wrapper(int arg1, ...) { va_list va; sollya_obj_t a; va_start(va, arg1); a = sollya_lib_v_build_end_elliptic_list(va); va_end(va); return a; } int main(void) { sollya_obj_t listobj, tmp; sollya_lib_init(); /* Empty end-elliptic list from nothing: expecting error */ listobj = stupid_wrapper(-1, NULL); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* Empty end-elliptic list with an invalid pointer after NULL: expecting error */ listobj = stupid_wrapper(-1, NULL, 0x1); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* List with one non-integer element, with invalide pointer after NULL */ listobj = stupid_wrapper(-1, SOLLYA_COS(SOLLYA_X_), NULL, 0x1); sollya_lib_printf("%b. ", listobj); if (sollya_lib_get_element_in_list(&tmp, listobj, 2)) { sollya_lib_printf("listobj[2] is %b\n", tmp); sollya_lib_clear_obj(tmp); } else sollya_lib_printf("listobj[2] does not exist.\n"); sollya_lib_clear_obj(listobj); /* List with one integer element, with invalid pointer after NULL*/ listobj = stupid_wrapper(-1, SOLLYA_CONST(3.), NULL, 0x1); sollya_lib_printf("%b. ", listobj); if (sollya_lib_get_element_in_list(&tmp, listobj, 2)) { sollya_lib_printf("listobj[2] is %b\n", tmp); sollya_lib_clear_obj(tmp); } else sollya_lib_printf("listobj[2] does not exist.\n"); sollya_lib_clear_obj(listobj); /* List from an array. Ends with a non-integer element */ listobj = stupid_wrapper(-1, SOLLYA_COS(SOLLYA_X_), SOLLYA_CONST(3.), sollya_lib_double_obj(), NULL); sollya_lib_printf("%b. ", listobj); if (sollya_lib_get_element_in_list(&tmp, listobj, 4)) { sollya_lib_printf("listobj[2] is %b\n", tmp); sollya_lib_clear_obj(tmp); } else sollya_lib_printf("listobj[2] does not exist.\n"); sollya_lib_clear_obj(listobj); /* List from an array with 2 elements of the array. Ends with an integer element */ listobj = stupid_wrapper(-1, SOLLYA_COS(SOLLYA_X_), SOLLYA_CONST(3.), NULL); sollya_lib_printf("%b. ", listobj); if (sollya_lib_get_element_in_list(&tmp, listobj, 4)) { sollya_lib_printf("listobj[4] is %b\n", tmp); sollya_lib_clear_obj(tmp); } else sollya_lib_printf("listobj[4] does not exist.\n"); sollya_lib_clear_obj(listobj); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tv_build_end_elliptic_list.reference000066400000000000000000000002431300174114700244250ustar00rootroot00000000000000error error [|cos(_x_)...|]. listobj[2] is cos(_x_) [|3...|]. listobj[2] is 5 [|cos(_x_), 3, double...|]. listobj[2] is double [|cos(_x_), 3...|]. listobj[4] is 6 sollya-6.0+ds/tests-lib/tv_build_list.c000066400000000000000000000021021300174114700201720ustar00rootroot00000000000000#include #include sollya_obj_t stupid_wrapper(int arg1, ...) { va_list va; sollya_obj_t a; va_start(va, arg1); a = sollya_lib_v_build_list(va); va_end(va); return a; } int main(void) { sollya_obj_t listobj; sollya_lib_init(); /* Empty list from nothing */ listobj = stupid_wrapper(-1, NULL); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* Empty list with invalid pointers after NULL */ listobj = stupid_wrapper(-1, NULL, 0x1); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* List with one element */ listobj = stupid_wrapper(-1, SOLLYA_CONST(3.), NULL, 0x1); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); /* List of three elements */ listobj = stupid_wrapper(-1, SOLLYA_COS(SOLLYA_X_), SOLLYA_CONST(3.), sollya_lib_double_obj(), NULL); sollya_lib_printf("%b\n", listobj); sollya_lib_clear_obj(listobj); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tv_build_list.reference000066400000000000000000000000521300174114700217100ustar00rootroot00000000000000[| |] [| |] [|3|] [|cos(_x_), 3, double|] sollya-6.0+ds/tests-lib/tv_construct_function.c000066400000000000000000000346101300174114700220020ustar00rootroot00000000000000#include #include #include #include int stupid_wrapper(sollya_obj_t *f, sollya_base_function_t type, ...) { int res; va_list va; va_start(va, type); res = sollya_lib_v_construct_function(f, type, va); va_end(va); return res; } void euler_gamma(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } int stupid1(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } char *type_to_string(sollya_base_function_t type) { switch (type) { case SOLLYA_BASE_FUNC_ASINH: return "SOLLYA_BASE_FUNC_ASINH"; case SOLLYA_BASE_FUNC_LIBRARYCONSTANT: return "SOLLYA_BASE_FUNC_LIBRARYCONSTANT"; case SOLLYA_BASE_FUNC_CONSTANT: return "SOLLYA_BASE_FUNC_CONSTANT"; case SOLLYA_BASE_FUNC_PI: return "SOLLYA_BASE_FUNC_PI"; case SOLLYA_BASE_FUNC_LIBRARYFUNCTION: return "SOLLYA_BASE_FUNC_LIBRARYFUNCTION"; case SOLLYA_BASE_FUNC_PROCEDUREFUNCTION: return "SOLLYA_BASE_FUNC_PROCEDUREFUNCTION"; case SOLLYA_BASE_FUNC_POW: return "SOLLYA_BASE_FUNC_POW"; default: return "UNKNOWN"; } } int main(void) { sollya_base_function_t type; sollya_obj_t f, obj1, obj2, obj3; int res; sollya_lib_init(); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_ASINH; obj1 = SOLLYA_X_; res = stupid_wrapper(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_ASINH; obj1 = SOLLYA_X_; obj2 = sollya_lib_parse_string("[|1,2|]"); res = stupid_wrapper(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_ASINH; obj1 = sollya_lib_parse_string("[1,2]"); obj2 = SOLLYA_X_; res = stupid_wrapper(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_ASINH; obj1 = sollya_lib_parse_string("[|1,2|]"); obj2 = SOLLYA_X_; res = stupid_wrapper(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_LIBRARYCONSTANT; obj1 = SOLLYA_X_; res = stupid_wrapper(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_LIBRARYCONSTANT; obj1 = sollya_lib_parse_string("[|1,2|]"); res = stupid_wrapper(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_LIBRARYCONSTANT; obj1 = sollya_lib_libraryconstant("superconst", euler_gamma); res = stupid_wrapper(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_CONSTANT; obj1 = sollya_lib_libraryconstant("superconst", euler_gamma); res = stupid_wrapper(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_CONSTANT; obj1 = SOLLYA_CONST(3.0); res = stupid_wrapper(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_PI; res = stupid_wrapper(&f, type, NULL); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_PI; obj1 = SOLLYA_CONST(3.0); res = stupid_wrapper(&f, type, obj1); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_LIBRARYFUNCTION; obj1 = SOLLYA_CONST(3.0); obj2 = sollya_lib_parse_string("[|1,2|]"); res = stupid_wrapper(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_LIBRARYFUNCTION; obj1 = SOLLYA_CONST(3.0); obj2 = sollya_lib_build_function_libraryfunction(SOLLYA_X_, "superfunc", stupid1); res = stupid_wrapper(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_LIBRARYFUNCTION; obj1 = SOLLYA_CONST(3.0); obj2 = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "superfunc", stupid1); res = stupid_wrapper(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_PROCEDUREFUNCTION; obj1 = sollya_lib_parse_string("[1,2]"); obj2 = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "superfunc", stupid1); res = stupid_wrapper(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_PROCEDUREFUNCTION; obj1 = sollya_lib_parse_string("[1,2]"); obj2 = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); obj2 = sollya_lib_build_function_procedurefunction(SOLLYA_X_, obj2); res = stupid_wrapper(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_PROCEDUREFUNCTION; obj1 = SOLLYA_CONST(3.0); obj2 = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); obj2 = sollya_lib_build_function_procedurefunction(SOLLYA_COS(SOLLYA_X_), obj2); res = stupid_wrapper(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_POW; obj1 = SOLLYA_X_; obj2 = SOLLYA_CONST(3.0); res = stupid_wrapper(&f, type, obj1, obj2); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); f = NULL; obj1 = NULL; obj2 = NULL; obj3 = NULL; res = -1; type = SOLLYA_BASE_FUNC_POW; obj1 = SOLLYA_X_; obj2 = SOLLYA_X_; obj3 = sollya_lib_parse_string("[|1,2|]"); res = stupid_wrapper(&f, type, obj1, obj2, obj3); if (res) sollya_lib_printf("Constructed %b from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); else sollya_lib_printf("Impossible to construct (f=%b) from type=%s, obj1=%b, obj2=%b and obj3=%b\n", f, type_to_string(type), obj1, obj2, obj3); if (f != NULL) sollya_lib_clear_obj(f); if (obj1 != NULL) sollya_lib_clear_obj(obj1); if (obj2 != NULL) sollya_lib_clear_obj(obj2); if (obj3 != NULL) sollya_lib_clear_obj(obj3); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tv_construct_function.reference000066400000000000000000000044711300174114700235200ustar00rootroot00000000000000Constructed asinh(_x_) from type=SOLLYA_BASE_FUNC_ASINH, obj1=_x_, obj2=NULL and obj3=NULL Constructed asinh(_x_) from type=SOLLYA_BASE_FUNC_ASINH, obj1=_x_, obj2=[|1, 2|] and obj3=NULL Constructed [0.88137358701954302523260932497979230902816032826163;1.443635475178810342493276740273105269405553003157] from type=SOLLYA_BASE_FUNC_ASINH, obj1=[1;2], obj2=_x_ and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_ASINH, obj1=[|1, 2|], obj2=_x_ and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_LIBRARYCONSTANT, obj1=_x_, obj2=NULL and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_LIBRARYCONSTANT, obj1=[|1, 2|], obj2=NULL and obj3=NULL Constructed superconst from type=SOLLYA_BASE_FUNC_LIBRARYCONSTANT, obj1=superconst, obj2=NULL and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_CONSTANT, obj1=superconst, obj2=NULL and obj3=NULL Constructed 3 from type=SOLLYA_BASE_FUNC_CONSTANT, obj1=3, obj2=NULL and obj3=NULL Constructed pi from type=SOLLYA_BASE_FUNC_PI, obj1=NULL, obj2=NULL and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_PI, obj1=3, obj2=NULL and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_LIBRARYFUNCTION, obj1=3, obj2=[|1, 2|] and obj3=NULL Constructed 0 from type=SOLLYA_BASE_FUNC_LIBRARYFUNCTION, obj1=3, obj2=superfunc and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_LIBRARYFUNCTION, obj1=3, obj2=superfunc(cos(_x_)) and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_PROCEDUREFUNCTION, obj1=[1;2], obj2=superfunc(cos(_x_)) and obj3=NULL Constructed [2.7182818284590452353602874713526624977572470936999;7.3890560989306502272304274605750078131803155705519] from type=SOLLYA_BASE_FUNC_PROCEDUREFUNCTION, obj1=[1;2], obj2=function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; }) and obj3=NULL Impossible to construct (f=NULL) from type=SOLLYA_BASE_FUNC_PROCEDUREFUNCTION, obj1=3, obj2=(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; }))(cos(_x_)) and obj3=NULL Constructed _x_^3 from type=SOLLYA_BASE_FUNC_POW, obj1=_x_, obj2=3 and obj3=NULL Constructed _x_^_x_ from type=SOLLYA_BASE_FUNC_POW, obj1=_x_, obj2=_x_ and obj3=[|1, 2|] sollya-6.0+ds/tests-lib/tv_decompose_function.c000066400000000000000000000431461300174114700217400ustar00rootroot00000000000000#include #include #include int stupid_wrapper(sollya_obj_t f, sollya_base_function_t *type, int *n, ...) { va_list va; int res; va_start(va, n); res = sollya_lib_v_decompose_function(f, type, n, va); va_end(va); return res; } char *pretty_print(sollya_base_function_t type) { switch(type) { case SOLLYA_BASE_FUNC_ABS: return "SOLLYA_BASE_FUNC_ABS"; case SOLLYA_BASE_FUNC_ACOS: return "SOLLYA_BASE_FUNC_ACOS"; case SOLLYA_BASE_FUNC_ACOSH: return "SOLLYA_BASE_FUNC_ACOSH"; case SOLLYA_BASE_FUNC_ADD: return "SOLLYA_BASE_FUNC_ADD"; case SOLLYA_BASE_FUNC_ASIN: return "SOLLYA_BASE_FUNC_ASIN"; case SOLLYA_BASE_FUNC_ASINH: return "SOLLYA_BASE_FUNC_ASINH"; case SOLLYA_BASE_FUNC_ATAN: return "SOLLYA_BASE_FUNC_ATAN"; case SOLLYA_BASE_FUNC_ATANH: return "SOLLYA_BASE_FUNC_ATANH"; case SOLLYA_BASE_FUNC_CEIL: return "SOLLYA_BASE_FUNC_CEIL"; case SOLLYA_BASE_FUNC_CONSTANT: return "SOLLYA_BASE_FUNC_CONSTANT"; case SOLLYA_BASE_FUNC_COS: return "SOLLYA_BASE_FUNC_COS"; case SOLLYA_BASE_FUNC_COSH: return "SOLLYA_BASE_FUNC_COSH"; case SOLLYA_BASE_FUNC_DIV: return "SOLLYA_BASE_FUNC_DIV"; case SOLLYA_BASE_FUNC_DOUBLE: return "SOLLYA_BASE_FUNC_DOUBLE"; case SOLLYA_BASE_FUNC_DOUBLEDOUBLE: return "SOLLYA_BASE_FUNC_DOUBLEDOUBLE"; case SOLLYA_BASE_FUNC_DOUBLEEXTENDED: return "SOLLYA_BASE_FUNC_DOUBLEEXTENDED"; case SOLLYA_BASE_FUNC_ERF: return "SOLLYA_BASE_FUNC_ERF"; case SOLLYA_BASE_FUNC_ERFC: return "SOLLYA_BASE_FUNC_ERFC"; case SOLLYA_BASE_FUNC_EXP: return "SOLLYA_BASE_FUNC_EXP"; case SOLLYA_BASE_FUNC_EXP_M1: return "SOLLYA_BASE_FUNC_EXP_M1"; case SOLLYA_BASE_FUNC_FLOOR: return "SOLLYA_BASE_FUNC_FLOOR"; case SOLLYA_BASE_FUNC_FREE_VARIABLE: return "SOLLYA_BASE_FUNC_FREE_VARIABLE"; case SOLLYA_BASE_FUNC_HALFPRECISION: return "SOLLYA_BASE_FUNC_HALFPRECISION"; case SOLLYA_BASE_FUNC_LIBRARYCONSTANT: return "SOLLYA_BASE_FUNC_LIBRARYCONSTANT"; case SOLLYA_BASE_FUNC_LIBRARYFUNCTION: return "SOLLYA_BASE_FUNC_LIBRARYFUNCTION"; case SOLLYA_BASE_FUNC_LOG: return "SOLLYA_BASE_FUNC_LOG"; case SOLLYA_BASE_FUNC_LOG_10: return "SOLLYA_BASE_FUNC_LOG_10"; case SOLLYA_BASE_FUNC_LOG_1P: return "SOLLYA_BASE_FUNC_LOG_1P"; case SOLLYA_BASE_FUNC_LOG_2: return "SOLLYA_BASE_FUNC_LOG_2"; case SOLLYA_BASE_FUNC_MUL: return "SOLLYA_BASE_FUNC_MUL"; case SOLLYA_BASE_FUNC_NEARESTINT: return "SOLLYA_BASE_FUNC_NEARESTINT"; case SOLLYA_BASE_FUNC_NEG: return "SOLLYA_BASE_FUNC_NEG"; case SOLLYA_BASE_FUNC_PI: return "SOLLYA_BASE_FUNC_PI"; case SOLLYA_BASE_FUNC_POW: return "SOLLYA_BASE_FUNC_POW"; case SOLLYA_BASE_FUNC_PROCEDUREFUNCTION: return "SOLLYA_BASE_FUNC_PROCEDUREFUNCTION"; case SOLLYA_BASE_FUNC_QUAD: return "SOLLYA_BASE_FUNC_QUAD"; case SOLLYA_BASE_FUNC_SIN: return "SOLLYA_BASE_FUNC_SIN"; case SOLLYA_BASE_FUNC_SINGLE: return "SOLLYA_BASE_FUNC_SINGLE"; case SOLLYA_BASE_FUNC_SINH: return "SOLLYA_BASE_FUNC_SINH"; case SOLLYA_BASE_FUNC_SQRT: return "SOLLYA_BASE_FUNC_SQRT"; case SOLLYA_BASE_FUNC_SUB: return "SOLLYA_BASE_FUNC_SUB"; case SOLLYA_BASE_FUNC_TAN: return "SOLLYA_BASE_FUNC_TAN"; case SOLLYA_BASE_FUNC_TANH: return "SOLLYA_BASE_FUNC_TANH"; case SOLLYA_BASE_FUNC_TRIPLEDOUBLE: return"SOLLYA_BASE_FUNC_TRIPLEDOUBLE"; default: return "Unknown type"; } } void euler_gamma(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } int stupid1(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } /* Note: given as an example in the documentation. We suppose that the library has already been initialized */ int is_made_of_constants(sollya_obj_t f) { sollya_obj_t tmp1 = NULL; sollya_obj_t tmp2 = NULL; int n, r, res; sollya_base_function_t type; r = sollya_lib_decompose_function(f, &type, &n, &tmp1, &tmp2, NULL); if (!r) { sollya_lib_printf("%b is not a mathematical function.", f); res = 0; } else if (n >= 3) { sollya_lib_printf("Unexpected error: %b has more than two arguments.\n", f); res = 0; } else { switch (type) { case SOLLYA_BASE_FUNC_FREE_VARIABLE: res = 0; break; case SOLLYA_BASE_FUNC_PI: res = 1; break; case SOLLYA_BASE_FUNC_CONSTANT: res = 1; break; case SOLLYA_BASE_FUNC_LIBRARYCONSTANT: res = 1; break; default: res = is_made_of_constants(tmp1); if ((res) && (n==2)) res = is_made_of_constants(tmp2); } } if (tmp1) sollya_lib_clear_obj(tmp1); if (tmp2) sollya_lib_clear_obj(tmp2); return res; } int main(void) { sollya_obj_t f, tmp, tmp2, tmp3; sollya_base_function_t type; sollya_obj_t g[3]; int n; int res; sollya_lib_init(); /* Constant */ f = SOLLYA_PI; type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Another constant */ f = SOLLYA_CONST(3); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* A library constant constant */ f = sollya_lib_libraryconstant("superconst", euler_gamma); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Free variable */ f = SOLLYA_X_; type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Elementary function */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Procedure function */ tmp = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); tmp = sollya_lib_build_function_procedurefunction(SOLLYA_X_, tmp); tmp2 = sollya_lib_diff(tmp); tmp3 = SOLLYA_SIN(SOLLYA_X_); f = sollya_lib_apply(tmp2, tmp3, NULL); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(tmp); sollya_lib_clear_obj(tmp2); sollya_lib_clear_obj(tmp3); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* arithmetic operator */ f = SOLLYA_ADD(SOLLYA_X_, sollya_lib_build_function_libraryfunction(SOLLYA_X_, "stupid1", stupid1)); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s, n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, -1, NULL, NULL, NULL)\n", f, pretty_print(type), n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* A Sollya object that is not an expression */ f = sollya_lib_absolute(); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Another one */ f = sollya_lib_parse_string("[1,2]"); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("%b: type = %s, n = %d, subfunctions = %b, %b and %b.\n", f, pretty_print(type), n, g[0], g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /*************************************************************/ /* Testing what happens when NULL is encountered prematurely */ /*************************************************************/ /* As second argument */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, NULL, &n, &g[1], &g[2]); if (res) sollya_lib_printf("NULL given as 2nd argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As third argument */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("NULL given as 3rd argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fourth argument */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("NULL given as 4th argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fourth argument in a binary operator */ f = SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17)); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("NULL given as 4th argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fifth argument in a binary operator */ f = SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17)); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, &g[0], NULL, &g[2]); if (res) sollya_lib_printf("NULL given as 5th argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[0], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fourth argument in a library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("NULL given as 4th argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[1], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fifth argument in a library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); type = (sollya_base_function_t) -1; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &type, &n, &g[0], NULL, &g[2]); if (res) sollya_lib_printf("NULL given as 5th argument. %b: type = %s, n = %d, subfunctions = %b and %b.\n", f, pretty_print(type), n, g[0], g[2]); else sollya_lib_printf("%b is not a functional expression (type=%s. Expecting 'Unknown type')\n", f, pretty_print(type)); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /*******************************************************/ /* Testing the function presented in the documentation */ /*******************************************************/ f = sollya_lib_libraryconstant("superconst", euler_gamma); f = SOLLYA_MUL(SOLLYA_ADD(SOLLYA_PI, SOLLYA_CONST(1)), f); if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); f = SOLLYA_X_; if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); f = SOLLYA_SIN(SOLLYA_ADD(SOLLYA_X_, SOLLYA_CONST(1))); if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); f = SOLLYA_SIN(SOLLYA_EXP(SOLLYA_CONST(1))); if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); f = sollya_lib_parse_string("[0,1]"); if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); f = sollya_lib_relative(); if (is_made_of_constants(f)) sollya_lib_printf("%b is made of constants.\n", f); else sollya_lib_printf("%b is *NOT* made of constants.\n", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tv_decompose_function.reference000066400000000000000000000043471300174114700234540ustar00rootroot00000000000000pi: type = SOLLYA_BASE_FUNC_PI, n = 0, subfunctions = pi, NULL and NULL. 3: type = SOLLYA_BASE_FUNC_CONSTANT, n = 0, subfunctions = 3, NULL and NULL. superconst: type = SOLLYA_BASE_FUNC_LIBRARYCONSTANT, n = 0, subfunctions = superconst, NULL and NULL. _x_: type = SOLLYA_BASE_FUNC_FREE_VARIABLE, n = 1, subfunctions = _x_, NULL and NULL. exp(sin(_x_) + 17): type = SOLLYA_BASE_FUNC_EXP, n = 1, subfunctions = sin(_x_) + 17, NULL and NULL. (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(sin(_x_)): type = SOLLYA_BASE_FUNC_PROCEDUREFUNCTION, n = 1, subfunctions = sin(_x_), diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })) and NULL. stupid1(cos(_x_)): type = SOLLYA_BASE_FUNC_LIBRARYFUNCTION, n = 1, subfunctions = cos(_x_), stupid1 and NULL. _x_ + stupid1: type = SOLLYA_BASE_FUNC_ADD, n = 2, subfunctions = _x_, stupid1 and NULL. absolute is not a functional expression (type=Unknown type. Expecting 'Unknown type') [1;2] is not a functional expression (type=Unknown type. Expecting 'Unknown type') NULL given as 2nd argument. exp(sin(_x_) + 17): type = Unknown type, n = 1, subfunctions = sin(_x_) + 17 and NULL. NULL given as 3rd argument. exp(sin(_x_) + 17): type = SOLLYA_BASE_FUNC_EXP, n = -1, subfunctions = sin(_x_) + 17 and NULL. NULL given as 4th argument. exp(sin(_x_) + 17): type = SOLLYA_BASE_FUNC_EXP, n = 1, subfunctions = NULL and NULL. NULL given as 4th argument. sin(_x_) + 17: type = SOLLYA_BASE_FUNC_ADD, n = 2, subfunctions = NULL and NULL. NULL given as 5th argument. sin(_x_) + 17: type = SOLLYA_BASE_FUNC_ADD, n = 2, subfunctions = sin(_x_) and NULL. NULL given as 4th argument. stupid1(cos(_x_)): type = SOLLYA_BASE_FUNC_LIBRARYFUNCTION, n = 1, subfunctions = NULL and NULL. NULL given as 5th argument. stupid1(cos(_x_)): type = SOLLYA_BASE_FUNC_LIBRARYFUNCTION, n = 1, subfunctions = cos(_x_) and NULL. ((pi) + 1) * superconst is made of constants. _x_ is *NOT* made of constants. sin(_x_ + 1) is *NOT* made of constants. sin(exp(1)) is made of constants. [0;1] is not a mathematical function.[0;1] is *NOT* made of constants. relative is not a mathematical function.relative is *NOT* made of constants. sollya-6.0+ds/tests-lib/tv_execute_procedure.c000066400000000000000000000042301300174114700215560ustar00rootroot00000000000000#include sollya_obj_t stupid_wrapper(sollya_obj_t arg1, ...) { va_list va; sollya_obj_t a; va_start(va, arg1); a = sollya_lib_v_execute_procedure(arg1, va); va_end(va); return a; } int callback(sollya_msg_t msg, void *data) { (void)msg; /* Avoiding "unused parameter" warning */ (void)data; /* Avoiding "unused parameter" warning */ return 0; } int main(void) { sollya_obj_t proc1, proc2, proc3, one, two, three, proc1Res, proc1Resb, proc1Resc, proc2Res, proc3Res, proc3Resb; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); proc1 = sollya_lib_parse_string("proc (a,b) { \"a = \", a, \", b = \", b; return a + b; }"); proc2 = sollya_lib_parse_string("proc () { write(\"Coucou\\n\"); }"); proc3 = sollya_lib_parse_string("proc (l = ...) { \"l = \", l; return exp(_x_); }"); one = SOLLYA_CONST_SI64(1); two = SOLLYA_CONST_SI64(2); three = SOLLYA_CONST_SI64(3); proc1Res = stupid_wrapper(proc1, one, two, NULL); proc1Resb = stupid_wrapper(proc1, one, NULL); proc1Resc = stupid_wrapper(proc1, one, two, three, NULL); proc2Res = stupid_wrapper(proc2, NULL); proc3Res = stupid_wrapper(proc3, one, two, three, NULL); proc3Resb = stupid_wrapper(proc3, NULL); sollya_lib_printf("proc1 = %b, args = %b, %b: result = %b\n", proc1, one, two, proc1Res); sollya_lib_printf("proc1 = %b, args = %b: result = %b\n", proc1, one, proc1Resb); sollya_lib_printf("proc1 = %b, args = %b, %b, %b: result = %b\n", proc1, one, two, three, proc1Resc); sollya_lib_printf("proc2 = %b: result = %b\n", proc2, proc2Res); sollya_lib_printf("proc3 = %b, args = %b, %b, %b: result = %b\n", proc3, one, two, three, proc3Res); sollya_lib_printf("proc3 = %b: result = %b\n", proc3, one, two, three, proc3Resb); sollya_lib_clear_obj(proc3Res); sollya_lib_clear_obj(proc3Resb); sollya_lib_clear_obj(proc2Res); sollya_lib_clear_obj(proc1Res); sollya_lib_clear_obj(proc1Resb); sollya_lib_clear_obj(proc1Resc); sollya_lib_clear_obj(three); sollya_lib_clear_obj(two); sollya_lib_clear_obj(one); sollya_lib_clear_obj(proc3); sollya_lib_clear_obj(proc2); sollya_lib_clear_obj(proc1); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tv_execute_procedure.reference000066400000000000000000000010441300174114700232720ustar00rootroot00000000000000a = 1, b = 2 Coucou l = [|1, 2, 3|] l = [|void|] proc1 = proc(a, b) { "a = ", a, ", b = ", b; return (a) + (b); }, args = 1, 2: result = 3 proc1 = proc(a, b) { "a = ", a, ", b = ", b; return (a) + (b); }, args = 1: result = error proc1 = proc(a, b) { "a = ", a, ", b = ", b; return (a) + (b); }, args = 1, 2, 3: result = error proc2 = proc() { write("Coucou\n"); return void; }: result = void proc3 = proc(l = ...) { "l = ", l; return exp(_x_); }, args = 1, 2, 3: result = exp(_x_) proc3 = proc(l = ...) { "l = ", l; return exp(_x_); }: result = 1 sollya-6.0+ds/tests-lib/tv_fpminimax.c000066400000000000000000000146331300174114700200440ustar00rootroot00000000000000#include #include sollya_obj_t stupid_wrapper(sollya_obj_t arg1, sollya_obj_t arg2, sollya_obj_t arg3, sollya_obj_t arg4, ...) { va_list va; sollya_obj_t a; va_start(va, arg4); a = sollya_lib_v_fpminimax(arg1, arg2, arg3, arg4, va); va_end(va); return a; } int main(void) { sollya_obj_t pstar, P, f, n, formats, I, fp, mode, constrainedpart, powers, tmp1, tmp2, P1, P2, P3; sollya_lib_init(); pstar = sollya_lib_parse_string("5846006549323611671784298104022718622318882177971b-162 + x * (37857459261849734002934198358497784854969213609141b-241 + x * (-23384026197294176595383359674367214160107584181507b-165 + x * (-38602791478525408905485501706553096127203819717855b-228 + x * (31178701574267686389540459856148935530651557981629b-169 + x * (14117092987825147270453985390332190734246695748303b-216 + x * (-16628060881742355087337911794409009456208012766191b-173))))))"); f = SOLLYA_COS(SOLLYA_X_); n = SOLLYA_CONST(6); formats = sollya_lib_parse_string("[|DD, DD, D...|]"); I = sollya_lib_parse_string("[-1b-5;1b-5]"); fp = sollya_lib_default(); mode = sollya_lib_default(); constrainedpart = sollya_lib_default(); P = stupid_wrapper(f, n, formats, I, fp, mode, constrainedpart, pstar, NULL); sollya_lib_printexpansion(P); sollya_lib_clear_obj(pstar); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(formats); sollya_lib_clear_obj(I); sollya_lib_clear_obj(fp); sollya_lib_clear_obj(mode); sollya_lib_clear_obj(constrainedpart); sollya_lib_clear_obj(P); pstar = sollya_lib_parse_string("2148263723907549819858926287983956687732819b-218 + x * (46768052394587948180729798097226792243112547550905b-165 + x * (-25507165977932281269808564943557572116806817621809b-228 + x * (-31178701565420095891159605334409136402204722409645b-167 + x * (12584781347098934684186528379166357990161007221285b-216 + x * (24941946363609599630853575496590807881363811501643b-171 + x * (-27084577193023540426845942064151570020527090561271b-208))))))"); f = SOLLYA_SIN(SOLLYA_X_); n = SOLLYA_CONST(6); formats = sollya_lib_parse_string("[|32...|]"); I = sollya_lib_parse_string("[-1b-5;1b-5]"); fp = sollya_lib_fixed(); mode = sollya_lib_absolute(); constrainedpart = sollya_lib_default(); tmp1 = stupid_wrapper(f, n, formats, I, fp, mode, constrainedpart, pstar, NULL); P = sollya_lib_horner(tmp1); sollya_lib_clear_obj(tmp1); powers = sollya_lib_powers(); sollya_lib_set_display(powers); sollya_lib_clear_obj(powers); sollya_lib_printf("%b\n",P); sollya_lib_clear_obj(pstar); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(formats); sollya_lib_clear_obj(I); sollya_lib_clear_obj(fp); sollya_lib_clear_obj(mode); sollya_lib_clear_obj(constrainedpart); sollya_lib_clear_obj(P); pstar = sollya_lib_parse_string("x^3 * (7794680717168470900797342378780962700124730873177b-165 + x * 31179902867931546748200780881663744737011812548003b-169)"); f = SOLLYA_EXP(SOLLYA_X_); n = sollya_lib_parse_string("[|3,4|]"); formats = sollya_lib_parse_string("[|D,24|]"); tmp1 = sollya_lib_off(); sollya_lib_set_roundingwarnings(tmp1); sollya_lib_clear_obj(tmp1); I = sollya_lib_parse_string("[-1/256; 1/246]"); constrainedpart = sollya_lib_parse_string("1+x+x^2/2"); fp = sollya_lib_default(); mode = sollya_lib_default(); tmp1 = stupid_wrapper(f, n, formats, I, constrainedpart, fp, mode, pstar, NULL); P = sollya_lib_horner(tmp1); sollya_lib_clear_obj(tmp1); powers = sollya_lib_powers(); sollya_lib_set_display(powers); sollya_lib_clear_obj(powers); sollya_lib_printf("%b\n",P); sollya_lib_clear_obj(pstar); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(formats); sollya_lib_clear_obj(I); sollya_lib_clear_obj(fp); sollya_lib_clear_obj(mode); sollya_lib_clear_obj(constrainedpart); sollya_lib_clear_obj(P); f = SOLLYA_COS(SOLLYA_EXP(SOLLYA_X_)); pstar = sollya_lib_parse_string("12634443274879194690170438040404782420883156872817b-164 + x * (-9838489776505477022831228470738983214292503288671b-163 + x * (-32311422838792817804696665515592631012661758648301b-165 + x * (-25268886572680378753378093437862180139058069966971b-166 + x * (15055969478386755176354565521121927285916932024465b-168 + x * 3245144072789014252966495640681210160689977302851b-164))))"); mode = sollya_lib_absolute(); n = SOLLYA_CONST(5); fp = sollya_lib_default(); constrainedpart = sollya_lib_default(); tmp1 = SOLLYA_SUB(sollya_lib_copy_obj(f), sollya_lib_copy_obj(pstar)); tmp2 = sollya_lib_parse_string("[-1b-7; 1b-7]"); I = sollya_lib_dirtyfindzeros(tmp1, tmp2); sollya_lib_clear_obj(tmp1); sollya_lib_clear_obj(tmp2); formats = sollya_lib_parse_string("[|DD...|]"); P1 = stupid_wrapper(f, n, formats, I, mode, constrainedpart, fp, pstar, NULL); sollya_lib_clear_obj(formats); formats = sollya_lib_parse_string("[|D...|]"); P2 = stupid_wrapper(f, n, formats, I, mode, constrainedpart, fp, pstar, NULL); sollya_lib_clear_obj(formats); formats = sollya_lib_parse_string("[|D, D, D, 24...|]"); P3 = stupid_wrapper(f, n, formats, I, mode, constrainedpart, fp, pstar, NULL); sollya_lib_clear_obj(formats); sollya_lib_clear_obj(I); I = sollya_lib_parse_string("[-1b-7; 1b-7]"); tmp1 = SOLLYA_SUB(sollya_lib_copy_obj(f), sollya_lib_copy_obj(pstar)); tmp2 = sollya_lib_dirtyinfnorm(tmp1, I); sollya_lib_printf("Error of pstar: %b\n", tmp2); sollya_lib_clear_obj(tmp1); sollya_lib_clear_obj(tmp2); tmp1 = SOLLYA_SUB(sollya_lib_copy_obj(f), sollya_lib_copy_obj(P1)); tmp2 = sollya_lib_dirtyinfnorm(tmp1, I); sollya_lib_printf("Error of P1: %b\n", tmp2); sollya_lib_clear_obj(tmp1); sollya_lib_clear_obj(tmp2); tmp1 = SOLLYA_SUB(sollya_lib_copy_obj(f), sollya_lib_copy_obj(P2)); tmp2 = sollya_lib_dirtyinfnorm(tmp1, I); sollya_lib_printf("Error of P2: %b\n", tmp2); sollya_lib_clear_obj(tmp1); sollya_lib_clear_obj(tmp2); tmp1 = SOLLYA_SUB(sollya_lib_copy_obj(f), sollya_lib_copy_obj(P3)); tmp2 = sollya_lib_dirtyinfnorm(tmp1, I); sollya_lib_printf("Error of P3: %b\n", tmp2); sollya_lib_clear_obj(tmp1); sollya_lib_clear_obj(tmp2); sollya_lib_clear_obj(I); sollya_lib_clear_obj(pstar); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(fp); sollya_lib_clear_obj(mode); sollya_lib_clear_obj(constrainedpart); sollya_lib_clear_obj(P1); sollya_lib_clear_obj(P2); sollya_lib_clear_obj(P3); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tv_fpminimax.reference000066400000000000000000000012741300174114700215550ustar00rootroot00000000000000(0x3ff0000000000000 + 0xbc09fda20235c100) + x * ((0x3b29ecd485d34781 + 0xb7c1cbc97120359a) + x * (0xbfdfffffffffff98 + x * (0xbbfa6e0b3183cb0d + x * (0x3fa5555555145337 + x * (0x3ca3540480618939 + x * 0xbf56c138142d8c3b))))) x * (1 + x^2 * (-357913941 * 2^(-31) + x^2 * (35789873 * 2^(-32)))) 1 + x * (1 + x * (1 * 2^(-1) + x * (375300225001191 * 2^(-51) + x * (5592621 * 2^(-27))))) Error of pstar: 41623862533526995219855274593333067596572580995543 * 2^(-215) Error of P1: 41623862533526995249852857301809387823617141062435 * 2^(-215) Error of P2: 43429285529967733230721931906794206008049814555029 * 2^(-215) Error of P3: 28553921171649539207471988588453621507466219169379 * 2^(-214) sollya-6.0+ds/tests-lib/tv_get_subfunctions.c000066400000000000000000000244121300174114700214310ustar00rootroot00000000000000#include #include #include #include int stupid_wrapper(sollya_obj_t f, int *n, ...) { va_list va; int res; va_start(va, n); res = sollya_lib_v_get_subfunctions(f, n, va); va_end(va); return res; } void euler_gamma(mpfr_t res, mp_prec_t prec) { mpfr_set_prec(res, prec); mpfr_const_euler(res, GMP_RNDN); return; } int stupid1(mpfi_t result, mpfi_t x, int n) { (void)x; /* Avoiding "unused parameter" warning */ (void)n; /* Avoiding "unused parameter" warning */ mpfi_set_ui(result, 0); return 0; } int main(void) { sollya_obj_t f, tmp, tmp2, tmp3; sollya_obj_t g[3]; int n; int res; sollya_lib_init(); /* Constant */ f = SOLLYA_PI; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Another constant */ f = SOLLYA_CONST(3); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* A library constant constant */ f = sollya_lib_libraryconstant("superconst", euler_gamma); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Free variable */ f = SOLLYA_X_; g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Elementary function */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Procedure function */ tmp = sollya_lib_parse_string("proc(X,n,p) {var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; };"); tmp = sollya_lib_build_function_procedurefunction(SOLLYA_X_, tmp); tmp2 = sollya_lib_diff(tmp); tmp3 = SOLLYA_SIN(SOLLYA_X_); f = sollya_lib_apply(tmp2, tmp3, NULL); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); sollya_lib_clear_obj(tmp); sollya_lib_clear_obj(tmp2); sollya_lib_clear_obj(tmp3); /* Library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* arithmetic operator */ f = SOLLYA_ADD(SOLLYA_X_, sollya_lib_build_function_libraryfunction(SOLLYA_X_, "stupid1", stupid1)); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* A Sollya object that is not an expression */ f = sollya_lib_absolute(); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* Another one */ f = sollya_lib_parse_string("[1,2]"); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, &g[0], &g[1], &g[2], NULL); if (res) sollya_lib_printf("Subfunction of %b: %b, %b and %b (n=%d)\n", f, g[0], g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /*************************************************************/ /* Testing what happens when NULL is encountered prematurely */ /*************************************************************/ /* As second argument */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("Subfunction of %b with NULL as 2nd argument: %b and %b (n=%d)\n", f, g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As third argument */ f = SOLLYA_EXP(SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17))); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("Subfunction of %b with NULL as 3rd argument: %b and %b (n=%d)\n", f, g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As third argument in a binary operator */ f = SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17)); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("Subfunction of %b with NULL as 3rd argument: %b and %b (n=%d)\n", f, g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fourth argument in a binary operator */ f = SOLLYA_ADD(SOLLYA_SIN(SOLLYA_X_), SOLLYA_CONST(17)); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, &g[0], NULL, &g[2]); if (res) sollya_lib_printf("Subfunction of %b with NULL as 4th argument: %b and %b (n=%d)\n", f, g[0], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As third argument in a library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, NULL, &g[1], &g[2]); if (res) sollya_lib_printf("Subfunction of %b with NULL as 3rd argument: %b and %b (n=%d)\n", f, g[1], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); /* As fourth argument in a library function */ f = sollya_lib_build_function_libraryfunction(SOLLYA_COS(SOLLYA_X_), "stupid1", stupid1); g[0] = NULL; g[1] = NULL; g[2] = NULL; n = -1; res = stupid_wrapper(f, &n, &g[0], NULL, &g[2]); if (res) sollya_lib_printf("Subfunction of %b with NULL as 4th argument: %b and %b (n=%d)\n", f, g[0], g[2], n); else sollya_lib_printf("%b is not a functional expression (n=%d, g[0]=%b, g[1]=%b, g[2]=%b. Expecting -1, NULL, NULL, NULL)\n", f, n, g[0], g[1], g[2]); sollya_lib_clear_obj(f); sollya_lib_clear_obj(g[0]); sollya_lib_clear_obj(g[1]); sollya_lib_clear_obj(g[2]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tv_get_subfunctions.reference000066400000000000000000000025611300174114700231460ustar00rootroot00000000000000Subfunction of pi: pi, NULL and NULL (n=0) Subfunction of 3: 3, NULL and NULL (n=0) Subfunction of superconst: superconst, NULL and NULL (n=0) Subfunction of _x_: _x_, NULL and NULL (n=1) Subfunction of exp(sin(_x_) + 17): sin(_x_) + 17, NULL and NULL (n=1) Subfunction of (diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })))(sin(_x_)): sin(_x_), diff(function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; res = exp(X); prec = oldPrec!; return res; })) and NULL (n=1) Subfunction of stupid1(cos(_x_)): cos(_x_), stupid1 and NULL (n=1) Subfunction of _x_ + stupid1: _x_, stupid1 and NULL (n=2) absolute is not a functional expression (n=-1, g[0]=NULL, g[1]=NULL, g[2]=NULL. Expecting -1, NULL, NULL, NULL) [1;2] is not a functional expression (n=-1, g[0]=NULL, g[1]=NULL, g[2]=NULL. Expecting -1, NULL, NULL, NULL) Subfunction of exp(sin(_x_) + 17) with NULL as 2nd argument: sin(_x_) + 17 and NULL (n=-1) Subfunction of exp(sin(_x_) + 17) with NULL as 3rd argument: NULL and NULL (n=1) Subfunction of sin(_x_) + 17 with NULL as 3rd argument: NULL and NULL (n=2) Subfunction of sin(_x_) + 17 with NULL as 4th argument: sin(_x_) and NULL (n=2) Subfunction of stupid1(cos(_x_)) with NULL as 3rd argument: NULL and NULL (n=1) Subfunction of stupid1(cos(_x_)) with NULL as 4th argument: cos(_x_) and NULL (n=1) sollya-6.0+ds/tests-lib/tv_implementpoly.c000066400000000000000000000167331300174114700207550ustar00rootroot00000000000000#include #include #include #include #include #include #define A_DIM 15 #define TEMP_IMPLEMENTATION_FILE "timplementpoly.implementation.c" #define TEMP_PROOF_FILE "timplementpoly.implementation.gappa" #define READBUFFERSIZE 1024 int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_IMPLEMENTED_POLY_DIFFERS_FROM_ORIGINAL_ONE: sollya_lib_printf("Caught the message: the implemented polynomial is different from the original one.\n"); break; case SOLLYA_MSG_INFERED_COEFF_PREC_HIGHER_THAN_REQUIRED: sollya_lib_printf("Caught the message: the inferred precision of a coefficient is higher than what seems to be needed to meet the accuracy target.\n"); break; case SOLLYA_MSG_COEFF_NOT_TWICE_GREATER_THAN_SUBPOLY: sollya_lib_printf("Caught the message: a coefficient in a Horner scheme is not guaranteed to also be twice as large as the subpolynomial.\n"); break; case SOLLYA_MSG_ERROR_ON_DETERMINING_THE_REQUIRED_PRECISIONS: sollya_lib_printf("Caught the message: an error has occurred during the determination of the required precisions.\n"); break; default: sollya_lib_printf("Unexpected warning %d.\n", message); } return 0; } sollya_obj_t stupid_wrapper(sollya_obj_t arg1, sollya_obj_t arg2, sollya_obj_t arg3, sollya_obj_t arg4, sollya_obj_t arg5, sollya_obj_t arg6, ...) { va_list va; sollya_obj_t a; va_start(va, arg6); a = sollya_lib_v_implementpoly(arg1, arg2, arg3, arg4, arg5, arg6, va); va_end(va); return a; } void read_and_print_file(char *filename) { FILE *fd; char readBuffer[READBUFFERSIZE]; int i; size_t readChars; if ((fd = fopen(filename,"r")) == NULL) { exit(1); } while (1) { for (i=0;i; # Disable some annoying warnings: #@-Wno-dichotomy-failure # Helper definitions for decomposing the free variable xh = double(xhm); xm = xhm - xh; # Transcription of the C code p_coeff_0h = double(1.50000000000000000000000000000000000000000000000000000000000000000000000000000000e+01); p_coeff_1h = double(1.40000000000000000000000000000000000000000000000000000000000000000000000000000000e+01); p_coeff_2h = double(1.30000000000000000000000000000000000000000000000000000000000000000000000000000000e+01); p_coeff_3h = double(1.20000000000000000000000000000000000000000000000000000000000000000000000000000000e+01); p_coeff_4h = double(1.10000000000000000000000000000000000000000000000000000000000000000000000000000000e+01); p_coeff_5h = double(1.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+01); p_coeff_6h = double(9.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_7h = double(8.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_8h = double(7.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_9h = double(6.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_10h = double(5.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_11h = double(4.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_12h = double(3.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_13h = double(2.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_coeff_14h = double(1.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00); p_t_1_0h = p_coeff_14h; p_t_2_0hm = mul_rel<102>(p_t_1_0h,xhm); p_t_2_0h = double(p_t_2_0hm); p_t_2_0m = p_t_2_0hm - p_t_2_0h; p_t_3_0hm = add_rel<102>(p_coeff_13h,p_t_2_0hm); p_t_3_0h = double(p_t_3_0hm); p_t_3_0m = p_t_3_0hm - p_t_3_0h; p_t_4_0hm = mul_rel<102>(p_t_3_0hm,xhm); p_t_4_0h = double(p_t_4_0hm); p_t_4_0m = p_t_4_0hm - p_t_4_0h; p_t_5_0hm = add_rel<102>(p_coeff_12h,p_t_4_0hm); p_t_5_0h = double(p_t_5_0hm); p_t_5_0m = p_t_5_0hm - p_t_5_0h; p_t_6_0hm = mul_rel<102>(p_t_5_0hm,xhm); p_t_6_0h = double(p_t_6_0hm); p_t_6_0m = p_t_6_0hm - p_t_6_0h; p_t_7_0hm = add_rel<102>(p_coeff_11h,p_t_6_0hm); p_t_7_0h = double(p_t_7_0hm); p_t_7_0m = p_t_7_0hm - p_t_7_0h; p_t_8_0hm = mul_rel<102>(p_t_7_0hm,xhm); p_t_8_0h = double(p_t_8_0hm); p_t_8_0m = p_t_8_0hm - p_t_8_0h; p_t_9_0hm = add_rel<102>(p_coeff_10h,p_t_8_0hm); p_t_9_0h = double(p_t_9_0hm); p_t_9_0m = p_t_9_0hm - p_t_9_0h; p_t_10_0hm = mul_rel<102>(p_t_9_0hm,xhm); p_t_10_0h = double(p_t_10_0hm); p_t_10_0m = p_t_10_0hm - p_t_10_0h; p_t_11_0hm = add_rel<102>(p_coeff_9h,p_t_10_0hm); p_t_11_0h = double(p_t_11_0hm); p_t_11_0m = p_t_11_0hm - p_t_11_0h; p_t_12_0hm = mul_rel<102>(p_t_11_0hm,xhm); p_t_12_0h = double(p_t_12_0hm); p_t_12_0m = p_t_12_0hm - p_t_12_0h; p_t_13_0hm = add_rel<102>(p_coeff_8h,p_t_12_0hm); p_t_13_0h = double(p_t_13_0hm); p_t_13_0m = p_t_13_0hm - p_t_13_0h; p_t_14_0hm = mul_rel<102>(p_t_13_0hm,xhm); p_t_14_0h = double(p_t_14_0hm); p_t_14_0m = p_t_14_0hm - p_t_14_0h; p_t_15_0hm = add_rel<102>(p_coeff_7h,p_t_14_0hm); p_t_15_0h = double(p_t_15_0hm); p_t_15_0m = p_t_15_0hm - p_t_15_0h; p_t_16_0hm = mul_rel<102>(p_t_15_0hm,xhm); p_t_16_0h = double(p_t_16_0hm); p_t_16_0m = p_t_16_0hm - p_t_16_0h; p_t_17_0hm = add_rel<102>(p_coeff_6h,p_t_16_0hm); p_t_17_0h = double(p_t_17_0hm); p_t_17_0m = p_t_17_0hm - p_t_17_0h; p_t_18_0hm = mul_rel<102>(p_t_17_0hm,xhm); p_t_18_0h = double(p_t_18_0hm); p_t_18_0m = p_t_18_0hm - p_t_18_0h; p_t_19_0hm = add_rel<102>(p_coeff_5h,p_t_18_0hm); p_t_19_0h = double(p_t_19_0hm); p_t_19_0m = p_t_19_0hm - p_t_19_0h; p_t_20_0hm = mul_rel<102>(p_t_19_0hm,xhm); p_t_20_0h = double(p_t_20_0hm); p_t_20_0m = p_t_20_0hm - p_t_20_0h; p_t_21_0hm = add_rel<102>(p_coeff_4h,p_t_20_0hm); p_t_21_0h = double(p_t_21_0hm); p_t_21_0m = p_t_21_0hm - p_t_21_0h; p_t_22_0hm = mul_rel<102>(p_t_21_0hm,xhm); p_t_22_0h = double(p_t_22_0hm); p_t_22_0m = p_t_22_0hm - p_t_22_0h; p_t_23_0hm = add_rel<102>(p_coeff_3h,p_t_22_0hm); p_t_23_0h = double(p_t_23_0hm); p_t_23_0m = p_t_23_0hm - p_t_23_0h; p_t_24_0hm = mul_rel<102>(p_t_23_0hm,xhm); p_t_24_0h = double(p_t_24_0hm); p_t_24_0m = p_t_24_0hm - p_t_24_0h; p_t_25_0hm = add_rel<102>(p_coeff_2h,p_t_24_0hm); p_t_25_0h = double(p_t_25_0hm); p_t_25_0m = p_t_25_0hm - p_t_25_0h; p_t_26_0hm = mul_rel<102>(p_t_25_0hm,xhm); p_t_26_0h = double(p_t_26_0hm); p_t_26_0m = p_t_26_0hm - p_t_26_0h; p_t_27_0hm = add_rel<102>(p_coeff_1h,p_t_26_0hm); p_t_27_0h = double(p_t_27_0hm); p_t_27_0m = p_t_27_0hm - p_t_27_0h; p_t_28_0hm = mul_rel<102>(p_t_27_0hm,xhm); p_t_28_0h = double(p_t_28_0hm); p_t_28_0m = p_t_28_0hm - p_t_28_0h; p_t_29_0hm = add_rel<102>(p_coeff_0h,p_t_28_0hm); p_t_29_0h = double(p_t_29_0hm); p_t_29_0m = p_t_29_0hm - p_t_29_0h; p_reshm = p_t_29_0hm; p_resh = p_t_29_0h; p_resm = p_t_29_0m; # Mathematical equivalents Mx = xhm; Mp_coeff_0 = p_coeff_0h; Mp_coeff_1 = p_coeff_1h; Mp_coeff_2 = p_coeff_2h; Mp_coeff_3 = p_coeff_3h; Mp_coeff_4 = p_coeff_4h; Mp_coeff_5 = p_coeff_5h; Mp_coeff_6 = p_coeff_6h; Mp_coeff_7 = p_coeff_7h; Mp_coeff_8 = p_coeff_8h; Mp_coeff_9 = p_coeff_9h; Mp_coeff_10 = p_coeff_10h; Mp_coeff_11 = p_coeff_11h; Mp_coeff_12 = p_coeff_12h; Mp_coeff_13 = p_coeff_13h; Mp_coeff_14 = p_coeff_14h; Mp_t_1_0 = Mp_coeff_14; Mp_t_2_0 = Mp_t_1_0 * Mx; Mp_t_3_0 = Mp_coeff_13 + Mp_t_2_0; Mp_t_4_0 = Mp_t_3_0 * Mx; Mp_t_5_0 = Mp_coeff_12 + Mp_t_4_0; Mp_t_6_0 = Mp_t_5_0 * Mx; Mp_t_7_0 = Mp_coeff_11 + Mp_t_6_0; Mp_t_8_0 = Mp_t_7_0 * Mx; Mp_t_9_0 = Mp_coeff_10 + Mp_t_8_0; Mp_t_10_0 = Mp_t_9_0 * Mx; Mp_t_11_0 = Mp_coeff_9 + Mp_t_10_0; Mp_t_12_0 = Mp_t_11_0 * Mx; Mp_t_13_0 = Mp_coeff_8 + Mp_t_12_0; Mp_t_14_0 = Mp_t_13_0 * Mx; Mp_t_15_0 = Mp_coeff_7 + Mp_t_14_0; Mp_t_16_0 = Mp_t_15_0 * Mx; Mp_t_17_0 = Mp_coeff_6 + Mp_t_16_0; Mp_t_18_0 = Mp_t_17_0 * Mx; Mp_t_19_0 = Mp_coeff_5 + Mp_t_18_0; Mp_t_20_0 = Mp_t_19_0 * Mx; Mp_t_21_0 = Mp_coeff_4 + Mp_t_20_0; Mp_t_22_0 = Mp_t_21_0 * Mx; Mp_t_23_0 = Mp_coeff_3 + Mp_t_22_0; Mp_t_24_0 = Mp_t_23_0 * Mx; Mp_t_25_0 = Mp_coeff_2 + Mp_t_24_0; Mp_t_26_0 = Mp_t_25_0 * Mx; Mp_t_27_0 = Mp_coeff_1 + Mp_t_26_0; Mp_t_28_0 = Mp_t_27_0 * Mx; Mp_t_29_0 = Mp_coeff_0 + Mp_t_28_0; Mp_res = Mp_t_29_0; # Definition of the relative arithmetical error epsilon = (p_reshm - Mp_res) / Mp_res; # Implication to prove {( xhm in [-1b-1,1b-1] /\ not xhm in [-1b-401,1b-401] ) -> ( epsilon in ? )} # Hints and Meta-Hints for expansion decomposition xh ~ xhm; p_t_2_0h ~ p_t_2_0hm; p_t_3_0h ~ p_t_3_0hm; p_t_4_0h ~ p_t_4_0hm; p_t_5_0h ~ p_t_5_0hm; p_t_6_0h ~ p_t_6_0hm; p_t_7_0h ~ p_t_7_0hm; p_t_8_0h ~ p_t_8_0hm; p_t_9_0h ~ p_t_9_0hm; p_t_10_0h ~ p_t_10_0hm; p_t_11_0h ~ p_t_11_0hm; p_t_12_0h ~ p_t_12_0hm; p_t_13_0h ~ p_t_13_0hm; p_t_14_0h ~ p_t_14_0hm; p_t_15_0h ~ p_t_15_0hm; p_t_16_0h ~ p_t_16_0hm; p_t_17_0h ~ p_t_17_0hm; p_t_18_0h ~ p_t_18_0hm; p_t_19_0h ~ p_t_19_0hm; p_t_20_0h ~ p_t_20_0hm; p_t_21_0h ~ p_t_21_0hm; p_t_22_0h ~ p_t_22_0hm; p_t_23_0h ~ p_t_23_0hm; p_t_24_0h ~ p_t_24_0hm; p_t_25_0h ~ p_t_25_0hm; p_t_26_0h ~ p_t_26_0hm; p_t_27_0h ~ p_t_27_0hm; p_t_28_0h ~ p_t_28_0hm; p_t_29_0h ~ p_t_29_0hm; # Meta-Hints for Horner scheme p_t_1_0h ~ Mp_t_1_0; p_t_2_0hm ~ Mp_t_2_0; p_t_3_0hm ~ Mp_t_3_0; p_t_4_0hm ~ Mp_t_4_0; p_t_5_0hm ~ Mp_t_5_0; p_t_6_0hm ~ Mp_t_6_0; p_t_7_0hm ~ Mp_t_7_0; p_t_8_0hm ~ Mp_t_8_0; p_t_9_0hm ~ Mp_t_9_0; p_t_10_0hm ~ Mp_t_10_0; p_t_11_0hm ~ Mp_t_11_0; p_t_12_0hm ~ Mp_t_12_0; p_t_13_0hm ~ Mp_t_13_0; p_t_14_0hm ~ Mp_t_14_0; p_t_15_0hm ~ Mp_t_15_0; p_t_16_0hm ~ Mp_t_16_0; p_t_17_0hm ~ Mp_t_17_0; p_t_18_0hm ~ Mp_t_18_0; p_t_19_0hm ~ Mp_t_19_0; p_t_20_0hm ~ Mp_t_20_0; p_t_21_0hm ~ Mp_t_21_0; p_t_22_0hm ~ Mp_t_22_0; p_t_23_0hm ~ Mp_t_23_0; p_t_24_0hm ~ Mp_t_24_0; p_t_25_0hm ~ Mp_t_25_0; p_t_26_0hm ~ Mp_t_26_0; p_t_27_0hm ~ Mp_t_27_0; p_t_28_0hm ~ Mp_t_28_0; p_t_29_0hm ~ Mp_t_29_0; p_reshm ~ Mp_res; # Dichotomies for triple-double decomposition # Dichotomy for the error bound epsilon $ xhm; sollya-6.0+ds/tests-lib/tv_max.c000066400000000000000000000211441300174114700166340ustar00rootroot00000000000000#include #include sollya_obj_t stupid_wrapper(sollya_obj_t arg1, ...) { va_list va; sollya_obj_t a; va_start(va, arg1); a = sollya_lib_v_max(arg1, va); va_end(va); return a; } int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: sollya_lib_printf("The following test is not certified (probably because the max is reached by two equal values).\n"); break; case SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: sollya_lib_printf("The test will rely on pure FP evaluation (probably because 0 is the maximum but it is hard to prove it).\n"); break; case SOLLYA_MSG_MAX_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL: sollya_lib_printf("Warning: the following test involves a NaN\n"); break; case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The following expression is not correctly typed.\n"); break; default: sollya_lib_printf("Unexpected warning %d\n", message); } return 0; } int main(void) { sollya_obj_t a[4]; sollya_obj_t b,c; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* Tests a simple maximum */ a[0] = sollya_lib_constant_from_int(4); a[1] = sollya_lib_constant_from_int(5); a[2] = sollya_lib_constant_from_int(1); a[3] = sollya_lib_constant_from_int(3); b = stupid_wrapper(a[0], a[1], a[2], a[3], NULL); sollya_lib_printf("max(4,5,1,3) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 4); b = stupid_wrapper(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); for(i=0;i<4;i++) sollya_lib_clear_obj(a[i]); /* Tests a tricky case where the maximum is impossible to detect */ a[0] = sollya_lib_parse_string("17 + log2(13)/log2(9)"); a[1] = sollya_lib_parse_string("17 + log(13)/log(9)"); b = stupid_wrapper(a[0], a[1], NULL); sollya_lib_printf("max of 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 2); b = stupid_wrapper(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); /* Tests a tricky case when the maximum is possible to detect, but at some point of the algorithm it was impossible to detect it for sure */ a[0] = sollya_lib_parse_string("17 + log2(13)/log2(9)"); a[1] = sollya_lib_parse_string("17 + log(13)/log(9)"); a[2] = SOLLYA_CONST(100); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("max of 17 + log2(13)/log2(9), 17 + log(13)/log(9), 100 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* The same but in reversed order */ a[0] = SOLLYA_CONST(100); a[1] = sollya_lib_parse_string("17 + log2(13)/log2(9)"); a[2] = sollya_lib_parse_string("17 + log(13)/log(9)"); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("max of 100, 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* Tests another tricky case where the maximum is impossible to detect */ a[0] = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); a[1] = sollya_lib_parse_string("0"); b = stupid_wrapper(a[0], a[1], NULL); sollya_lib_printf("max of sin(pi/3)-sqrt(3)/2 and 0 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 2); b = stupid_wrapper(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); /* Tests another tricky case where the maximum is possible to detect, but the list contains elements that are hard to evaluate */ a[0] = SOLLYA_CONST(0); a[1] = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); a[2] = sollya_lib_parse_string("1"); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("max of 0, sin(pi/3)-sqrt(3)/2 and 1 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* The same, but in reversed order */ a[0] = sollya_lib_parse_string("1"); a[1] = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); a[2] = SOLLYA_CONST(0); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("max of 1 and sin(pi/3)-sqrt(3)/2 and 0 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* Tests what happens when a NaN is in the list */ a[0] = sollya_lib_constant_from_int(2); a[1] = sollya_lib_parse_string("NaN"); a[2] = sollya_lib_constant_from_int(1); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("max(2,NaN,1) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); a[0] = sollya_lib_constant_from_int(2); a[1] = SOLLYA_LOG(SOLLYA_CONST(-17)); a[2] = sollya_lib_constant_from_int(1); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("max(2,log(-17),1) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); a[0] = sollya_lib_parse_string("NaN"); a[1] = sollya_lib_constant_from_int(1); a[2] = sollya_lib_constant_from_int(2); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("max(NaN,1,2) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); a[0] = SOLLYA_LOG(SOLLYA_CONST(-17)); a[1] = sollya_lib_constant_from_int(1); a[2] = sollya_lib_constant_from_int(2); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("max(log(-17),1,2) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* Tests maximum of only one element */ a[0] = sollya_lib_constant_from_int(17); b = stupid_wrapper(a[0], NULL); sollya_lib_printf("max of 17 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 1); b = stupid_wrapper(c, NULL); sollya_lib_printf("max(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); /* Tests maximum of an empty list */ c = sollya_lib_list(NULL, 0); b = stupid_wrapper(c, NULL); sollya_lib_printf("max of an empty list returns %b\n\n", b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); /* Tests what happens if a list is given, followed by a constant */ a[0] = sollya_lib_constant_from_int(4); a[1] = sollya_lib_constant_from_int(1); a[2] = sollya_lib_constant_from_int(3); a[3] = sollya_lib_constant_from_int(5); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, a[3], NULL); sollya_lib_printf("max(%b, 5) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); for(i=0;i<4;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tv_max.reference000066400000000000000000000034571300174114700203570ustar00rootroot00000000000000max(4,5,1,3) returns 5 max([|4, 5, 1, 3|]) returns 5 The following test is not certified (probably because the max is reached by two equal values). max of 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns 17 + log2(13) / log2(9) The following test is not certified (probably because the max is reached by two equal values). max([|17 + log2(13) / log2(9), 17 + log(13) / log(9)|]) returns 17 + log2(13) / log2(9) max of 17 + log2(13)/log2(9), 17 + log(13)/log(9), 100 returns 100 max([|17 + log2(13) / log2(9), 17 + log(13) / log(9), 100|]) returns 100 max of 100, 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns 100 max([|100, 17 + log2(13) / log2(9), 17 + log(13) / log(9)|]) returns 100 The test will rely on pure FP evaluation (probably because 0 is the maximum but it is hard to prove it). max of sin(pi/3)-sqrt(3)/2 and 0 returns sin((pi) / 3) - sqrt(3) / 2 The test will rely on pure FP evaluation (probably because 0 is the maximum but it is hard to prove it). max([|sin((pi) / 3) - sqrt(3) / 2, 0|]) returns sin((pi) / 3) - sqrt(3) / 2 max of 0, sin(pi/3)-sqrt(3)/2 and 1 returns 1 max([|0, sin((pi) / 3) - sqrt(3) / 2, 1|]) returns 1 max of 1 and sin(pi/3)-sqrt(3)/2 and 0 returns 1 max([|1, sin((pi) / 3) - sqrt(3) / 2, 0|]) returns 1 max(2,NaN,1) returns 2 max([|2, NaN, 1|]) returns 2 Warning: the following test involves a NaN max(2,log(-17),1) returns 2 Warning: the following test involves a NaN max([|2, log(-17), 1|]) returns 2 max(NaN,1,2) returns 2 max([|NaN, 1, 2|]) returns 2 Warning: the following test involves a NaN max(log(-17),1,2) returns 2 Warning: the following test involves a NaN max([|log(-17), 1, 2|]) returns 2 max of 17 returns 17 max([|17|]) returns 17 The following expression is not correctly typed. max of an empty list returns error max([|4, 1, 3|], 5) returns 4 sollya-6.0+ds/tests-lib/tv_min.c000066400000000000000000000211371300174114700166340ustar00rootroot00000000000000#include #include sollya_obj_t stupid_wrapper(sollya_obj_t arg1, ...) { va_list va; sollya_obj_t a; va_start(va, arg1); a = sollya_lib_v_min(arg1, va); va_end(va); return a; } int callback(sollya_msg_t msg, void *data) { (void)data; /* Avoiding "unused parameter" warning */ int message = sollya_lib_get_msg_id(msg); switch(message) { case SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_UNDECIDED: sollya_lib_printf("The following test is not certified (probably because the min is reached by two equal values).\n"); break; case SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_THAT_IS_NOT_FAITHFUL: sollya_lib_printf("The test will rely on pure FP evaluation (probably because 0 is the minimum but it is hard to prove it).\n"); break; case SOLLYA_MSG_MIN_RELIES_ON_FP_RESULT_FAITHFUL_BUT_NOT_REAL: sollya_lib_printf("Warning: the following test involves a NaN\n"); break; case SOLLYA_MSG_EXPR_NOT_CORRECTLY_TYPED: sollya_lib_printf("The following expression is not correctly typed.\n"); break; default: sollya_lib_printf("Unexpected warning %d\n", message); } return 0; } int main(void) { sollya_obj_t a[4]; sollya_obj_t b,c; int i; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* Tests a simple minimum */ a[0] = sollya_lib_constant_from_int(4); a[1] = sollya_lib_constant_from_int(5); a[2] = sollya_lib_constant_from_int(1); a[3] = sollya_lib_constant_from_int(3); b = stupid_wrapper(a[0], a[1], a[2], a[3], NULL); sollya_lib_printf("min(4,5,1,3) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 4); b = stupid_wrapper(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); for(i=0;i<4;i++) sollya_lib_clear_obj(a[i]); /* Tests a tricky case where the minimum is impossible to detect */ a[0] = sollya_lib_parse_string("17 + log2(13)/log2(9)"); a[1] = sollya_lib_parse_string("17 + log(13)/log(9)"); b = stupid_wrapper(a[0], a[1], NULL); sollya_lib_printf("min of 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 2); b = stupid_wrapper(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); /* Tests a tricky case when the minimum is possible to detect, but at some point of the algorithm it was impossible to detect it for sure */ a[0] = sollya_lib_parse_string("17 + log2(13)/log2(9)"); a[1] = sollya_lib_parse_string("17 + log(13)/log(9)"); a[2] = SOLLYA_CONST(1); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("min of 17 + log2(13)/log2(9), 17 + log(13)/log(9), 1 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* The same but in reversed order */ a[0] = SOLLYA_CONST(1); a[1] = sollya_lib_parse_string("17 + log2(13)/log2(9)"); a[2] = sollya_lib_parse_string("17 + log(13)/log(9)"); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("min of 1, 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* Tests another tricky case where the minimum is impossible to detect */ a[0] = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); a[1] = sollya_lib_parse_string("0"); b = stupid_wrapper(a[0], a[1], NULL); sollya_lib_printf("min of sin(pi/3)-sqrt(3)/2 and 0 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 2); b = stupid_wrapper(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); /* Tests another tricky case where the minimum is possible to detect, but the list contains elements that are hard to evaluate */ a[0] = SOLLYA_CONST(0); a[1] = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); a[2] = sollya_lib_parse_string("-1"); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("min of 0, sin(pi/3)-sqrt(3)/2 and -1 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* The same, but in reversed order */ a[0] = sollya_lib_parse_string("-1"); a[1] = sollya_lib_parse_string("sin(pi/3) - sqrt(3)/2"); a[2] = SOLLYA_CONST(0); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("min of -1 and sin(pi/3)-sqrt(3)/2 and 0 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* Tests what happens when a NaN is in the list */ a[0] = sollya_lib_constant_from_int(2); a[1] = sollya_lib_parse_string("NaN"); a[2] = sollya_lib_constant_from_int(1); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("min(2,NaN,1) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); a[0] = sollya_lib_constant_from_int(2); a[1] = SOLLYA_LOG(SOLLYA_CONST(-17)); a[2] = sollya_lib_constant_from_int(1); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("min(2,log(-17),1) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); a[0] = sollya_lib_parse_string("NaN"); a[1] = sollya_lib_constant_from_int(1); a[2] = sollya_lib_constant_from_int(2); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("min(NaN,1,2) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); a[0] = SOLLYA_LOG(SOLLYA_CONST(-17)); a[1] = sollya_lib_constant_from_int(1); a[2] = sollya_lib_constant_from_int(2); b = stupid_wrapper(a[0], a[1], a[2], NULL); sollya_lib_printf("min(log(-17),1,2) returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); sollya_lib_clear_obj(a[1]); sollya_lib_clear_obj(a[2]); /* Tests minimum of only one element */ a[0] = sollya_lib_constant_from_int(17); b = stupid_wrapper(a[0], NULL); sollya_lib_printf("min of 17 returns %b\n\n", b); sollya_lib_clear_obj(b); c = sollya_lib_list(a, 1); b = stupid_wrapper(c, NULL); sollya_lib_printf("min(%b) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); sollya_lib_clear_obj(a[0]); /* Tests minimum of an empty list */ c = sollya_lib_list(NULL, 0); b = stupid_wrapper(c, NULL); sollya_lib_printf("min of an empty list returns %b\n\n", b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); /* Tests what happens if a list is given, followed by a constant */ a[0] = sollya_lib_constant_from_int(4); a[1] = sollya_lib_constant_from_int(1); a[2] = sollya_lib_constant_from_int(3); a[3] = sollya_lib_constant_from_int(5); c = sollya_lib_list(a, 3); b = stupid_wrapper(c, a[3], NULL); sollya_lib_printf("min(%b, 5) returns %b\n\n", c, b); sollya_lib_clear_obj(b); sollya_lib_clear_obj(c); for(i=0;i<4;i++) sollya_lib_clear_obj(a[i]); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tv_min.reference000066400000000000000000000033571300174114700203540ustar00rootroot00000000000000min(4,5,1,3) returns 1 min([|4, 5, 1, 3|]) returns 1 The following test is not certified (probably because the min is reached by two equal values). min of 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns 17 + log(13) / log(9) The following test is not certified (probably because the min is reached by two equal values). min([|17 + log2(13) / log2(9), 17 + log(13) / log(9)|]) returns 17 + log(13) / log(9) min of 17 + log2(13)/log2(9), 17 + log(13)/log(9), 1 returns 1 min([|17 + log2(13) / log2(9), 17 + log(13) / log(9), 1|]) returns 1 min of 1, 17 + log2(13)/log2(9) and 17 + log(13)/log(9) returns 1 min([|1, 17 + log2(13) / log2(9), 17 + log(13) / log(9)|]) returns 1 The test will rely on pure FP evaluation (probably because 0 is the minimum but it is hard to prove it). min of sin(pi/3)-sqrt(3)/2 and 0 returns 0 The test will rely on pure FP evaluation (probably because 0 is the minimum but it is hard to prove it). min([|sin((pi) / 3) - sqrt(3) / 2, 0|]) returns 0 min of 0, sin(pi/3)-sqrt(3)/2 and -1 returns -1 min([|0, sin((pi) / 3) - sqrt(3) / 2, -1|]) returns -1 min of -1 and sin(pi/3)-sqrt(3)/2 and 0 returns -1 min([|-1, sin((pi) / 3) - sqrt(3) / 2, 0|]) returns -1 min(2,NaN,1) returns 1 min([|2, NaN, 1|]) returns 1 Warning: the following test involves a NaN min(2,log(-17),1) returns 1 Warning: the following test involves a NaN min([|2, log(-17), 1|]) returns 1 min(NaN,1,2) returns 1 min([|NaN, 1, 2|]) returns 1 Warning: the following test involves a NaN min(log(-17),1,2) returns 1 Warning: the following test involves a NaN min([|log(-17), 1, 2|]) returns 1 min of 17 returns 17 min([|17|]) returns 17 The following expression is not correctly typed. min of an empty list returns error min([|4, 1, 3|], 5) returns 1 sollya-6.0+ds/tests-lib/tv_remez.c000066400000000000000000003717771300174114700172150ustar00rootroot00000000000000#include #include sollya_obj_t stupid_wrapper(sollya_obj_t arg1, sollya_obj_t arg2, sollya_obj_t arg3, ...) { va_list va; sollya_obj_t a; va_start(va, arg3); a = sollya_lib_v_remez(arg1, arg2, arg3, va); va_end(va); return a; } int boolean_not_eq(sollya_obj_t a, sollya_obj_t b) { sollya_obj_t tmp; int res; tmp = sollya_lib_cmp_not_equal(a,b); res = sollya_lib_is_true(tmp); sollya_lib_clear_obj(tmp); return res; } int callback(sollya_msg_t msg, void *data) { (void)msg; /* Avoiding "unused parameter" warning */ (void)data; /* Avoiding "unused parameter" warning */ return 0; } int main(void) { sollya_obj_t f, n, I, w, quality, p, res, pold32, pold64, psvn, prec; sollya_lib_init(); sollya_lib_install_msg_callback(callback, NULL); /* This set of tests the problem mentioned in the commit message of revision 1270 */ sollya_lib_printf("=============== Check remez #1 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[-1,1]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("11692536319630510474283968587625525849426869787677b-163 + x * (11692461446776396870604093448366028590354143070281b-163 + x * (11673235319402898388606243422629423700138678461245b-164 + x * (31133428140297179651102037915750686232945795875449b-167 + x * (16385167097562211512230476137789746035022726429977b-168 + x * 3269345410694656957446976530521438920874314212397b-168))))"); pold64 = sollya_lib_parse_string("11692536319630510474283968587625525849426869787677b-163 + x * (11692461446776396870604093448366028590354143070281b-163 + x * (11673235319402898388606243422629423700138678461245b-164 + x * (31133428140297179651102037915750686232945795875449b-167 + x * (16385167097562211512230476137789746035022726429977b-168 + x * 3269345410694656957446976530521438920874314212397b-168))))"); psvn = sollya_lib_parse_string("5846268159844744362743250522846987862429367629517b-162 + x * (11692461446497641124271694526853099581211451868505b-163 + x * (46692941277687010312354789479617646356383574093505b-166 + x * (31133428154210205207475891032719442864509304264413b-167 + x * (32770334189338630118937388326942173859103583586297b-169 + x * 26154763134310317818688286279981231602507327130357b-171))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #2 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_SIN(SOLLYA_X_); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[8602502489799048500699352110124879245308378241707b-164;7945546686039470376946513431105230628758836096031b-161]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("2214847272544331422982959495339200583251295560623b-168 + x * (22570554785080561636146441606989328655486420601777b-164 + x * (14059659517842917521277573489957716260107438465453b-167 + x * (-45540662462117273602262338480450403246420473478025b-167 + x * 28992086169774180186447811867835608633187677753845b-169)))"); pold64 = sollya_lib_parse_string("2214847272544331422982959495339200583251295560623b-168 + x * (22570554785080561636146441606989328655486420601777b-164 + x * (14059659517842917521277573489957716260107438465453b-167 + x * (-45540662462117273602262338480450403246420473478025b-167 + x * 28992086169774180186447811867835608633187677753845b-169)))"); psvn = sollya_lib_parse_string("35437554945294880980632330593543073201088752576427b-172 + x * (45141109621726235334917783839125819818331107328775b-165 + x * (7029829603586427223675545515975596612915570331385b-166 + x * (-11385165569957834689007715202379973379744083428327b-165 + x * 14496043012911941041556939044573938262006021182555b-168)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #3 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[-1,1]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("127320445892597569233192084573816508818883486078679099554120447022081703359819068009205547b-296 + x * (1018557044797143666503767416322855867839491631117818135205555253332674508098291366773725959b-299 + x * (508441106512784560521103888523310670303733435407883686814016285688113354381980961005656571b-299 + x * (1356052046777263815902350693610623816222104351491496878169889792980744642403155011929747871b-302 + x * (1427349359299711414482673569219142091501984527550101477773398194525418017639951550600094011b-304 + x * 142400076760410063419384360841976625466855068476814073302706323729266395387747260369551141b-303))))"); pold64 = sollya_lib_parse_string("23385072639206744003725553236226897950127307962451b-164 + x * (365389420211574099793611713376448329829065556119b-158 + x * (46692941283719626881488690119204107293177946206343b-166 + x * (31133428132962382466270199289173155642175257945163b-167 + x * (32770334150519966250277800665629495916849322658691b-169 + x * 13077381702228291991132998535625300995139355424413b-170))))"); psvn = sollya_lib_parse_string("1018563567135987915012032258711626357126926844785584405249158988500045361779294524522137609b-299 + x * (63659815291914294289514095925732401040544551614636617651518742466446015741886727574488441b-295 + x * (2033764425613398113005508465663637496484258379622733425468204193164419557706436715536867277b-301 + x * (1356052049838784195049149578638111221779213254032530089671765628325726082534242762143843701b-302 + x * (713674681588234494371962064568899835020713913740079267560613729649927766384468681112736739b-303 + x * 142400072661608631070456694965201033405098147932863694799040634951915614775231369251933923b-303))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #4 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_SIN(SOLLYA_X_); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[374691828310027073697551143672108152896494840720292515058859891294604926811223524123212345b-299;346077367399210202326012086853215365101795134298550595521910142083912300379007927274911891b-296]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("771761635395839434377129531728754385222063722650731773025337381349894526273800455320994827b-306 + x * (491543155523301332510096977904466770120443466902627277040602137207242486357322286394764839b-298 + x * (306192269961748776289513828518754452203023757960747199912707501846371742102754825130961253b-301 + x * (-991787802459613064655442347525062928740559494434023642211380691777391678934404916892326387b-301 + x * 1262783450062636101159847119423691169466818338834735686194803407195747225125865497190175227b-304)))"); pold64 = sollya_lib_parse_string("4429694543892476662758950169267086222983904426445b-169 + x * (705329837039797126620403885467797756064876572665b-159 + x * (14059659515839393799760722484884113456401859506117b-167 + x * (-22770331230580585570448475640636477599253588269445b-166 + x * 14496043084575263078863254256762631012805774503031b-168)))"); psvn = sollya_lib_parse_string("771761604782391317266041851785945726969630324975846680133806343191685414408397696546623025b-306 + x * (983086312139836775818762885502129911710245659966259444915127631295702907925608027660771709b-299 + x * (1224769054074531902982422536607908492630645593827460997931865849686410542941640013242217675b-303 + x * (-1983575597502081965714353024113746965208457974615584377507146126565280394079564572724184361b-302 + x * 1262783444340237354442532109902524854573062009580400181046879466613800524190097257252128189b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #5 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_SUB(SOLLYA_POW(SOLLYA_CONST(2), SOLLYA_X_), SOLLYA_CONST(1)),SOLLYA_X_); n = SOLLYA_CONST(9); I = sollya_lib_parse_string("[-1/16, 1/16]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("32417143657589090276342392320386542212634719195519b-165 + x * (22469851728064591059583753980795080887258113935177b-166 + x * (10383276248605324150931761963547736824435408824845b-167 + x * (28788554626783304799277995343333212138822726194415b-171 + x * (31927528755121801828772085911906676930045165407763b-174 + x * (29507302051812361584763105995068885830047872617559b-177 + x * (46749493035990890820236833700755803008100799330757b-181 + x * (4050534911275574634871329395893993407613062655611b-181 + x * (39932254070374564388452160149914943140225571249661b-188 + x * 44286286888723497574154492217999447288717640509613b-192))))))))"); pold64 = sollya_lib_parse_string("32417143657589090276342392320386542212634719195519b-165 + x * (22469851728064591059583753980795080887258113935177b-166 + x * (10383276248605324150931761963547736824435408824845b-167 + x * (28788554626783304799277995343333212138822726194415b-171 + x * (31927528755121801828772085911906676930045165407763b-174 + x * (29507302051812361584763105995068885830047872617559b-177 + x * (46749493035990890820236833700755803008100799330757b-181 + x * (4050534911275574634871329395893993407613062655611b-181 + x * (39932254070374564388452160149914943140225571249661b-188 + x * 44286286888723497574154492217999447288717640509613b-192))))))))"); psvn = sollya_lib_parse_string("16208571828794545138171196160198665353392027726519b-164 + x * (1404365733004036941223984624239966955522849707087b-162 + x * (20766552497210648301863523826884866697474843319139b-168 + x * (28788554626783304799277546456383385755588541941189b-171 + x * (7981882188780450457193021387137975228227525851703b-172 + x * (29507302051812361607733914252846404885311057946759b-177 + x * (23374746517995445671169652317254474972656939309419b-180 + x * (16202139645101822893887622168399062673636756653911b-183 + x * (19966127035178946160378341872570680908647845093767b-187 + x * 22143143457750640206904485509370313176196151922715b-191))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #6 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[0, 1]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("11691999891702459232513188345837804387460473133465b-163 + x * (23385884215836431320692282794470362044234264759653b-164 + x * (23341752494481389797661158971731272634607100367573b-165 + x * (31877473745927764039755782208650650896265284145499b-167 + x * (13020439476544364685564705598260199073785811131065b-168 + x * 10404004557414297823136671010327185596581741545881b-169))))"); pold64 = sollya_lib_parse_string("11691999891702459232513188345837804387460473133465b-163 + x * (23385884215836431320692282794470362044234264759653b-164 + x * (23341752494481389797661158971731272634607100367573b-165 + x * (31877473745927764039755782208650650896265284145499b-167 + x * (13020439476544364685564705598260199073785811131065b-168 + x * 10404004557414297823136671010327185596581741545881b-169))))"); psvn = sollya_lib_parse_string("46767999566809558881308044468442218032103592655757b-165 + x * (11692942107914186071032289323545495195098625849317b-163 + x * (1458859530921322116893682516178375390461742133049b-161 + x * (15938736871253002006918388195626326961019565596185b-166 + x * (26040878969624894003265505832639851578483944977057b-169 + x * 41616018202667367394235807063903500749064273666975b-171))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #7 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_COS(SOLLYA_EXP(SOLLYA_X_)); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[-1b-7, 1b-7]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("25268886549758389380340876080809564841766313745633b-165 + x * (-19676979553010954045662456941477966428585006577331b-164 + x * (-1009731963712275556396770797362269719145679957307b-160 + x * (-25268886572680378753378093437862180139058073796075b-166 + x * (30111938956773510352709131042243854571830406972593b-169 + x * 12980576291156057011865982562724840642811102794567b-166))))"); pold64 = sollya_lib_parse_string("25268886549758389380340876080809564841766313745633b-165 + x * (-19676979553010954045662456941477966428585006577331b-164 + x * (-1009731963712275556396770797362269719145679957307b-160 + x * (-25268886572680378753378093437862180139058073796075b-166 + x * (30111938956773510352709131042243854571830406972593b-169 + x * 12980576291156057011865982562724840642811102794567b-166))))"); psvn = sollya_lib_parse_string("25268886549758389380340964094845911511083285927847b-165 + x * (-39353959106021908091317784228352609542993628947795b-165 + x * (-8077855709698204451264858061909024193753897104777b-163 + x * (-25268886572680378560233411601948682207329758068657b-166 + x * (30111938956773161130666968507397664953869736937191b-169 + x * 12980576291149064825229651770061989288082684342499b-166))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #8 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); n = sollya_lib_build_list(SOLLYA_CONST(0), SOLLYA_CONST(2), SOLLYA_CONST(4), SOLLYA_CONST(6), SOLLYA_CONST(8), NULL); I = sollya_lib_parse_string("[0;18365771228192875685539220798973244513816620097673b-164]"); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_COS(SOLLYA_X_)); res = stupid_wrapper(f,n,I,w, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("46768052391966959108624215231152264196631503496533b-165 + x^2 * (-46768051993840437443783072518668792259606171959491b-166 + x^2 * (31178661612951199203931279724159830154661317721883b-169 + x^2 * (-16625815622415464147749762639614753800875397430565b-173 + x^2 * 37351022179333407291017870331792433578970727797399b-180)))"); pold64 = sollya_lib_parse_string("46768052391966959108624215231152264196631503496533b-165 + x^2 * (-46768051993840437443783072518668792259606171959491b-166 + x^2 * (31178661612951199203931279724159830154661317721883b-169 + x^2 * (-16625815622415464147749762639614753800875397430565b-173 + x^2 * 37351022179333407291017870331792433578970727797399b-180)))"); psvn = sollya_lib_parse_string("23384026195983475555764083291413192636174326996971b-164 + x^2 * (-5846006499229983362883814289569946057071030537265b-163 + x^2 * (31178661612930653056505238164343085429561431777217b-169 + x^2 * (-33251631243914015813578984958842684370701439463593b-174 + x^2 * 37351022158050956678139896134233747310006229285203b-180)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #9 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[0, 1]"); w = sollya_lib_default(); quality = sollya_lib_parse_string("1e-5"); res = stupid_wrapper(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("11691999891702459232513188345837804387460473133465b-163 + x * (23385884215836431320692282794470362044234264759653b-164 + x * (23341752494481389797661158971731272634607100367573b-165 + x * (31877473745927764039755782208650650896265284145499b-167 + x * (13020439476544364685564705598260199073785811131065b-168 + x * 10404004557414297823136671010327185596581741545881b-169))))"); pold64 = sollya_lib_parse_string("11691999891702459232513188345837804387460473133465b-163 + x * (23385884215836431320692282794470362044234264759653b-164 + x * (23341752494481389797661158971731272634607100367573b-165 + x * (31877473745927764039755782208650650896265284145499b-167 + x * (13020439476544364685564705598260199073785811131065b-168 + x * 10404004557414297823136671010327185596581741545881b-169))))"); psvn = sollya_lib_parse_string("46767999566809558881308044468442218032103592655757b-165 + x * (11692942107914186071032289323545495195098625849317b-163 + x * (1458859530921322116893682516178375390461742133049b-161 + x * (15938736871253002006918388195626326961019565596185b-166 + x * (26040878969624894003265505832639851578483944977057b-169 + x * 41616018202667367394235807063903500749064273666975b-171))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[0, 1]"); w = sollya_lib_default(); quality = sollya_lib_parse_string("1e-10"); res = stupid_wrapper(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("11691999891702299312469444817572169311673890781507b-163 + x * (5846471053959190028880485661894891163596000435605b-162 + x * (2917719061827678043813769415697570710862370049051b-162 + x * (31877473743673721131764284633492051013566249115055b-167 + x * (26040878964869758854248710691789107998476450084373b-169 + x * 20808009104796731383700609709219405830023419999013b-170))))"); pold64 = sollya_lib_parse_string("11691999891702299312469444817572169311673890781507b-163 + x * (5846471053959190028880485661894891163596000435605b-162 + x * (2917719061827678043813769415697570710862370049051b-162 + x * (31877473743673721131764284633492051013566249115055b-167 + x * (26040878964869758854248710691789107998476450084373b-169 + x * 20808009104796731383700609709219405830023419999013b-170))))"); psvn = sollya_lib_parse_string("5845999945851149656234435605422211132352886535717b-162 + x * (23385884215836760115545970932838216522984359588165b-164 + x * (5835438123655356087555656737495441519792436822103b-163 + x * (31877473743673721133327937242850399199174475687415b-167 + x * (6510219741217439713495165031525459507010189269817b-167 + x * 10404004552398365689695293864167514071470455315299b-169))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(5); I = sollya_lib_parse_string("[0, 1]"); w = sollya_lib_default(); quality = sollya_lib_parse_string("1e-15"); res = stupid_wrapper(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("11691999891702299312469444817572169311673890781507b-163 + x * (5846471053959190028880485661894891163596000435605b-162 + x * (2917719061827678043813769415697570710862370049051b-162 + x * (31877473743673721131764284633492051013566249115055b-167 + x * (26040878964869758854248710691789107998476450084373b-169 + x * 20808009104796731383700609709219405830023419999013b-170))))"); pold64 = sollya_lib_parse_string("11691999891702299312469444817572169311673890781507b-163 + x * (5846471053959190028880485661894891163596000435605b-162 + x * (2917719061827678043813769415697570710862370049051b-162 + x * (31877473743673721131764284633492051013566249115055b-167 + x * (26040878964869758854248710691789107998476450084373b-169 + x * 20808009104796731383700609709219405830023419999013b-170))))"); psvn = sollya_lib_parse_string("5845999945851149656234435605422211132352886535717b-162 + x * (23385884215836760115545970932838216522984359588165b-164 + x * (5835438123655356087555656737495441519792436822103b-163 + x * (31877473743673721133327937242850399199174475687415b-167 + x * (6510219741217439713495165031525459507010189269817b-167 + x * 10404004552398365689695293864167514071470455315299b-169))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #10 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_ATAN(SOLLYA_X_); n = SOLLYA_CONST(10); I = sollya_lib_parse_string("[-1, 1]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("38372544245022954071593576343710401499b-180 + x * (23380900442023710590629720276282789164224450528167b-164 + x * (-33609089175829249495416553130562627902380011341963b-215 + x * (-7723855757337398739828398738169459706253746872539b-164 + x * (14798371425256328739831059603503168717188731259649b-211 + x * (33702797323732429414901179632614772732191491283097b-167 + x * (-20026589901676225916120391461096241995653144141359b-210 + x * (-7965193355045203212490647632529296700704259316517b-166 + x * (11492309484232489173482584564890302837739876433267b-209 + x * (31196332541693159565915304978636341240498090752081b-170 + x * (-18696265896642848807310482596711689481317128284659b-211))))))))))"); pold64 = sollya_lib_parse_string("38372544245022954071593576343710401499b-180 + x * (23380900442023710590629720276282789164224450528167b-164 + x * (-33609089175829249495416553130562627902380011341963b-215 + x * (-7723855757337398739828398738169459706253746872539b-164 + x * (14798371425256328739831059603503168717188731259649b-211 + x * (33702797323732429414901179632614772732191491283097b-167 + x * (-20026589901676225916120391461096241995653144141359b-210 + x * (-7965193355045203212490647632529296700704259316517b-166 + x * (11492309484232489173482584564890302837739876433267b-209 + x * (31196332541693159565915304978636341240498090752081b-170 + x * (-18696265896642848807310482596711689481317128284659b-211))))))))))"); psvn = sollya_lib_parse_string("-299518546557879520665255352509681884284993b-181 + x * (46761800881643993210141123783443178910382594686091b-165 + x * (15626932760797014273458339403729579988713039201177b-197 + x * (-30895422984424026393941474369915254415267721041803b-166 + x * (-37843049683583409517658396527903377324449648118839b-195 + x * (33702797050918309664309509947748141237482896518641b-167 + x * (14340405569685532672251459301997641076318498173369b-192 + x * (-31860772758098094375292352991903847201619947720321b-168 + x * (-34116843989195391948704554536758220176631032690829b-193 + x * (974885357098662804386862783336303497880652218429b-165 + x * 13921338801137066666041733737929563262809760263031b-193)))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #11 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(3); I = sollya_lib_parse_string("[0, 1]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("46742573553811911796274412764391966160112581418361b-165 + x * (185720745566008984665440218961959381728519963271b-157 + x * (2465278576003452056620348681425508255554707916727b-162 + x * 26187910218233432242621629490193931328425524460129b-166))"); pold64 = sollya_lib_parse_string("46742573553811911796274412764391966160112581418361b-165 + x * (185720745566008984665440218961959381728519963271b-157 + x * (2465278576003452056620348681425508255554707916727b-162 + x * 26187910218233432242621629490193931328425524460129b-166))"); psvn = sollya_lib_parse_string("5842821694226678901701403157817208990903244674607b-162 + x * (11886127716219130633708414511730040683306080916975b-163 + x * (19722228608052746177156080281278926582286515128695b-165 + x * 26187910218226727873273123845127088231281394729319b-166))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #12 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_SIN(SOLLYA_X_); n = SOLLYA_CONST(10); I = sollya_lib_parse_string("[-1, 1]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("-1678574854834777132325060817371809361210735b-195 + x * (5846006547781923868641738892908189653030528304081b-162 + x * (5186811493742158415982843490921456281458058504887b-212 + x * (-31178700608529053074795655135118567830794991320849b-167 + x * (-17684054797287521526384201972347004604281755888439b-211 + x * (24942872635780650464194733939244297067048845011387b-171 + x * (22016393755287390814121400437369894118518307246709b-210 + x * (-4749415908268213847793669454772779765296429152301b-174 + x * (-45380107924050076762231472980106618449214871580875b-211 + x * (32950198265521156768718284738219033131726498607409b-183 + x * 33095953091156378813051015035960771162990683757215b-212)))))))))"); pold64 = sollya_lib_parse_string("-1678574854834777132325060817371809361210735b-195 + x * (5846006547781923868641738892908189653030528304081b-162 + x * (5186811493742158415982843490921456281458058504887b-212 + x * (-31178700608529053074795655135118567830794991320849b-167 + x * (-17684054797287521526384201972347004604281755888439b-211 + x * (24942872635780650464194733939244297067048845011387b-171 + x * (22016393755287390814121400437369894118518307246709b-210 + x * (-4749415908268213847793669454772779765296429152301b-174 + x * (-45380107924050076762231472980106618449214871580875b-211 + x * (32950198265521156768718284738219033131726498607409b-183 + x * 33095953091156378813051015035960771162990683757215b-212)))))))))"); psvn = sollya_lib_parse_string("-501469618235094668449707646317635919279433b-200 + x * (11692013095563848406205506363824123741381520090139b-163 + x * (35620680907110926409952304136880869962315563985327b-221 + x * (-31178700608529090497338468003375391002953276015721b-167 + x * (-1128778635011195860269996678779233379792952318519b-213 + x * (24942872635784374822466512879970305036022055002917b-171 + x * (11978333137537591148120847557596099349826247948291b-215 + x * (-9498831816665181898799354229729984976210026113385b-175 + x * (-25536101833773061591914574416528636823559165769255b-216 + x * (32950198285237698762568735027923570972010884588359b-183 + x * 19058765346681769783426726535203697116534992847419b-217)))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #13 ================\n"); prec = SOLLYA_CONST(400); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_EXP(SOLLYA_X_)); n = SOLLYA_CONST(25); I = sollya_lib_parse_string("[-1/8, 1/8]"); quality = sollya_lib_parse_string("1e-40"); res = stupid_wrapper(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("161390617380431786853494948250188242145606612051826469551955379941434960076203657512239965672175150832369427924571327933b-396 + x * (2582249878086908589655919172003011874329705792829223512815518586697713929528373906645973178921345938870139944690922674719b-400 + x * (2582249878086908589655919172003011874329705792829223485685832626402974434496485981425174368061267812180286898481509725671b-401 + x * (1721499918724605726437279448002007916219803861886149410406732804556694110264268799366882772800656159764861209972164484205b-402 + x * (430374979681151431609319862000501979054950965471732012462885573145148550524342099381399012383180900245523589700170524133b-402 + x * (1377199934979684581149823558401606332975843089496293355610634191387301345954222763890552010541004557848043938741178151699b-406 + x * (918133289986456387433215705601070888650562042107828893577378984985802017340780034420418039342184959156809188297142744975b-408 + x * (2098590377111900314133064469945304888344142586006558021664462294500550566006715853849729548334078513627267405790955317995b-412 + x * (2098590377111900314133064469945304888345787506900621321180727067543258071161052823401917796984757736187655589072408299063b-415 + x * (466353417135977847585125437765623308514931894662593265387822335180764499496513126666357989921279120928715711788963003853b-416 + x * (1492330934835129112272401400849994541401556850483751940809697007101719533588456093085148424645368218472711086153465369745b-421 + x * (542665794485501495371782327581816454357534185948580690447803027072292049780254099877219461967508882519283166690502899997b-423 + x * (723554392647335327162376436776575188728320134851889625237160943201761614313054851000351657881568088833377803218059300269b-427 + x * (1781056966516517728399695844345844215372471556174952462382582280718355455253866004121406344397890554175851263316922607569b-432 + x * (508873419004719350971341650169098890399521214954235811771143731737284929667556652712937386546656949766148389278605087449b-434 + x * (2171193254420135897477725344179594326124834570679287455570164950528675466483358002551258133738010625366840419395002970151b-440 + x * (542798313605033974370075337706401928002793026768980861612649913973919428294315062471434161634783741775104301987170180913b-442 + x * (2043476004160127903487494000509588015818708867395743746978714423885089063524101669876222772309992862092677104256708028515b-448 + x * (454105778702250630730985753828746431279635370264398739548474403059075817085065739554350706233574401054757346846349616091b-450 + x * (1529619465102318290396191335466982351668824576419822769979570691541195457819322839083484971691416193070080717307820096573b-456 + x * (19120243313792727007427770378223565295754614486585379700107158437774929323650748483979182572831002782497789306950108115b-454 + x * (1864678966975461754778135403670357609027436049075542111503616505395034722356341051966639526803224699875841442314088899867b-465 + x * (678065070284798591971107193700619246254693193913266466079001229674269542931115396375932917051666799806461803260495692375b-468 + x * (1886789853182169718590609346799899921135706970254622139162469534096421624662899054210479361093776718465635395892988821967b-474 + x * (2516112710027923243369908368888976324181415757063417914592398528680717333744550145476637666909737722020354051992072953817b-479 + x * 50307115488146658682733933302724747268538227244369668577358664240031360337093741929589647579922106753044861061577239247b-478))))))))))))))))))))))))"); pold64 = sollya_lib_parse_string("40347654345107946713373737062547060536401653012956617387988844985358740019050914378059991418043787708092356981303897685b-394 + x * (2582249878086908589655919172003011874329705792829223512815518586697713929528373906645973178921345938870139926226572530419b-400 + x * (2582249878086908589655919172003011874329705792829223485685832626402974434496485981425174368061267812180282125000422255911b-401 + x * (860749959362302863218639724001003958109901930943074705203366402278347055132134399683441386400328079882648031171242699173b-401 + x * (860749959362302863218639724001003958109901930943464024925771146290297101048684198762798024766361800519426800804325423261b-403 + x * (2689843623007196447558249137503137369093443534172447960177019905053322941316841335723734395587899493844083791919392107b-397 + x * (1836266579972912774866431411202141777301124084215657787154757969971604034681560068840836078684369856252482870680526569565b-409 + x * (524647594277975078533266117486326222086035646501639505416115573625137641501678963462432387083804078551349852471424366881b-410 + x * (2098590377111900314133064469945304888345787506900621321180727067543258071161052823401917796924550191857500025280407601681b-415 + x * (932706834271955695170250875531246617029863789325186530775644670361528998993026253332715959587593584168853466498978493359b-417 + x * (746165467417564556136200700424997270700778425241875970404848503550859766794228046542575476250648530710852883838050956953b-420 + x * (2170663177942005981487129310327265817430136743794322761791212108289168199121016399510605899167723492392769350299425793467b-425 + x * (361777196323667663581188218388287594364160067425944812618580471600880807156527425474829065505737939544865331259422833885b-426 + x * (1781056966516517728399695844345844215372471556174952462382582280718355455253865956950153988746212242282738289838998624873b-432 + x * (1017746838009438701942683300338197780799042429908471623542287463474569859335115708752954312779336577592615316744664682969b-435 + x * (2171193254420135897477725344179594326124834570679287455570164950528675466485064591832988938624819005420325820282167690501b-440 + x * (542798313605033974370075337706401928002793026768980861612649913973919428258372130710028952129061378622338285405291189611b-442 + x * (2043476004160127903487494000509588015818708867395743746978714423885089022119822083619278399482467899458468117240299862735b-448 + x * (1816423114809002522923943015314985725118541481057594958193897612236306014723991503049169276327319997307976033324504731927b-452 + x * (1529619465102318290396191335466982351668824576419822769979570691541861911335333959863748886364482689496284252774938835763b-456 + x * (611847786041367264237688652103154089464147663570732150403429069992530290695438702459754703049302351095233153303462760107b-459 + x * (116542435435966359673633462729397350564214753067221381968976030733466566923737898464146533011998759208748515650262757833b-461 + x * (678065070284798591971107193700619246254693193913266466079001447615324869593187070765855363583452756240464620094460862779b-468 + x * (943394926591084859295304673399949960567853485127311069581315469253949592743326197255792712101563256946658640743668942465b-473 + x * (1258056355013961621684954184444488162090707878531708957293674068630135446803760583617837399906318732340257693807559576789b-478 + x * 804913847810346538923742932843595956296611635909914696819171177188150929320002028022779677696622256806586637731183250781b-482))))))))))))))))))))))))"); psvn = sollya_lib_parse_string("322781234760863573706989896500376484291213224103652939103910759882869920152407315024479931344350301664738855877716953233b-397 + x * (2582249878086908589655919172003011874329705792829223512815518586697713929528373906645973178921345938870139917496983436547b-400 + x * (322781234760863573706989896500376484291213224103652935710729078300371804312060747678146796007658476522534400639048326257b-398 + x * (215187489840575715804659931000250989527475482735768676300841600569586763783033599920860346600082019970677345421220989365b-399 + x * (215187489840575715804659931000250989527475482735866006231442786572574275262171049690699506191590450147611339571114332875b-401 + x * (86074995936230286321863972400100395810990193093518334725664636961706334122138922743159500658812783583670405968683128629b-402 + x * (229533322496614096858303926400267722162640510526957223394344746246450504335195008605104509835545644409092901087604544675b-406 + x * (524647594277975078533266117486326222086035646501639505416115573625137641501678963462432387083862534640861338611109593713b-410 + x * (1049295188555950157066532234972652444172893753450310660590363533771629035580526411700958898544937412080047978435348712663b-414 + x * (932706834271955695170250875531246617029863789325186530775644670361528998993026253332715955100711707168416780337610877655b-417 + x * (1492330934835129112272401400849994541401556850483751940809697007101719533588456093085147444937191584321384263876383340095b-421 + x * (2170663177942005981487129310327265817430136743794322761791212108289168199121016399511022765792218903652988214513312856103b-425 + x * (1447108785294670654324752873553150377456640269703779250474321886403523228626109701995372192338698312632456211997150128931b-428 + x * (55658030203641179012490495135807631730389736130467264449455696272448607976683310769804731474744691911992680097598424237b-427 + x * (2035493676018877403885366600676395561598084859816943247084574926949139718670227902558813571256713100640996854633281035007b-436 + x * (2171193254420135897477725344179594326124834570679287455570164950528675466485542447945601193415112392184189585676454336315b-440 + x * (542798313605033974370075337706401928002793026768980861612649913973919428280091492437959294874814210466569463784562330835b-442 + x * (2043476004160127903487494000509588015818708867395743746978714423885089009799059654815955419940954308858052258556151366221b-448 + x * (1816423114809002522923943015314985725118541481057594958193897612236304581434438367655186328396155237501320381759356490615b-452 + x * (1529619465102318290396191335466982351668824576419822769979570691542070957164975815069679148246384821231067099343136098321b-456 + x * (2447391144165469056950754608412616357856590654282928601613716280000378390117407187338735367488534615108410922687299482825b-461 + x * (932339483487730877389067701835178804513718024537771055751808243625667767026354230066961864474108971019815002730940286519b-464 + x * (169516267571199647992776798425154811563673298478316616519750338800836477027932354552473274172640840616069899166552838595b-466 + x * (471697463295542429647652336699974980283926742563655534790671511774808513886873528374826427763415526242932575396729201841b-472 + x * (2516112710027923243369908368888976324181415757063417914589335963128256773414910370734693737723384103402834997935138370453b-479 + x * 1609827695620693077847485865687191912593223271819829393342670614997429234517774491398970587717345702913258027881874277425b-483))))))))))))))))))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #14 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_EXP(SOLLYA_X_); n = SOLLYA_CONST(10); I = sollya_lib_parse_string("[0, 1]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("23384026197294909850223840992809340481141545456185b-164 + x * (23384026197183194624978796257378849130918970768719b-164 + x * (11692013103063455329995041984738330602777159874659b-164 + x * (31178701049749408969300159772616151147056225354243b-167 + x * (31178718928032908530740508502853005869373615788143b-169 + x * (24942641274774123930888945415406111016671104869359b-171 + x * (33264627827944578300293076057231916380765491375043b-174 + x * (18950258324398416999410271318831779761843002307777b-176 + x * (39016347215689526123052797965843565732733417180009b-180 + x * (14014192292950540150415375020363290646996307648069b-182 + x * 2802308148667058909292393693969468428746054200227b-182)))))))))"); pold64 = sollya_lib_parse_string("23384026197294909850223840992809340481141545456185b-164 + x * (23384026197183194624978796257378849130918970768719b-164 + x * (11692013103063455329995041984738330602777159874659b-164 + x * (31178701049749408969300159772616151147056225354243b-167 + x * (31178718928032908530740508502853005869373615788143b-169 + x * (24942641274774123930888945415406111016671104869359b-171 + x * (33264627827944578300293076057231916380765491375043b-174 + x * (18950258324398416999410271318831779761843002307777b-176 + x * (39016347215689526123052797965843565732733417180009b-180 + x * (14014192292950540150415375020363290646996307648069b-182 + x * 2802308148667058909292393693969468428746054200227b-182)))))))))"); psvn = sollya_lib_parse_string("11692013098647454925479766594890768402020389016685b-163 + x * (2923003274647899314022989689912663654170960733739b-161 + x * (23384026206126916717621326407453992440024639124631b-165 + x * (3897337631218641563117791179495583256345586131443b-164 + x * (31178718928039669757532735707023766163548760260885b-169 + x * (24942641274676881997211624204256299106764248859825b-171 + x * (33264627829661543681005336437047562199181910619221b-174 + x * (1184391144687711538704423090650991631165709423125b-172 + x * (4877043417471098209911175115217626323630091258985b-177 + x * (28028384133527983626040751345914065460389879764863b-183 + x * 44836931077334323181376267238444603759641933172525b-186)))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #15 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_COS(SOLLYA_X_)); n = SOLLYA_CONST(15); I = sollya_lib_parse_string("[-1/2, 1/4]"); quality = sollya_lib_parse_string("1e-40"); res = stupid_wrapper(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("2037035976334486086268445369435520635669474321562577451975655157097896464243257676249067023b-300 + x * (-147022966028724218954630457508230947486371372871749025252274007219232544034284648139415787b-373 + x * (-2037035976334486086267813534277772106898100862459457575607571406931639199411180914730434671b-301 + x * (1644629116256985976487964471064420022272893859535101909440375675266852682766040066939757477b-368 + x * (1358023984222990723447194731402895074478493689559655697573367338981199184886376418609600393b-304 + x * (-1410502123645648389482990176064909235877375828877296670824273606862592472726771255810394497b-361 + x * (-1448558916504522421008699188242670201543249049661405841998293770230912599051296200711718225b-309 + x * (539099188072322128769712711403419973541337473075122764966536485997508305218365952629146421b-354 + x * (827747952288080278806805188627854434960592102720762386536796656170780754344747602124202003b-314 + x * (-797047321997901203825499478107502791492353540573826383432166459902911767841610788036548779b-350 + x * (-1177241534201309254225497658165796336282985949571010147067884030194722915344294071302142951b-321 + x * (2000920995024742776650603097530534335966489792343502135715895342850001531040565868127767b-338 + x * (1141573461565483381928707239907860736890956525739802194008371659491759020811660632918762481b-328 + x * (-1569482484524507248868121030716379419120450572564469525806037183646653943119665927925997873b-347 + x * (-1614534504445457486506762534809318663084383593349434912234239957430267008365062703268491847b-336 + x * (-428026523256046596374630313117538331924801089558422800532774851557691869752368542107371539b-341)))))))))))))))"); pold64 = sollya_lib_parse_string("23384026197294446691258953661820219905513142999997b-164 + x * (-27003854063734750849884821333808741158467473742595b-241 + x * (-23384026197294446691251700549919982557379607705321b-165 + x * (37758832721834729315051124292478278364221823357325b-233 + x * (1948668849774537223221542671047764362309720717625b-165 + x * (-32383540589224596878145415657450161861333033785079b-226 + x * (-33257281702818745252782110178958829782540667558185b-174 + x * (6188555176873990055241491435716663097447123323431b-218 + x * (38008321946068544570195875158242165410103806748873b-180 + x * (-36598618138537720042729778331398363620481658419391b-216 + x * (-3378517512224125484327326252982467949824603981687b-183 + x * (23520713260932955827973162823434838850936138699919b-212 + x * (13104620655457709642089971023765909010985616378681b-192 + x * (-36033550669396221651928873829838168286171617182909b-212 + x * (-9266973579996565980194798904182086061308550848519b-199 + x * (-39308028131999003166237923968395842357350102726509b-208)))))))))))))))"); psvn = sollya_lib_parse_string("2037035976334486086268445369435520635669474321562577451975655157097896464243257671397097913b-300 + x * (-1176183728229793751637043660065847579890970982973992202010414015204696627262467139379764029b-376 + x * (-254629497041810760783476691784721513362262607807432196950946425866454899926397153399607781b-298 + x * (1644629116256985976487964471064420022272893859535101909434031953675864992648891286038789435b-368 + x * (1358023984222990723447194731402895074478493689559655697573367338981199184883856076285964445b-304 + x * (-705251061822824194741495088032454617938687914438648335410722373975668856478821775383473093b-360 + x * (-724279458252261210504349594121335100771624524830702920999146885115456297982352023632567717b-308 + x * (539099188072322128769712711403419973541337473075122764966008962096033302633773492746513937b-354 + x * (413873976144040139403402594313927217480296051360381193268398328085389343770403986416032953b-313 + x * (-778366525388575394360839334089358194816751504466627327570123773750386092643938586073693b-340 + x * (-1177241534201309254225497658165796336282985949571010147067884030191605631226200688044978549b-321 + x * (512235774726334150822554392967816790007421386839936546743185078349352360000905812636728755b-346 + x * (1141573461565483381928707239907860736890956525739802194008371657122260546600652960078317033b-328 + x * (-784741242262253624434060515358189709560225286282234762903248657515610266886473073544093209b-346 + x * (-201816813055682185813345316851164832885547949168679364029279847737577066398917512602560307b-333 + x * (-1712106093024186385498521252470153327699204358233691202130959727264412424137740563374441917b-343)))))))))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #16 ================\n"); prec = SOLLYA_CONST(200); sollya_lib_set_prec(prec); f = SOLLYA_SIN(SOLLYA_X_); w = SOLLYA_CONST(1); n = SOLLYA_CONST(9); I = sollya_lib_parse_string("[-1/2, 1/2]"); quality = sollya_lib_parse_string("1e-40"); res = stupid_wrapper(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("-86947901283126667b-244 + x * (1606938044258570093798407961449753679676162673259975802224191b-200 + x * (13636820948132726187694106438306066516729639249701307318935b-373 + x * (-1071292029371495160966220394362561448878316413905740061801861b-202 + x * (-111990244421936242081011350812209431978491985227156656276615b-371 + x * (857033575383108922734866118457470597964184028156001905494615b-206 + x * (549321510198610685060667636750153381459576297857810582292629b-370 + x * (-652963883135120024306270284879808076963840233212115246631809b-211 + x * (-1596641875356444035698494903347006028859398613195275802297331b-370 + x * 1153615303801817099389035339506468998354123628680403050940707b-218))))))))"); pold64 = sollya_lib_parse_string("1101702397987b-245 + x * (1606938044258570093798407961449753679676162673259975802192261b-200 + x * (-1391143701206469558761975841650146109945844716683463572892595b-394 + x * (-1071292029371495160966220394362561448878316413905740060751103b-202 + x * (1099410985292744598667779066844465641116416435838202025648363b-390 + x * (857033575383108922734866118457470597964184028156004135919475b-206 + x * (-1161799305280053672790319311141790392778132728191469440939649b-388 + x * (-1305927766270240048612540569759616153927680466426312867749207b-212 + x * (95785462876615352149535634672062757573412322268306607987879b-384 + x * 576807651900908549694517669753234499177061814565628571151813b-217))))))))"); psvn = sollya_lib_parse_string("5119600653300209b-246 + x * (803469022129285046899203980724876839838081336629987901096367b-199 + x * (-201900659293567833992865902103684434843931295566368931355751b-383 + x * (-1071292029371495160966220394362561448878316413905740060766587b-202 + x * (825124598372502403051371387459200482219416407231744562965875b-380 + x * (428516787691554461367433059228735298982092014078002051962743b-205 + x * (-1009147081261682703749474816682212409401787097671013031504583b-377 + x * (-326481941567560012153135142439904038481920116606570763522007b-210 + x * (366558600702259702423292890113706752781180393271089391738525b-374 + x * 576807651900908549694517669753234499177061814562399320345937b-217))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #17 ================\n"); prec = SOLLYA_CONST(200); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_EXP(SOLLYA_ADD(SOLLYA_POW(SOLLYA_COS(SOLLYA_X_), SOLLYA_CONST(2)), SOLLYA_CONST(1)))); n = SOLLYA_CONST(15); I = sollya_lib_parse_string("[1,2]"); quality = sollya_lib_parse_string("1e-40"); res = stupid_wrapper(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1429129772344635854127522980319603763315581962207637816481495b-197 + x * (1258278747211590164438565899307058663065266450700796107832479b-198 + x * (-1202878917246296858587934180920738608442450055679313080135115b-195 + x * (336837707566227764251712761526301661125280453907774843967313b-192 + x * (-1411317735908160715166251154609539762583930751245877998128451b-193 + x * (1180739419570963338745592334849712845368799300827296718761131b-192 + x * (-1400829552020409071501690715419925186599874201865469197848967b-192 + x * (73774156815960633806864131107864831639587911807241292641453b-188 + x * (-720401733120572588026235911018525487050411202136172115523201b-192 + x * (80348824392035439630284753878261997158325598597726556408827b-190 + x * (-416085524045616662367389437501662300792235411427007456053439b-194 + x * (1516396334943608786362280214735888311251638266120825634313019b-198 + x * (-906020503784862624475910695302721150708070846898444362431877b-200 + x * (1187929837442894851249315789697675967541152927109058015663159b-204 + x * (-1304662018163848750887736589024039856901512670169419818894241b-210 + x * (-729069044992515022585488029954641599182740016769331847317347b-212)))))))))))))))"); pold64 = sollya_lib_parse_string("714564886172317927063761490159801881657790981010465303668201b-196 + x * (1258278747211590164438565899307058663065266454696322711478861b-198 + x * (-18794983081973388415436471576886540756913282158790900538475b-189 + x * (1347350830264911057006851046105206644501121819436710187690425b-194 + x * (-1411317735908160715166251154609539762583930755266304814879647b-193 + x * (590369709785481669372796167424856422684399651964417662529631b-191 + x * (-700414776010204535750845357709962593299937102737693735725465b-191 + x * (1180386509055370140909826097725837306233406592143442790143967b-192 + x * (-720401733120572588026235911018525487050411204371202279457173b-192 + x * (1285581190272567034084556062052191954533209582358572230577769b-194 + x * (-832171048091233324734778875003324601584470826805302456706021b-195 + x * (379099083735902196590570053683972077812909568986721325878589b-196 + x * (-906020503784862624475910695302721150708070855821307509854977b-200 + x * (1187929837442894851249315789697675967541152949455838970639555b-204 + x * (-163082752270481093860967073628004982112689101024071081715501b-207 + x * (-1458138089985030045170976059909283198365479984009101751117121b-213)))))))))))))))"); psvn = sollya_lib_parse_string("714564886172317927063761490159801881657790980941038093582955b-196 + x * (157284843401448770554820737413382332883158307209856051503421b-195 + x * (-601439458623148429293967090460369304221225030011602564440427b-194 + x * (1347350830264911057006851046105206644501121822298593252104795b-194 + x * (-1411317735908160715166251154609539762583930758300920035042625b-193 + x * (295184854892740834686398083712428211342199826569628293662483b-190 + x * (-350207388005102267875422678854981296649968552055066361959517b-190 + x * (1180386509055370140909826097725837306233406594606596965076293b-192 + x * (-180100433280143147006558977754631371762602801520776769328315b-190 + x * (1285581190272567034084556062052191954533209586044565215103713b-194 + x * (-832171048091233324734778875003324601584470829853727191930371b-195 + x * (758198167471804393181140107367944155625819141777467611978757b-197 + x * (-906020503784862624475910695302721150708070862754694236638027b-200 + x * (148491229680361856406164473712209495942644120860204666721477b-201 + x * (-1304662018163848750887736589024039856901512916200236511645811b-210 + x * (-1458138089985030045170976059909283198365479945115367833194563b-213)))))))))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #18 ================\n"); prec = SOLLYA_CONST(200); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_TAN(SOLLYA_X_)); n = SOLLYA_CONST(10); I = sollya_lib_parse_string("[1/4,1/2]"); quality = sollya_lib_parse_string("1e-40"); res = stupid_wrapper(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1094653698906394439537746354636570119587248281854588161151645b-219 + x * (803437057336964936961730558645726525457791801950137635572287b-199 + x * (902021694368808954079103247381093078629104460444437390593653b-210 + x * (1056889635883223009274070235439924443715342210868409313160023b-201 + x * (1239694968725463472760134669503154963255295977288145886845797b-205 + x * (282532854374805521596477948893958861358073979772606588154531b-202 + x * (745643752889790461146602566612321479694038184243781141844107b-201 + x * (-1171551728340426070339628381549725358789127811584844764092781b-201 + x * (813974777057437275620501698223620379521525143974703084506525b-200 + x * (-573353867651326030295462629700963357884059020692651314615537b-200 + x * 909290520151942024628769491295084023281483044413698733753071b-202)))))))))"); pold64 = sollya_lib_parse_string("1094653698906394439537746354636570119587248281853335503513195b-219 + x * (100429632167120617120216319830715815682223975243767208610777b-196 + x * (112752711796101119259887905922636634828638057555448406782225b-207 + x * (528444817941611504637035117719962221857671105434210743859435b-200 + x * (1239694968725463472760134669503154963255295977287215108448943b-205 + x * (282532854374805521596477948893958861358073979772985177962475b-202 + x * (372821876444895230573301283306160739847019092121678155896023b-200 + x * (-146443966042553258792453547693715669848640976448024424165389b-198 + x * (813974777057437275620501698223620379521525143974379564626113b-200 + x * (-1146707735302652060590925259401926715768118041384923094249915b-201 + x * 113661315018992753078596186411885502910185380551687459548631b-199)))))))))"); psvn = sollya_lib_parse_string("547326849453197219768873177318285059793624140926213615540933b-218 + x * (803437057336964936961730558645726525457791801950137694214707b-199 + x * (902021694368808954079103247381093078629104460442909284056059b-210 + x * (1056889635883223009274070235439924443715342210868431674482813b-201 + x * (1239694968725463472760134669503154963255295977286397777664587b-205 + x * (141266427187402760798238974446979430679036989886667072346625b-201 + x * (372821876444895230573301283306160739847019092121472590934753b-200 + x * (-1171551728340426070339628381549725358789127811583535484887981b-201 + x * (406987388528718637810250849111810189760762571987017133695939b-199 + x * (-573353867651326030295462629700963357884059020692248788608963b-200 + x * 909290520151942024628769491295084023281483044413265206466819b-202)))))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #19 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_POW(SOLLYA_X_, SOLLYA_CONST(2.5))); n = SOLLYA_CONST(7); I = sollya_lib_parse_string("[1,2]"); quality = sollya_lib_parse_string("1e-40"); res = stupid_wrapper(f,n,I,w,quality, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("30384532462332540461916109637629717389849715629829b-171 + x * (-3988089244372918017948764449242449608854351178857b-165 + x * (12811690968338316880563803186322867131597579395639b-164 + x * (7556488996758112745826292894088723697015390350955b-163 + x * (-28279885329592063848877875417848304249497177042921b-167 + x * (28332008519536597633619239409928869027803601428177b-169 + x * (-581679350863052459602370172446562830505796444253b-166 + x * 22636516313646583057384577954643601031050496316849b-175))))))"); pold64 = sollya_lib_parse_string("30384532462332540461916109637629717389849715629829b-171 + x * (-3988089244372918017948764449242449608854351178857b-165 + x * (12811690968338316880563803186322867131597579395639b-164 + x * (7556488996758112745826292894088723697015390350955b-163 + x * (-28279885329592063848877875417848304249497177042921b-167 + x * (28332008519536597633619239409928869027803601428177b-169 + x * (-581679350863052459602370172446562830505796444253b-166 + x * 22636516313646583057384577954643601031050496316849b-175))))))"); psvn = sollya_lib_parse_string("30384532462332540461916109637629717389849717946267b-171 + x * (-7976178488745836035897528898484899217708702741833b-166 + x * (12811690968338316880563803186322867131597579611375b-164 + x * (30225955987032450983305171576354894788061560871829b-165 + x * (-28279885329592063848877875417848304249497175487639b-167 + x * (14166004259768298816809619704964434513901799366283b-168 + x * (-4653434806904419676818961379572502644046370912779b-169 + x * 45273032627293166114769155909287202062100984362831b-176))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(quality); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #20 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[1;32769b-15]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519116931250074582514616920029812964033041191732166366208315683368591845444321107391435481b-299 + x * (461432969284079015555143407908324792312068012734235836652935285714259885748478589922847529b-299 + x * (346082648236258546966032322765771598479520265273144739387947665823565730921236322003050251b-299 + x * (-1845774007687049558287217203353987444440450373590070022669568374961280228727054054051744831b-318 + x * 1845774123550678624355073867555708750724188033665817979913979575189149376462087383277483735b-304)))"); pold64 = sollya_lib_parse_string("519116931250074582514616920029812964033041191732166366208315683368591845444321107391435481b-299 + x * (461432969284079015555143407908324792312068012734235836652935285714259885748478589922847529b-299 + x * (346082648236258546966032322765771598479520265273144739387947665823565730921236322003050251b-299 + x * (-1845774007687049558287217203353987444440450373590070022669568374961280228727054054051744831b-318 + x * 1845774123550678624355073867555708750724188033665817979913979575189149376462087383277483735b-304)))"); psvn = sollya_lib_parse_string("1038233862500138128475875956868800306632428862675682390630488920717334717811797516870946673b-300 + x * (1845731877136404353345197824363965360441000443429813536018330496370929583427539223063362555b-301 + x * (1384330592944901753130528148077906569022099276087325621882837928258673245249321784698887013b-301 + x * (-1845773996114896639580051046710666959523710035868209257249170813067311098077820745452470793b-318 + x * 461443530887625512479768353802665452066045555725266067356194961948251810773107744094813571b-302)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #21 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32769b-15;16385b-14]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038237383518400955977367009839350382183594881758703803206614495107092340077049399411473967b-300 + x * (115356481865619084755480970440415065182680519289900564187797650531309907130834307553810629b-297 + x * (346093210646321553188501224312760439606720851854109105733752355133531620668552095227966953b-299 + x * (-1384372810757865863246870774013473664314069086622551199217497615222312154655846982330854047b-316 + x * 922915226483104741726827502416104539849150495728611277321715440071753905846249319975793783b-303)))"); pold64 = sollya_lib_parse_string("1038237383518400955977367009839350382183594881758703803206614495107092340077049399411473967b-300 + x * (115356481865619084755480970440415065182680519289900564187797650531309907130834307553810629b-297 + x * (346093210646321553188501224312760439606720851854109105733752355133531620668552095227966953b-299 + x * (-1384372810757865863246870774013473664314069086622551199217497615222312154655846982330854047b-316 + x * 922915226483104741726827502416104539849150495728611277321715440071753905846249319975793783b-303)))"); psvn = sollya_lib_parse_string("519118691759194958869938336993917153759287839591458508418456567188501184298624872726100021b-299 + x * (922851854924996828995230076840742652224275493891088804975529618856025119380957142467717349b-300 + x * (1384372842585153765895329298580219550625999434847837181868479524834573737784352062675124987b-301 + x * (-21630825122885172715474116247404241411834884929307264625155299577493640947606454518049021b-310 + x * 461457613241508225907237045562485154919767748953769588607075164270235967889768812953893733b-302)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #22 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[16385b-14;32771b-15]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038240905073938809564185146674779242326355205294558935393649861808689793476646895917998267b-300 + x * (1845675539125013381333631624704875717580705390911799805070033763505954280685015813184580603b-301 + x * (346103774023416837754962784984162191045292920130593796757336225574631447590348180153720899b-299 + x * (-576839612789582407852511079083681823850070896509088950771773952643899923582045367370743271b-314 + x * 1845886784100803912445798173029574729693497483658677219270101727506998653158623117662166741b-304)))"); pold64 = sollya_lib_parse_string("1038240905073938809564185146674779242326355205294558935393649861808689793476646895917998267b-300 + x * (1845675539125013381333631624704875717580705390911799805070033763505954280685015813184580603b-301 + x * (346103774023416837754962784984162191045292920130593796757336225574631447590348180153720899b-299 + x * (-576839612789582407852511079083681823850070896509088950771773952643899923582045367370743271b-314 + x * 1845886784100803912445798173029574729693497483658677219270101727506998653158623117662166741b-304)))"); psvn = sollya_lib_parse_string("519120452536963884821173244848899789501807316772478296222446759249397538745336823375809823b-299 + x * (1845675539125101694015605706461280777337860878884343298135109298542343529268042667699390915b-301 + x * (1384415096093534892035237675001300304985047505891202043397431733335781664070540161603927133b-301 + x * (-72104951508279319815327385157588544245642023780291058217791044568868088235988999943887227b-311 + x * 922943392050313663616110263716550440504329578501301689158501826794379977010195644488727179b-303)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #23 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32771b-15;8193b-13]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("259561106791707898293039710633779037559822312544256220625440469079039924536763394805587147b-298 + x * (922823682480649549181635253331914708804520679107862064077300309229451099522323876193792447b-300 + x * (692228676735226522485987916737252642808432088179842657020342965630357539103964428753876415b-300 + x * (-1615200212850920429100564708444107526276999411623835378169119182171976132997095979778353947b-315 + x * 1845943116954514373788808938428499536418675482610443460189101910631877163996812552600989749b-304)))"); pold64 = sollya_lib_parse_string("259561106791707898293039710633779037559822312544256220625440469079039924536763394805587147b-298 + x * (922823682480649549181635253331914708804520679107862064077300309229451099522323876193792447b-300 + x * (692228676735226522485987916737252642808432088179842657020342965630357539103964428753876415b-300 + x * (-1615200212850920429100564708444107526276999411623835378169119182171976132997095979778353947b-315 + x * 1845943116954514373788808938428499536418675482610443460189101910631877163996812552600989749b-304)))"); psvn = sollya_lib_parse_string("1038244427166820551565755973067147360355241963809994452142709091116644179810577841611351723b-300 + x * (1845647364961387421825523150084311418659650045680119146295042340946491798656971546590638849b-301 + x * (1384457353470320573860561042760847856837132747863114232386055905953473938377168004599301501b-301 + x * (-1615200211404136432467443495420435952306923966226610031809054827327191469221677447918295401b-315 + x * 922971558477168891593098006011029689206256949520522791428989183983865797157679647198709371b-303)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #24 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[8193b-13;32773b-15]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519123974898574090744797403189736402875820343090487170676158955496764340486780611707469221b-299 + x * (922809593679210720180621035369069149157607579947128535502043286129863499054654321549929891b-300 + x * (692249807357959376265836253883008438741613503989811188430199387556659219846343306612461139b-300 + x * (-129796835530224738633653365732089398163841549341692837949460264183292272644176377903552073b-311 + x * 922999725763696665770522218372845778462978965972769992666437562934620922571048924718626613b-303)))"); pold64 = sollya_lib_parse_string("519123974898574090744797403189736402875820343090487170676158955496764340486780611707469221b-299 + x * (922809593679210720180621035369069149157607579947128535502043286129863499054654321549929891b-300 + x * (692249807357959376265836253883008438741613503989811188430199387556659219846343306612461139b-300 + x * (-129796835530224738633653365732089398163841549341692837949460264183292272644176377903552073b-311 + x * 922999725763696665770522218372845778462978965972769992666437562934620922571048924718626613b-303)))"); psvn = sollya_lib_parse_string("1038247949797137138198411810152236042027150025677663036108739190315224689959792247512160749b-300 + x * (1845619187358509774604842467695937623435744055179726882540505213863424591596696213891671669b-301 + x * (346124903678946567323148220705739125716697802928868252801660951027451205747159679274351253b-299 + x * (-129796835439795219968125879277623388697425667763867935773182028537886821315832571839139797b-311 + x * 461499862881804183887307941678648489033912962903390891925428506090593169530838666607860305b-302)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #25 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32773b-15;16387b-14]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519125736482478728255637096057110002668939858540359785187786624133365569476475713671526253b-299 + x * (1845591006316039313290133964477145081689851856783638624326715045513173982902030827577833881b-301 + x * (173067734978792493403998750245008224483827818145325564230859424100484935217540396100814837b-298 + x * (-1269163346883319747703475308401267430788360043492450542435418710232211881459685542953257601b-314 + x * 923027893909746625680981117047890403034071303800802551819413990779907053305630158715234517b-303)))"); pold64 = sollya_lib_parse_string("519125736482478728255637096057110002668939858540359785187786624133365569476475713671526253b-299 + x * (1845591006316039313290133964477145081689851856783638624326715045513173982902030827577833881b-301 + x * (173067734978792493403998750245008224483827818145325564230859424100484935217540396100814837b-298 + x * (-1269163346883319747703475308401267430788360043492450542435418710232211881459685542953257601b-314 + x * 923027893909746625680981117047890403034071303800802551819413990779907053305630158715234517b-303)))"); psvn = sollya_lib_parse_string("129781434120618301441886891494335257230404040267358123905067326858051091215008648316707077b-297 + x * (1845591006316127658316151392181817495790692827365561158476937662377994536076814765442483925b-301 + x * (1384541879830207451864381985396784724052974165647827955280948849702069351845888573147632721b-301 + x * (-1269163346159839445350523220045430584331992463269364606309266712655742118702639730565130127b-314 + x * 230756973477414581247598169075781406036468241818904491493725969017677964460473556657443327b-301)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #26 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[16387b-14;32775b-15]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("129781874583791038442386371655888238747214651568295499870462632615589784132048754166817559b-297 + x * (1845562821833811595888707917735803085968761361790239982389832893025681836759066641151458825b-301 + x * (1384584148813992118218502092824141150820996752581358234459863858555017483845838529217963523b-301 + x * (-1499966094994776220877820593486293830101759281321418876570529901431945302547470745474971957b-314 + x * 923056062915433300256084594722183984064011594047292071874020456477159231091344608769404751b-303)))"); pold64 = sollya_lib_parse_string("129781874583791038442386371655888238747214651568295499870462632615589784132048754166817559b-297 + x * (1845562821833811595888707917735803085968761361790239982389832893025681836759066641151458825b-301 + x * (1384584148813992118218502092824141150820996752581358234459863858555017483845838529217963523b-301 + x * (-1499966094994776220877820593486293830101759281321418876570529901431945302547470745474971957b-314 + x * 923056062915433300256084594722183984064011594047292071874020456477159231091344608769404751b-303)))"); psvn = sollya_lib_parse_string("519127498335158630438849944537739003235788144925780928440246986880208839775007090726675597b-299 + x * (1845562821833899951698211738738811196398297128357832936381554474912053986902403755733150637b-301 + x * (1384584148813859610721502078307685229594954837084035891935610394605149725267561036620748249b-301 + x * (-749983047135625881737490579257942200594490085861072813969764878125190845156216961172183267b-313 + x * 1846112125830689993741463623643395385818060771384246846684899278004784835999453500264629919b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #27 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32775b-15;4097b-12]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038258520913329631182690364241114017060837400037458356533335658790054537690003841798971393b-300 + x * (1845534633911397139670115973835376772897004392321237091077394093224806285780259610993209833b-301 + x * (692313210833575385125038578893698920052248173732735304293505140886091558303904658423931033b-300 + x * (-1730782929220944054148482567938745159575983219937856205356812931349500903196307292525312495b-314 + x * 923084232780782923926735159276129795162580209945750248756228435482593334497531568751473455b-303)))"); pold64 = sollya_lib_parse_string("1038258520913329631182690364241114017060837400037458356533335658790054537690003841798971393b-300 + x * (1845534633911397139670115973835376772897004392321237091077394093224806285780259610993209833b-301 + x * (692313210833575385125038578893698920052248173732735304293505140886091558303904658423931033b-300 + x * (-1730782929220944054148482567938745159575983219937856205356812931349500903196307292525312495b-314 + x * 923084232780782923926735159276129795162580209945750248756228435482593334497531568751473455b-303)))"); psvn = sollya_lib_parse_string("1038258520913318582835871273068850476933856497077008462622245762799976468802191980219453751b-300 + x * (230691829238935688283021954504460225955832164377297712195680683883387600919481882172279827b-298 + x * (1384626421667018250622821490040263781999764206537059040333196049055481337520408035865245597b-301 + x * (-1730782928497375439674518395023876303183168123788598217714567069661455459900593836351181579b-314 + x * 461542116390347308923267897641860796326923886221496814784474481383857636583464998032289687b-302)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #28 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[4097b-12;32777b-15]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038262045694030331360107288571033481310845936055396192569911648051621914710101903264082523b-300 + x * (1845506442548454768920116619308727687991614007806277523964786136086245050686512829575540843b-301 + x * (173083587298761427962455984082138996639756712278337144683760477571124473370811720671440019b-298 + x * (-1961613850206626209203908481303935475641262125973990140990420781913512806725438551266796249b-314 + x * 28847262609556929122639338428295863535850904646269632285682528473324343941472711236120323b-298)))"); pold64 = sollya_lib_parse_string("1038262045694030331360107288571033481310845936055396192569911648051621914710101903264082523b-300 + x * (1845506442548454768920116619308727687991614007806277523964786136086245050686512829575540843b-301 + x * (173083587298761427962455984082138996639756712278337144683760477571124473370811720671440019b-298 + x * (-1961613850206626209203908481303935475641262125973990140990420781913512806725438551266796249b-314 + x * 28847262609556929122639338428295863535850904646269632285682528473324343941472711236120323b-298)))"); psvn = sollya_lib_parse_string("1038262045694019281327644184498830223124624538903533316526000381856241934726227296243277141b-300 + x * (461376610637135786574950413989595397954553370890732717751691452128820892831594675084109125b-299 + x * (692334349194979445970636423727417256143496794350725629890609626014440059141562269050675299b-300 + x * (-980806924741506717818749967271003360851474142455928734971270525619689801236608458317349921b-313 + x * 461556201752866711574665321587582831953372202433881041376295584330220815148852534671601019b-302)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #29 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32777b-15;16389b-14]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519132785506249659649202446742857299970401223489329249721092671862612630646516898175534471b-299 + x * (922739123872321640347645406112487210240542424232485865309181772337452142304813401978565157b-300 + x * (1384710978983089614554980944010000553236544926984416074420180493723390468154027020533019691b-301 + x * (-274057357324581485608201308026878795188066463784519077329794224330771414587511991256451199b-311 + x * 923140575090575960281429569584646159509857496569850532443973947641407848668443675573329097b-303)))"); pold64 = sollya_lib_parse_string("519132785506249659649202446742857299970401223489329249721092671862612630646516898175534471b-299 + x * (922739123872321640347645406112487210240542424232485865309181772337452142304813401978565157b-300 + x * (1384710978983089614554980944010000553236544926984416074420180493723390468154027020533019691b-301 + x * (-274057357324581485608201308026878795188066463784519077329794224330771414587511991256451199b-311 + x * 923140575090575960281429569584646159509857496569850532443973947641407848668443675573329097b-303)))"); psvn = sollya_lib_parse_string("1038265571012488267580081747701507502552864186319462514593895218257388262663254136335223063b-300 + x * (1845478247744731668861670841934712268962889917703749792296961594361126466257897183888722895b-301 + x * (1384710978982957070664622808178739493641569277585846232694551334615901588430012311059927601b-301 + x * (-548114714468248737546338914998330532715841724616354653209882304138110057649247627183294433b-312 + x * 1846281150180975297622580633121261037106757793781048506247239550278406622496601732122485233b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #30 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[16389b-14;32779b-15]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519134548434402756767156555739491223749783992943450543735006853556479254975332814832586831b-299 + x * (1845450049499621444821257909088314960970174514175996642815635808483444745999950335490924487b-301 + x * (692376631723210447209723438129936623162107424838590538473236247198461508299268646645182651b-300 + x * (-1211658977517938259044519799457477565612229358925289453861820187775265473657297948543474075b-313 + x * 1846337495070143691660987442551713494094189875111533870425503384713134072129251923138744189b-304)))"); pold64 = sollya_lib_parse_string("519134548434402756767156555739491223749783992943450543735006853556479254975332814832586831b-299 + x * (1845450049499621444821257909088314960970174514175996642815635808483444745999950335490924487b-301 + x * (692376631723210447209723438129936623162107424838590538473236247198461508299268646645182651b-300 + x * (-1211658977517938259044519799457477565612229358925289453861820187775265473657297948543474075b-313 + x * 1846337495070143691660987442551713494094189875111533870425503384713134072129251923138744189b-304)))"); psvn = sollya_lib_parse_string("519134548434397230064956936127972782382520850925244827929853218836000799005904648968273143b-299 + x * (230681256187463730471925329479143461564111131822598486908688243409777897014209001777846291b-298 + x * (1384753263446288338396241827674000401222192703237048413873503052479299741967864085811668019b-301 + x * (-1211658977156087710136727201386554177595012980707457086826797163585841616876353357638132717b-313 + x * 1846337495069967063330522310584765768262905119753111305766662117014275030040591328883128009b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #31 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32779b-15;8195b-13]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("129784077907877229989358408559022727015506092336158554639793545988337383876342394802174983b-297 + x * (1845421847813048003890891490305799586237781940993530060924167527705002243397401652292399469b-301 + x * (346198887945090207628197443350771030623367818935766056578607553395243263683162740596574271b-299 + x * (-1327095570084590892482248321617848024550507093692816293544367981215387497436366034675858795b-313 + x * 923196920839335626205194440883751587784554165940231967259873678081231946926685373213603605b-303)))"); pold64 = sollya_lib_parse_string("129784077907877229989358408559022727015506092336158554639793545988337383876342394802174983b-297 + x * (1845421847813048003890891490305799586237781940993530060924167527705002243397401652292399469b-301 + x * (346198887945090207628197443350771030623367818935766056578607553395243263683162740596574271b-299 + x * (-1327095570084590892482248321617848024550507093692816293544367981215387497436366034675858795b-313 + x * 923196920839335626205194440883751587784554165940231967259873678081231946926685373213603605b-303)))"); psvn = sollya_lib_parse_string("129784077907875848103021982645840680645591515169750492797657603107699291758590525037607837b-297 + x * (1845421847813136413633870703430607052046900605464424242657808159061539467274966216924228471b-301 + x * (346198887945057065588968490245692536303137108974197916838210212886896320833374986466764927b-299 + x * (-331773892430679565249001833341009611065841487884530153968475059201120001178518278702171029b-311 + x * 1846393841678494618689572625930147418834828664945174741628459702119652349640192118655305321b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #32 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[8195b-13;32781b-15]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038276150195205231598046738711326787177258175938486395650936392494584531982139206239184115b-300 + x * (1845393642684581673262535084218842151923675663720046624798283948403833291890563117846027567b-301 + x * (692418921992592502835948587721625658789940441742669912865045829664790944938388346827005581b-300 + x * (-90158700457546112553689981541875410522556478042701804576870900283483380686066639012347575b-309 + x * 1846450190006787079679592267911737638039999300863927226721933815878236131218424338147248637b-304)))"); pold64 = sollya_lib_parse_string("1038276150195205231598046738711326787177258175938486395650936392494584531982139206239184115b-300 + x * (1845393642684581673262535084218842151923675663720046624798283948403833291890563117846027567b-301 + x * (692418921992592502835948587721625658789940441742669912865045829664790944938388346827005581b-300 + x * (-90158700457546112553689981541875410522556478042701804576870900283483380686066639012347575b-309 + x * 1846450190006787079679592267911737638039999300863927226721933815878236131218424338147248637b-304)))"); psvn = sollya_lib_parse_string("259569037548798543705211766440273847552185791158218877274658712831809194210870713833745673b-298 + x * (1845393642684670093795418658443966483959499499111436368344376226006811395102256883883741195b-301 + x * (86552365249065776586275418697003276474007004222425941606188960245812786516813868977909749b-297 + x * (-721269603479421542891763001724490699127240426599723243259503557550901344348923138863739103b-312 + x * 230806273750826305071032548154040822033001931080469550661156849783960847391861039573187439b-301)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #33 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32781b-15;16391b-14]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("259569919416359157263353411595457107631487782846370515248264225272015360527824594363826399b-298 + x * (115335339632117571316138611855828589074790000759090941028960355593604439013749368475305519b-297 + x * (173110017507646127293946241187089077523281184437658863294068384210744593210320374774470417b-298 + x * (-389497472387211515714083349816328582000148764030707683808210862949049454218666003932452401b-311 + x * 923253270027271825969308891928787425004862776651570518692548000594247064900609481273701205b-303)))"); pold64 = sollya_lib_parse_string("259569919416359157263353411595457107631487782846370515248264225272015360527824594363826399b-298 + x * (115335339632117571316138611855828589074790000759090941028960355593604439013749368475305519b-297 + x * (173110017507646127293946241187089077523281184437658863294068384210744593210320374774470417b-298 + x * (-389497472387211515714083349816328582000148764030707683808210862949049454218666003932452401b-311 + x * 923253270027271825969308891928787425004862776651570518692548000594247064900609481273701205b-303)))"); psvn = sollya_lib_parse_string("519139838832712785294744793651849205116744861032104915377745580281528028175234451240326511b-299 + x * (922682717056984786191037842560048361064150737445945643745434647385992378443837872514948331b-300 + x * (346220035015259106481160210084789300105860147286960056577337502664764130028140026088559053b-299 + x * (-778994944593464631590340766081149572734753525688109985050433618675051212447864257923529627b-312 + x * 923253270027183503718302883172076158284093998622393550288930910988039761075871500306073869b-303)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #34 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[16391b-14;32783b-15]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("32446350177305655626960987935742946812325170002522767312791157638567102933964497546634605b-295 + x * (1845337222100605068161869797262611840822189092245241589797562358357269406524276475910977639b-301 + x * (86557652500536780164080755973761565595940061827114833473856294034809846659646798323076743b-297 + x * (-836723808545697939112234873358000218526157193537343518615496583468179871302592432518607973b-312 + x * 923281445910996724629512929320034672478053969908467355594159490598884955120472381156840557b-303)))"); pold64 = sollya_lib_parse_string("32446350177305655626960987935742946812325170002522767312791157638567102933964497546634605b-295 + x * (1845337222100605068161869797262611840822189092245241589797562358357269406524276475910977639b-301 + x * (86557652500536780164080755973761565595940061827114833473856294034809846659646798323076743b-297 + x * (-836723808545697939112234873358000218526157193537343518615496583468179871302592432518607973b-312 + x * 923281445910996724629512929320034672478053969908467355594159490598884955120472381156840557b-303)))"); psvn = sollya_lib_parse_string("1038283205673769919911887025331851626448194016385847841894509031764122005422656005340735635b-300 + x * (1845337222100693510277772059379214171997026956522498276381252238605922803714852220093772511b-301 + x * (1384922440008455878062060395599360175063199452216836309401558676876383623276463266751524873b-301 + x * (-1673447616729456992937773129116785790977599349155587035126314461539364498038188339220166517b-313 + x * 923281445910908399683084596640108535366700793165165294325102396864118622171225970267733811b-303)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #35 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32783b-15;2049b-11]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038286734220307239720704557190733547822740233150419403919615053957098975441209633569686853b-300 + x * (461327251661103022054384452204918703840591591979662598242558653096653916764392844993155701b-299 + x * (173120592978464878523250110885262068594635284888249060190772989330683453346211323951145019b-298 + x * (-894456195135440284141609327212459558817515685541830444876237823904741453274093716964232117b-312 + x * 1846619245309188953313966043331537677921113939942277956355175799511092774945261000205458275b-304)))"); pold64 = sollya_lib_parse_string("1038286734220307239720704557190733547822740233150419403919615053957098975441209633569686853b-300 + x * (461327251661103022054384452204918703840591591979662598242558653096653916764392844993155701b-299 + x * (173120592978464878523250110885262068594635284888249060190772989330683453346211323951145019b-298 + x * (-894456195135440284141609327212459558817515685541830444876237823904741453274093716964232117b-312 + x * 1846619245309188953313966043331537677921113939942277956355175799511092774945261000205458275b-304)))"); psvn = sollya_lib_parse_string("259571683555074044470670818178587812230825000699277365821145378951477594615160521312012945b-298 + x * (461327251661125135281638642126583135701747950391370487202780401118873146425858441195315429b-299 + x * (1384964743827586411485602529357234366644873145451430649939007038090334979300009801889793807b-301 + x * (-1788912389908919596374529568446813066503320970901186502380149207073680919363378497109230273b-313 + x * 461654811327253074507525053023055519156890774698540669390486172381238009591314241263639607b-302)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #36 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[2049b-11;32785b-15]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519145131652542185217707763517530853629482604390562710940905508700387992755729079147518445b-299 + x * (922640393872480403813800177925378752771650649922883158877492845194018341940238359134743875b-300 + x * (692503525759418150173428322959528988817757243557271875472398578625935986248675832975195243b-300 + x * (-1904384209409806576422326601306777292609996776581303101650200507548917112622001929760874319b-313 + x * 461668900129045661844556472102129996706923997672351301852902828249902414108550958025784073b-302)))"); pold64 = sollya_lib_parse_string("519145131652542185217707763517530853629482604390562710940905508700387992755729079147518445b-299 + x * (922640393872480403813800177925378752771650649922883158877492845194018341940238359134743875b-300 + x * (692503525759418150173428322959528988817757243557271875472398578625935986248675832975195243b-300 + x * (-1904384209409806576422326601306777292609996776581303101650200507548917112622001929760874319b-313 + x * 461668900129045661844556472102129996706923997672351301852902828249902414108550958025784073b-302)))"); psvn = sollya_lib_parse_string("1038290263305073306910021357436777192703295793131639015679471380799055303888403647377259899b-300 + x * (1845280787745049271330801829385601924012697162885023235578234014713148345855702891268450563b-301 + x * (692503525759351835754213767281560999066059958340277525211195856674418520000763995276439531b-300 + x * (-1904384209047823516880656194229500482163654355185846454456001023003869726586038172925283849b-313 + x * 1846675600516005986703186368235938935641456969689551398906012084701101900989550520438953497b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #37 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32785b-15;16393b-14]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("519146896464090670964582799011339625361876312484969902057815620146269565557712154432556743b-299 + x * (922626282700954902775491508103862824059066665916649646534456723782791265130430024881922389b-300 + x * (1385049363082215960042012852378943648217286866499398277925205949319793323173306680123576807b-301 + x * (-2019863074830693468602081973853455808051455628892417786481781217095389893397674055267503279b-313 + x * 1846731957443027016328279822610383179119522193788621019425224466359106076002887389125705337b-304)))"); pold64 = sollya_lib_parse_string("519146896464090670964582799011339625361876312484969902057815620146269565557712154432556743b-299 + x * (922626282700954902775491508103862824059066665916649646534456723782791265130430024881922389b-300 + x * (1385049363082215960042012852378943648217286866499398277925205949319793323173306680123576807b-301 + x * (-2019863074830693468602081973853455808051455628892417786481781217095389893397674055267503279b-313 + x * 1846731957443027016328279822610383179119522193788621019425224466359106076002887389125705337b-304)))"); psvn = sollya_lib_parse_string("129786724116021284589522791389533938685366914467921888591421991207973332630177941352280335b-297 + x * (922626282700999140024719752636160971604564766039702962600835043546126010405661939156175315b-300 + x * (1385049363082083319064688842536214923187066318823787115934850164088246633478542653277439281b-301 + x * (-2019863074468688320416400256549979086423852482583986753156892163967545423708598910926249469b-313 + x * 923365978721425175130951042714906397326260406560816810752882959071052073486538252895994867b-303)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #38 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[16393b-14;32787b-15]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038297323089667131239012803580298341305713834793419452962509467851074752565013307757925211b-300 + x * (461306084903729408475343382353118217458409264416593990336519465374065385491184797547928089b-299 + x * (692545839259066841913693084826024353050072653235181386446947448934842309391203558978010225b-300 + x * (-133459311678504620865868670843504381990951036478161257103477502586783643932650946540974923b-309 + x * 923394158044887273321169016644805632854020760156510314516944026455765523834141879892028803b-303)))"); pold64 = sollya_lib_parse_string("1038297323089667131239012803580298341305713834793419452962509467851074752565013307757925211b-300 + x * (461306084903729408475343382353118217458409264416593990336519465374065385491184797547928089b-299 + x * (692545839259066841913693084826024353050072653235181386446947448934842309391203558978010225b-300 + x * (-133459311678504620865868670843504381990951036478161257103477502586783643932650946540974923b-309 + x * 923394158044887273321169016644805632854020760156510314516944026455765523834141879892028803b-303)))"); psvn = sollya_lib_parse_string("519148661544828032169112102124382491302320248973389841878107879960509083336343313940712093b-299 + x * (922612169807503059598077710548707697089552788794835145315237686434928383156922308443824261b-300 + x * (1385091678518001030710303067495711898717493641565016862821034871695097707892835720800233351b-301 + x * (-1067674493247023348006567289431697340072623351320326378673614505309301324650879612282858339b-312 + x * 923394158044798937592228773002626337647906422756899856455862690345226526602596370564158317b-303)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #39 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[32787b-15;8197b-13]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038300853789610722717431117998072253672745354894008819884081084657820842766590196380279323b-300 + x * (922598055191821408672718405244320303689195084515518394521613676725148488667342591269985053b-300 + x * (692566998913432581940713261525895859800522806638943732672249466782620232752379964505934067b-300 + x * (-1125420972904246892390459207958219498521812206768675803782281061308773968546984562494103223b-312 + x * 1846844676456477726400395348253828365600567546020264505003689125703323360661624398778675999b-304)))"); pold64 = sollya_lib_parse_string("1038300853789610722717431117998072253672745354894008819884081084657820842766590196380279323b-300 + x * (922598055191821408672718405244320303689195084515518394521613676725148488667342591269985053b-300 + x * (692566998913432581940713261525895859800522806638943732672249466782620232752379964505934067b-300 + x * (-1125420972904246892390459207958219498521812206768675803782281061308773968546984562494103223b-312 + x * 1846844676456477726400395348253828365600567546020264505003689125703323360661624398778675999b-304)))"); psvn = sollya_lib_parse_string("1038300853789599654128620928191626403462648427765647651718303542069532121112884285723288433b-300 + x * (57662378449491603544925455540598389841828254930253970683478709975367784588910161998384317b-296 + x * (173141749728341562327965010722690133162605762229874074625618492074160663896377606365502051b-298 + x * (-1125420972723222228136979778653159546641743330995910397970803424610079692501283999601450839b-312 + x * 230855584557037631193855946593581809239481891779533705777169923044462180995976007328272449b-301)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #40 ================\n"); prec = SOLLYA_CONST(300); sollya_lib_set_prec(prec); f = SOLLYA_DIV(SOLLYA_EXP(SOLLYA_X_), SOLLYA_CONST(2)); n = SOLLYA_CONST(4); I = sollya_lib_parse_string("[8197b-13;32789b-15]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("1038304385028081108032949485150642166821786168174196617731484907518431023000345463323466159b-300 + x * (1845167877707743853301029862315370528448617293542570314524618753478073554077018916083953161b-301 + x * (1385176321008686108005887213926430898412220922469336951557518747806594802627115704254710467b-301 + x * (-295792744001313994757328807870081597724043138056186589579893810117232836871800794189163391b-310 + x * 57715657454474657665133753721862497061635908198782446418079866976955603901528724645894937b-299)))"); pold64 = sollya_lib_parse_string("1038304385028081108032949485150642166821786168174196617731484907518431023000345463323466159b-300 + x * (1845167877707743853301029862315370528448617293542570314524618753478073554077018916083953161b-301 + x * (1385176321008686108005887213926430898412220922469336951557518747806594802627115704254710467b-301 + x * (-295792744001313994757328807870081597724043138056186589579893810117232836871800794189163391b-310 + x * 57715657454474657665133753721862497061635908198782446418079866976955603901528724645894937b-299)))"); psvn = sollya_lib_parse_string("129788048128508754719487677985588652217030582751023707667272355799437698858583880493596255b-297 + x * (922583938853916180095837031088441763457759698847839528028476278601053096850981462009406181b-300 + x * (1385176321008553430606693149765976057091289953765215499825608320368344363306656509825322385b-301 + x * (-147896371978027533617145218288141306016409404459395846496000360299907460107780973037514293b-309 + x * 1846901038543012363042900512235202156962321012189403619311425629162308800009952703983856039b-304)))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #41 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_SUB(SOLLYA_CONST(1), SOLLYA_DIV(SOLLYA_X_, SOLLYA_SIN(SOLLYA_X_))); n = sollya_lib_build_list(SOLLYA_CONST(3), SOLLYA_CONST(5), NULL); I = sollya_lib_parse_string("[-1/8; 1/8]"); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_SIN(SOLLYA_X_)); res = stupid_wrapper(f,n,I,w, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("x^3 * (-31178697691997280151363863339059689087420918752665b-167 + x^2 * 24930042264710159851265878394398318040604898615191b-171)"); pold64 = sollya_lib_parse_string("x^3 * (-31178697691997280151363863339059689087420918752665b-167 + x^2 * 24930042264710159851265878394398318040604898615191b-171)"); psvn = sollya_lib_parse_string("x^3 * (-15589348845998640053441772179009544391934198160575b-166 + x^2 * 3116255283088763354828944887199725512210848109683b-168)"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #42 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_CONST(1); n = SOLLYA_CONST(6); I = sollya_lib_parse_string("[-1b-5; 1b-5]"); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_COS(SOLLYA_X_)); res = stupid_wrapper(f,n,I,w, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("5846006549323611671784298104022718622318882177971b-162 + x * (37857459261849734002934198358497784854969213609141b-241 + x * (-23384026197294176595383359674367214160107584181507b-165 + x * (-9650697869631352226371375426638274030332473125873b-226 + x * (31178701574267686389540459856148935530651557981629b-169 + x * (28234185975650294540907970780664381466140252467453b-217 + x * (-33256121763484710174675823588818018912416025532385b-174))))))"); pold64 = sollya_lib_parse_string("5846006549323611671784298104022718622318882177971b-162 + x * (37857459261849734002934198358497784854969213609141b-241 + x * (-23384026197294176595383359674367214160107584181507b-165 + x * (-9650697869631352226371375426638274030332473125873b-226 + x * (31178701574267686389540459856148935530651557981629b-169 + x * (28234185975650294540907970780664381466140252467453b-217 + x * (-33256121763484710174675823588818018912416025532385b-174))))))"); psvn = sollya_lib_parse_string("46768052394588893374274383349804429530193101540037b-165 + x * (37828133831966473044668513721851715408518819224469b-244 + x * (-46768052394588353190751917165222241452885446611429b-166 + x * (-25427705009315713179984612760631972436763477326811b-230 + x * (1948668848391730452279130065687865733407030940519b-165 + x * (19097661627829399791264180875000091942897986598809b-219 + x * (-33256121763550137230701412675274816909367928737119b-174))))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #43 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = SOLLYA_SIN(SOLLYA_X_); n = SOLLYA_CONST(6); I = sollya_lib_parse_string("[-1b-5; 1b-5]"); res = stupid_wrapper(f,n,I, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("2148263723907549819858926287983956687732819b-218 + x * (46768052394587948180729798097226792243112547550905b-165 + x * (-25507165977932281269808564943557481990277558638851b-228 + x * (-31178701565420095891159605334409136402204722409641b-167 + x * (25169562694197869368373056758332575493933394803211b-217 + x * (24941946363609599630853575496590807881363811448161b-171 + x * (-13542288596511770213422971032075701040404674585399b-207))))))"); pold64 = sollya_lib_parse_string("2148263723907549819858926287983956687732819b-218 + x * (46768052394587948180729798097226792243112547550905b-165 + x * (-25507165977932281269808564943557481990277558638851b-228 + x * (-31178701565420095891159605334409136402204722409641b-167 + x * (25169562694197869368373056758332575493933394803211b-217 + x * (24941946363609599630853575496590807881363811448161b-171 + x * (-13542288596511770213422971032075701040404674585399b-207))))))"); psvn = sollya_lib_parse_string("-31657351710771318264480101926512972684047b-216 + x * (11692013098646987045182253340122523086369332160129b-163 + x * (45142061063915304495253236000306896279355752461095b-232 + x * (-15589350782710047985431039322670567918156898471475b-166 + x * (-32638902245554706260123356836597206211247789846683b-220 + x * (12470973181805555448555253907066439009244525141935b-170 + x * 43769018414430920138875951265888862687962052230975b-211)))))"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(prec); sollya_lib_printf("=============== Check remez #44 ================\n"); prec = sollya_lib_default(); sollya_lib_set_prec(prec); f = sollya_lib_parse_string("1-(1+x+x^2/2)/exp(x)"); n = sollya_lib_build_list(SOLLYA_CONST(3), SOLLYA_CONST(4), NULL); I = sollya_lib_parse_string("[-1b-8;12167298183958086083256693241475396846566462796809b-171]"); w = SOLLYA_DIV(SOLLYA_CONST(1), SOLLYA_EXP(SOLLYA_X_)); res = stupid_wrapper(f,n,I,w, NULL); p = sollya_lib_horner(res); pold32 = sollya_lib_parse_string("x^3 * (7794680717168470900797342378780962700124730873177b-165 + x * 31179902867931546748200780881663744737011812548003b-169)"); pold64 = sollya_lib_parse_string("x^3 * (7794680717168470900797342378780962700124730873177b-165 + x * 31179902867931546748200780881663744737011812548003b-169)"); psvn = sollya_lib_parse_string("x^3 * (31178722868673883627864298068285024212112392034985b-167 + x * 7794975716982886342439431644725264558026848337299b-167)"); if (boolean_not_eq(p, psvn) && boolean_not_eq(p, pold32) && boolean_not_eq(p, pold64)) sollya_lib_printf("%b\n", p); else sollya_lib_printf("Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK\n"); sollya_lib_clear_obj(psvn); sollya_lib_clear_obj(pold32); sollya_lib_clear_obj(pold64); sollya_lib_clear_obj(p); sollya_lib_clear_obj(res); sollya_lib_clear_obj(f); sollya_lib_clear_obj(n); sollya_lib_clear_obj(I); sollya_lib_clear_obj(w); sollya_lib_clear_obj(prec); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tv_remez.reference000066400000000000000000000167631300174114700207200ustar00rootroot00000000000000=============== Check remez #1 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #2 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #3 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #4 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #5 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #6 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #7 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #8 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #9 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #10 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #11 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #12 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #13 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #14 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #15 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #16 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #17 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #18 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #19 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #20 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #21 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #22 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #23 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #24 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #25 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #26 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #27 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #28 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #29 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #30 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #31 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #32 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #33 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #34 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #35 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #36 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #37 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #38 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #39 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #40 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #41 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #42 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #43 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #44 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK sollya-6.0+ds/tests-lib/tvoid.c000066400000000000000000000003041300174114700164560ustar00rootroot00000000000000#include int main(void) { sollya_obj_t f; sollya_lib_init(); f = sollya_lib_void(); sollya_lib_printf("%b", f); sollya_lib_clear_obj(f); sollya_lib_close(); return 0; } sollya-6.0+ds/tests-lib/tvoid.reference000066400000000000000000000000041300174114700201670ustar00rootroot00000000000000voidsollya-6.0+ds/tests-tool/000077500000000000000000000000001300174114700153775ustar00rootroot00000000000000sollya-6.0+ds/tests-tool/Makefile.am000066400000000000000000000040351300174114700174350ustar00rootroot00000000000000REGULAR_TESTFILES = \ check001.sollya check002.sollya check003.sollya check004.sollya check005.sollya \ check006.sollya check007.sollya check008.sollya check009.sollya check010.sollya \ check011.sollya check012.sollya check013.sollya check014.sollya check015.sollya \ check016.sollya check017.sollya check018.sollya check019.sollya check020.sollya \ check021.sollya check022.sollya check023.sollya check024.sollya check025.sollya \ check026.sollya check027.sollya check028.sollya check029.sollya check030.sollya \ check031.sollya MAYFAIL_TESTFILES = timecheck.sollya TESTFILES = $(REGULAR_TESTFILES) $(MAYFAIL_TESTFILES) EXTRA_DIST = check.proto $(TESTFILES) $(TESTFILES:.sollya=.sollya.reference) REGULAR_TESTS = $(REGULAR_TESTFILES:.sollya=.sh) MAYFAIL_TESTS = $(MAYFAIL_TESTFILES:.sollya=.sh) TESTS = $(REGULAR_TESTS) $(MAYFAIL_TESTS) check_PROGRAMS = force_compilation check_LIBRARIES = libraryexample.a # the library will be a shared library actually, # but we do not know how to explain this to automake. force_compilation_SOURCES = MOSTLYCLEANFILES = $(TESTS) libraryexample.a libraryexample.$(OBJEXT): libraryexample.c $(CC) $(CFLAGS) $(AM_CPPFLAGS) -fPIC -Wall -c '$(srcdir)/libraryexample.c' libraryexample.a: libraryexample.$(OBJEXT) $(CC) $(LDFLAGS) $(AM_LDFLAGS) -shared -o libraryexample.a libraryexample.$(OBJEXT) -lmpfi -lmpfr -lgmp .PHONY: force_compilation$(EXEEXT) force_compilation$(EXEEXT): @echo "Recompiling sollya";cd $(top_builddir); $(MAKE) sollya$(EXEEXT) $(REGULAR_TESTS): check.proto @echo "Building "$@ @echo "#!/bin/sh" > $@ @echo "SOLLYA="$(top_builddir)"/sollya" >> $@ @echo "TESTFILES=\""$(@:.sh=.sollya)"\"" >> $@ @echo "RETURN_CODE_IN_CASE_OF_FAILURE=1" >> $@ @cat "$(srcdir)/check.proto" >> $@ @chmod +x $@ $(MAYFAIL_TESTS): check.proto @echo "Building "$@ @echo "#!/bin/sh" > $@ @echo "SOLLYA="$(top_builddir)"/sollya" >> $@ @echo "TESTFILES=\""$(@:.sh=.sollya)"\"" >> $@ @echo "RETURN_CODE_IN_CASE_OF_FAILURE=77" >> $@ @cat "$(srcdir)/check.proto" >> $@ @chmod +x $@ sollya-6.0+ds/tests-tool/check.proto000066400000000000000000000007201300174114700175400ustar00rootroot00000000000000if test -z "${srcdir}" then srcdir=`dirname "$0"` SOLLYA="${srcdir}/${SOLLYA}" fi TEST=0 for i in $TESTFILES do if ! test -e ${srcdir}/$i then echo "Unexpected error: test input file seems to be missing. Are you in the right directory?" >&2 TEST=1 else $SOLLYA < ${srcdir}/$i > $i.output if ! diff $i.output ${srcdir}/$i.reference > /dev/null then TEST=$RETURN_CODE_IN_CASE_OF_FAILURE else rm $i.output fi fi done exit $TEST sollya-6.0+ds/tests-tool/check001.sollya000066400000000000000000000234311300174114700201250ustar00rootroot00000000000000restart; print("=============== Test number 1 ================"); verbosity = 1!; roundingwarnings = on!; sin(pi * 3); tan(pi/2); sin(pi * 3)/cos(pi * 2.5); 0/0; 1/0; /*********************************************************************************/ restart; print("=============== Test number 2 ================"); printfloat(1b128 - 1b103 - 1b-500); printfloat(1b128 - 1b103 - 1b-74); printfloat(1b128 - 1b103 - 1b-75); printfloat(1b128 - 1b103); printfloat(1b128 - 1b103 + 1b-500); printfloat(1b128 - 1b103 + 1b-74); printfloat(1b128 - 1b103 + 1b-75); printfloat(1.0000000010111111111111111000001_2 * 2^(-140)); printfloat(-1.0000000010111111111111111000001_2 * 2^(-140)); printfloat(1b-1000); printfloat(-1b-1000); printfloat(0); printfloat(-0); printfloat(infty); printfloat(-infty); printfloat(NaN); printfloat(1b-150); prec = 2000!; printfloat(1b-150 + 1b-1000); printfloat(1b-150 - 1b-1000); printfloat(-1b-150 + 1b-1000); printfloat(-1b-150 - 1b-1000); /*********************************************************************************/ restart; print("=============== Test number 3 ================"); 0/0; 3/0; sin(5 * pi) / sin(5 * pi); sin(5 * pi) / 0; x/x; sin(x)/cos(x + 0.5 * pi); evaluate(0/0,17); evaluate(3/0,17); evaluate(sin(5 * pi)/sin(5 * pi),17); evaluate(sin(5 * pi) / 0, 17); evaluate(x/x,17); evaluate(x/x,0); evaluate(sin(x)/cos(x + 0.5 * pi),17); evaluate(0/0,[0.17]); evaluate(3/0,[0.17]); evaluate(sin(5 * pi)/sin(5 * pi),[0.17]); evaluate(sin(5 * pi) / 0, [0.17]); evaluate(x/x,[0.17]); evaluate(x/x,[0]); evaluate(x/x,[-1b-100000;-1b-100000]); evaluate(sin(x)/cos(x + 0.5 * pi),[0.17]); /*********************************************************************************/ restart; 0 * infty; infty - infty; infty + (-infty); infty + (-1) * infty; [0] * infty; infty * [0]; infty * 0; [infty] * 0; 0 * [infty]; [0] * [infty]; [infty] * [0]; 0 * [-infty,infty]; 0 * [3,4]; [0] * 3; [0] * [3,4]; /*********************************************************************************/ restart; 2 + [3;4]; [4;5] + [5;6]; 1 + 1~0/2~; exp([5;5]); a = exp(sin(x)); a([5;6]); /*********************************************************************************/ restart; midpointmode = on; evaluate(sin(x),3.5); evaluate(sin(x),[3.5;3.5]); evaluate(sin(x),3.4); evaluate(sin(x),[3.4;3.4]); evaluate(sin(pi * x),3.5); evaluate(sin(pi * x),[3.5;3.5]); evaluate(sin(pi * x),3.4); evaluate(sin(pi * x),[3.4;3.4]); evaluate(cos(x),3.5); evaluate(cos(x),[3.5;3.5]); evaluate(cos(x),3.4); evaluate(cos(x),[3.4;3.4]); evaluate(cos(pi * x),3.5); evaluate(cos(pi * x),[3.5;3.5]); evaluate(cos(pi * x),3.4); evaluate(cos(pi * x),[3.4;3.4]); /*********************************************************************************/ restart; 23~2/3~; 23~3/2~; 0.1~1/2~; 0.125~0/0~; 0.1~2/1~; 0.1~1/9~; 0.1~9/1~; 0.1~9/1~ == 0.1~1/9~; -23~2/3~; -23~3/2~; -0.1~1/2~; -0.125~0/0~; -0.1~2/1~; -0.1~1/9~; -0.1~9/1~; -0.1~9/1~ == -0.1~1/9~; midpointmode = on; 23~2/3~; 23~3/2~; 0.1~1/2~; 0.125~0/0~; 0.1~2/1~; 0.1~1/9~; 0.1~9/1~; 0.1~9/1~ == 0.1~1/9~; -23~2/3~; -23~3/2~; -0.1~1/2~; -0.125~0/0~; -0.1~2/1~; -0.1~1/9~; -0.1~9/1~; -0.1~9/1~ == -0.1~1/9~; /*********************************************************************************/ restart; %12%4097; %10%0.1; %34000%0.1; 5e-3; 0.5; 5.0; /*********************************************************************************/ restart; midpointmode = on!; [-10971362213211443216165490671142190371208827223443b-165;-43885448852845772864661962684568761484835308893771b-167]; [43885448852845772864661962684568761484835308893771b-167;10971362213211443216165490671142190371208827223443b-165]; [0;0]; [1.25;1.25]; prec = 300!; d = [1 + 1b-200; 1 + 1b-200]; prec = 50!; d; midpointmode = off!; 0~0/0~; 1~0/0~e2; /*********************************************************************************/ restart; p = 11692536319630510474283968587625525849426869787677b-163 + x * (23384922893552793741208186896732057180708286140565b-164 + x * (46692941277611593554424973690517694800554713844979b-166 + x * (3891678517537147456387754739468835779118224484425b-164 + x * (1024072943597638219514404758611859127188920401873b-164 + x * 26154763285557255659575812244171511366994513699585b-171)))); accurateinfnorm(p - exp(x), [-1;1], 20); accurateinfnorm(p - exp(x), [-1;1], 30); accurateinfnorm(p - exp(x), [-1;1], 40); /*********************************************************************************/ restart; p = 11692536319630510474283968587625525849426869787677b-163 + x * (23384922893552793741208186896732057180708286140565b-164 + x * (46692941277611593554424973690517694800554713844979b-166 + x * (3891678517537147456387754739468835779118224484425b-164 + x * (1024072943597638219514404758611859127188920401873b-164 + x * 26154763285557255659575812244171511366994513699585b-171)))); midpointmode = on!; infnorm(p - exp(x), [-1;1]); accurateinfnorm(p - exp(x), [-1;1], 40); /*********************************************************************************/ restart; print("=============== Test number 4 ================"); true && false; /*********************************************************************************/ restart; print("=============== Test number 5 ================"); (1 == exp(0)) && (0 == log(1)); /*********************************************************************************/ restart; print("=============== Test number 6 ================"); [|2,3,4|]:.5; /*********************************************************************************/ restart; print("=============== Test number 7 ================"); [|1,2,3|]:.[|4,5,6|]; /*********************************************************************************/ restart; print("=============== Test number 8 ================"); [||]:.1; /*********************************************************************************/ restart; print("=============== Test number 9 ================"); autosimplify = on !; print(x - x); autosimplify = off ; print(x - x); /*********************************************************************************/ restart; autosimplify = on !; print(rationalapprox(sin(pi/5.99),7)); autosimplify = off !; print(rationalapprox(sin(pi/5.99),7)); /*********************************************************************************/ restart; autosimplify; /*********************************************************************************/ restart; print("=============== Test number 10 ================"); print(canonical(1 + x * (x + 3 * x^2))); print(canonical((x + 1)^7)); /*********************************************************************************/ restart; print("=============== Test number 11 ================"); print(canonical(exp((x + 1)^5) - log(asin(((x + 2) + x)^4 * (x + 1)) + x))); /*********************************************************************************/ restart; print("=============== Test number 12 ================"); canonical; (x + 2)^9; canonical = on; (x + 2)^9; canonical; canonical = off!; (x + 2)^9; /*********************************************************************************/ restart; checkinfnorm(sin(x),[0;1.75], 1); checkinfnorm(sin(x),[0;1.75], 1/2); checkinfnorm(sin(x),[0;20/39], 1/2); /*********************************************************************************/ restart; print("=============== Test number 13 ================"); p = 11692536319630510474283968587625525849426869787677b-163 + x * (23384922893552793741208186896732057180708286140565b-164 + x * (46692941277611593554424973690517694800554713844979b-166 + x * (3891678517537147456387754739468835779118224484425b-164 + x * (1024072943597638219514404758611859127188920401873b-164 + x * 26154763285557255659575812244171511366994513699585b-171)))); b = dirtyinfnorm(p - exp(x), [-1;1]); checkinfnorm(p - exp(x), [-1;1], b); b1 = round(b, 20, RU); checkinfnorm(p - exp(x), [-1;1], b1); b2 = round(b, 25, RU); checkinfnorm(p - exp(x), [-1;1], b2); diam = 1b-20!; checkinfnorm(p - exp(x), [-1;1], b2); /*********************************************************************************/ restart; print("=============== Test number 14 ================"); coeff((1+x)^5,3); /*********************************************************************************/ restart; print("=============== Test number 15 ================"); coeff(sin(x),0); /*********************************************************************************/ restart; print("=============== Test number 16 ================"); [|1,...,3|]@[|7,8,9|]; /*********************************************************************************/ restart; print("=============== Test number 17 ================"); "Hello "@"World!"; /*********************************************************************************/ restart; print("=============== Test number 18 ================"); p = remez(exp(x),5,[0;1],default,1e-5); q = remez(exp(x),5,[0;1],1,1e-5); p==q; /*********************************************************************************/ restart; print("=============== Test number 19 ================"); prec; prec=200; /*********************************************************************************/ restart; print("=============== Test number 20 ================"); degree((1+x)*(2+5*x^2)); degree(0); /*********************************************************************************/ restart; print("=============== Test number 21 ================"); /* Non-regression test for revision 1596 */ coeff(x+x^2/4, 1.75); /*********************************************************************************/ restart; print("=============== Test number 22 ================"); /* Non-regression test for revision 1623 */ roundingwarnings = on!; d = [sin(pi/6)*(1-1b-40)]; log2(sup(d)-inf(d)); /*********************************************************************************/ restart; print("=============== Test number 23 ================"); /* Non-regression test for revision */ (x * 1 - 1 * x * 1)/x^1; d=degree((x * 1 - 1 * x * 1)/x^1); d;sollya-6.0+ds/tests-tool/check001.sollya.reference000066400000000000000000000211211300174114700220540ustar00rootroot00000000000000The tool has been restarted. =============== Test number 1 ================ 0 Warning: rounding has happened. The displayed value is *NOT* guaranteed to be a faithful rounding of the true result. The displayed value has been computed using plain floating-point arithmetic and might be completely wrong. -5.2672331945605609510698374476395405103035179241388e12715 Warning: rounding has happened. The displayed value is *NOT* guaranteed to be a faithful rounding of the true result. The displayed value has been computed using plain floating-point arithmetic and might be completely wrong. -0.6154138956554673381485474094428967527572078572788 Warning: the given expression is undefined or numerically unstable. NaN Warning: the given expression is undefined or numerically unstable. NaN The tool has been restarted. =============== Test number 2 ================ 0x7f7fffff 0x7f7fffff 0x7f7fffff 0x7f800000 0x7f800000 0x7f800000 0x7f800000 0x00000201 0x80000201 0x00000000 0x80000000 0x00000000 0x80000000 0x7f800000 0xff800000 0x7fc00003 0x00000000 0x00000001 0x00000000 0x80000000 0x80000001 The tool has been restarted. =============== Test number 3 ================ Warning: the given expression is undefined or numerically unstable. NaN Warning: the given expression is undefined or numerically unstable. NaN 1 Warning: the given expression is undefined or numerically unstable. NaN 1 sin(x) / cos(1.57079632679489661923132169163975144209858469968754 + x) [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] 1 1 -1 [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [1;1] [1;1] [1;1] [-1.0000000000000000000000000000000000000000000000003;-0.99999999999999999999999999999999999999999999999968] The tool has been restarted. Warning: the given expression is undefined or numerically unstable. NaN Warning: the given expression is undefined or numerically unstable. NaN Warning: the given expression is undefined or numerically unstable. NaN Warning: the given expression is undefined or numerically unstable. NaN [NaN;NaN] [NaN;NaN] Warning: the given expression is undefined or numerically unstable. NaN [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] The tool has been restarted. [5;6] [9;11] [11;13] [148.41315910257660342111558004055227962348766759388;148.413159102576603421115580040552279623487667593883] [0.38330499517227140530067429899271699432422152576599;0.75622562754285520105978586991665623136079159670959] The tool has been restarted. Midpoint mode has been activated. -0.35078322768961984812036880004363558508498173594059 -0.3507832276896198481203688000436355850849817359405~9/7~ -0.25554110202683131924990242936373907581092037943433 -0.255541102026831319249902429363739075810920379434~5/3~ -1 [-1;-0.99999999999999999999999999999999999999999999999998] -0.95105651629515357211643933337938214340569863412572 -0.95105651629515357211643933337938214340569863412~6/5~ -0.93645668729079633769865762667176046301995776578196 -0.9364566872907963376986576266717604630199577657819~8/5~ -0.9667981925794610142822015397656939111959444268489 -0.96679819257946101428220153976569391119594442684~9/8~ [-4.8942202993684414615007371081363957013662123327175e-12715;5.0628857292543278449623900656885559485888217625524e-12715] [-4.8942202993684414615007371081363957013662123327175e-12715;5.0628857292543278449623900656885559485888217625524e-12715] -0.30901699437494742410229341718281905886015458990293 -0.30901699437494742410229341718281905886015458990~4/2~ The tool has been restarted. [232;233] Warning: the range bounds are given in inverse order. Will revert them. [232;233] [0.11;0.12] [0.125;0.125] Warning: the range bounds are given in inverse order. Will revert them. [0.11;0.12] [0.11;0.190000000000000000000000000000000000000000000000004] Warning: the range bounds are given in inverse order. Will revert them. [0.11;0.190000000000000000000000000000000000000000000000004] Warning: the range bounds are given in inverse order. Will revert them. true Warning: the range bounds are given in inverse order. Will revert them. [-233;-232] [-233;-232] Warning: the range bounds are given in inverse order. Will revert them. [-0.12;-0.11] [-0.125;-0.125] [-0.12;-0.11] Warning: the range bounds are given in inverse order. Will revert them. [-0.190000000000000000000000000000000000000000000000004;-0.11] [-0.190000000000000000000000000000000000000000000000004;-0.11] Warning: the range bounds are given in inverse order. Will revert them. true Midpoint mode has been activated. 0.23~2/3~e3 Warning: the range bounds are given in inverse order. Will revert them. 0.23~2/3~e3 0.1~0/3~ [0.125] Warning: the range bounds are given in inverse order. Will revert them. 0.1~0/3~ [0.11;0.190000000000000000000000000000000000000000000000004] Warning: the range bounds are given in inverse order. Will revert them. [0.11;0.190000000000000000000000000000000000000000000000004] Warning: the range bounds are given in inverse order. Will revert them. true Warning: the range bounds are given in inverse order. Will revert them. -0.23~3/2~e3 -0.23~3/2~e3 Warning: the range bounds are given in inverse order. Will revert them. -0.1~3/0~ [-0.125] -0.1~3/0~ Warning: the range bounds are given in inverse order. Will revert them. [-0.190000000000000000000000000000000000000000000000004;-0.11] [-0.190000000000000000000000000000000000000000000000004;-0.11] Warning: the range bounds are given in inverse order. Will revert them. true The tool has been restarted. 4096 Warning: the precision of values in the tool must be at least 12 bits. 0.100006103515625 0.1 5e-3 0.5 5 The tool has been restarted. -0.2345909579608844241969993617028300510911361813189~3/1~ 0.2345909579608844241969993617028300510911361813189~1/3~ [0] [1.25] 0.1000000000000000000000000000000000000000000000000000000000000~6/7~e1 [0;0] [1000;1000] The tool has been restarted. 4.52055246569216251373291015625e-5 4.520552107578623690642416477203369140625e-5 4.5205521043867324948450914234854280948638916015625e-5 The tool has been restarted. 0.45205~5/7~e-4 4.5205521043867324948450914234854280948638916015625e-5 The tool has been restarted. =============== Test number 4 ================ false The tool has been restarted. =============== Test number 5 ================ true The tool has been restarted. =============== Test number 6 ================ [|2, 3, 4, 5|] The tool has been restarted. =============== Test number 7 ================ [|1, 2, 3, [|4, 5, 6|]|] The tool has been restarted. =============== Test number 8 ================ [|1|] The tool has been restarted. =============== Test number 9 ================ 0 Automatic pure tree simplification has been deactivated. x - x The tool has been restarted. 0.5 1 / 2 The tool has been restarted. on The tool has been restarted. =============== Test number 10 ================ 1 + x^2 + 3 * x^3 1 + 7 * x + 21 * x^2 + 35 * x^3 + 35 * x^4 + 21 * x^5 + 7 * x^6 + x^7 The tool has been restarted. =============== Test number 11 ================ exp(1 + 5 * x + 10 * x^2 + 10 * x^3 + 5 * x^4 + x^5) - log(asin(16 + 80 * x + 160 * x^2 + 160 * x^3 + 80 * x^4 + 16 * x^5) + x) The tool has been restarted. =============== Test number 12 ================ off 512 + x * (2304 + x * (4608 + x * (5376 + x * (4032 + x * (2016 + x * (672 + x * (144 + x * (18 + x)))))))) Canonical automatic printing output has been activated. 512 + 2304 * x + 4608 * x^2 + 5376 * x^3 + 4032 * x^4 + 2016 * x^5 + 672 * x^6 + 144 * x^7 + 18 * x^8 + x^9 on 512 + x * (2304 + x * (4608 + x * (5376 + x * (4032 + x * (2016 + x * (672 + x * (144 + x * (18 + x)))))))) The tool has been restarted. true false true The tool has been restarted. =============== Test number 13 ================ false false false true The tool has been restarted. =============== Test number 14 ================ 10 The tool has been restarted. =============== Test number 15 ================ 0 The tool has been restarted. =============== Test number 16 ================ [|1, 2, 3, 7, 8, 9|] The tool has been restarted. =============== Test number 17 ================ Hello World! The tool has been restarted. =============== Test number 18 ================ true The tool has been restarted. =============== Test number 19 ================ 165 The precision has been set to 200 bits. The tool has been restarted. =============== Test number 20 ================ 3 0 The tool has been restarted. =============== Test number 21 ================ 0.25 The tool has been restarted. =============== Test number 22 ================ Warning: at least one of the given expressions is not a constant but requires evaluation. Evaluation is guaranteed to ensure the inclusion property. The approximate result is at least 165 bit accurate. -165 The tool has been restarted. =============== Test number 23 ================ 0 0 sollya-6.0+ds/tests-tool/check002.sollya000066400000000000000000000523221300174114700201270ustar00rootroot00000000000000restart; print("=============== Test number 21 ================"); degree(sin(x)); /*********************************************************************************/ restart; print("=============== Test number 22 ================"); denominator(5/3); /*********************************************************************************/ restart; print("=============== Test number 23 ================"); denominator(exp(x)); /*********************************************************************************/ restart; print("=============== Test number 24 ================"); a = 5/3; b = numerator(a)/denominator(a); print(a); print(b); /*********************************************************************************/ restart; print("=============== Test number 25 ================"); a = exp(x/3); b = numerator(a)/denominator(a); print(a); print(b); /*********************************************************************************/ restart; print("=============== Test number 26 ================"); diff(sin(x)); /*********************************************************************************/ restart; print("=============== Test number 27 ================"); diff(x); /*********************************************************************************/ restart; print("=============== Test number 28 ================"); diff(x^x); /*********************************************************************************/ restart; print("=============== Test number 29 ================"); dirtyfindzeros(sin(x),[-5;5]); /*********************************************************************************/ restart; print("=============== Test number 30 ================"); p=889889516953035728989970006432565914118046095519567616686877970197303381060661650911373862730167175148439925356273269082482473781952934014048404246810557360519237b-677 + x * (392685047947827601505450851321573944986223666748888685200576755780370155425b-270 + x * (6001249631295599119794173987807978692360967732847507181353592112990700057773b-269 + x * (2810819263714567704618725647638922679615238080553927915691512053415493045486398123b-285 + x * (-1824058336184758458969066742009524525357478424213884880689936002406163518809888085b-282 + x * (-1635962643824047985870094070979551805254244569221628530659549014596616547292989167b-278 + x * (-2221893430275237204276174740150279260780200400045772335021314186970726126808696491b-277 + x * (-2344509239333157190743702590067848983609138523264986348387970421264340202282344565b-278 + x * (-3121432669974466360620808110931436402064131037978432583759915593600761236225527063b-280 + x * (-773917963800655166097602101204889507346108619385550777380687347677098189388564217b-280 + x * (-2456664134304800458388215318267381311201333055351202856339933444862365076107756847b-284 + x * (-1626720184987310978262797176693785746775034556205416914324062489909804126678683201b-286 + x * (-231104585279383115477600187708095312641841452578724474216559610155717712302025371b-286 + x * (-3680933644980096067735623537745219210440859046288758139373481017585165187552360301b-293 + x * (-3259689780494466170755267237788248621126395891437548729425851984090889527932420467b-296 + x * (-2599581435183057564397429433475659302180945474761956190281405670069071985683851999b-299 + x * (-3771179902233087427639666368377239797574764415450620446939473166738711685615183895b-303 + x * (-2508412234578166550400356517439588588327863629620629190868385191302596018780682931b-306 + x * (-1540608616477279281853195566313817469497355478589189627649550204979246859107513235b-309 + x * (-439420220920635814586214935574679946204072083482674523109789601765718916704991809b-311 + x * (-468009060720422950370977235618689599561097108833058268913827599220755870449426295b-315 + x * (-3739077119919913294750192472007104569820618708197803907725629332704076068719295703b-322 + x * (-3514943933746426633390643217415002305637086338940264554241886448080254523542173265b-326 + x * (-3121059047879984256463610608157531597037330470020568347331973617204048749182934027b-330 + x * (-1312864579354111113262887940181808301155092005746585944813912861708582761491319641b-333 + x * (-2098749518855048435933859742742670915157652108930060387529476190902580900838616375b-338 + x * (-3195552184735422400133725426132014485645520463361323915420874124693907919094524053b-343 + x * (-1161174353415833860864692662949187722583547339054896423623857188819947376179950943b-346 + x * (-3228938344731937420734334058400932964515218194142091268051871251523584603041078219b-352 + x * (-2151302959832759124631216490489706786963489942946375656340323023788975847458739825b-356))))))))))))))))))))))))))))); d=[-4893299745940809486040077668449425316537438754630519635933996919120902374669723385b-273;2695250614315944697239070405079945412534462960416900368955895306421692489413122311b-273]; points=24; prec=175; dirtyfindzeros(p,d); /*********************************************************************************/ restart; print("=============== Test number 31 ================"); points=8; f = -30879717245370838070712349676119593593642999021581b-262 + x * (1602925418421145866385980186544493412434987593471b-254 + x * (-144948056238098910579201b-166 + x * (-1388389088155368481780539b-165 + x * (372930446538976826977091605b-169 + x * (7333084534724264674540922032302739059645825242835b-240 + x * (-94154913290208326181858262191b-170 + x * (-152168648655806210645752736485b-169 + x * (2992713756691814828898030219764943b-179 + x * (7864786055259407372240893441876605835537257488915b-232 + x * (-6237493281774519295840632997189523667b-185 + x * (5264288383950269840958432779126676591b-184 + x * (6453344754657534210994036765929996563355b-191 + x * (-6089947420748690786646030842592001600390475761005b-219 + x * (-2139151602838708708137808745068947971942145b-197 + x * (8850601420712161663364843707773604622727713b-196 + x * (-2419778405705671295420161430155309749637707589b-204 + x * (-3913767832602863851535634495388834967093390830155b-213 + x * (784340317346483980869004045703825518731284039053b-209 + x * (-6859726825402852929223039253369380154403233703215b-212 + x * (11081394390954533787967018784553174028016039913693b-214 + x^2 * (-24561358996401390906662829513814827282875378510003b-223 + x * (-17086162780105315413330664009610314631565480702611b-226 + x * (-22781550373473753884440885346147086175420640936815b-231 + x^2 * (35889703972980190734873025529930178836354978952767b-240 + x * (10633986362364500958480896453312645581142215986005b-242 + x * (1519140908909214422640128064758949368734602283715b-244 + x^2 * (-14304370489407223620997619662649785320314783802521b-256 + x * (-29531603591034268120769279303535040661295037527785b-261 + x * (-14765801795517134060384639651767520330647518763893b-265 + x^2 * (26952194364722897108438272733351053152554472752631b-275 + x * (3080250784539759669535802598097263217434796886015b-276 + x * (43808011157898804188953636950716632425739333489991b-285 + x^2 * (-15952846168452480615038593256590978522033100104463b-293 + x * (-6544757402442043329246602361678350162885374401831b-296)))))))))))))))))))))))))))))))))); dirtyfindzeros(f,[-1/4;1/2]); /*********************************************************************************/ restart; print("=============== Test number 32 ================"); L1=dirtyfindzeros(x^2*sin(1/x),[0;1]); points=1000!; L2=dirtyfindzeros(x^2*sin(1/x),[0;1]); length(L1); length(L2); /*********************************************************************************/ restart; print("=============== Test number 33 ================"); prec=175!; points=72!; d=[-1/4;1/4]; q= -9218359857239378053149166583414477383319548700448408553592614065149393107991574094431779300909386394607724189300652164116661978352015199072381966773909782438444550115978733458953108338817245522910437621b-747 + x * (-4918945581850403406186365246730251739531892020830917620356470726738192033495929931205b-325 + x * (-280736214993231305175183134111309934939054691730352833297755584396641782537401123811229b-323 + x * (-3296794439148309983785257966527617622126569684362773368016441937091041142082807278547641356788607659b-360 + x * (-1162815620496786429742938279084772339215067215118977341562864870861668735850030387236811817383275179b-353 + x * (-1008541912689173056903175399302104307006639210660465294545137759381337242490809077257293229781348079b-348 + x * (-2342913806489465941429371682485389038775917098603823839631204684807467024475578205433216649559568839b-345 + x * (-3845503555651277193086598769066174969324632164736960479656500661911447287579321920589602471937980643b-342 + x * (-577388972082389265291281910620877528441488726209642544260999332316920744567964515411193102000402419b-336 + x * (-519219181883197970470878489090701126949156069237610094611622947494413702365023482664291543865804873b-333 + x * (-2833359990866141307959291185985539134181537071084158331012832327708969383520113454051058610804395489b-333 + x * (-2945185149312769605397704065992698709602457770414444045223857485639187743533141939697575628713244193b-331 + x * (-1160468705007854401734543272536512039790059278102973696577338293528508320591522206996381660982531121b-328 + x * (-2723447513989440327784471543923582516019769993810371302136778008007642879840422786007059761302054621b-328 + x * (-570584550655303616960095423606880840241523063309212080829789158981209868316415767065068498275244243b-325 + x * (-2471253493541736589990015790002930883291119152102682986179125591155169242944859296371005415159337601b-327 + x * (-2392736186293296342257968331718144679176384826805684359679444147838260255459545951974398227442622079b-328 + x * (609643702336915022892676446979464315541801774685703048044330521476797219277029459405194253086689979b-327 + x * (3231097593498066092130647891005502845743365718576424144385833584357950035247553737581486666711443263b-329 + x * (-2616929422912460208671159862929181361563168014320722181061325647954659236057543538176422702212765551b-329 + x * (-1086487167545885239762353531760289115589103541139412690935586322082743117281008925919085965653794949b-327 + x * (1153825455878837467942846302880561850626910163556219817718535312940642431171044830413067264936560961b-329 + x * (426190615910837958652435841808042265057578969751017988354235596856555790286394949735695426638795801b-326 + x * (-3049261258248492512553957727488457032717889068046361580110964834482321516378120619338953799867457085b-331 + x * (-586261917347835885602204268267128317301691595415261615087931507852755272136513833664941669345299455b-327 + x * (557404050939006934986049431419816775556256361324564754562880001875773387045401098578530387413592223b-329 + x * (1387792776779230471943447791424857914519796928841252577718784103138982912056821653821032532984716727b-329 + x * (-3285995967957263591382748517270098492767877788997345843579947925264244169977616724843010359331969369b-332 + x * (-2893733837361007965265880750279330910788837913921452587000653264181468595447220905672781622950041213b-331 + x * (2199755241022371297558315217874257721807914029642563602999313936664508235707383402095170887612052351b-332 + x * (1341716602486466713792361354627466135493950524298879098494972829279985925927125951673813790414661531b-331 + x * (-2618762158988042172639597959959233154121151634038714713650241708720138932317777436297331043107894569b-333 + x * (-2222628791105864876742284319851745692732772143298609730741825215152369549318866089775799001868289055b-333 + x * (1394252569291750341939137699870781790569095818186015349376261485403297214984487021889254669548510317b-333 + x * (1639933449461612644715031920116769872569878983758303565286275554365180610123210270899340090394758633b-334 + x * (-2686057470023396416882760325090034443069344463883329368721499542644237388965710943335487207802554807b-335 + x * (-4248031130778005062883783455569307697104170780174332854998143813334933628573225956680251203811974769b-337 + x * (1182918772047457832161326831475275004541615944168604737874353936451448673730065881982623690307880759b-335 + x * (1155942155199347992714554253750644756926549142439146462958050288530938493284793615956292869693993481b-337 + x * (-3843970797311274539703466942415513626343815100833181510828503241149349525263807555842211835887304945b-338 + x * (-911896617945003768467549496971757071792384511583649215671089976857370126562063072959032092688041765b-339 + x * (2899153875447292358555647058674865557982018754475514975431680646518577945787343771760767453586380373b-339 + x * (2814711995680979197123599172392312114997239503565632824186823439044755104186889295015107391523650727b-346 + x * (-4078068662294376287769630395391036045953560687435461579992166934989325356469416963310883551455800035b-341 + x * (1578093989360301650113165157647756083606175911087206489455403622990533896570996899941806640379305599b-343 + x * (670274776634839762718996133891259887713238683778474539521833015020547136895362189421392897901904115b-340 + x * (-4319276991183372496512264650033207768343638687536414370045488224752399433905265872744718416595562123b-345 + x * (-823910437157444415290569431881368027976363385359934647481458147660890954766469931007465699329136957b-342 + x * (2069930588992432394648381630714319993106283612167245241249177946697377775227910464866309506467164921b-345 + x * (471956936811187245496581795621972370251530022010989098340371078673016223669556054707117062221148627b-343 + x * (-1682144801681154037288113413880602875598325892042327333948090678520839713740738536970627274924722261b-346 + x * (-3999428992054846599226237581872104205444421412485465539254360461538783192239568417702429208288527227b-348 + x * (614426987676766313865592763161818760240370442461047379882461858639453374203432090754069797245993535b-346 + x * (1924281412982230934592123665752061076486907029124263508746995295869043166996273560145191699834020075b-349 + x * (-828221707009915071892889554884240633428190641459446811664259375137324321171016305265421983147628791b-348 + x * (-3228859555947787361261301546703259141951112730680872932487743821293715337493903582977099568017411617b-352 + x * (2088399455699548526173998278568807469735959977808714960654457704286587767096744447139202052956622891b-351 + x * (4180181285584806296773300952793969462002402079745687195409223730823971765973558485858389778959828347b-355 + x * (-2481907107341039122200669115276819951315877544533462699078887554357896026632162111609352376691377825b-353 + x * (-881049855457576526204607872590866998927428796875075523974303014990268119597795987642082333399947437b-357 + x * 2792182385824577983264051229631298430934776956763131548378368724335093098253842026336792725034277253b-355))))))))))))))))))))))))))))))))))))))))))))))))))))))))))); dirtyfindzeros(q,d); /*********************************************************************************/ restart; display=dyadic!; print("=============== Test number 34 ================"); /* Check if dirtyinfnorm seems to return a faithful rounding of the true value ||f||_I */ test_dirtyinfnorm = proc(f, I) { var oldprec, res, infr, supr, L, L2, t, r, stop, a, nbiter; oldprec = prec; prec = prec + 100!; L = dirtyfindzeros(diff(f), I); L2 = [||]; for t in L do { L2 = L2 :. [round(t, oldprec, RD), round(t, oldprec, RU)]; }; L = [inf(I),inf(I)].:L2:.[sup(I),sup(I)]; stop = false; nbiter = 0; while !stop do { infr = 0; supr = 0; for t in L do { r = evaluate(abs(f), t); if inf(r) > infr then infr = inf(r); if sup(r) > supr then supr = sup(r); }; r = [infr, supr]; a := floor(-log2( (sup(r)-inf(r)) / inf(abs(r)) )); if a >= oldprec+10 then stop = true; nbiter = nbiter + 1; prec = prec + 100!; if nbiter >= 5 then { nbiter = @Inf@; stop = true; }; }; if nbiter == @Inf@ then print("test_dirtyinfnorm did not manage to evaluate f with enough accuracy. The result of the test might be unreliable."); prec = oldprec!; res=dirtyinfnorm(f,I); if res in [round(inf(r), oldprec, RD), round(sup(r), oldprec, RU)] then print("dirtyinfnorm(", f, ",", I,") at precision", oldprec, "returns a faithful result") else print("dirtyinfnorm(", f, ",", I,") at precision", oldprec, "returned", res, "which is neither", round(inf(r), oldprec, RD), "nor", round(sup(r), oldprec, RU),". The result is hence not faithful."); }; test_dirtyinfnorm(sin(x),[-10;10]); print("=============== Test number 35 ================"); /* Do not restart here because we use test_dirtyinfnorm. We increment the counter just for legacy reasons */ prec=15!; test_dirtyinfnorm(exp(cos(x))*sin(x),[0;5]); prec=40!; test_dirtyinfnorm(exp(cos(x))*sin(x),[0;5]); prec=100!; test_dirtyinfnorm(exp(cos(x))*sin(x),[0;5]); prec=200!; test_dirtyinfnorm(exp(cos(x))*sin(x),[0;5]); prec=50!; test_dirtyinfnorm(exp(x),[1;2]); prec=100!; test_dirtyinfnorm(exp(x),[1;2]); prec=default!; p = 11691999891702459232513188345837804387460473133465b-163 + x * (11692942107918215660346141397235181022117132379831b-163 + x * (5835438123620347449415289742932818158651775091869b-163 + x * (3984684218240970504969472776081331362033160518301b-164 + x * (26040878953088729371129411196520398147571622258327b-169 + x * 20808009114828595646273342020654371193163483094671b-170)))); test_dirtyinfnorm(p-exp(x),[0;1]); p1 = 11691999891702459232513188345837804387460473133465b-163 + x * (11692942107918215660346141397235181022117132379831b-163 + x * (5835438123620347449415289742932818158651775091869b-163 + x * (3984684218240970504969472776081331362033160518301b-164 + x * (26040878953088729371129411196520398147571622258327b-169 + x * 20808009114828595646273342020654371193163483094671b-170)))); p2 = 11691999891702299312469444817572169311673890781507b-163 + x * (23385884215836760115521942647579564654384001742411b-164 + x * (1458859530913839021906884707848785355431185024535b-161 + x * (15938736871836860565882142316746025506783124556517b-166 + x * (26040878964869758854248710691789107998476450095123b-169 + x * 41616018209593462767401219418438811660046839978843b-171)))); p3 = 11691999891702299312469444817572169311673890781507b-163 + x * (23385884215836760115521942647579564654384001742411b-164 + x * (1458859530913839021906884707848785355431185024535b-161 + x * (15938736871836860565882142316746025506783124556517b-166 + x * (26040878964869758854248710691789107998476450095123b-169 + x * 41616018209593462767401219418438811660046839978843b-171)))); test_dirtyinfnorm(p1-exp(x),[0;1]); test_dirtyinfnorm(p2-exp(x),[0;1]); test_dirtyinfnorm(p3-exp(x),[0;1]); Q5 = 5750871b-37 * x^6 + 13462391b-39 * x^5 - 7528339b-32 * x^4 + 14577171b-41 * x^3 + 5814467b-26 * x^2 - 8388607b-24* x + 1; L1 = 11512405b-38 * x^6 + 13401955b-39 * x^5 - 470491b-28 * x^4 + 7234989b-40 * x^3 + 11628935b-27 * x^2 - 8388607b-24* x + 1 - (2878101b-36 * x^6 + 6700979b-38 * x^5 - 470491b-28 * x^4 + 7234987b-40 * x^3 + 11628935b-27 * x^2 - 8388607b-24* x + 1); f = log2(1 + 2^(x * (-1))); test_dirtyinfnorm((Q5+L1)-f,[0;1]); test_dirtyinfnorm(17, [-1,1]); test_dirtyinfnorm(x, [-1;1.5]); test_dirtyinfnorm(x^2 + x -1, [-2;1]); test_dirtyinfnorm(x^2 + x -1, [-2;2]); test_dirtyinfnorm(sin(17 * (x-3)) * cos(x-3) * exp(x/4), [-2;2]); test_dirtyinfnorm(sin(-51 + x * 17) * cos(-3 + x) * exp(x * 1b-2) + 4 - (5841986838484490273226357258541178809257197853603b-160 + x * (-1657010884744388725768284702475520358103564313103b-163 + x * (1566987824830335456879991047308861887585745670967b-162 + x * (18637702919758264241676014573759486129098461080361b-165 + x * (-4691389977422298284816628406735202847317903770937b-165 + x * (-3641480240898210056437514385988871012264138539689b-165)))))), [-2;2]); test_dirtyinfnorm((x * (46768052394588893382517914646921013753690502283181b-165 + x * (-23842604129029764481373810400725037839108682209013b-310 + x * (-31178701596392595588345276430836652277717061563611b-167 + x * (19474296355951076471139239730950050055091215313371b-300 + x * (6235740319278519117669054529057531256595154021039b-169 + x * (-8903255600987858885078854107239112353939531067197b-291 + x * (-19004160973039296358594544346438861776255280578323b-176 + x * (13978875722788212683821368308788823202998673317847b-285 + x * (16892587531590485568360414041618499983605528356089b-182 + x * (-5509367034013013747984244537606353757286793710935b-278 + x * (-9828414563834216782252138074806120633549802775429b-188 + x * (36514821794022558047614397315048656003649092374341b-276 + x * (4032170077040468786771930826281267656340291488583b-194 + x * (-15157407289929000622398688419996925341779253679627b-271 + x * (-19661622363274627316629009823189604834794640905605b-204 + x * (9925527665865119935372490664410596660907859285007b-268 + x * 9244923258117519852493775515420083692797862150005b-211))))))))))))))))) / sin(x) - 1, [-1/4;1/4]); /*********************************************************************************/ restart; print("=============== Test number 36 ================"); dirtyinfnorm(x^2, [log(0);log(1)]); /*********************************************************************************/ restart; print("=============== Test number 37 ================"); sin(10); dirtyintegral(cos(x),[0;10]); points=2000!; dirtyintegral(cos(x),[0;10]); /*********************************************************************************/ restart; print("=============== Test number 38 ================"); display = decimal; a = evaluate(sin(pi * x), 0.25); a; display = binary; a; display = hexadecimal; a; display = dyadic; a; display = powers; a; /*********************************************************************************/ restart; print("=============== Test number 39 ================"); 5 / 2; /*********************************************************************************/ restart; print("=============== Test number 40 ================"); x / 2;sollya-6.0+ds/tests-tool/check002.sollya.reference000066400000000000000000000213671300174114700220710ustar00rootroot00000000000000The tool has been restarted. =============== Test number 21 ================ -1 The tool has been restarted. =============== Test number 22 ================ 3 The tool has been restarted. =============== Test number 23 ================ Warning: the expression given is not a fraction. Will consider it as a fraction with denominator 1. 1 The tool has been restarted. =============== Test number 24 ================ 5 / 3 5 / 3 The tool has been restarted. =============== Test number 25 ================ Warning: the expression given is not a fraction. Will consider it as a fraction with denominator 1. Warning: the expression given is not a fraction. Will consider it as a fraction with denominator 1. exp(x / 3) exp(x / 3) The tool has been restarted. =============== Test number 26 ================ cos(x) The tool has been restarted. =============== Test number 27 ================ 1 The tool has been restarted. =============== Test number 28 ================ x^x * (1 + log(x)) The tool has been restarted. =============== Test number 29 ================ [|-3.1415926535897932384626433832795028841971693993751, 0, 3.1415926535897932384626433832795028841971693993751|] The tool has been restarted. =============== Test number 30 ================ The number of points has been set to 24. The precision has been set to 175 bits. [|-0.27620731976955658969395873271160757157430613176756617, -0.153375369093314463053373856415089923845367286245662016, -7.241334073292277341354279209158456757611929708835963e-2, -7.2413340732922771569268803462173581357399245626850215e-2, -6.8562001979847336855782392874984841492976000520805575e-36, 0.12868915582117545963368195688501287605691694181041506|] The tool has been restarted. =============== Test number 31 ================ The number of points has been set to 8. [|-0.24713873073113257661364344444399504026877021645667, 0.49713702082313212554616915823819745799022465237171|] The tool has been restarted. =============== Test number 32 ================ 18 25 The tool has been restarted. =============== Test number 33 ================ [|-0.24675695042278393475009541259944780067362448950599322, -0.19164513063974640135742136011628031325527988804464345, -0.145554248149418271721764550500169153912092301037746583, -0.107570572806048700953690068019994092347508577747527385, -7.486357314193808712365882447978637403239106362227434e-2, -4.7420860087340074816876054582176771338744375723325883e-2, -2.5569539511973301671265741938082704141119595025307828e-2, -9.6658829670910164628561398290543577718523826925691488e-3, -1.73030828251178554354835171964347180155527776809239316e-10|] The tool has been restarted. =============== Test number 34 ================ dirtyinfnorm( sin(x) , [-10;10] ) at precision 165 returns a faithful result =============== Test number 35 ================ dirtyinfnorm( exp(cos(x)) * sin(x) , [0;5] ) at precision 15 returns a faithful result dirtyinfnorm( exp(cos(x)) * sin(x) , [0;5] ) at precision 40 returns a faithful result dirtyinfnorm( exp(cos(x)) * sin(x) , [0;5] ) at precision 100 returns a faithful result dirtyinfnorm( exp(cos(x)) * sin(x) , [0;5] ) at precision 200 returns a faithful result dirtyinfnorm( exp(x) , [1;2] ) at precision 50 returns a faithful result dirtyinfnorm( exp(x) , [1;2] ) at precision 100 returns a faithful result dirtyinfnorm( 11691999891702459232513188345837804387460473133465b-163 + x * (11692942107918215660346141397235181022117132379831b-163 + x * (5835438123620347449415289742932818158651775091869b-163 + x * (3984684218240970504969472776081331362033160518301b-164 + x * (26040878953088729371129411196520398147571622258327b-169 + x * 20808009114828595646273342020654371193163483094671b-170)))) - exp(x) , [0;1] ) at precision 165 returns a faithful result dirtyinfnorm( 11691999891702459232513188345837804387460473133465b-163 + x * (11692942107918215660346141397235181022117132379831b-163 + x * (5835438123620347449415289742932818158651775091869b-163 + x * (3984684218240970504969472776081331362033160518301b-164 + x * (26040878953088729371129411196520398147571622258327b-169 + x * 20808009114828595646273342020654371193163483094671b-170)))) - exp(x) , [0;1] ) at precision 165 returns a faithful result dirtyinfnorm( 11691999891702299312469444817572169311673890781507b-163 + x * (23385884215836760115521942647579564654384001742411b-164 + x * (1458859530913839021906884707848785355431185024535b-161 + x * (15938736871836860565882142316746025506783124556517b-166 + x * (26040878964869758854248710691789107998476450095123b-169 + x * 41616018209593462767401219418438811660046839978843b-171)))) - exp(x) , [0;1] ) at precision 165 returns a faithful result dirtyinfnorm( 11691999891702299312469444817572169311673890781507b-163 + x * (23385884215836760115521942647579564654384001742411b-164 + x * (1458859530913839021906884707848785355431185024535b-161 + x * (15938736871836860565882142316746025506783124556517b-166 + x * (26040878964869758854248710691789107998476450095123b-169 + x * 41616018209593462767401219418438811660046839978843b-171)))) - exp(x) , [0;1] ) at precision 165 returns a faithful result dirtyinfnorm( 5750871b-37 * x^6 + 13462391b-39 * x^5 - 7528339b-32 * x^4 + 14577171b-41 * x^3 + 5814467b-26 * x^2 - 8388607b-24 * x + 1 + 11512405b-38 * x^6 + 13401955b-39 * x^5 - 470491b-28 * x^4 + 7234989b-40 * x^3 + 11628935b-27 * x^2 - 8388607b-24 * x + 1 - (2878101b-36 * x^6 + 6700979b-38 * x^5 - 470491b-28 * x^4 + 7234987b-40 * x^3 + 11628935b-27 * x^2 - 8388607b-24 * x + 1) - log2(1 + 2^(x * (-1))) , [0;1] ) at precision 165 returns a faithful result Warning: the expression is constant. dirtyinfnorm( 17 , [-1;1] ) at precision 165 returns a faithful result dirtyinfnorm( x , [-1;3b-1] ) at precision 165 returns a faithful result dirtyinfnorm( x^2 + x - 1 , [-2;1] ) at precision 165 returns a faithful result dirtyinfnorm( x^2 + x - 1 , [-2;2] ) at precision 165 returns a faithful result dirtyinfnorm( sin(17 * (x - 3)) * cos(x - 3) * exp(x / 4) , [-2;2] ) at precision 165 returns a faithful result dirtyinfnorm( sin(-51 + x * 17) * cos(-3 + x) * exp(x * 1b-2) + 4 - (5841986838484490273226357258541178809257197853603b-160 + x * (-1657010884744388725768284702475520358103564313103b-163 + x * (1566987824830335456879991047308861887585745670967b-162 + x * (18637702919758264241676014573759486129098461080361b-165 + x * (-4691389977422298284816628406735202847317903770937b-165 + x * (-3641480240898210056437514385988871012264138539689b-165)))))) , [-2;2] ) at precision 165 returns a faithful result dirtyinfnorm( (x * (46768052394588893382517914646921013753690502283181b-165 + x * (-23842604129029764481373810400725037839108682209013b-310 + x * (-31178701596392595588345276430836652277717061563611b-167 + x * (19474296355951076471139239730950050055091215313371b-300 + x * (6235740319278519117669054529057531256595154021039b-169 + x * (-8903255600987858885078854107239112353939531067197b-291 + x * (-19004160973039296358594544346438861776255280578323b-176 + x * (13978875722788212683821368308788823202998673317847b-285 + x * (16892587531590485568360414041618499983605528356089b-182 + x * (-5509367034013013747984244537606353757286793710935b-278 + x * (-9828414563834216782252138074806120633549802775429b-188 + x * (36514821794022558047614397315048656003649092374341b-276 + x * (4032170077040468786771930826281267656340291488583b-194 + x * (-15157407289929000622398688419996925341779253679627b-271 + x * (-19661622363274627316629009823189604834794640905605b-204 + x * (9925527665865119935372490664410596660907859285007b-268 + x * 9244923258117519852493775515420083692797862150005b-211))))))))))))))))) / sin(x) - 1 , [-1b-2;1b-2] ) at precision 165 returns a faithful result The tool has been restarted. =============== Test number 36 ================ Warning: a bound of the interval is infinite or NaN. This command cannot handle such intervals. NaN The tool has been restarted. =============== Test number 37 ================ -0.54402111088936981340474766185137728168364301291622 -0.54400304905152629822448058882475382036536298356282 -0.54401997751158321972222697312583199035995837926893 The tool has been restarted. =============== Test number 38 ================ Display mode is decimal numbers. 0.70710678118654752440084436210484903928483593768847 Display mode is binary numbers. 1.01101010000010011110011001100111111100111011110011001001000010001011001011111011000100110110011011101010100101010111110100111110001110101101111011000001011101010001_2 * 2^(-1) Display mode is hexadecimal numbers. 0x1.6a09e667f3bcc908b2fb1366ea957d3e3adec1751p-1 Display mode is dyadic numbers. 33070006991101558613323983488220944360067107133265b-165 Display mode is dyadic numbers in integer-power-of-2 notation. 33070006991101558613323983488220944360067107133265 * 2^(-165) The tool has been restarted. =============== Test number 39 ================ 2.5 The tool has been restarted. =============== Test number 40 ================ x * 0.5 sollya-6.0+ds/tests-tool/check003.sollya000066400000000000000000000072601300174114700201310ustar00rootroot00000000000000restart; print("=============== Test number 41 ================"); x / x; /*********************************************************************************/ restart; print("=============== Test number 42 ================"); 3 / 0; /*********************************************************************************/ restart; print("=============== Test number 43 ================"); diff(sin(x) / exp(x)); /*********************************************************************************/ restart; print("=============== Test number 44 ================"); verbosity=1!; a = 1+ 2^(-100); DD(a); prec=50!; DD(a); /*********************************************************************************/ restart; print("=============== Test number 45 ================"); display=binary!; DE(0.1); round(0.1,64,RN); /*********************************************************************************/ restart; print("=============== Test number 46 ================"); D(2^(-2000)); DE(2^(-2000)); /*********************************************************************************/ restart; print("=============== Test number 47 ================"); verbosity=1!; f = sin(DE(x)); f(pi); g = sin(round(x,64,RN)); /*********************************************************************************/ restart; print("=============== Test number 48 ================"); display=binary!; D(0.1); D(4.17); D(1.011_2 * 2^(-1073)); /*********************************************************************************/ restart; print("=============== Test number 49 ================"); "Hello" == "Hello"; "Hello" == "Salut"; "Hello" == 5; 5 + x == 5 + x; /*********************************************************************************/ restart; print("=============== Test number 50 ================"); 1 == exp(0); asin(1) * 2 == pi; exp(5) == log(4); /*********************************************************************************/ restart; print("=============== Test number 51 ================"); prec = 12; 16384 == 16385; /*********************************************************************************/ restart; print("=============== Test number 52 ================"); error == error; /*********************************************************************************/ restart; print("=============== Test number 53 ================"); print(5 + "foo"); /*********************************************************************************/ restart; print("=============== Test number 54 ================"); error; /*********************************************************************************/ restart; print("=============== Test number 55 ================"); error == error; error != error; /*********************************************************************************/ restart; print("=============== Test number 56 ================"); correct = 5 + 6; incorrect = 5 + "foo"; correct == correct; incorrect == correct; /*********************************************************************************/ restart; print("=============== Test number 57 ================"); print(evaluate(sin(pi * x), 2.25)); /*********************************************************************************/ restart; print("=============== Test number 58 ================"); print(evaluate(sin(pi * x), 2)); /*********************************************************************************/ restart; print("=============== Test number 59 ================"); print(evaluate(sin(pi * x), [2, 2.25])); /*********************************************************************************/ restart; print("=============== Test number 60 ================"); print(evaluate(sin(pi * x), 2 + 0.25 * x)); autosimplify=off; print(evaluate(sin(pi * x), 2 + 0.25 * x)); sollya-6.0+ds/tests-tool/check003.sollya.reference000066400000000000000000000065711300174114700220720ustar00rootroot00000000000000The tool has been restarted. =============== Test number 41 ================ 1 The tool has been restarted. =============== Test number 42 ================ Warning: the given expression is undefined or numerically unstable. NaN The tool has been restarted. =============== Test number 43 ================ (exp(x) * cos(x) - sin(x) * exp(x)) / exp(x)^2 The tool has been restarted. =============== Test number 44 ================ 1.0000000000000000000000000000007888609052210118054 1.000000000000000000000000000000788860905 The tool has been restarted. =============== Test number 45 ================ 1.100110011001100110011001100110011001100110011001100110011001101_2 * 2^(-4) 1.100110011001100110011001100110011001100110011001100110011001101_2 * 2^(-4) The tool has been restarted. =============== Test number 46 ================ 0 8.7098098162172166755761954947788722958591037427054e-603 The tool has been restarted. =============== Test number 47 ================ -5.016557612668332023557327080330757013831561670255e-20 Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. The tool has been restarted. =============== Test number 48 ================ 1.100110011001100110011001100110011001100110011001101_2 * 2^(-4) 1.000010101110000101000111101011100001010001111010111_2 * 2^(2) 1.1_2 * 2^(-1073) The tool has been restarted. =============== Test number 49 ================ true false false true The tool has been restarted. =============== Test number 50 ================ true true false The tool has been restarted. =============== Test number 51 ================ The precision has been set to 12 bits. false The tool has been restarted. =============== Test number 52 ================ false The tool has been restarted. =============== Test number 53 ================ Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error The tool has been restarted. =============== Test number 54 ================ error The tool has been restarted. =============== Test number 55 ================ false false The tool has been restarted. =============== Test number 56 ================ Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. true Warning: the evaluation of one of the sides of an equality test yields error due to a syntax error or an error on a side-effect. The other side either also yields error due to an syntax or side-effect error or does not evaluate to error. The boolean returned may be meaningless. false The tool has been restarted. =============== Test number 57 ================ 0.70710678118654752440084436210484903928483593768847 The tool has been restarted. =============== Test number 58 ================ [-1.7298645251438126951650861503109812954283676799168e-12715;7.5941198201187963145069564314525661706039084390068e-12716] The tool has been restarted. =============== Test number 59 ================ [-5.143390272677254630046998919961912407349224165421e-50;0.70710678118654752440084436210484903928483593768866] The tool has been restarted. =============== Test number 60 ================ sin((pi) * 2 + x * (pi) * 0.25) Automatic pure tree simplification has been deactivated. sin((pi) * (2 + 0.25 * x)) sollya-6.0+ds/tests-tool/check004.sollya000066400000000000000000000104051300174114700201250ustar00rootroot00000000000000restart; print("=============== Test number 61 ================"); print(evaluate(sin(pi * 1/x), 0)); /*********************************************************************************/ restart; print("=============== Test number 62 ================"); print(expand(x^3)); /*********************************************************************************/ restart; print("=============== Test number 63 ================"); print(expand((x + 2)^3 + 2 * x)); /*********************************************************************************/ restart; print("=============== Test number 64 ================"); print(expand(exp((x + (x + 3))^5))); /*********************************************************************************/ restart; print("=============== Test number 65 ================"); a=round(Pi,20,RN); e=exponent(a); e; m=mantissa(a); a-m*2^e; /*********************************************************************************/ restart; print("=============== Test number 66 ================"); true && false; 2<1; /*********************************************************************************/ restart; print("=============== Test number 67 ================"); findzeros(sin(x),[-5;5]); diam=1e-10!; findzeros(sin(x),[-5;5]); /*********************************************************************************/ restart; print("=============== Test number 68 ================"); autosimplify = off!; fullparentheses = off; print(1 + 2 + 3); fullparentheses = on; print(1 + 2 + 3); /*********************************************************************************/ restart; print("=============== Test number 69 ================"); 5 >= 4; 5 >= 5; 5 >= 6; exp(2) >= exp(1); log(1) >= exp(2); /*********************************************************************************/ restart; print("=============== Test number 70 ================"); prec = 12; 16384 >= 16385; /*********************************************************************************/ restart; print("=============== Test number 71 ================"); 5 > 4; 5 > 5; 5 > 6; exp(2) > exp(1); log(1) > exp(2); /*********************************************************************************/ restart; print("=============== Test number 72 ================"); prec = 12; 16384 > 16385; /*********************************************************************************/ restart; print("=============== Test number 73 ================"); guessdegree(exp(x),[-1;1],1e-10); /*********************************************************************************/ restart; print("=============== Test number 74 ================"); guessdegree(1, [-1;1], 1e-8, 1/exp(x)); /*********************************************************************************/ restart; print("=============== Test number 75 ================"); head([|1,2,3|]); head([|1,2...|]); /*********************************************************************************/ restart; print("=============== Test number 76 ================"); verbosity = 1!; q = implementpoly(1 - simplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,"p","implementation.c"); printexpansion(q); r = implementpoly(1 - simplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,"p","implementation.c",honorcoeffprec); printexpansion(r); /*********************************************************************************/ restart; print("=============== Test number 77 ================"); hopitalrecursions=0; evaluate(log(1+x)^2/x^2,[-1/2; 1]); hopitalrecursions=1; evaluate(log(1+x)^2/x^2,[-1/2; 1]); /*********************************************************************************/ restart; print("=============== Test number 78 ================"); print(horner(1 + 2 * x + 3 * x^2)); print(horner((x + 1)^7)); /*********************************************************************************/ restart; print("=============== Test number 79 ================"); print(horner(exp((x + 1)^5) - log(asin(x + x^3) + x))); /*********************************************************************************/ restart; print("=============== Test number 80 ================"); verbosity = 1!; q = implementpoly(1 - simplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,"p","implementation.c"); printexpansion(q); r = implementpoly(1 - simplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,"p","implementation.c",honorcoeffprec); printexpansion(r); sollya-6.0+ds/tests-tool/check004.sollya.reference000066400000000000000000000071721300174114700220710ustar00rootroot00000000000000The tool has been restarted. =============== Test number 61 ================ [-1;1] The tool has been restarted. =============== Test number 62 ================ x * x * x The tool has been restarted. =============== Test number 63 ================ 8 + 12 * x + 6 * x * x + x * x * x + 2 * x The tool has been restarted. =============== Test number 64 ================ exp(243 + 405 * x + 270 * x * x + 90 * x * x * x + 15 * x * x * x * x + x * x * x * x * x + x * 405 + 108 * x * 5 * x + 54 * x * x * 5 * x + 12 * x * x * x * 5 * x + x * x * x * x * 5 * x + x * x * 270 + 27 * x * x * x * 10 + 9 * x * x * x * x * 10 + x * x * x * x * x * 10 + x * x * x * 90 + 6 * x * x * x * x * 10 + x * x * x * x * x * 10 + x * x * x * x * 5 * x + 15 * x * x * x * x + x * x * x * x * x) The tool has been restarted. =============== Test number 65 ================ -17 0 The tool has been restarted. =============== Test number 66 ================ false false The tool has been restarted. =============== Test number 67 ================ [|[-3.14208984375;-3.140869140625], [-1.220703125e-3;1.220703125e-3], [3.140869140625;3.14208984375]|] [|[-3.14159265370108187198638916015625;-3.141592652536928653717041015625], [-1.16415321826934814453125e-9;1.16415321826934814453125e-9], [3.141592652536928653717041015625;3.14159265370108187198638916015625]|] The tool has been restarted. =============== Test number 68 ================ Full parentheses mode has been deactivated. 1 + 2 + 3 Full parentheses mode has been activated. (1 + 2) + 3 The tool has been restarted. =============== Test number 69 ================ true true false true false The tool has been restarted. =============== Test number 70 ================ The precision has been set to 12 bits. false The tool has been restarted. =============== Test number 71 ================ true false false true false The tool has been restarted. =============== Test number 72 ================ The precision has been set to 12 bits. false The tool has been restarted. =============== Test number 73 ================ [10;10] The tool has been restarted. =============== Test number 74 ================ [8;9] The tool has been restarted. =============== Test number 75 ================ 1 1 The tool has been restarted. =============== Test number 76 ================ 0x3ff0000000000000 + x^2 * 0xbfc5555555555555 Warning: the inferred precision of the 2th coefficient of the polynomial is greater than the necessary precision computed for this step. This may make the automatic determination of precisions useless. 0x3ff0000000000000 + x^2 * (0xbfc5555555555555 + 0xbc65555555555555 + 0xb905555555555555) The tool has been restarted. =============== Test number 77 ================ The number of recursions for Hopital's rule has been set to 0. [-infty;infty] The number of recursions for Hopital's rule has been set to 1. [-2.5225887222397812376689284858327062723020005374411;6.7725887222397812376689284858327062723020005374412] The tool has been restarted. =============== Test number 78 ================ 1 + x * (2 + x * 3) 1 + x * (7 + x * (21 + x * (35 + x * (35 + x * (21 + x * (7 + x)))))) The tool has been restarted. =============== Test number 79 ================ exp(1 + x * (5 + x * (10 + x * (10 + x * (5 + x))))) - log(asin(x * (1 + x^2)) + x) The tool has been restarted. =============== Test number 80 ================ 0x3ff0000000000000 + x^2 * 0xbfc5555555555555 Warning: the inferred precision of the 2th coefficient of the polynomial is greater than the necessary precision computed for this step. This may make the automatic determination of precisions useless. 0x3ff0000000000000 + x^2 * (0xbfc5555555555555 + 0xbc65555555555555 + 0xb905555555555555) sollya-6.0+ds/tests-tool/check005.sollya000066400000000000000000000105261300174114700201320ustar00rootroot00000000000000restart; print("=============== Test number 81 ================"); p = 0x3ff0000000000000 + x * (0x3ff0000000000000 + x * (0x3fe0000000000000 + x * (0x3fc5555555555559 + x * (0x3fa55555555555bd + x * (0x3f811111111106e2 + x * (0x3f56c16c16bf5eb7 + x * (0x3f2a01a01a292dcd + x * (0x3efa01a0218a016a + x * (0x3ec71de360331aad + x * (0x3e927e42e3823bf3 + x * (0x3e5ae6b2710c2c9a + x * (0x3e2203730c0a7c1d + x * 0x3de5da557e0781df)))))))))))); q = implementpoly(p,[-1/2;1/2],1b-60,D,"p","implementation.c",honorcoeffprec,"implementation.gappa"); if (q != p) then print("During implementation, rounding has happened.") else print("Polynomial implemented as given."); /*********************************************************************************/ restart; print("=============== Test number 82 ================"); infnorm(exp(x),[-2;3]); /*********************************************************************************/ restart; print("=============== Test number 83 ================"); infnorm(exp(x),[-2;3],[| [0;1], [2;2.5] |]); /*********************************************************************************/ restart; print("=============== Test number 84 ================"); infnorm(exp(x),[-2;3],"proof.txt", [| [0;1], [2;2.5] |]); /*********************************************************************************/ restart; print("=============== Test number 85 ================"); infnorm(exp(x),[1;1]); /*********************************************************************************/ restart; print("=============== Test number 86 ================"); infnorm(exp(x), [log(0);log(1)]); /*********************************************************************************/ restart; print("=============== Test number 87 ================"); inf([1;3]); inf(0); /*********************************************************************************/ restart; print("=============== Test number 88 ================"); display=binary!; I=[0.111110000011111_2; 1]; inf(I); prec=12!; inf(I); /*********************************************************************************/ restart; print("=============== Test number 89 ================"); sin(10); integral(cos(x),[0;10]); diam=1e-5!; integral(cos(x),[0;10]); /*********************************************************************************/ restart; print("=============== Test number 90 ================"); isbound(x); isbound(f); isbound(g); f=sin(x); isbound(x); isbound(f); isbound(g); /*********************************************************************************/ restart; print("=============== Test number 91 ================"); isbound(a); { var a; isbound(a); }; isbound(a); /*********************************************************************************/ restart; print("=============== Test number 92 ================"); f=sin(x); isbound(x); rename(x,y); isbound(x); /*********************************************************************************/ restart; print("=============== Test number 93 ================"); x=1; f=sin(y); rename(y,x); f; x; isbound(x); rename(x,y); isbound(x); x; /*********************************************************************************/ restart; print("=============== Test number 94 ================"); isevaluable(sin(pi * 1/x), 0.75); print(evaluate(sin(pi * 1/x), 0.75)); /*********************************************************************************/ restart; print("=============== Test number 95 ================"); isevaluable(sin(pi * 1/x), 0.5); print(evaluate(sin(pi * 1/x), 0.5)); /*********************************************************************************/ restart; print("=============== Test number 96 ================"); isevaluable(sin(pi * 1/x), 0); print(evaluate(sin(pi * 1/x), 0)); /*********************************************************************************/ restart; print("=============== Test number 97 ================"); length("Hello World!"); /*********************************************************************************/ restart; print("=============== Test number 98 ================"); length([|1,...,5|]); /*********************************************************************************/ restart; print("=============== Test number 99 ================"); length([| |]); /*********************************************************************************/ restart; print("=============== Test number 100 ================"); length([|1,2...|]);sollya-6.0+ds/tests-tool/check005.sollya.reference000066400000000000000000000065511300174114700220720ustar00rootroot00000000000000The tool has been restarted. =============== Test number 81 ================ Warning: a coefficient is not at least 2 times greater than a already evaluated sub-polynomial. This procedure is not able to implement the polynomial correctly in this case. Warning: the inferred precision of the 13th coefficient of the polynomial is greater than the necessary precision computed for this step. This may make the automatic determination of precisions useless. Warning: a problem has been encountered during the determination of the precisions needed. The produced implementation may be incorrect. Polynomial implemented as given. The tool has been restarted. =============== Test number 82 ================ [20.085536923187667740928529654581717896987907838554;20.0855369231876677409285296545817178969879078385544] The tool has been restarted. =============== Test number 83 ================ [20.085536923187667740928529654581717896987907838554;20.0855369231876677409285296545817178969879078385544] The tool has been restarted. =============== Test number 84 ================ [20.085536923187667740928529654581717896987907838554;20.0855369231876677409285296545817178969879078385544] The tool has been restarted. =============== Test number 85 ================ [2.7182818284590452353602874713526624977572470936999;2.7182818284590452353602874713526624977572470937] The tool has been restarted. =============== Test number 86 ================ Warning: the bounds of the range an infinity norm is to be computed on are not numbers. [0;infty] The tool has been restarted. =============== Test number 87 ================ 1 0 The tool has been restarted. =============== Test number 88 ================ 1.11110000011111_2 * 2^(-1) 1.11110000011111_2 * 2^(-1) The tool has been restarted. =============== Test number 89 ================ -0.54402111088936981340474766185137728168364301291622 [-0.54710197983579690224097637163525943075698599257333;-0.54094015130013183848150540881373370744053741191729] [-0.54432915685955427101857780295936956775293876382777;-0.54371306401249969508039644221927489010425803173555] The tool has been restarted. =============== Test number 90 ================ false false false true true false The tool has been restarted. =============== Test number 91 ================ false true false The tool has been restarted. =============== Test number 92 ================ true Information: the free variable has been renamed from "x" to "y". false The tool has been restarted. =============== Test number 93 ================ Information: the free variable has been renamed from "y" to "x". sin(x) x true Information: the free variable has been renamed from "x" to "y". true 1 The tool has been restarted. =============== Test number 94 ================ true -0.86602540378443864676372317075293618347140262690519 The tool has been restarted. =============== Test number 95 ================ true [-1.7298645251438126951650861503109812954283676799168e-12715;7.5941198201187963145069564314525661706039084390068e-12716] The tool has been restarted. =============== Test number 96 ================ true [-1;1] The tool has been restarted. =============== Test number 97 ================ 12 The tool has been restarted. =============== Test number 98 ================ 5 The tool has been restarted. =============== Test number 99 ================ 0 The tool has been restarted. =============== Test number 100 ================ infty sollya-6.0+ds/tests-tool/check006.sollya000066400000000000000000000067451300174114700201430ustar00rootroot00000000000000restart; print("=============== Test number 101 ================"); 5 <= 4; 5 <= 5; 5 <= 6; exp(2) <= exp(1); log(1) <= exp(2); /*********************************************************************************/ restart; print("=============== Test number 102 ================"); prec = 12; 16385 <= 16384; /*********************************************************************************/ restart; print("=============== Test number 103 ================"); 5 < 4; 5 < 5; 5 < 6; exp(2) < exp(1); log(1) < exp(2); /*********************************************************************************/ restart; print("=============== Test number 104 ================"); prec = 12; 16384 < 16385; /*********************************************************************************/ restart; print("=============== Test number 105 ================"); a=round(Pi,20,RN); e=exponent(a); m=mantissa(a); m; a-m*2^e; /*********************************************************************************/ restart; print("=============== Test number 106 ================"); a = round(Pi,30,RD); b = round(Pi,30,RU); d = [a,b]; d; midpointmode=on!; d; /*********************************************************************************/ restart; print("=============== Test number 107 ================"); mid([1;3]); mid(17); /*********************************************************************************/ restart; print("=============== Test number 108 ================"); 5 - 2; /*********************************************************************************/ restart; print("=============== Test number 109 ================"); x - 2; /*********************************************************************************/ restart; print("=============== Test number 110 ================"); x - x; /*********************************************************************************/ restart; print("=============== Test number 111 ================"); diff(sin(x) - exp(x)); /*********************************************************************************/ restart; print("=============== Test number 112 ================"); 5 * 2; /*********************************************************************************/ restart; print("=============== Test number 113 ================"); x * 2; /*********************************************************************************/ restart; print("=============== Test number 114 ================"); x * x; /*********************************************************************************/ restart; print("=============== Test number 115 ================"); diff(sin(x) * exp(x)); /*********************************************************************************/ restart; print("=============== Test number 116 ================"); "Hello" != "Hello"; "Hello" != "Salut"; "Hello" != 5; 5 + x != 5 + x; /*********************************************************************************/ restart; print("=============== Test number 117 ================"); 1 != exp(0); asin(1) * 2 != pi; exp(5) != log(4); /*********************************************************************************/ restart; print("=============== Test number 118 ================"); prec = 12; 16384 != 16385; /*********************************************************************************/ restart; print("=============== Test number 119 ================"); error != error; /*********************************************************************************/ restart; print("=============== Test number 120 ================"); nop;sollya-6.0+ds/tests-tool/check006.sollya.reference000066400000000000000000000036511300174114700220710ustar00rootroot00000000000000The tool has been restarted. =============== Test number 101 ================ false true true false true The tool has been restarted. =============== Test number 102 ================ The precision has been set to 12 bits. false The tool has been restarted. =============== Test number 103 ================ false false true false true The tool has been restarted. =============== Test number 104 ================ The precision has been set to 12 bits. true The tool has been restarted. =============== Test number 105 ================ 411775 0 The tool has been restarted. =============== Test number 106 ================ [3.1415926516056060791015625;3.1415926553308963775634765625] 0.314159265~1/6~e1 The tool has been restarted. =============== Test number 107 ================ 2 17 The tool has been restarted. =============== Test number 108 ================ 3 The tool has been restarted. =============== Test number 109 ================ -2 + x The tool has been restarted. =============== Test number 110 ================ 0 The tool has been restarted. =============== Test number 111 ================ cos(x) - exp(x) The tool has been restarted. =============== Test number 112 ================ 10 The tool has been restarted. =============== Test number 113 ================ x * 2 The tool has been restarted. =============== Test number 114 ================ x^2 The tool has been restarted. =============== Test number 115 ================ sin(x) * exp(x) + exp(x) * cos(x) The tool has been restarted. =============== Test number 116 ================ false true true false The tool has been restarted. =============== Test number 117 ================ false false true The tool has been restarted. =============== Test number 118 ================ The precision has been set to 12 bits. true The tool has been restarted. =============== Test number 119 ================ false The tool has been restarted. =============== Test number 120 ================ sollya-6.0+ds/tests-tool/check007.sollya000066400000000000000000000070311300174114700201310ustar00rootroot00000000000000restart; print("=============== Test number 121 ================"); succ = proc(n) { return n + 1; }; succ; succ(5); /*********************************************************************************/ restart; print("=============== Test number 122 ================"); ! false; /*********************************************************************************/ restart; print("=============== Test number 123 ================"); ! (1 == exp(0)); /*********************************************************************************/ restart; print("=============== Test number 124 ================"); numerator(5/3); /*********************************************************************************/ restart; print("=============== Test number 125 ================"); numerator(exp(x)); /*********************************************************************************/ restart; print("=============== Test number 126 ================"); a = 5/3; b = numerator(a)/denominator(a); print(a); print(b); /*********************************************************************************/ restart; print("=============== Test number 127 ================"); a = exp(x/3); b = numerator(a)/denominator(a); print(a); print(b); /*********************************************************************************/ restart; print("=============== Test number 128 ================"); canonical=on; p=1+x+x^2; mode=off; p; canonical=mode; p; /*********************************************************************************/ restart; print("=============== Test number 129 ================"); p=1+x+x^2; mode=on; p; canonical=mode; p; /*********************************************************************************/ restart; print("=============== Test number 130 ================"); false || false; /*********************************************************************************/ restart; print("=============== Test number 131 ================"); (1 == exp(0)) || (0 == log(1)); /*********************************************************************************/ restart; print("=============== Test number 132 ================"); parse("exp(x)"); /*********************************************************************************/ restart; print("=============== Test number 133 ================"); verbosity=1!; prec=12!; a = 2*pi; a; prec=20!; a; /*********************************************************************************/ restart; print("=============== Test number 134 ================"); prec=12!; d = [pi; 5]; d; prec=20!; d; /*********************************************************************************/ restart; print("=============== Test number 135 ================"); 1 + 2; /*********************************************************************************/ restart; print("=============== Test number 136 ================"); x + 2; /*********************************************************************************/ restart; print("=============== Test number 137 ================"); x + x; /*********************************************************************************/ restart; print("=============== Test number 138 ================"); diff(sin(x) + exp(x)); /*********************************************************************************/ restart; print("=============== Test number 139 ================"); f=x^2*sin(1/x); points=10; dirtyfindzeros(f, [0;1]); points=100; dirtyfindzeros(f, [0;1]); /*********************************************************************************/ restart; print("=============== Test number 140 ================"); 5 ^ 2;sollya-6.0+ds/tests-tool/check007.sollya.reference000066400000000000000000000055401300174114700220710ustar00rootroot00000000000000The tool has been restarted. =============== Test number 121 ================ proc(n) { nop; return (n) + (1); } 6 The tool has been restarted. =============== Test number 122 ================ true The tool has been restarted. =============== Test number 123 ================ false The tool has been restarted. =============== Test number 124 ================ 5 The tool has been restarted. =============== Test number 125 ================ Warning: the expression given is not a fraction. Will consider it as a fraction with denominator 1. exp(x) The tool has been restarted. =============== Test number 126 ================ 5 / 3 5 / 3 The tool has been restarted. =============== Test number 127 ================ Warning: the expression given is not a fraction. Will consider it as a fraction with denominator 1. Warning: the expression given is not a fraction. Will consider it as a fraction with denominator 1. exp(x / 3) exp(x / 3) The tool has been restarted. =============== Test number 128 ================ Canonical automatic printing output has been activated. 1 + x + x^2 Canonical automatic printing output has been deactivated. 1 + x * (1 + x) The tool has been restarted. =============== Test number 129 ================ 1 + x * (1 + x) Canonical automatic printing output has been activated. 1 + x + x^2 The tool has been restarted. =============== Test number 130 ================ false The tool has been restarted. =============== Test number 131 ================ true The tool has been restarted. =============== Test number 132 ================ exp(x) The tool has been restarted. =============== Test number 133 ================ 6.283 6.28319 The tool has been restarted. =============== Test number 134 ================ [3.141;5] [3.140625;5] The tool has been restarted. =============== Test number 135 ================ 3 The tool has been restarted. =============== Test number 136 ================ 2 + x The tool has been restarted. =============== Test number 137 ================ x * 2 The tool has been restarted. =============== Test number 138 ================ cos(x) + exp(x) The tool has been restarted. =============== Test number 139 ================ The number of points has been set to 10. [|0, 0.31830988618379067153776752674502872406891929148092|] The number of points has been set to 100. [|0, 2.4485375860291590118289809749617594159147637806224e-2, 3.9788735772973833942220940843128590508614911435115e-2, 4.5472840883398667362538218106432674866988470211559e-2, 5.3051647697298445256294587790838120678153215246819e-2, 6.3661977236758134307553505349005744813783858296184e-2, 7.957747154594766788444188168625718101722982287023e-2, 0.106103295394596890512589175581676241356306430493638, 0.15915494309189533576888376337251436203445964574046, 0.31830988618379067153776752674502872406891929148092|] The tool has been restarted. =============== Test number 140 ================ 25 sollya-6.0+ds/tests-tool/check008.sollya000066400000000000000000000106001300174114700201260ustar00rootroot00000000000000restart; print("=============== Test number 141 ================"); x ^ 2; /*********************************************************************************/ restart; print("=============== Test number 142 ================"); 3 ^ (-5); /*********************************************************************************/ restart; print("=============== Test number 143 ================"); (-3) ^ (-2.5); /*********************************************************************************/ restart; print("=============== Test number 144 ================"); diff(sin(x) ^ exp(x)); /*********************************************************************************/ restart; print("=============== Test number 145 ================"); a=round(Pi,20,RN); precision(a); m=mantissa(a); ceil(log2(m)); /*********************************************************************************/ restart; print("=============== Test number 146 ================"); /*********************************************************************************/ restart; print("=============== Test number 147 ================"); 1.:[|2,3,4|]; /*********************************************************************************/ restart; print("=============== Test number 148 ================"); [|1,2,3|].:[|4,5,6|]; /*********************************************************************************/ restart; print("=============== Test number 149 ================"); 1.:[||]; /*********************************************************************************/ restart; print("=============== Test number 150 ================"); printexpansion(roundcoefficients(taylor(exp(x),5,0),[|DD...|])); /*********************************************************************************/ restart; print("=============== Test number 151 ================"); p = 11692536319630510474283968587625525849426869787677b-163 + x * (23384922893552793741208186896732057180708286140565b-164 + x * (46692941277611593554424973690517694800554713844979b-166 + x * (3891678517537147456387754739468835779118224484425b-164 + x * (1024072943597638219514404758611859127188920401873b-164 + x * 26154763285557255659575812244171511366994513699585b-171)))); printexpansion(p); /*********************************************************************************/ restart; print("=============== Test number 152 ================"); verbosity = 1!; prec = 3500!; printexpansion(pi); /*********************************************************************************/ restart; print("=============== Test number 153 ================"); printfloat(3); /*********************************************************************************/ restart; print("=============== Test number 154 ================"); prec=100!; verbosity = 1!; printfloat(exp(5)); /*********************************************************************************/ restart; print("=============== Test number 155 ================"); printhexa(3); /*********************************************************************************/ restart; print("=============== Test number 156 ================"); prec=100!; verbosity = 1!; printhexa(exp(5)); /*********************************************************************************/ restart; print("=============== Test number 157 ================"); print(x + 2 + exp(sin(x))); print("Hello","world"); print("Hello","you", 4 + 3, "other persons."); /*********************************************************************************/ restart; print("=============== Test number 158 ================"); print("Hello"); print([|"Hello"|]); s = "Hello"; print(s,[|s|]); t = "Hello\tyou"; print(t,[|t|]); /*********************************************************************************/ restart; print("=============== Test number 159 ================"); display = decimal; a = evaluate(sin(pi * x), 0.25); b = evaluate(sin(pi * x), [0.25; 0.25 + 1b-50]); print(a); display = binary; print(a); display = hexadecimal; print(a); display = dyadic; print(a); display = powers; print(a); display = decimal; midpointmode = off; print(b); midpointmode = on; print(b); display = dyadic; print(b); display = decimal; autosimplify = off; fullparentheses = off; print(x + x * ((x + 1) + 1)); fullparentheses = on; print(x + x * ((x + 1) + 1)); /*********************************************************************************/ restart; print("=============== Test number 160 ================"); printxml(x + 2 + exp(sin(x))); sollya-6.0+ds/tests-tool/check008.sollya.reference000066400000000000000000000120721300174114700220700ustar00rootroot00000000000000The tool has been restarted. =============== Test number 141 ================ x^2 The tool has been restarted. =============== Test number 142 ================ 4.1152263374485596707818930041152263374485596707819e-3 The tool has been restarted. =============== Test number 143 ================ Warning: the given expression is undefined or numerically unstable. NaN The tool has been restarted. =============== Test number 144 ================ sin(x)^exp(x) * ((cos(x) * exp(x)) / sin(x) + exp(x) * log(sin(x))) The tool has been restarted. =============== Test number 145 ================ 19 19 The tool has been restarted. =============== Test number 146 ================ The tool has been restarted. =============== Test number 147 ================ [|1, 2, 3, 4|] The tool has been restarted. =============== Test number 148 ================ [|[|1, 2, 3|], 4, 5, 6|] The tool has been restarted. =============== Test number 149 ================ [|1|] The tool has been restarted. =============== Test number 150 ================ 0x3ff0000000000000 + x * (0x3ff0000000000000 + x * (0x3fe0000000000000 + x * ((0x3fc5555555555555 + 0x3c65555555555555) + x * ((0x3fa5555555555555 + 0x3c45555555555555) + x * (0x3f81111111111111 + 0x3c01111111111111))))) The tool has been restarted. =============== Test number 151 ================ (0x3ff0002eec908ce9 + 0xbc7df99eb225af5b + 0xb8d55834b08b1f18) + x * ((0x3ff0002835917719 + 0x3c6d82c073b25ebf + 0xb902cf062b54b7b6 + 0x35b0000000000000) + x * ((0x3fdff2d7e6a9c5e9 + 0xbc7b09a95b0d520f + 0xb915b639add55731 + 0x35a8000000000000) + x * ((0x3fc54d67338ba09f + 0x3c4867596d0631cf + 0xb8ef0756bdb4af6e) + x * ((0x3fa66c209b825167 + 0x3c45ec5b6655b076 + 0xb8d8c125286400bc) + x * (0x3f81e55425e72ab4 + 0x3c263b25a1bf597b + 0xb8c843e0401dadd0 + 0x3540000000000000))))) The tool has been restarted. =============== Test number 152 ================ (0x400921fb54442d18 + 0x3ca1a62633145c07 + 0xb92f1976b7ed8fbc + 0x35c4cf98e804177d + 0x32631d89cd9128a5 + 0x2ec0f31c6809bbdf + 0x2b5519b3cd3a431b + 0x27e8158536f92f8a + 0x246ba7f09ab6b6a9 + 0xa0eedd0dbd2544cf + 0x1d779fb1bd1310ba + 0x1a1a637ed6b0bff6 + 0x96aa485fca40908e + 0x933e501295d98169 + 0x8fd160dbee83b4e0 + 0x8c59b6d799ae131c + 0x08f6cf70801f2e28 + 0x05963bf0598da483 + 0x023871574e69a459 + 0x8000000005702db3 + 0x8000000000000000) The tool has been restarted. =============== Test number 153 ================ 0x40400000 The tool has been restarted. =============== Test number 154 ================ 0x431469c5 The tool has been restarted. =============== Test number 155 ================ 0x4008000000000000 The tool has been restarted. =============== Test number 156 ================ 0x40628d389970338f The tool has been restarted. =============== Test number 157 ================ x + 2 + exp(sin(x)) Hello world Hello you 7 other persons. The tool has been restarted. =============== Test number 158 ================ Hello [|"Hello"|] Hello [|"Hello"|] Hello you [|"Hello\tyou"|] The tool has been restarted. =============== Test number 159 ================ Display mode is decimal numbers. 0.70710678118654752440084436210484903928483593768847 Display mode is binary numbers. 1.01101010000010011110011001100111111100111011110011001001000010001011001011111011000100110110011011101010100101010111110100111110001110101101111011000001011101010001_2 * 2^(-1) Display mode is hexadecimal numbers. 0x1.6a09e667f3bcc908b2fb1366ea957d3e3adec1751p-1 Display mode is dyadic numbers. 33070006991101558613323983488220944360067107133265b-165 Display mode is dyadic numbers in integer-power-of-2 notation. 33070006991101558613323983488220944360067107133265 * 2^(-165) Display mode is decimal numbers. Midpoint mode has been deactivated. [0.70710678118654752440084436210484903928483593768845;0.70710678118654949743721782517557347782646274417049] Midpoint mode has been activated. 0.7071067811865~4/5~ Display mode is dyadic numbers. [2066875436943847413332748968013809022504194195829b-161;16535003495550825444196237019385936414432675156571b-164] Display mode is decimal numbers. Automatic pure tree simplification has been deactivated. Full parentheses mode has been deactivated. x + x * (x + 1 + 1) Full parentheses mode has been activated. x + (x * ((x + 1) + 1)) The tool has been restarted. =============== Test number 160 ================ x x 2 x (x + 1b1) + exp(sin(x)) sollya-6.0+ds/tests-tool/check009.sollya000066400000000000000000000124371300174114700201410ustar00rootroot00000000000000restart; print("=============== Test number 161 ================"); procedure succ(n) { return n + 1; }; succ(5); 3 + succ(0); succ; /*********************************************************************************/ restart; print("=============== Test number 162 ================"); succ = proc(n) { return n + 1; }; succ(5); 3 + succ(0); succ; /*********************************************************************************/ restart; print("=============== Test number 163 ================"); add = proc(m,n) { var res; res := m + n; return res; }; add(5,6); add; verbosity = 1!; add(3); add(true,false); /*********************************************************************************/ restart; print("=============== Test number 164 ================"); succ = proc(n) { return n + 1; }; succ(5); succ(x); /*********************************************************************************/ restart; print("=============== Test number 165 ================"); hey = proc() { print("Hello world."); }; hey(); print(hey()); hey; /*********************************************************************************/ restart; print("=============== Test number 166 ================"); fac = proc(n) { var res; if (n == 0) then res := 1 else res := n * fac(n - 1); return res; }; fac(5); fac(11); fac; /*********************************************************************************/ restart; print("=============== Test number 167 ================"); myprocs = [| proc(m,n) { return m + n; }, proc(m,n) { return m - n; } |]; (myprocs[0])(5,6); (myprocs[1])(5,6); succ = proc(n) { return n + 1; }; pred = proc(n) { return n - 1; }; applier = proc(p,n) { return p(n); }; applier(succ,5); applier(pred,5); /*********************************************************************************/ restart; print("=============== Test number 168 ================"); verbosity = 1!; myquit = proc(n) { print(n); quit; }; myquit; myquit(5); /*********************************************************************************/ restart; print("=============== Test number 169 ================"); printsucc = proc(n) { var succ; succ = proc(n) { return n + 1; }; print("Successor of",n,"is",succ(n)); }; printsucc(5); /*********************************************************************************/ restart; print("=============== Test number 170 ================"); makeadd = proc(n) { var add; print("n =",n); add = proc(m,n) { return n + m; }; return add; }; makeadd(4); (makeadd(4))(5,6); /*********************************************************************************/ /* restart; */ /* print("=============== Test number 171 ================"); */ /* quit; */ /*********************************************************************************/ restart; print("=============== Test number 172 ================"); pi10 = rationalapprox(Pi,10); pi50 = rationalapprox(Pi,50); pi100 = rationalapprox(Pi,100); r = rationalapprox(sin(pi/5.9),7); print( pi10, ": ", simplify(floor(-log2(abs(pi10-Pi)/Pi))), "bits." ); print( pi50, ": ", simplify(floor(-log2(abs(pi50-Pi)/Pi))), "bits." ); print( pi100, ": ", simplify(floor(-log2(abs(pi100-Pi)/Pi))), "bits." ); print( r, ": ", simplify(floor(-log2(abs(r-sin(pi/5.9))/sin(pi/5.9)))), "bits." ); /*********************************************************************************/ restart; print("=============== Test number 173 ================"); a=0.1; b=rationalapprox(a,4); numerator(b); denominator(b); print(simplify(floor(-log2(abs((b-a)/a)))), "bits."); /*********************************************************************************/ restart; print("=============== Test number 174 ================"); display=binary!; round(Pi,20,RD); /*********************************************************************************/ restart; print("=============== Test number 175 ================"); /*********************************************************************************/ restart; print("=============== Test number 176 ================"); /*********************************************************************************/ restart; print("=============== Test number 177 ================"); p = 23384026195983479554312107615576132098315751748267b-164 + x^2 * (-46768051993840437443783072518668792259606171959529b-166 + x^2 * (15589330806475599601965639862079915077330658862695b-168 + x^2 * (-33251631244830928295499525279229507601750795147543b-174 + x^2 * 37351022179333407291017870331792433578970741553163b-180))); canonical=on!; p; /*********************************************************************************/ restart; print("=============== Test number 178 ================"); /*********************************************************************************/ restart; print("=============== Test number 179 ================"); f=sin(x); f; rename(x,y); f; /*********************************************************************************/ restart; print("=============== Test number 180 ================"); a=1; f=sin(x); rename(x,a); a; f; /*********************************************************************************/ restart; print("=============== Test number 181 ================"); mylist = [|"0", "1", "2", "3"|]; procedure enumerate(l) { var k, h; k = 0; while (l != [||]) do { h = head(l); "l = ", l; "k = ", k; "h = ", h; l = tail(l); k = k + 1; }; }; enumerate(mylist); sollya-6.0+ds/tests-tool/check009.sollya.reference000066400000000000000000000064771300174114700221050ustar00rootroot00000000000000The tool has been restarted. =============== Test number 161 ================ 6 4 proc(n) { nop; return (n) + (1); } The tool has been restarted. =============== Test number 162 ================ 6 4 proc(n) { nop; return (n) + (1); } The tool has been restarted. =============== Test number 163 ================ 11 proc(m, n) { var res; res := (m) + (n); return res; } Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. Warning: the given expression or command could not be handled. error The tool has been restarted. =============== Test number 164 ================ 6 1 + x The tool has been restarted. =============== Test number 165 ================ Hello world. Hello world. void proc() { print("Hello world."); return void; } The tool has been restarted. =============== Test number 166 ================ 120 39916800 proc(n) { var res; if (n) == (0) then res := 1 else res := (n) * (fac((n) - (1))); return res; } The tool has been restarted. =============== Test number 167 ================ 11 -1 6 4 The tool has been restarted. =============== Test number 168 ================ proc(n) { print(n); quit; return void; } Warning: a quit or restart command may not be part of a procedure body. The procedure will not be executed. Warning: an error occurred while executing a procedure. Warning: the given expression or command could not be handled. error The tool has been restarted. =============== Test number 169 ================ Successor of 5 is 6 The tool has been restarted. =============== Test number 170 ================ n = 4 proc(m, n) { nop; return (n) + (m); } n = 4 11 The tool has been restarted. =============== Test number 172 ================ 3.140625 : 11 bits. 85563208 / 27235615 : 51 bits. 4422001152019829 / 1407566683404023 : 100 bits. 33 / 65 : 14 bits. The tool has been restarted. =============== Test number 173 ================ 1 10 166 bits. The tool has been restarted. =============== Test number 174 ================ 1.1001001000011111101_2 * 2^(1) The tool has been restarted. =============== Test number 175 ================ The tool has been restarted. =============== Test number 176 ================ The tool has been restarted. =============== Test number 177 ================ 0.99999999994393749280444571988532724907643631727382 + -0.49999999571557467737204931630836834563663039748203 * x^2 + 4.1666613233501090518825397221274871865177524190297e-2 * x^4 + -1.3886529147528614170718065838317679966260169134874e-3 * x^6 + 2.437267919111162694221738667927916761689966804242e-5 * x^8 The tool has been restarted. =============== Test number 178 ================ The tool has been restarted. =============== Test number 179 ================ sin(x) Information: the free variable has been renamed from "x" to "y". sin(y) The tool has been restarted. =============== Test number 180 ================ Information: the free variable has been renamed from "x" to "a". a sin(a) The tool has been restarted. =============== Test number 181 ================ l = [|"0", "1", "2", "3"|] k = 0 h = 0 l = [|"1", "2", "3"|] k = 1 h = 1 l = [|"2", "3"|] k = 2 h = 2 l = [|"3"|] k = 3 h = 3 sollya-6.0+ds/tests-tool/check010.sollya000066400000000000000000000101631300174114700201230ustar00rootroot00000000000000restart; print("=============== Test number 181 ================"); verbosity=1!; f=sin(x); rename(y,z); /*********************************************************************************/ restart; print("=============== Test number 182 ================"); rename(x,y); isbound(x); isbound(y); /*********************************************************************************/ restart; print("=============== Test number 183 ================"); print(exp(x)); a = 3; restart; print("=============== Test number 184 ================"); print(x); a; /*********************************************************************************/ restart; print("=============== Test number 185 ================"); print(exp(x)); for i from 1 to 10 do { print(i); if (i == 5) then restart; }; /*********************************************************************************/ restart; print("=============== Test number 186 ================"); print(exp(x)); a = 3; for i from 1 to 10 do { print(i); if (i == 5) then { restart; i = 7; }; }; print(x); a; /*********************************************************************************/ restart; print("=============== Test number 187 ================"); succ = proc(n) { var res; res := n + 1; return res; }; succ(5); succ; /*********************************************************************************/ restart; print("=============== Test number 188 ================"); hey = proc(s) { print("Hello",s); }; hey("world"); hey; /*********************************************************************************/ restart; print("=============== Test number 189 ================"); revert([| |]); /*********************************************************************************/ restart; print("=============== Test number 190 ================"); revert([|2,3,5,2,1,4|]); /*********************************************************************************/ restart; print("=============== Test number 191 ================"); display=binary!; round(Pi,20,RN); /*********************************************************************************/ restart; print("=============== Test number 192 ================"); p=exp(1) + x*(exp(2) + x*exp(3)); display=binary!; roundcoefficients(p,[|DD,D,D|]); roundcoefficients(p,[|DD,D...|]); /*********************************************************************************/ restart; print("=============== Test number 193 ================"); f=sin(exp(1)*x); display=binary!; f; roundcoefficients(f,[|D...|]); /*********************************************************************************/ restart; print("=============== Test number 194 ================"); p=exp(1) + x*(exp(2) + x*exp(3)); verbosity=1!; display=binary!; roundcoefficients(p,[|DD,D|]); /*********************************************************************************/ restart; print("=============== Test number 195 ================"); printbinary(roundcorrectly([1.010001_2; 1.0101_2])); printbinary(roundcorrectly([1.00001_2; 1.001_2])); /*********************************************************************************/ restart; print("=============== Test number 196 ================"); roundcorrectly([-1; 1]); /*********************************************************************************/ restart; print("=============== Test number 197 ================"); display=binary!; round(Pi,20,RN); /*********************************************************************************/ restart; print("=============== Test number 198 ================"); display=binary!; a=2^(-1100); round(a,53,RN); double(a); /*********************************************************************************/ restart; print("=============== Test number 199 ================"); display=binary!; round(Pi,20,RU); /*********************************************************************************/ restart; print("=============== Test number 200 ================"); display=binary!; round(Pi,20,RZ); /*********************************************************************************/ restart; print("=============== Test number 200b ================"); prec=12!; roundingwarnings=on!; verbosity=1!; printbinary(round(1 - 2^-10000, 170, RD));sollya-6.0+ds/tests-tool/check010.sollya.reference000066400000000000000000000103071300174114700220600ustar00rootroot00000000000000The tool has been restarted. =============== Test number 181 ================ Warning: the current free variable is named "x" and not "y". Can only rename the free variable. The last command will have no effect. The tool has been restarted. =============== Test number 182 ================ Information: the free variable has been named "y". false true The tool has been restarted. =============== Test number 183 ================ exp(x) The tool has been restarted. =============== Test number 184 ================ x Warning: the identifier "a" is neither assigned to, nor bound to a library function nor external procedure, nor equal to the current free variable. Will interpret "a" as "x". x The tool has been restarted. =============== Test number 185 ================ exp(x) 1 2 3 4 5 The tool has been restarted. Warning: the tool has been restarted inside a for loop. The for loop will no longer be executed. The tool has been restarted. =============== Test number 186 ================ exp(x) 1 2 3 4 5 The tool has been restarted. 8 9 10 x Warning: the identifier "a" is neither assigned to, nor bound to a library function nor external procedure, nor equal to the current free variable. Will interpret "a" as "x". x The tool has been restarted. =============== Test number 187 ================ 6 proc(n) { var res; res := (n) + (1); return res; } The tool has been restarted. =============== Test number 188 ================ Hello world proc(s) { print("Hello", s); return void; } The tool has been restarted. =============== Test number 189 ================ [| |] The tool has been restarted. =============== Test number 190 ================ [|4, 1, 2, 5, 3, 2|] The tool has been restarted. =============== Test number 191 ================ 1.100100100001111111_2 * 2^(1) The tool has been restarted. =============== Test number 192 ================ 1.010110111111000010101000101100010100010101110110100101010011010101011111101110001010110001000000010011101_2 * 2^(1) + x * (1.110110001110011001001011100011010100110111011010111_2 * 2^(2) + x * (1.010000010101111001011011111101101111101100010000011_2 * 2^(4))) 1.010110111111000010101000101100010100010101110110100101010011010101011111101110001010110001000000010011101_2 * 2^(1) + x * (1.110110001110011001001011100011010100110111011010111_2 * 2^(2) + x * (1.010000010101111001011011111101101111101100010000011_2 * 2^(4))) The tool has been restarted. =============== Test number 193 ================ sin(x * (1.0101101111110000101010001011000101000101011101101001010100110101010111111011100010101100010000000100111001111010011110011110001110110001011100111000101100000111101_2 * 2^(1))) Warning: the given function is not a polynomial. sin(x * (1.0101101111110000101010001011000101000101011101101001010100110101010111111011100010101100010000000100111001111010011110011110001110110001011100111000101100000111101_2 * 2^(1))) The tool has been restarted. =============== Test number 194 ================ Warning: the number of the given formats does not correspond to the degree of the given polynomial. 1.010110111111000010101000101100010100010101110110100101010011010101011111101110001010110001000000010011101_2 * 2^(1) + x * (1.110110001110011001001011100011010100110111011010111_2 * 2^(2) + x * (1.01000001010111100101101111110110111110110001000001011111001011010100101111011111110001010011011101000100110000111010001110010000010110000101100000111001011100101001_2 * 2^(4))) The tool has been restarted. =============== Test number 195 ================ 1.01_2 1_2 The tool has been restarted. =============== Test number 196 ================ NaN The tool has been restarted. =============== Test number 197 ================ 1.100100100001111111_2 * 2^(1) The tool has been restarted. =============== Test number 198 ================ 1_2 * 2^(-1100) 0 The tool has been restarted. =============== Test number 199 ================ 1.100100100001111111_2 * 2^(1) The tool has been restarted. =============== Test number 200 ================ 1.1001001000011111101_2 * 2^(1) The tool has been restarted. =============== Test number 200b ================ 1.1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111_2 * 2^(-1) sollya-6.0+ds/tests-tool/check011.sollya000066400000000000000000000116761300174114700201360ustar00rootroot00000000000000restart; print("=============== Test number 201 ================"); searchgal(log(x),2,53,15,DD,1b-112); searchgal(log(x),2,53,18,DD,1b-112); /*********************************************************************************/ restart; print("=============== Test number 202 ================"); f = exp(x); s = searchgal(f,2,53,18,DD,1b-112); if (s != [||]) then { v = s[0]; print("The rounding error is 2^(",evaluate(log2(abs(DD(f)/f - 1)),v),")"); } else print("No value found"); /*********************************************************************************/ restart; print("=============== Test number 203 ================"); searchgal([|sin(x),cos(x)|],1,53,15,[|D,D|],[|1b-62,1b-60|]); /*********************************************************************************/ restart; print("=============== Test number 204 ================"); print(simplify((6 + 2) + (5 + exp(0)) * x)); /*********************************************************************************/ restart; print("=============== Test number 205 ================"); print(simplify((log(x - x + 1) + asin(1)))); /*********************************************************************************/ restart; print("=============== Test number 206 ================"); print(simplify((log(x - x + 1) + asin(1)) - (atan(1) * 2))); /*********************************************************************************/ restart; print("=============== Test number 207 ================"); print(dirtysimplify(sin(pi * x))); print(dirtysimplify(erf(exp(3) + x * log(4)))); /*********************************************************************************/ restart; print("=============== Test number 208 ================"); prec = 20!; t = erf(0.5); s = dirtysimplify(erf(0.5)); prec = 200!; t; s; /*********************************************************************************/ restart; print("=============== Test number 209 ================"); sort([| |]); sort([|2,3,5,2,1,4|]); /*********************************************************************************/ restart; print("=============== Test number 210 ================"); p = taylor(exp(x),5,0); s = subpoly(p,[|1,3,5|]); print(p); print(s); /*********************************************************************************/ restart; print("=============== Test number 211 ================"); p = 4796568030627869258949197042963788191b-177 + x * (46761800884047421181259440552565578328448901056339b-165 + x * (-33609089175829249495416553130562663456590502543041b-215 + x * (-30895423029349594959313594952677838825014987490297b-166 + x * (29596742850512657479662119207006362021992423718371b-212 + x * (33702797323732429414901179632614772732191491284101b-167 + x * (-20026589901676225916120391461096255235365099259017b-210 + x * (-31860773420180812849962590530117186802817037268701b-168 + x * (45969237936929956693930338259561235603992813577235b-211 + x * (15598166270846579782957652489318170620249045378353b-169 + x * (-4674066474160712201827620649177924334750337535841b-209)))))))))); subpoly(p,[|1,3,5...|]); /*********************************************************************************/ restart; print("=============== Test number 212 ================"); subpoly(exp(x),[|1,2,3|]); /*********************************************************************************/ restart; print("=============== Test number 213 ================"); f=sin(x); g=cos(x); substitute(f,g); f(g); /*********************************************************************************/ restart; print("=============== Test number 214 ================"); a=1; f=sin(x); substitute(f,a); /*********************************************************************************/ restart; print("=============== Test number 215 ================"); sup([1;3]); sup(5); /*********************************************************************************/ restart; print("=============== Test number 216 ================"); display=binary!; I=[0; 0.111110000011111_2]; sup(I); prec=12!; sup(I); /*********************************************************************************/ restart; print("=============== Test number 217 ================"); tail([|1,2,3|]); tail([|1,2...|]); /*********************************************************************************/ restart; print("=============== Test number 218 ================"); f=exp(x); p=46742573553811911796274412764391966160112581418361b-165 + x * (185720745566008984665440218961959381728519963271b-157 + x * (2465278576003452056620348681425508255554707916727b-162 + x * 26187910218233432242621629490193931328425524460129b-166)); taylorrecursions=0; evaluate(f-p, [0;1]); taylorrecursions=1; evaluate(f-p, [0;1]); /*********************************************************************************/ restart; print("=============== Test number 219 ================"); print(taylor(exp(x),5,0)); /*********************************************************************************/ restart; print("=============== Test number 220 ================"); print(taylor(asin(x),7,0));sollya-6.0+ds/tests-tool/check011.sollya.reference000066400000000000000000000063721300174114700220700ustar00rootroot00000000000000The tool has been restarted. =============== Test number 201 ================ [| |] [|2.0000000000384972054234822280704975128173828125|] The tool has been restarted. =============== Test number 202 ================ The rounding error is 2^( -112.106878438809380148206984258358542322113874177832 ) The tool has been restarted. =============== Test number 203 ================ [|1.00000000000159494639717649988597258925437927246094|] The tool has been restarted. =============== Test number 204 ================ 8 + 6 * x The tool has been restarted. =============== Test number 205 ================ (pi) / 2 The tool has been restarted. =============== Test number 206 ================ (pi) / 2 - (pi) / 4 * 2 The tool has been restarted. =============== Test number 207 ================ sin(3.1415926535897932384626433832795028841971693993751 * x) erf(20.0855369231876677409285296545817178969879078385544 + x * 1.3862943611198906188344642429163531361510002687205) The tool has been restarted. =============== Test number 208 ================ 0.520499877813046537682746653891964528736451575757963700058806 0.52050018310546875 The tool has been restarted. =============== Test number 209 ================ [| |] [|1, 2, 2, 3, 4, 5|] The tool has been restarted. =============== Test number 210 ================ 1 + x * (1 + x * (0.5 + x * (1 / 6 + x * (1 / 24 + x / 120)))) x * (1 + x^2 * (1 / 6 + x^2 / 120)) The tool has been restarted. =============== Test number 211 ================ x * (0.9998663294659198699758128595805243329626735872723 + x^2 * (-0.33030478550486126059609343553423613729820606468504 + x^2 * (0.180159294636523467997437751178959039617773054107393 + x * (-1.21704858321866028906175835649390114311877360260197e-14 + x * (-8.5156350833702702996505336803770858918120961566742e-2 + x * (1.39681284176342339364451388757935358048374878126733e-14 + x * (2.0845114175434561643018447784809880955983412532269e-2 + x * (-5.6810131012579436265697622426011349460288598691964e-15)))))))) The tool has been restarted. =============== Test number 212 ================ 0 The tool has been restarted. =============== Test number 213 ================ sin(cos(x)) sin(cos(x)) The tool has been restarted. =============== Test number 214 ================ 0.84147098480789650665250232163029899962256306079837 The tool has been restarted. =============== Test number 215 ================ 3 5 The tool has been restarted. =============== Test number 216 ================ 1.11110000011111_2 * 2^(-1) 1.11110000011111_2 * 2^(-1) The tool has been restarted. =============== Test number 217 ================ [|2, 3|] [|2...|] The tool has been restarted. =============== Test number 218 ================ The number of recursions for Taylor evaluation has been set to 0. [-0.46839364816303627522963565754743169862357620487739;0.4694778175466708649168246499708805444358300351778] The number of recursions for Taylor evaluation has been set to 1. [-0.13813111495387910066337940912697015317218647208804;0.13921528433751369035056840155041899898444030238844] The tool has been restarted. =============== Test number 219 ================ 1 + x * (1 + x * (0.5 + x * (1 / 6 + x * (1 / 24 + x / 120)))) The tool has been restarted. =============== Test number 220 ================ x * (1 + x^2 * (1 / 6 + x^2 * (3 / 40 + x^2 * 5 / 112))) sollya-6.0+ds/tests-tool/check012.sollya000066400000000000000000000211561300174114700201310ustar00rootroot00000000000000restart; print("=============== Test number 221 ================"); print(taylor(erf(x),6,0)); /*********************************************************************************/ restart; print("=============== Test number 222 ================"); /*********************************************************************************/ restart; print("=============== Test number 223 ================"); verbosity=1!; a = 1+ 2^(-55)+2^(-115); TD(a); prec=110!; TD(a); /*********************************************************************************/ restart; print("=============== Test number 224 ================"); true && false; 2>1; /*********************************************************************************/ restart; print("=============== Test number 225 ================"); exp(x); a = 3; {var a, b; a=5; b=3; {var a; var b; b = true; a = 1; a; b;}; a; b; }; a; /*********************************************************************************/ restart; print("=============== Test number 226 ================"); verbosity=0!; 1.2+"toto"; verbosity=1!; 1.2+"toto"; verbosity=2!; 1.2+"toto"; /*********************************************************************************/ restart; print("=============== Test number 227 ================"); print(void); void; /*********************************************************************************/ restart; print("=============== Test number 228 ================"); hey = proc() { print("Hello world."); }; hey; hey(); hey(void); print(hey()); /*********************************************************************************/ restart; worstcase(exp(x),24,[1,2],24,1b-26); /*********************************************************************************/ restart; print("=============== Test number 229 ================"); write(x + 2 + exp(sin(x))); write("Hello\n"); write("Hello","world\n"); write("Hello","you", 4 + 3, "other persons.\n"); /*********************************************************************************/ restart; print("=============== Test number 230 ================"); write("Hello","\n"); write([|"Hello"|],"\n"); s = "Hello"; write(s,[|s|],"\n"); t = "Hello\tyou"; write(t,[|t|],"\n"); /*********************************************************************************/ restart; print("=============== Test number 231 ================"); write(x + 2 + exp(sin(x))) > "foo.sol"; readfile("foo.sol"); /*********************************************************************************/ restart; print("=============== Test number 232 ================"); write(x + 2 + exp(sin(x))) >> "foo.sol"; /*********************************************************************************/ restart; print("=============== Test number 233 ================"); pstar = 5846006549323611671784298104022718622318882177971b-162 + x * (37857459261849734002934198358497784854969213609141b-241 + x * (-23384026197294176595383359674367214160107584181507b-165 + x * (-38602791478525408905485501706553096127203819717855b-228 + x * (31178701574267686389540459856148935530651557981629b-169 + x * (14117092987825147270453985390332190734246695748303b-216 + x * (-16628060881742355087337911794409009456208012766191b-173)))))); P = fpminimax(cos(x),6,[|DD, DD, D...|],[-1b-5;1b-5],default,default,default,pstar); printexpansion(P); pstar = 2148263723907549819858926287983956687732819b-218 + x * (46768052394587948180729798097226792243112547550905b-165 + x * (-25507165977932281269808564943557572116806817621809b-228 + x * (-31178701565420095891159605334409136402204722409645b-167 + x * (12584781347098934684186528379166357990161007221285b-216 + x * (24941946363609599630853575496590807881363811501643b-171 + x * (-27084577193023540426845942064151570020527090561271b-208)))))); P = fpminimax(sin(x),6,[|32...|],[-1b-5;1b-5], fixed, absolute, default, pstar); display = powers!; P; pstar = x^3 * (7794680717168470900797342378780962700124730873177b-165 + x * 31179902867931546748200780881663744737011812548003b-169); P = fpminimax(exp(x), [|3,4|], [|D,24|], [-1/256; 1/246], 1+x+x^2/2, default, default, pstar); display = powers!; P; f = cos(exp(x)); pstar = 12634443274879194690170438040404782420883156872817b-164 + x * (-9838489776505477022831228470738983214292503288671b-163 + x * (-32311422838792817804696665515592631012661758648301b-165 + x * (-25268886572680378753378093437862180139058069966971b-166 + x * (15055969478386755176354565521121927285916932024465b-168 + x * 3245144072789014252966495640681210160689977302851b-164)))); listpoints = dirtyfindzeros(f-pstar, [-1b-7; 1b-7]); P1 = fpminimax(f, 5, [|DD...|], listpoints, absolute, default, default, pstar); P2 = fpminimax(f, 5, [|D...|], listpoints, absolute, default, default, pstar); P3 = fpminimax(f, 5, [|D, D, D, 24...|], listpoints, absolute, default, default, pstar); print("Error of pstar: ", dirtyinfnorm(f-pstar, [-1b-7; 1b-7])); print("Error of P1: ", dirtyinfnorm(f-P1, [-1b-7; 1b-7])); print("Error of P2: ", dirtyinfnorm(f-P2, [-1b-7; 1b-7])); print("Error of P3: ", dirtyinfnorm(f-P3, [-1b-7; 1b-7])); /*********************************************************************************/ restart; print("=============== Test number 234 ================"); autosimplify=off!; 1+1; 1-+2; -3--4; 5+-8; 3*6; 4*-5; 4/-3; 2-5^3; 2+-3/4; 4/-5-+6; 3*5/45; 3/4/6; 2*6+5*5; 5+3/6; 5-+5*+5; 24+2; -4-9*4; 32/48*3; 5+-4*-4*64-34^2/-2*5-7+8*3*4--5; 3*sin(3)+5--cos(7); -exp(24*sin(1)/2); (2-5)^3; 2^(-53); 2^((-5)^4); 2^(-54); (2+-3)/4; 2+(-3)/4; 2+-(3/4); 2+-(-3)/4; 2+(-3/4); (4/-5)-+6; 4/(-5-+6); 4/-5-(+6); (4/-5)-(+6); 3*(5/45); (3*5)/45; ((3*5)/4)/5; 3*5/(45); 3*(5/4)^5; (3/4)/6; 3/(4/6); 2*(6+5*5); (2*6)+5*5; 2*(6+5)*5; 2*6+(5*5); (2*(6+5))*5; (2*6+5)*5; ((2*6)+5)*5; (5+3)/6; 5+(3/6); 5-(+5*+5); (5-+5)*+5; 5-+(5*+5); (24)+2; 2^(4+2); -(4-10)*4; (-4)-10*4; (-4-10)*4; (-4)^(-10)*4; -4^-(10*4); -(4-10)*4; -(4^-(10*4)); (-4)^(-10)*4; -(4^-(10*4)); (32)/4^(8*3); 3^(2/48)*3; (32/4)^(8*3); 3^(2/(48))*3; 3^(2/4^(8*3)); ((32)/4)^8*3; 3^(2/48)*3; (32/(48))*3; 32/4^(8*3); 3^(2/48*3); 5+-4*-4*64-34^2/-2*5-7+8*3*4--5; 5+-4*(-4*6^(4-3)^4)^2/-2*5-7+8*3*4--5; (5+-4)*-(4*6^(4-3)^4^2/-2*5-7+8*3*4)--5; 5+-(4*(-4)*64-(34^2)/(-2*5-7)+8*3*4)--5; (5+-(4*-4*(64-3^(42/-2*5)-7)+8*3))*4--5; 5+-(4*-4)*(64-34^2/-2*5-7+8)*3*4--5; 5+(-4*-4)*(64-(34)^2/-2*5)-7+8*3*4--5; (5+-4)*-(4*64-(34^2/-2*5-7)+8*3)*4--5; /*********************************************************************************/ restart; print("=============== Test number 235 ================"); /*********************************************************************************/ restart; print("=============== Test number 236 ================"); n=5; evaluate(x^(n-1),[-1;1]); /*********************************************************************************/ restart; print("=============== Test number 237 ================"); 0/0; evaluate(0/0, 5); evaluate(0/0, 0); evaluate(0/0, [0]); evaluate(0/0, [5]); evaluate(x/0, 0); evaluate(x/0, [0]); evaluate(x/x, 0); evaluate(x/x, [0]); evaluate(0/x, 0); evaluate(0/x, [0]); [0]/0; [0]/[0]; 0/[0]; [0/0]; f=x/0; f(0); f([0]); g=x/x; print(g); h=0/x; print(h); /*********************************************************************************/ restart; print("=============== Test number 238 ================"); f = (x^2 * (1 + x * (1 + x * (4503599627370499b-54 + x * (-3752999689475461b-53 + x * (-5329259559057319b-53 + x * (-1788929851961367b-52 + x * (-8882099256210257b-56 + x * (7312987743051867b-57 + x * (7211277638711261b-56 + x * (2786461313115475b-55 + x * (1352843919470941b-55 + x * (5069832394710785b-59 + x * (-4873555530492657b-60 + x * (-3495525007749119b-59))))))))))))))) / sin(expm1(x))^2 - 1; I = [-1b-3;5196450266065432598057546071880117403221093486137b-165]; X = -41166165720757628181777558633249450796232650243605b-170; (inf(I) <= X) && (X <= sup(I)); dirtyinfnorm(f,I); f(X); /*********************************************************************************/ restart; print("=============== Test number 239 ================"); numberroots(0.25*x^3 - x^2 + 1,[2;7]); numberroots(0.25*x^3 - x^2 + 1,[1;7]); numberroots(0.25*x^3 - x^2 + 1,[-5;7]); numberroots(exp(1)*x-18,[2;7]); numberroots(exp(x),[2;7]); restart; print("=============== Test number 240 ================"); autodiff(sin(x),5,17); autodiff(sin(x),5,[17]); autodiff(x^x,5,17); autodiff(2^x,5,17); autodiff(x^18,5,17); autodiff(x^0,5,17); autodiff(x^2,5,17); autodiff(1^x,5,17); autodiff(exp(sin(x))^log2(1 + sin(x)^2) * erf(x),80,[1;2]); autodiff(exp(sin(x))^log2(1 + sin(x)^2) * erf(x),80,1); autodiff(exp(sin(x))^log2(1 + sin(x)^2) * erf(x),80,[1]); restart; print("=============== Test number 241 ================"); /* Non-regression test for bug #16164 */ verbosity=0!; fpminimax(erf(-24 + x),[|0|],[|double|],[1b-1075;8],default,default,default); sollya-6.0+ds/tests-tool/check012.sollya.reference000066400000000000000000001067541300174114700220760ustar00rootroot00000000000000The tool has been restarted. =============== Test number 221 ================ x * (1 / sqrt((pi) / 4) + x^2 * ((sqrt((pi) / 4) * 4 / (pi) * (-2)) / 6 + x^2 * (sqrt((pi) / 4) * 4 / (pi) * 12) / 120)) The tool has been restarted. =============== Test number 222 ================ The tool has been restarted. =============== Test number 223 ================ 1.00000000000000002775557561562891353466491600711096 1.000000000000000027755575615628913534664916007110955975699724 The tool has been restarted. =============== Test number 224 ================ false true The tool has been restarted. =============== Test number 225 ================ exp(x) 1 true 5 3 3 The tool has been restarted. =============== Test number 226 ================ error Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. Information: the expression or a partial evaluation of it has been the following: (1.2) + ("toto") error The tool has been restarted. =============== Test number 227 ================ void The tool has been restarted. =============== Test number 228 ================ proc() { print("Hello world."); return void; } Hello world. Hello world. Hello world. void The tool has been restarted. prec = 165 x = 1.99999988079071044921875 f(x) = 7.3890552520751953125 eps = 4.5998601423446695596184695493764120138001954979037e-9 = 2^(-27.695763) x = 2 f(x) = 7.38905620574951171875 eps = 1.44563608749673018122228379395533417878125150587072e-8 = 2^(-26.043720) The tool has been restarted. =============== Test number 229 ================ x + 2 + exp(sin(x))Hello Helloworld Helloyou7other persons. The tool has been restarted. =============== Test number 230 ================ Hello [|"Hello"|] Hello[|"Hello"|] Hello you[|"Hello\tyou"|] The tool has been restarted. =============== Test number 231 ================ x + 2 + exp(sin(x)) The tool has been restarted. =============== Test number 232 ================ The tool has been restarted. =============== Test number 233 ================ (0x3ff0000000000000 + 0xbc09fda20235c100) + x * ((0x3b29ecd485d34781 + 0xb7c1cbc97120359a) + x * (0xbfdfffffffffff98 + x * (0xbbfa6e0b3183cb0d + x * (0x3fa5555555145337 + x * (0x3ca3540480618939 + x * 0xbf56c138142d8c3b))))) x * (1 + x^2 * (-357913941 * 2^(-31) + x^2 * (35789873 * 2^(-32)))) 1 + x * (1 + x * (1 * 2^(-1) + x * (375300225001191 * 2^(-51) + x * (5592621 * 2^(-27))))) Error of pstar: 41623862533526995219855274593333067596572580995543 * 2^(-215) Error of P1: 41623862533526995249852857301809387823617141062435 * 2^(-215) Error of P2: 43429285529967733230721931906794206008049814555029 * 2^(-215) Error of P3: 28553921171649539207471988588453621507466219169379 * 2^(-214) The tool has been restarted. =============== Test number 234 ================ 2 -1 1 -3 18 -20 -1.3333333333333333333333333333333333333333333333333 -123 1.25 -6.8 0.33333333333333333333333333333333333333333333333333 0.125 37 5.5 -20 26 -40 2 4013 6.177262278522906304443431930143512851759113184217 -24285.9146611129530939587447727541679010508347690744 -27 1.1102230246251565404236316680908203125e-16 1.39234637988958594318883410818490335842688858253435e188 5.5511151231257827021181583404541015625e-17 -0.25 1.25 1.25 2.75 1.25 -6.8 -0.36363636363636363636363636363636363636363636363636 -6.8 -6.8 0.33333333333333333333333333333333333333333333333333 0.33333333333333333333333333333333333333333333333333 0.75 0.33333333333333333333333333333333333333333333333333 9.1552734375 0.125 4.5 62 37 110 37 110 85 85 1.3333333333333333333333333333333333333333333333333 5.5 -20 0 -20 26 64 24 -44 -56 3.814697265625e-6 -8.2718061255302767487140869206996285356581211090088e-25 24 -8.2718061255302767487140869206996285356581211090088e-25 3.814697265625e-6 -8.2718061255302767487140869206996285356581211090088e-25 1.136868377216160297393798828125e-13 3.14051814518196971703964779587883075100091503019375 4722366482869645213696 3.14051814518196971703964779587883075100091503019375 1.00000000000000780610981129906618988434224948090255 50331648 3.14051814518196971703964779587883075100091503019375 2 1.136868377216160297393798828125e-13 1.1472026904398770894730586135365973741913799219369 4013 5859 -24 870 3577 567370 47363 -12703 The tool has been restarted. =============== Test number 235 ================ The tool has been restarted. =============== Test number 236 ================ [0;1] The tool has been restarted. =============== Test number 237 ================ Warning: the given expression is undefined or numerically unstable. NaN [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] 1 [1;1] 0 [0;0] [-infty;infty] [NaN;NaN] [0;0] [NaN;NaN] Warning: the given expression is undefined or numerically unstable. NaN [-infty;infty] 1 0 The tool has been restarted. =============== Test number 238 ================ true 8.1297511363991581030970926503655261289613034673227e-20 8.1297511363991581030970926503655261289613034673227e-20 The tool has been restarted. =============== Test number 239 ================ 1 2 3 1 Warning: the given function must be a polynomial in this context. Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error The tool has been restarted. =============== Test number 240 ================ [|[-0.96139749187955685726163694486915609849206725405894;-0.96139749187955685726163694486915609849206725405892], [-0.2751633380515969222203426565518628985969736882986;-0.27516333805159692222034265655186289859697368829859], [0.96139749187955685726163694486915609849206725405892;0.96139749187955685726163694486915609849206725405894], [0.27516333805159692222034265655186289859697368829858;0.27516333805159692222034265655186289859697368829861], [-0.96139749187955685726163694486915609849206725405896;-0.9613974918795568572616369448691560984920672540589], [-0.27516333805159692222034265655186289859697368829862;-0.27516333805159692222034265655186289859697368829858]|] [|[-0.96139749187955685726163694486915609849206725405894;-0.96139749187955685726163694486915609849206725405892], [-0.2751633380515969222203426565518628985969736882986;-0.27516333805159692222034265655186289859697368829859], [0.96139749187955685726163694486915609849206725405892;0.96139749187955685726163694486915609849206725405894], [0.27516333805159692222034265655186289859697368829858;0.27516333805159692222034265655186289859697368829861], [-0.96139749187955685726163694486915609849206725405896;-0.9613974918795568572616369448691560984920672540589], [-0.27516333805159692222034265655186289859697368829862;-0.27516333805159692222034265655186289859697368829858]|] [|[8.2724026188633676417699999999999999999999999999927e20;8.2724026188633676417700000000000000000000000000157e20], [3.1709884106032649006689059189689875321018220121288e21;3.1709884106032649006689059189689875321018220121379e21], [1.22037362812477135146527020637096995701538959849263e22;1.2203736281247713514652702063709699570153895984963e22], [4.7149719797641181157448821110822360052469088771702e22;4.7149719797641181157448821110822360052469088771852e22], [1.8285595553799088668993329843624310946532127455557e23;1.82855955537990886689933298436243109465321274556173e23], [7.1177167975596881388464104315965462422574720857932e23;7.1177167975596881388464104315965462422574720858186e23]|] [|[131072;131072], [90852.187250353151595935448623766119130791953610866;90852.18725035315159593544862376611913079195361087], [62973.937440286497133966462330688631174667036471398;62973.937440286497133966462330688631174667036471403], [43650.207185492964765709576780084745883631810687609;43650.207185492964765709576780084745883631810687618], [30256.018041481914205798100863262755588448753098228;30256.018041481914205798100863262755588448753098236], [20971.87360042402723672184112492761537175709484389;20971.873600424027236721841124927615371757094843897]|] [|[14063084452067724991009;14063084452067724991009], [14890324713954061755186;14890324713954061755186], [14890324713954061755186;14890324713954061755186], [14014423260192058122528;14014423260192058122528], [12365667582522404225760;12365667582522404225760], [10183490950312568185920;10183490950312568185920]|] [|[1;1], [0;0], [0;0], [0;0], [0;0], [0;0]|] [|[289;289], [34;34], [2;2], [0;0], [0;0], [0;0]|] [|[1;1], [0;0], [0;0], [0;0], [0;0], [0;0]|] [|[1.6141098350913265201165182766751660422572465082689;2.7055664264617172362686272458125796237129210742258], [-3.18170955578781671250140859867228938424940111856135;5.3107326708678786848796569934180860695602497383355], [-26.7163731922041039501980246696009182436694971461;12.4017113673384498714655744627254545512458677568624], [-181.14089199334961442985384099042710778827783812196;156.503823822803811132671177895633623338719003912927], [-1294.7148264875959350401814226110415966565776756955;1536.00512355020066553334935043058390240978469685435], [-14951.4565877378655529290365487296550106301948838258;16390.347407110246872498519601111018607053982955163], [-1.93780918979212375285911252002766508524654567819326e5;1.876361576624133966877308482494931426395563925082e5], [-2.7357612151745557143812604520279266823336896234337e6;2.5976462450734721257588265697105548177032463142369e6], [-4.1194381550230500718380929486228585287806925754978e7;4.1408751977274360063068777853003008515264000576901e7], [-6.9707353222261987719549169278064932127346039155378e8;7.1609587997041335223140053249341233960201304267737e8], [-1.31900067694567299361094741187926456171958080384785e10;1.32690760444782605182439738541211540421096281100005e10], [-2.69067811631987208681982375426415347399315900897486e11;2.66675367374857169714782552252236294341925504014677e11], [-5.8769369855311893556522948830030736365971929475302e12;5.839072987553619434977928591955643800957931627345e12], [-1.3688392808151896552577653287226046830719362443603e14;1.3710928571092048197460394233087444841895611195639e14], [-3.4187078986868834416508596318463095152456269394212e15;3.4305114672529943310839203712853431634162958766351e15], [-9.0801027068831710050978857907546210761647828332268e16;9.0832498885516895416720396426685853396800376469664e16], [-2.5528028410856348236681728503341748805429729527972e18;2.5508631917680143113401972435089952934991627062146e18], [-7.568309219672858119965187350902710210402683005237e19;7.5619852137898246407515799279879155503252867171096e19], [-2.35992290779787574051936462153512833753873120499863e21;2.36013074413675659021488965154757715323291340048364e21], [-7.7269667452157717209826313353351230380712703236628e22;7.7323505833479810759394701113126141981228179032282e22], [-2.6514209380376596296149813359263806477349969017572e24;2.6506768993429470099323323582445276980839504019612e24], [-9.5016191557883418775756879513726231934214578785013e25;9.4999365796959501073040742281439588785521209246264e25], [-3.5507068602427564844432962136452674082927620233439e27;3.5519665933340707442058803469965991410504163131039e27], [-1.38210966674007799553611498480629615105240092574347e29;1.38209596317531132067983004658756971769780466122586e29], [-5.59110652625267762124978176103051021942339522453e30;5.5905878063905404334354127413282048033620387173393e30], [-2.3473359974404890720773387171639383081479354629456e32;2.34733971246454178762036427713565242034320380749006e32], [-1.02156550812014820104491927642633264633548434769392e34;1.0214560452991537152794575861751714700686385559582e34], [-4.6013137571436071883173478136534623910530631447304e35;4.601671097194470633268850625579668867758353837113e35], [-2.1429937424239009007655878995791194151787062011244e37;2.1430908400231194252062536703608587899546244377346e37], [-1.0307955562248892496849324155435591205935719627823e39;1.03076473008495050200008623024821285138301762480498e39], [-5.114973947816251525863180400411043361351483175616e40;5.1150323622133863299527480536337812859461761295978e40], [-2.6160422000481110917005504308962470134474581645608e42;2.61602972357558606541740311569451452420774988418436e42], [-1.37775466061423672749836047264986076787185347027454e44;1.37774643031222856804722980394662765883862703628723e44], [-7.4651739000311898437775101791178394931840711085793e45;7.465381896292168015908913188507210998389398757856e45], [-4.1584205913006728947532697135062129901030756428087e47;4.158302656308125525990382714318761267159166308294e47], [-2.3794112722926535871029984198195135483684674900115e49;2.3793874940765008833557205996378069121950029471159e49], [-1.39751214637699642376191896626664646452847320417206e51;1.39755390813940437628920444271321188284234896085418e51], [-8.4201003864102135937037647884866001185184012593742e52;8.4199582547788916238513489293642028401195618756268e52], [-5.2004032567715300233211739092611315154988134183991e54;5.200442106246405781610905916229576100283667251915e54], [-3.2905387061580343790523611226807452617680378113024e56;3.2905622833403762575346052571031812723100029974052e56], [-2.13182570298846546944241546906801688176513390674095e58;2.1317969562832803788841373721251037642298255270684e58], [-1.4133013074984417233475717250794392095294228479353e60;1.41331112992047201421039540778955978846340058214484e60], [-9.5829704991510881591673588379168940712435850492428e61;9.5829780600853819895273887396614980578264923030683e61], [-6.6423413215884297635498613067285340780778851320187e63;6.6423155970281512539203883180962154537864647757776e63], [-4.7041805589161249229200597673221962056879144573485e65;4.7042023231313276861068512859658642247942640580423e65], [-3.4024656450035285474609877652876475011820209965841e67;3.4024535033688481510935643310830770513984227634364e67], [-2.512182515860678171502545460819254939360358297629e69;2.51217936698584495656968603973577786634599839002704e69], [-1.89266062084264096892327122895865523569778861031424e71;1.8926713669401167554023301242177111608530176962969e71], [-1.45440615935801060259357228682256185457846125674614e73;1.4543998939882996441400546160147157850738642053906e73], [-1.1394956444317892645002117425195018684642165692419e75;1.139496534053621795188018512951848149101436323401e75], [-9.0990139527265907762477479994596234967722066035875e76;9.0990260916696213530969836767625023034822368868415e76], [-7.4024148285861441989749228207411059154462959986161e78;7.4023926634487562638460091056060787692314018379946e78], [-6.1333136943338004865117760910631658081368406142912e80;6.1333335586858128437729515225624983824054554437484e80], [-5.1739033998947713308945928822145500168993026169347e82;5.1738958053538812023581390981673502977521003787051e82], [-4.4422103542325036767600489735600838548279209363162e84;4.4422057979614867050541311671576291505555140876378e84], [-3.8806335339169800256931539049469712649068397218877e86;3.8806409639517906576586377761550350793519104815057e86], [-3.4482607962389292611756323021166978443812937193286e88;3.4482549244624981644392756059762312631697862733948e88], [-3.1157498669457507919985305185012467499505949885975e90;3.11575160874569778688485585541242174134000587545695e90], [-2.8620017259359514658845614754318163880335538404247e92;2.8620036185181807408979934632492545755119221865648e92], [-2.6718012005858900813143941883220049932170588358995e94;2.67179801494423873005658996106808041643775210201504e94], [-2.53425339481482798896683849501879764700099076252375e96;2.5342552307406731262260783357046829040825536239003e96], [-2.4417357861549537281321075923033170236858570168984e98;2.4417356763471286096308847609896322183741677288101e98], [-2.38914501754175392502653670730308696051945732911166e100;2.3891437994874207800502987168724315939346742359063e100], [-2.3734372157949609348243600106055853545163870197667e102;2.3734394076234040808704163265584311500868177673268e102], [-2.3933438571887767012472350475116362965895652819883e104;2.39334214973156884689002975142183811647163559991314e104], [-2.4492104406243478911254840835468200008513064037813e106;2.4492103254714334652496302275760938757860781936253e106], [-2.5430030201426598327493431768507088749831104973128e108;2.5430046140926031742595733894657233997737861618251e108], [-2.67840488088292960126843621584928073310155982810214e110;2.67840287121365062302046892131745115105371319695854e110], [-2.8610414643574085917966892624132710741348769210068e112;2.8610429818586778633658023506137404331237340216443e112], [-3.0988830219907648639482596904672269711249990080819e114;3.0988827215063845839996595154617503438160498894404e114], [-3.402787617050066876129616783966690183440648270135e116;3.4027861974223177829641109369861760392827050959714e116], [-3.78731304593782742900646687087501404339875211271326e118;3.7873153886791686286197960449991676064488182139519e118], [-4.271845441359281929601512574148415239697732755745e120;4.2718437090246956479846778081066886617455050963817e120], [-4.8821347180571453268720514988971629585823370567281e122;4.8821349001400551122890025084811047611101191813973e122], [-5.6524791722366940511850199624220728264439657863818e124;5.6524809334529443397850700976317978211753168422022e124], [-6.6287256352659837362025555696966801249531296290352e126;6.6287229349471603129560771626306768144514741943183e126], [-7.8724711055814570079644921445005619197740487523453e128;7.8724730296989598829860829928284648952525207569067e128], [-9.467013018544436712636415657143857775135421971063e130;9.467013309538475939527804322281976024572528818624e130], [-1.15257116054842180262817247822862138954863319173165e133;1.15257088427851495767343680363344167300293466684024e133], [-1.42039483286391153406952113971120839348361739649766e135;1.42039523479785637870593140976651919796932102459395e135], [-1.7716293092844190167584351330159781395374768579555e137;1.77162901691343306940015608785083666718203832096592e137]|] [|[1.6141098350913265201165182766751660422572465082689;1.61410983509132652011651827667516604225724650826936], [2.5118353814937763560094585162790228586152401086788;2.5118353814937763560094585162790228586152401086805], [0.70740936843670755723881149569123745768608285096694;0.70740936843670755723881149569123745768608285097316], [-13.3055741964726401365700924194962775523760506082387;-13.305574196472640136570092419496277552376050608204], [-46.241632910276551916477751546287679176512081095965;-46.24163291027655191647775154628767917651208109575], [93.219597826768055536981257193573059929163486338683;93.219597826768055536981257193573059929163486340186], [1215.8419346564652983594805342085548028395070491023;1215.84193465646529835948053420855480283950704911444], [1771.13526250416591006542982812526820608094754973646;1771.135262504165910065429828125268206080947549842], [-34935.202418757707740781762516542491785135828655975;-34935.202418757707740781762516542491785135828654955], [-2.06476247514133187665039631764848537329132304397364e5;-2.06476247514133187665039631764848537329132304386714e5], [9.1178135808776154964378372195131228042629106471943e5;9.1178135808776154964378372195131228042629106483968e5], [1.4434878849716050885587037188270795201558989042478e7;1.44348788497160508855870371882707952015589890439453e7], [8.9450812760697643415086723208320962688949483333017e6;8.945081276069764341508672320832096268894948352462e6], [-9.9977864723464935985319883731727476633280349021166e8;-9.9977864723464935985319883731727476633280348994316e8], [-5.3504367584754115460006641940514484861100162819962e9;-5.3504367584754115460006641940514484861100162779804e9], [6.6113630796035063679810664316038800420939815278337e10;6.6113630796035063679810664316038800420939815342368e10], [7.735647083037569669203820825578987186539222819474e11;7.7356470830375696692038208255789871865392228303403e11], [-2.4848720899346296146998262930723710445433017968911e12;-2.4848720899346296146998262930723710445433017773154e12], [-1.05096671459527966301582060201824283671904501889684e14;-1.05096671459527966301582060201824283671904501515762e14], [-2.60166360000065371835099616252110637411163109800136e14;-2.60166360000065371835099616252110637411163102245435e14], [1.40084311188869375894328354745546202238894495163143e16;1.40084311188869375894328354745546202238894496774777e16], [8.4497406027158964128552446848654046645534664783365e16;8.449740602715896412855244684865404664553466840623e16], [-1.3080947186211178279181606266386227565162145891369e18;-1.30809471862111782791816062663862275651621450349303e18], [-2.3493247533630868759646948809855504411004184547358e19;-2.3493247533630868759646948809855504411004182422402e19], [5.758654925794543298321272832641390565971940673624e19;5.758654925794543298321272832641390565971946196106e19], [6.4811376944387154015339303566422848949179947766684e21;6.4811376944387154015339303566422848949179962770767e21], [-1.70518284996377349795334330217143011134333600421874e22;-1.70518284996377349795334330217143011134333175072695e22], [-7.8679295329238856689020856605773463871281049122494e23;-7.8679295329238856689020856605773463871280923534497e23], [-3.9124411966496538857305567602340832375181767053805e24;-3.9124411966496538857305567602340832375181381519765e24], [-9.569000495588863421546916151274214866983369491517e24;-9.5690004955888634215469161512742148669821409797879e24], [7.8095282518397094077188277323875633099366699865742e27;7.8095282518397094077188277323875633099367105599506e27], [-1.19593653808794175865003680723981513060619787547936e29;-1.19593653808794175865003680723981513060618400649822e29], [-2.7399467802271778988233158324860044014600588550904e29;-2.73994678022717789882331583248600440145956880644554e29], [3.4005308770726838648562404284595945644582119700676e31;3.4005308770726838648562404284595945644583907525815e31], [-1.2746748482936960735401621016406738280069481666626e33;-1.27467484829369607354016210164067382800688089270819e33], [4.1513566746516313045064781886038307972912854821524e34;4.1513566746516313045064781886038307972915463309481e34], [-7.572319137546109949676191243303513903611160232118e35;-7.57231913754610994967619124330351390361011895303e35], [-9.6953062687864022997864339608355621436151459409658e35;-9.6953062687864022997864339608355621435723871714399e35], [5.7657586074354987214879836665600469068851403834944e38;5.7657586074354987214879836665600469068869451811923e38], [-2.4011388182311120507820973540462918168427220585172e40;-2.4011388182311120507820973540462918168419395999357e40], [6.2876240353925820837424028465782377582765345651096e41;6.2876240353925820837424028465782377582800165291625e41], [-8.552290182959565752040997599986089362242128538649e42;-8.5522901829595657520409975999860893622262345569224e42], [-1.8217659427750716852862784230937790061314779482706e44;-1.8217659427750716852862784230937790061240406398334e44], [1.75024872411113065033786014110648328092799148432817e46;1.75024872411113065033786014110648328093155694402173e46], [-6.8879452948002629997383052408563472436240346113487e47;-6.8879452948002629997383052408563472436065326880272e47], [1.64783833184577604901537114554226315379646041468315e49;1.6478383318457760490153711455422631538052524837371e49], [-9.408820774822490935190299284389775420277914301249e49;-9.408820774822490935190299284389775419826156721715e49], [-1.42335612321644384713672435934434368223453518603075e52;-1.4233561232164438471367243593443436822108044662539e52], [8.96258162177761937017146716144346257540685591718e53;8.9625816217776193701714671614434625755342345002366e53], [-3.1872312573298515061817792188059582671264791891782e55;-3.1872312573298515061817792188059582670566468152789e55], [6.1947861181484783927996715365377881503036156585773e56;6.1947861181484783927996715365377881506944495962754e56], [8.2339741355702940982298223909140776290134273231866e57;8.2339741355702940982298223909140776312454989914383e57], [-1.37960106045497775842755043954443284583795041893186e60;-1.37960106045497775842755043954443284570792893980558e60], [7.0841330598444884187010810888960177580186949549108e61;7.084133059844488418701081088896017758790894840683e61], [-2.2015835428325555263384508467276118566428484808074e63;-2.2015835428325555263384508467276118561754630951509e63], [2.30316085513030063139836599551835580206834741521036e64;2.303160855130300631398365995518355804950265436567e64], [2.23033308837514238791752223751847719831971190667226e66;2.2303330883751423879175222375184772001293318173085e66], [-1.84521425543450863822499361038799949786996109941136e68;-1.8452142554345086382249936103879994967132132473383e68], [8.1356062882040203191558078488944492674662768341974e69;8.135606288204020319155807848894449274990995779267e69], [-2.0061137983193390202789344887401774824025993310058e71;-2.00611379831933902027893448874017747742287926587263e71], [-2.0547260287958471060118200650573981032598716725681e72;-2.0547260287958471060118200650573980697437884508665e72], [5.4328525450115734311426797783951790540029708647463e74;5.4328525450115734311426797783951790769387329887013e74], [-3.3984242642531367436678504889857390531082455376375e76;-3.3984242642531367436678504889857390371542575093523e76], [1.26967914659592005798535964183632885380844925636407e78;1.26967914659592005798535964183632886508593227835657e78], [-1.7274589875825194313999233618237235020103359534275e79;-1.7274589875825194313999233618237234210190847519465e79], [-1.61513123681246792117433898819551415607899415010823e81;-1.6151312368124679211743389881955140969979436811314e81], [1.6143823565204557068192181926352250013716150227852e83;1.6143823565204557068192181926352250451387563873119e83], [-8.3556418093701618543682893921323671230398137932454e84;-8.3556418093701618543682893921323667938489186567396e84], [2.41463245328698439728699980960883272200808565387603e86;2.4146324532869843972869998096088329733474564307323e86], [2.5857307222772642112223179845732584357282937301086e87;2.5857307222772642112223179845732603833420939135475e87], [-8.4407006258082215596463382214308342428507904417864e89;-8.4407006258082215596463382214308327114324275684467e89], [6.0867142980954120290913518409968092789577769490334e91;6.0867142980954120290913518409968105006294787230588e91], [-2.5999632177001117027359793112349455661266336329233e93;-2.5999632177001117027359793112349445775575986893015e93], [3.9583689633197122145695960302908163327619461286525e94;3.9583689633197122145695960302908244456220538201284e94], [4.3860426445001255196662517140396851253567899153338e96;4.3860426445001255196662517140396918765105801707481e96], [-4.9309694790252102873614314577667372334551434936391e98;-4.9309694790252102873614314577667315378363196794801e98], [2.8716604016197221375117054938068938798697108665919e100;2.87166040161972213751170549380689875048234939028004e100], [-9.1951253380716359073466571746247959341739282167236e101;-9.195125338071635907346657174624753723165715920072e101], [-1.3511030909981200988610084973597076463507929634528e103;-1.3511030909981200988610084973596705794782310348639e103], [4.3205737408272084454964174365090323129143896011126e105;4.3205737408272084454964174365090652877093691964695e105], [-3.4432209474145553295646562890181602856453705655767e107;-3.443220947414555329564656289018130573653005671187e107]|] [|[1.6141098350913265201165182766751660422572465082689;1.61410983509132652011651827667516604225724650826936], [2.5118353814937763560094585162790228586152401086788;2.5118353814937763560094585162790228586152401086805], [0.70740936843670755723881149569123745768608285096694;0.70740936843670755723881149569123745768608285097316], [-13.3055741964726401365700924194962775523760506082387;-13.305574196472640136570092419496277552376050608204], [-46.241632910276551916477751546287679176512081095965;-46.24163291027655191647775154628767917651208109575], [93.219597826768055536981257193573059929163486338683;93.219597826768055536981257193573059929163486340186], [1215.8419346564652983594805342085548028395070491023;1215.84193465646529835948053420855480283950704911444], [1771.13526250416591006542982812526820608094754973646;1771.135262504165910065429828125268206080947549842], [-34935.202418757707740781762516542491785135828655975;-34935.202418757707740781762516542491785135828654955], [-2.06476247514133187665039631764848537329132304397364e5;-2.06476247514133187665039631764848537329132304386714e5], [9.1178135808776154964378372195131228042629106471943e5;9.1178135808776154964378372195131228042629106483968e5], [1.4434878849716050885587037188270795201558989042478e7;1.44348788497160508855870371882707952015589890439453e7], [8.9450812760697643415086723208320962688949483333017e6;8.945081276069764341508672320832096268894948352462e6], [-9.9977864723464935985319883731727476633280349021166e8;-9.9977864723464935985319883731727476633280348994316e8], [-5.3504367584754115460006641940514484861100162819962e9;-5.3504367584754115460006641940514484861100162779804e9], [6.6113630796035063679810664316038800420939815278337e10;6.6113630796035063679810664316038800420939815342368e10], [7.735647083037569669203820825578987186539222819474e11;7.7356470830375696692038208255789871865392228303403e11], [-2.4848720899346296146998262930723710445433017968911e12;-2.4848720899346296146998262930723710445433017773154e12], [-1.05096671459527966301582060201824283671904501889684e14;-1.05096671459527966301582060201824283671904501515762e14], [-2.60166360000065371835099616252110637411163109800136e14;-2.60166360000065371835099616252110637411163102245435e14], [1.40084311188869375894328354745546202238894495163143e16;1.40084311188869375894328354745546202238894496774777e16], [8.4497406027158964128552446848654046645534664783365e16;8.449740602715896412855244684865404664553466840623e16], [-1.3080947186211178279181606266386227565162145891369e18;-1.30809471862111782791816062663862275651621450349303e18], [-2.3493247533630868759646948809855504411004184547358e19;-2.3493247533630868759646948809855504411004182422402e19], [5.758654925794543298321272832641390565971940673624e19;5.758654925794543298321272832641390565971946196106e19], [6.4811376944387154015339303566422848949179947766684e21;6.4811376944387154015339303566422848949179962770767e21], [-1.70518284996377349795334330217143011134333600421874e22;-1.70518284996377349795334330217143011134333175072695e22], [-7.8679295329238856689020856605773463871281049122494e23;-7.8679295329238856689020856605773463871280923534497e23], [-3.9124411966496538857305567602340832375181767053805e24;-3.9124411966496538857305567602340832375181381519765e24], [-9.569000495588863421546916151274214866983369491517e24;-9.5690004955888634215469161512742148669821409797879e24], [7.8095282518397094077188277323875633099366699865742e27;7.8095282518397094077188277323875633099367105599506e27], [-1.19593653808794175865003680723981513060619787547936e29;-1.19593653808794175865003680723981513060618400649822e29], [-2.7399467802271778988233158324860044014600588550904e29;-2.73994678022717789882331583248600440145956880644554e29], [3.4005308770726838648562404284595945644582119700676e31;3.4005308770726838648562404284595945644583907525815e31], [-1.2746748482936960735401621016406738280069481666626e33;-1.27467484829369607354016210164067382800688089270819e33], [4.1513566746516313045064781886038307972912854821524e34;4.1513566746516313045064781886038307972915463309481e34], [-7.572319137546109949676191243303513903611160232118e35;-7.57231913754610994967619124330351390361011895303e35], [-9.6953062687864022997864339608355621436151459409658e35;-9.6953062687864022997864339608355621435723871714399e35], [5.7657586074354987214879836665600469068851403834944e38;5.7657586074354987214879836665600469068869451811923e38], [-2.4011388182311120507820973540462918168427220585172e40;-2.4011388182311120507820973540462918168419395999357e40], [6.2876240353925820837424028465782377582765345651096e41;6.2876240353925820837424028465782377582800165291625e41], [-8.552290182959565752040997599986089362242128538649e42;-8.5522901829595657520409975999860893622262345569224e42], [-1.8217659427750716852862784230937790061314779482706e44;-1.8217659427750716852862784230937790061240406398334e44], [1.75024872411113065033786014110648328092799148432817e46;1.75024872411113065033786014110648328093155694402173e46], [-6.8879452948002629997383052408563472436240346113487e47;-6.8879452948002629997383052408563472436065326880272e47], [1.64783833184577604901537114554226315379646041468315e49;1.6478383318457760490153711455422631538052524837371e49], [-9.408820774822490935190299284389775420277914301249e49;-9.408820774822490935190299284389775419826156721715e49], [-1.42335612321644384713672435934434368223453518603075e52;-1.4233561232164438471367243593443436822108044662539e52], [8.96258162177761937017146716144346257540685591718e53;8.9625816217776193701714671614434625755342345002366e53], [-3.1872312573298515061817792188059582671264791891782e55;-3.1872312573298515061817792188059582670566468152789e55], [6.1947861181484783927996715365377881503036156585773e56;6.1947861181484783927996715365377881506944495962754e56], [8.2339741355702940982298223909140776290134273231866e57;8.2339741355702940982298223909140776312454989914383e57], [-1.37960106045497775842755043954443284583795041893186e60;-1.37960106045497775842755043954443284570792893980558e60], [7.0841330598444884187010810888960177580186949549108e61;7.084133059844488418701081088896017758790894840683e61], [-2.2015835428325555263384508467276118566428484808074e63;-2.2015835428325555263384508467276118561754630951509e63], [2.30316085513030063139836599551835580206834741521036e64;2.303160855130300631398365995518355804950265436567e64], [2.23033308837514238791752223751847719831971190667226e66;2.2303330883751423879175222375184772001293318173085e66], [-1.84521425543450863822499361038799949786996109941136e68;-1.8452142554345086382249936103879994967132132473383e68], [8.1356062882040203191558078488944492674662768341974e69;8.135606288204020319155807848894449274990995779267e69], [-2.0061137983193390202789344887401774824025993310058e71;-2.00611379831933902027893448874017747742287926587263e71], [-2.0547260287958471060118200650573981032598716725681e72;-2.0547260287958471060118200650573980697437884508665e72], [5.4328525450115734311426797783951790540029708647463e74;5.4328525450115734311426797783951790769387329887013e74], [-3.3984242642531367436678504889857390531082455376375e76;-3.3984242642531367436678504889857390371542575093523e76], [1.26967914659592005798535964183632885380844925636407e78;1.26967914659592005798535964183632886508593227835657e78], [-1.7274589875825194313999233618237235020103359534275e79;-1.7274589875825194313999233618237234210190847519465e79], [-1.61513123681246792117433898819551415607899415010823e81;-1.6151312368124679211743389881955140969979436811314e81], [1.6143823565204557068192181926352250013716150227852e83;1.6143823565204557068192181926352250451387563873119e83], [-8.3556418093701618543682893921323671230398137932454e84;-8.3556418093701618543682893921323667938489186567396e84], [2.41463245328698439728699980960883272200808565387603e86;2.4146324532869843972869998096088329733474564307323e86], [2.5857307222772642112223179845732584357282937301086e87;2.5857307222772642112223179845732603833420939135475e87], [-8.4407006258082215596463382214308342428507904417864e89;-8.4407006258082215596463382214308327114324275684467e89], [6.0867142980954120290913518409968092789577769490334e91;6.0867142980954120290913518409968105006294787230588e91], [-2.5999632177001117027359793112349455661266336329233e93;-2.5999632177001117027359793112349445775575986893015e93], [3.9583689633197122145695960302908163327619461286525e94;3.9583689633197122145695960302908244456220538201284e94], [4.3860426445001255196662517140396851253567899153338e96;4.3860426445001255196662517140396918765105801707481e96], [-4.9309694790252102873614314577667372334551434936391e98;-4.9309694790252102873614314577667315378363196794801e98], [2.8716604016197221375117054938068938798697108665919e100;2.87166040161972213751170549380689875048234939028004e100], [-9.1951253380716359073466571746247959341739282167236e101;-9.195125338071635907346657174624753723165715920072e101], [-1.3511030909981200988610084973597076463507929634528e103;-1.3511030909981200988610084973596705794782310348639e103], [4.3205737408272084454964174365090323129143896011126e105;4.3205737408272084454964174365090652877093691964695e105], [-3.4432209474145553295646562890181602856453705655767e107;-3.443220947414555329564656289018130573653005671187e107]|] The tool has been restarted. =============== Test number 241 ================ error sollya-6.0+ds/tests-tool/check013.sollya000066400000000000000000000461061300174114700201340ustar00rootroot00000000000000restart; print("=============== Test number 241 ================"); verbosity=0!; test1 = proc(f, n, x0, mode) { var TStruct, p, errs, k, j, a, t, i, res; res=1; TStruct = taylorform(f,n,x0,mode); p = TStruct[0]; errs = TStruct[1]; if (inf(x0)==sup(x0)) then k=1 else k=10; for j from 1 to k+1 do { roundingwarnings=off!; a := inf(x0) + sup([(j-1)*(sup(x0)-inf(x0))/k]); roundingwarnings=on!; if (a>=sup(x0)) then a := sup(x0); t = taylor(f,n,a); for i from 0 to n do { if (! coeff(t,i) in coeff(p, i)+errs[i]) then { print("test1(",f,",",n,",",x0,",",mode,"): error with coefficient ",i," and point xi0 = ",a); res = 0; }; }; }; if (res==1) then print("Testing taylorform(",f,",",n,",",x0,",",mode,": OK"); }; test2 = proc(f, n, x0, I, mode) { var TStruct, p, errs, Delta, k, j, a, t, i, xk, res; res = 1; TStruct = taylorform(f,n,x0,I,mode); p = TStruct[0]; errs = TStruct[1]; Delta = TStruct[2]; if (inf(x0)==sup(x0)) then k=1 else k=10; for j from 1 to k+1 do { roundingwarnings=off!; a := inf(x0) + sup([(j-1)*(sup(x0)-inf(x0))/k]); roundingwarnings=on!; if (a>=sup(x0)) then a := sup(x0); for i from 0 to points do { roundingwarnings=off!; xk := inf(I) + sup([(i/points)*(sup(I)-inf(I))]); roundingwarnings=on!; if (xk >= sup(I)) then xk := sup(I); if (mode==relative) then dd = Delta else dd = [0]; for s from n to 0 by -1 do { dd = errs[s] + (xk-a)*dd; }; if (mode==absolute) then dd = dd + Delta; if (! (f(xk)-p(xk-a)) in dd) then { print("test2(",f,",",n,",",x0,",",I,",",mode,"): error at point x=",xk," and point xi0 = ",a); res = 0; }; }; }; if (res==1) then print("Testing taylorform(",f,",",n,",",x0,",",I,",",mode,": OK"); }; test1(exp(x),5,0,absolute); test1(sin(x),17,1289b-10, absolute); test1(sin(exp(x)) + 2 - x,7,0, absolute); test1(sin(exp(x)) + 2 - x,7,[-1;1], absolute); test1(sin(exp(x)) + 2 - x,7,1289b-10, absolute); p1 = taylorform(sin(exp(x)) + 2 - x,7,1289b-10, absolute); p2 = taylorform(sin(exp(x)) + 2 - x,7,1289b-10, relative); p3 = taylorform(sin(exp(x)) + 2 - x,7,1289b-10); (p1==p2); (p2==p3); test2(sin(exp(x)) + 2 - x,7,0,[-1;1], absolute); test2(sin(exp(x)) + 2 - x,7,[-1;1],[-1;1], absolute); test2(sin(exp(x)) + 2 - x,7,[-1;1],[-1;1], relative); test2(sin(exp(x)) + 2 - x,7,1289b-19,[-1b-8;1b-7], absolute); test2(sin(exp(x)) + 2 - x,7,1289b-19,[-1b-8;1b-7], relative); p1 = taylorform(sin(exp(x)) + 2 - x,7,1289b-19,[-1b-8;1b-7], absolute); p2 = taylorform(sin(exp(x)) + 2 - x,7,1289b-19,[-1b-8;1b-7]); p1==p2; test2(sin(exp(x)) + 2 - x,7,0,[-1b-8;1b-7],relative); test2(sin(exp(x)) + 2 - x,7,0,[-1b-8;1b-7],absolute); test2(sin(x)^4 + x^5 * exp(17 * x),7,1289b-19,[-1b-8;1b-7],relative); test2(2^x,7,1289b-19,[-1b-8;1b-7],relative); test2(x^17,7,1289b-19,[-1b-8;1b-7],relative); test2(x^5,7,1289b-19,[-1b-8;1b-7],relative); test2(2^x,7,1289b-19,[-1b-8;1b-7],absolute); test2(2^x,7,0,[-1b-8;1b-7],relative); test2(2^x,7,0,[-1b-8;1b-7],absolute); test2(x^17,7,1289b-19,[-1b-8;1b-7],absolute); test2(x^5,7,0,[-1b-8;1b-7],absolute); test2(1 + 2 * x + 3 * x^2 + 4 * x^3,7,0,[-1b-8;1b-7],relative); test2(2 * x + 3 * x^2 + 4 * x^3,7,0,[-1b-8;1b-7],relative); test2(exp(sin(x))^log2(1 + sin(x)^2) * erf(x),7,1289b-19,[-1b-8;1b-7],relative); test2(exp(sin(x))^log2(1 + sin(x)^2) * erf(x),7,1289b-19,[-1b-8;1b-7],absolute); test2(exp(sin(x))^log2(1 + sin(x)^2) * erf(x),7,0,[-1b-8;1b-7],absolute); test2(exp(sin(x))^log2(1 + sin(x)^2) * erf(x),7,0,[-1b-8;1b-7],relative); restart; print("=============== Test number 242 ================"); 5 in [-1;17]; 5 in [5;17]; 5 in [-1;5]; 5 in [-1;4]; 5 in [6;17]; 5 in [-4;7]; 4 in [-1;1]; 0 in sin([-17;17]); [5;7] in [2;8]; [2;3] in [4;5]; [2;3] in [2.5;5]; restart; print("=============== Test number 243 ================"); nearestint(exp(17)); nearestint(2.5); nearestint(3.5); nearestint(-exp(17)); nearestint(-2.5); nearestint(-3.5); restart; print("=============== Test number 243 ================"); SG(exp(5)); SG(1b-170); round(1b-170,SG,RN); round(1b-170,SG,RD); round(1b-170,SG,RU); round(1b-170,SG,RZ); restart; print("=============== Test number 244 ================"); succ = proc(n) { return n + 1; }; succ(5); 3 + succ(0); succ; add = proc(m,n) { var res; res := m + n; return res; }; add(5,6); add; verbosity = 1!; add(3); add(true,false); succ = proc(n) { return n + 1; }; succ(5); succ(x); hey = proc() { print("Hello world."); }; hey(); print(hey()); hey; fac = proc(n) { var res; if (n == 0) then res := 1 else res := n * fac(n - 1); return res; }; fac(5); fac(11); fac; myprocs = [| proc(m,n) { return m + n; }, proc(m,n) { return m - n; } |]; (myprocs[0])(5,6); (myprocs[1])(5,6); succ = proc(n) { return n + 1; }; pred = proc(n) { return n - 1; }; applier = proc(p,n) { return p(n); }; applier(succ,5); applier(pred,5); verbosity = 1!; myquit = proc(n) { print(n); quit; }; myquit; myquit(5); printsucc = proc(n) { var succ; succ = proc(n) { return n + 1; }; print("Successor of",n,"is",succ(n)); }; printsucc(5); makeadd = proc(n) { var add; print("n =",n); add = proc(m,n) { return n + m; }; return add; }; makeadd(4); (makeadd(4))(5,6); sumall = proc(L = ...) { var acc, i; acc = 0; for i in L do acc = acc + i; return acc; }; sumall; sumall(); sumall(2); sumall(2,5); sumall(2,5,7,9,16); sumall @ [|1,...,10|]; restart; print("=============== Test number 245 ================"); nop(17); restart; print("=============== Test number 246 ================"); parse("taylor(exp(x),5,0)"); restart; print("=============== Test number 247 ================"); /* Non-regression test for bug [#7216] */ d = [|dyadic, powers, binary|]; exprs = [|x^1, x^3, x^3.5, x^(-3), x^(-3.5), (-x)^3, (-x)^3.5, (-x)^(-3), (-x)^(-3.5)|]; procedure foo_gen(n, e) {var res; res = n * e; return res; }; for dd in d do { display=dd; exprs; procedure foo(n) {var res; res = n * x^1; return res; }; foo; procedure foo(n) {var res; res = n * x^3; return res; }; foo; procedure foo(n) {var res; res = n * x^3.5; return res; }; foo; procedure foo(n) {var res; res = n * x^(-3); return res; }; foo; procedure foo(n) {var res; res = n * x^(-3.5); return res; }; foo; procedure foo(n) {var res; res = n * (-x)^3; return res; }; foo; procedure foo(n) {var res; res = n * (-x)^3.5; return res; }; foo; procedure foo(n) {var res; res = n * (-x)^(-3); return res; }; foo; procedure foo(n) {var res; res = n * (-x)^(-3.5); return res; }; foo; for expr in exprs do { expr; write(expr); print(" ", expr); write(expr) > "foo.sol"; readfile("foo.sol"); print(expr) > "foo.sol"; readfile("foo.sol"); "This is a test " @ expr @ " ||| " @ expr; bind(foo_gen,n,expr); }; }; restart; print("=============== Test number 248 ================"); restart; /* Non-regression test for bug [#18992] */ verbosity=1; degree(x^(2^(2^80))); degree(0/x); degree(sin(x)); print("=============== Test number 249 ================"); restart; print("=============== Test number 250 ================"); (1b-150 + 1b-1000)==1b-150; 1b-150==1b-150; (1b-150 + 1b-1000)!=1b-150; 1b-150!=1b-150; (1b-150 + 1b-1000)>=1b-150; 1b-150>=1b-150; (1b-150 - 1b-1000)>=1b-150; (1b-150 + 1b-1000)<=1b-150; 1b-150<=1b-150; (1b-150 - 1b-1000)<=1b-150; log2(10)==1/log10(2); log2(10)<=1/log10(2); log2(10)<1/log10(2); log2(10)>=1/log10(2); log2(10)>1/log10(2); restart; print("=============== Test number 251 ================"); 0x1.babep5; 0x1.babeP5; restart; print("=============== Test number 252 ================"); p=43196308294462357981024142731744116362697650584913 * 2^(-162) + x * (18940787880364826805042269910263056604186704676385 * 2^(-174) + x * (-5407597148055485570520706914301083250046007009437 * 2^(-159) + x * (37158356061791619043023830634511656708279826437585 * 2^(-168) + x * (32172009152272473020619646792981657725473812329329 * 2^(-162) + x * (39187281871360719997063676655971689323407411628341 * 2^(-163) + x * (-26178718640082384235967489910783645916516005140397 * 2^(-160) + x * (34953759648934510005190488964943453595170700848359 * 2^(-159) + x * (-25072723712224167158963228120240167477268243723855 * 2^(-157) + x * (15974295673579355540834731298883300753051706741309 * 2^(-155) + x * (-2176005277471622096317865317106429160007158181801 * 2^(-151) + x * (33095761423826438946556046816497669710132120490171 * 2^(-154) + x * (-27718463467204126627436664918521327080755133519747 * 2^(-153) + x * (41018859930667620878816122286632372011502828873813 * 2^(-153) + x * (-26839299879098746961860416101061429355276420223739 * 2^(-152) + x * (31039058326645149073567114046352001019871290715243 * 2^(-152) + x * (-15801771700140275545965431016584266752105943750081 * 2^(-151) + x * (28076103767775091115696407203606638391234359105431 * 2^(-152) + x * (-42703195634516805510364492875454224918599509045247 * 2^(-153) + x * (26615563879496098110497721850307891153971825144695 * 2^(-153) + x * (-23883679720985746622879467992193972349337502563713 * 2^(-154) + x * (11421445412702654560555951381067331891187471180861 * 2^(-156) + x * (16755037220371053240555785133468864281631785332199 * 2^(-155) + x * (-11646670708092672585279036943937814846722577306673 * 2^(-154) + x * (40930309254568821225122401834793624138027143082127 * 2^(-156) + x * (-28530073517778957683685414455245651646608282167685 * 2^(-156) + x * (16797844237434699460571558890943993481011634641003 * 2^(-156) + x * (-34280238236703589306896157793274873208973597110311 * 2^(-158) + x * (15338943662913561221432544272089077525108228764329 * 2^(-158) + x * (-24217778558935481135350419674960859956074648358005 * 2^(-160) + x * (33803150088894044184226414786438554964658466346207 * 2^(-162) + x * (-41704166743539326703622522076463525048484223709581 * 2^(-164) + x * (45382762035972197898257359180449883318357559151117 * 2^(-166) + x * (-43393016157184010556768624341670918448542448702857 * 2^(-168) + x * (9062263530935343636230776487744808048086339345527 * 2^(-168) + x * (-26249957299281112459419473007793993250525153688655 * 2^(-172) + x * (8153372488500584383974032291269228233309776969651 * 2^(-173) + x * (-34275209578373058119395297855481723033952834442033 * 2^(-178) + x * (14947107854277265774083749720190587877532571672469 * 2^(-180) + x * (-42131790041261699503379598633077466039830243229279 * 2^(-185) + x * (46113329036784136269736055212911483845268185185643 * 2^(-189) + x * (-4598366306216743281628691776535731218705653553989 * 2^(-190) + x * (9516311956994985484307564235440345214209834280373 * 2^(-196) + x * (-4794052779112477067768031456163342500587090722373 * 2^(-201)))))))))))))))))))))))))))))))))))))))))))) - (985247789068894326741367665457048597966095675907751 * 2^(-168)); I = [1;2]; numberroots(p,I); restart; print("=============== Test number 253 ================"); NaN < 17; 17 <= NaN; NaN < NaN; NaN == NaN ; NaN == 17 ; NaN == "aaa" ; NaN != NaN ; NaN != 17 ; NaN != "aaa" ; NaN != error ; NaN == error; restart; print("=============== Test number 254 ================"); 1==1; restart; print("=============== Test number 255 ================"); { .a = 5, .b = exp(x) }; { .a = 5, .b = exp(x) }.a; { .a = 5, .b = exp(x) }.b; { .a = 5, .b = exp(x) }.b(5); c = { .a = 5; .b = exp(x) }; c.a; c.a + c.b; c.d = sin(pi * x); c.d; c.d(17.25); c.e.f.g = "Salut"; c; c.e; c.e; c.e.f.g @ " and hello"; c.h = { .a = 17, .n = true }; c.h.n; c; d.a.b.c = "Hallo"; d; d.a.b.c = 17; d; d.a.b = "Blub"; d; d.a.b = { .a = "Blub" }; d; d.a.b.d.e.f = "Blib"; d; d.a.b.f.h = 17; d; f = exp(x); f.a = 17; h = { .b = exp(x) }; h.a = 17; f; h; a = { .u=1}; b = { .toto = a }; b; a = { .toto = .25}; a = { .a = a }; a; t = { .b = 1; .b = 2}; restart; print("=============== Test number 256 ================"); verbosity=0; i = 1; "Test ", i, ": ", "(-3)^(+0) = ", (-3)^(+0), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "3^(+0) = ", 3^(+0), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "NaN^(+0) = ", NaN^(+0), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "NaN^(-0) = ", NaN^(-0), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(-infty)^(+0) = ", (-infty)^(+0), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(-infty)^(-0) = ", (-infty)^(-0), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(infty)^(+0) = ", (infty)^(+0), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(infty)^(-0) = ", (infty)^(-0), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(+0)^(-5) = ", (+0)^(-5), " IEEE 754-2008: +infty"; i := i + 1; "Test ", i, ": ", "(-0)^(-5) = ", (-0)^(-5), " IEEE 754-2008: -infty"; i := i + 1; "Test ", i, ": ", "(+0)^(-4) = ", (+0)^(-4), " IEEE 754-2008: +infty"; i := i + 1; "Test ", i, ": ", "(-0)^(-4) = ", (-0)^(-4), " IEEE 754-2008: +infty"; i := i + 1; "Test ", i, ": ", "(+0)^(+5) = ", (+0)^(+5), " IEEE 754-2008: +0"; i := i + 1; "Test ", i, ": ", "(-0)^(+5) = ", (-0)^(+5), " IEEE 754-2008: -0"; i := i + 1; "Test ", i, ": ", "(+0)^(+4) = ", (+0)^(+4), " IEEE 754-2008: +0"; i := i + 1; "Test ", i, ": ", "(-0)^(+4) = ", (-0)^(+4), " IEEE 754-2008: +0"; i := i + 1; "Test ", i, ": ", "(+0)^(-5.5) = ", (+0)^(-5.5), " IEEE 754-2008: +infty"; i := i + 1; "Test ", i, ": ", "(-0)^(-5.5) = ", (-0)^(-5.5), " IEEE 754-2008: +infty"; i := i + 1; "Test ", i, ": ", "(+0)^(-4.5) = ", (+0)^(-4.5), " IEEE 754-2008: +infty"; i := i + 1; "Test ", i, ": ", "(-0)^(-4.5) = ", (-0)^(-4.5), " IEEE 754-2008: +infty"; i := i + 1; "Test ", i, ": ", "(+0)^(+5.5) = ", (+0)^(+5.5), " IEEE 754-2008: +0"; i := i + 1; "Test ", i, ": ", "(-0)^(+5.5) = ", (-0)^(+5.5), " IEEE 754-2008: +0"; i := i + 1; "Test ", i, ": ", "(+0)^(+4.5) = ", (+0)^(+4.5), " IEEE 754-2008: +0"; i := i + 1; "Test ", i, ": ", "(-0)^(+4.5) = ", (-0)^(+4.5), " IEEE 754-2008: +0"; i := i + 1; "Test ", i, ": ", "(+0)^(-infty) = ", (+0)^(-infty), " IEEE 754-2008: +infty"; i := i + 1; "Test ", i, ": ", "(-0)^(-infty) = ", (-0)^(-infty), " IEEE 754-2008: +infty"; i := i + 1; "Test ", i, ": ", "(+0)^(+infty) = ", (+0)^(+infty), " IEEE 754-2008: +0"; i := i + 1; "Test ", i, ": ", "(-0)^(+infty) = ", (-0)^(+infty), " IEEE 754-2008: +0"; i := i + 1; "Test ", i, ": ", "(-1)^(+infty) = ", (-1)^(+infty), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(-1)^(-infty) = ", (-1)^(-infty), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(+1)^(+infty) = ", (+1)^(+infty), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(+1)^(-infty) = ", (+1)^(-infty), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(+1)^(-3) = ", (+1)^(-3), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(+1)^(-3.5) = ", (+1)^(-3.5), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(+1)^(-4) = ", (+1)^(-4), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(+1)^(-3.5) = ", (+1)^(-3.5), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(-1)^(-3) = ", (-1)^(-3), " IEEE 754-2008: -1"; i := i + 1; "Test ", i, ": ", "(-1)^(-3.5) = ", (-1)^(-3.5), " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "(-1)^(-4) = ", (-1)^(-4), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(-1)^(-4.5) = ", (-1)^(-4.5), " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "(+1)^(+0) = ", (+1)^(+0), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(+1)^(-0) = ", (+1)^(-0), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(-1)^(+0) = ", (-1)^(+0), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(-1)^(-0) = ", (-1)^(-0), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(+1)^(+2) = ", (+1)^(+2), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(-1)^(+2) = ", (-1)^(+2), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(+1)^(+2.5) = ", (+1)^(+2.5), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(-1)^(+2.5) = ", (-1)^(+2.5), " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "(+1)^(+infty) = ", (+1)^(+infty), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(+1)^(-infty) = ", (+1)^(-infty), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(-1)^(+infty) = ", (-1)^(+infty), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(-1)^(-infty) = ", (-1)^(-infty), " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(+1)^NaN = ", (+1)^NaN, " IEEE 754-2008: 1"; i := i + 1; "Test ", i, ": ", "(-1)^NaN = ", (-1)^NaN, " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "(-5)^(-5.5) = ", (-5)^(-5.5), " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "(-5)^(-4.5) = ", (-5)^(-4.5), " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "(-5)^(+5.5) = ", (-5)^(+5.5), " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "(-5)^(+4.5) = ", (-5)^(+4.5), " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "(+5)^(-5.5) = ", (+5)^(-5.5), " IEEE 754-2008: real"; i := i + 1; "Test ", i, ": ", "(+5)^(-4.5) = ", (+5)^(-4.5), " IEEE 754-2008: real"; i := i + 1; "Test ", i, ": ", "(+5)^(+5.5) = ", (+5)^(+5.5), " IEEE 754-2008: real"; i := i + 1; "Test ", i, ": ", "(+5)^(+4.5) = ", (+5)^(+4.5), " IEEE 754-2008: real"; i := i + 1; "Test ", i, ": ", "NaN^NaN = ", NaN^NaN, " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "(+infty)^(+infty) = ", (+infty)^(+infty), " IEEE 754-2008: +infty"; i := i + 1; "Test ", i, ": ", "(+infty)^(-infty) = ", (+infty)^(-infty), " IEEE 754-2008: +0"; i := i + 1; "Test ", i, ": ", "(-infty)^(+infty) = ", (-infty)^(+infty), " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "(-infty)^(-infty) = ", (-infty)^(-infty), " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "(+infty)^NaN = ", (+infty)^NaN, " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "(-infty)^NaN = ", (-infty)^NaN, " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "NaN^(+infty) = ", NaN^(+infty), " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "NaN^(-infty) = ", NaN^(-infty), " IEEE 754-2008: NaN"; i := i + 1; "Test ", i, ": ", "infty = ", infty; i := i + 1; "Test ", i, ": ", "-infty = ", -infty; i := i + 1; "Test ", i, ": ", "exp(-infty) = ", exp(-infty); i := i + 1; "Test ", i, ": ", "infty^infty = ", infty^infty; i := i + 1; "Test ", i, ": ", "infty^(-infty) = ", infty^(-infty); i := i + 1; restart; print("=============== Test number 257 ================"); [@Inf@]/[0,1], " ", [@Inf@]; [-@Inf@]/[0,1], " ", [-@Inf@]; [@Inf@]/[-1,0], " ", [-@Inf@]; [-@Inf@]/[-1,0], " ", [@Inf@]; [@Inf@]/[-1,1], " ", [-@Inf@, @Inf@]; [-@Inf@]/[-1,1], " ", [-@Inf@, @Inf@]; [@Inf@, @NaN@], " ", [@NaN@]; [@NaN@, 2], " ", [@NaN@]; [2, -2]; [@Inf@, -@Inf@]; [1,2]^[0], " ", [1]; [1, @Inf@]^[0], " ", [1]; [@Inf@, @Inf@]^[0], " ", [@NaN@]; [1/4, 1/2]^[@Inf@], " ", [0]; [0,1]*[@Inf@], " ", [@Inf@]; [0,1]/[0,1], " ", [0, @Inf@]; [@Inf@]/[0,1], " ", [@Inf@]; [1,2]/[0,1], " ", [1, @Inf@]; [0,1]*[2], " ", [0,2]; [3,4]^[-@Inf@], " ", [0]; [@Inf@, @Inf@]^[-5], " ", [0]; [@Inf@, @Inf@]^[-5.5], " ", [0]; [@Inf@, @Inf@]^[-6, -5], " ", [0]; [0]^[5], " ", [0]; [0]^[5.5], " ", [0]; [0]^[5, 6], " ", [0]; restart; print("=============== Test number 258 ================"); 1==2; restart; print("=============== Test number 259 ================"); min(1,2,3,exp(5),log(0.25)); min(17); min([|2,NaN,1|]); min([|1,NaN,2|]); l = [|1,2,3,exp(5),log(0.25)|]; min(l); print(min(exp(17),sin(62))); verbosity = 1!; print(min(17 + log2(13)/log2(9),17 + log(13)/log(9))); max(1,2,3,exp(5),log(0.25)); max(17); max([|2,NaN,1|]); max([|NaN,1,2|]); l = [|1,2,3,exp(5),log(0.25)|]; max(l); print(max(exp(17),sin(62))); verbosity = 1!; print(max(17 + log2(13)/log2(9),17 + log(13)/log(9))); restart; print("=============== Test number 260 ================"); sollya-6.0+ds/tests-tool/check013.sollya.reference000066400000000000000000000513151300174114700220670ustar00rootroot00000000000000The tool has been restarted. =============== Test number 241 ================ Testing taylorform( exp(x) , 5 , 0 , absolute : OK Testing taylorform( sin(x) , 17 , 1.2587890625 , absolute : OK Testing taylorform( sin(exp(x)) + 2 - x , 7 , 0 , absolute : OK Testing taylorform( sin(exp(x)) + 2 - x , 7 , [-1;1] , absolute : OK Testing taylorform( sin(exp(x)) + 2 - x , 7 , 1.2587890625 , absolute : OK true true Testing taylorform( sin(exp(x)) + 2 - x , 7 , 0 , [-1;1] , absolute : OK Testing taylorform( sin(exp(x)) + 2 - x , 7 , [-1;1] , [-1;1] , absolute : OK Testing taylorform( sin(exp(x)) + 2 - x , 7 , [-1;1] , [-1;1] , relative : OK Testing taylorform( sin(exp(x)) + 2 - x , 7 , 2.4585723876953125e-3 , [-3.90625e-3;7.8125e-3] , absolute : OK Testing taylorform( sin(exp(x)) + 2 - x , 7 , 2.4585723876953125e-3 , [-3.90625e-3;7.8125e-3] , relative : OK true Testing taylorform( sin(exp(x)) + 2 - x , 7 , 0 , [-3.90625e-3;7.8125e-3] , relative : OK Testing taylorform( sin(exp(x)) + 2 - x , 7 , 0 , [-3.90625e-3;7.8125e-3] , absolute : OK Testing taylorform( sin(x)^4 + x^5 * exp(17 * x) , 7 , 2.4585723876953125e-3 , [-3.90625e-3;7.8125e-3] , relative : OK Testing taylorform( 2^x , 7 , 2.4585723876953125e-3 , [-3.90625e-3;7.8125e-3] , relative : OK Testing taylorform( x^17 , 7 , 2.4585723876953125e-3 , [-3.90625e-3;7.8125e-3] , relative : OK Testing taylorform( x^5 , 7 , 2.4585723876953125e-3 , [-3.90625e-3;7.8125e-3] , relative : OK Testing taylorform( 2^x , 7 , 2.4585723876953125e-3 , [-3.90625e-3;7.8125e-3] , absolute : OK Testing taylorform( 2^x , 7 , 0 , [-3.90625e-3;7.8125e-3] , relative : OK Testing taylorform( 2^x , 7 , 0 , [-3.90625e-3;7.8125e-3] , absolute : OK Testing taylorform( x^17 , 7 , 2.4585723876953125e-3 , [-3.90625e-3;7.8125e-3] , absolute : OK Testing taylorform( x^5 , 7 , 0 , [-3.90625e-3;7.8125e-3] , absolute : OK Testing taylorform( 1 + 2 * x + 3 * x^2 + 4 * x^3 , 7 , 0 , [-3.90625e-3;7.8125e-3] , relative : OK Testing taylorform( 2 * x + 3 * x^2 + 4 * x^3 , 7 , 0 , [-3.90625e-3;7.8125e-3] , relative : OK Testing taylorform( exp(sin(x))^log2(1 + sin(x)^2) * erf(x) , 7 , 2.4585723876953125e-3 , [-3.90625e-3;7.8125e-3] , relative : OK Testing taylorform( exp(sin(x))^log2(1 + sin(x)^2) * erf(x) , 7 , 2.4585723876953125e-3 , [-3.90625e-3;7.8125e-3] , absolute : OK Testing taylorform( exp(sin(x))^log2(1 + sin(x)^2) * erf(x) , 7 , 0 , [-3.90625e-3;7.8125e-3] , absolute : OK Testing taylorform( exp(sin(x))^log2(1 + sin(x)^2) * erf(x) , 7 , 0 , [-3.90625e-3;7.8125e-3] , relative : OK The tool has been restarted. =============== Test number 242 ================ true true true false false true false true true false false The tool has been restarted. =============== Test number 243 ================ 24154953 2 4 -24154953 -2 -4 The tool has been restarted. =============== Test number 243 ================ 148.4131622314453125 0 0 0 1.40129846432481707092372958328991613128026194187652e-45 0 The tool has been restarted. =============== Test number 244 ================ 6 4 proc(n) { nop; return (n) + (1); } 11 proc(m, n) { var res; res := (m) + (n); return res; } Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. Warning: the given expression or command could not be handled. error 6 1 + x Hello world. Hello world. void proc() { print("Hello world."); return void; } 120 39916800 proc(n) { var res; if (n) == (0) then res := 1 else res := (n) * (fac((n) - (1))); return res; } 11 -1 6 4 proc(n) { print(n); quit; return void; } Warning: a quit or restart command may not be part of a procedure body. The procedure will not be executed. Warning: an error occurred while executing a procedure. Warning: the given expression or command could not be handled. error Successor of 5 is 6 n = 4 proc(m, n) { nop; return (n) + (m); } n = 4 11 proc(L = ...) { var acc, i; acc = 0; for i in L do acc = (acc) + (i); return acc; } 0 2 7 39 55 The tool has been restarted. =============== Test number 245 ================ The tool has been restarted. =============== Test number 246 ================ 1 + x * (1 + x * (0.5 + x * (0.166666666666666666666666666666666666666666666666665 + x * (4.1666666666666666666666666666666666666666666666666e-2 + x * 8.3333333333333333333333333333333333333333333333333e-3)))) The tool has been restarted. =============== Test number 247 ================ Display mode is dyadic numbers. [|x, x^3, x^7b-1, x^(-3), x^(-7b-1), x^3 * (-1), (x * (-1))^7b-1, (x * (-1))^(-3), (x * (-1))^(-7b-1)|] proc(n) { var res; res = (n) * ((x) ^ (1)); return res; } proc(n) { var res; res = (n) * ((x) ^ (3)); return res; } proc(n) { var res; res = (n) * ((x) ^ (3.5)); return res; } proc(n) { var res; res = (n) * ((x) ^ (-(3))); return res; } proc(n) { var res; res = (n) * ((x) ^ (-(3.5))); return res; } proc(n) { var res; res = (n) * ((-(x)) ^ (3)); return res; } proc(n) { var res; res = (n) * ((-(x)) ^ (3.5)); return res; } proc(n) { var res; res = (n) * ((-(x)) ^ (-(3))); return res; } proc(n) { var res; res = (n) * ((-(x)) ^ (-(3.5))); return res; } x x x x x This is a test x ||| x proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (1), e); } x^3 x^3 x^3 x^3 x^3 This is a test x^3 ||| x^3 proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (3), e); } x^7b-1 x^7b-1 x^7b-1 x^7b-1 x^7b-1 This is a test x^7b-1 ||| x^7b-1 proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (7b-1), e); } x^(-3) x^(-3) x^(-3) x^(-3) x^(-3) This is a test x^(-3) ||| x^(-3) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (-3), e); } x^(-7b-1) x^(-7b-1) x^(-7b-1) x^(-7b-1) x^(-7b-1) This is a test x^(-7b-1) ||| x^(-7b-1) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (-7b-1), e); } x^3 * (-1) (-x)^3 (-x)^3 (-x)^3 (-x)^3 This is a test (-x)^3 ||| (-x)^3 proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((-(x)) ^ (3), e); } (x * (-1))^7b-1 (-x)^7b-1 (-x)^7b-1 (-x)^7b-1 (-x)^7b-1 This is a test (-x)^7b-1 ||| (-x)^7b-1 proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((-(x)) ^ (7b-1), e); } (x * (-1))^(-3) (-x)^(-3) (-x)^(-3) (-x)^(-3) (-x)^(-3) This is a test (-x)^(-3) ||| (-x)^(-3) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((-(x)) ^ (-3), e); } (x * (-1))^(-7b-1) (-x)^(-7b-1) (-x)^(-7b-1) (-x)^(-7b-1) (-x)^(-7b-1) This is a test (-x)^(-7b-1) ||| (-x)^(-7b-1) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((-(x)) ^ (-7b-1), e); } Display mode is dyadic numbers in integer-power-of-2 notation. [|x, x^3, x^(7 * 2^(-1)), x^(-3), x^(-7 * 2^(-1)), x^3 * (-1), (x * (-1))^(7 * 2^(-1)), (x * (-1))^(-3), (x * (-1))^(-7 * 2^(-1))|] proc(n) { var res; res = (n) * ((x) ^ (1)); return res; } proc(n) { var res; res = (n) * ((x) ^ (3)); return res; } proc(n) { var res; res = (n) * ((x) ^ (3.5)); return res; } proc(n) { var res; res = (n) * ((x) ^ (-(3))); return res; } proc(n) { var res; res = (n) * ((x) ^ (-(3.5))); return res; } proc(n) { var res; res = (n) * ((-(x)) ^ (3)); return res; } proc(n) { var res; res = (n) * ((-(x)) ^ (3.5)); return res; } proc(n) { var res; res = (n) * ((-(x)) ^ (-(3))); return res; } proc(n) { var res; res = (n) * ((-(x)) ^ (-(3.5))); return res; } x x x x x This is a test x ||| x proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (1), e); } x^3 x^3 x^3 x^3 x^3 This is a test x^3 ||| x^3 proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (3), e); } x^(7 * 2^(-1)) x^(7 * 2^(-1)) x^(7 * 2^(-1)) x^(7 * 2^(-1)) x^(7 * 2^(-1)) This is a test x^(7 * 2^(-1)) ||| x^(7 * 2^(-1)) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (7 * 2^(-1)), e); } x^(-3) x^(-3) x^(-3) x^(-3) x^(-3) This is a test x^(-3) ||| x^(-3) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (-3), e); } x^(-7 * 2^(-1)) x^(-7 * 2^(-1)) x^(-7 * 2^(-1)) x^(-7 * 2^(-1)) x^(-7 * 2^(-1)) This is a test x^(-7 * 2^(-1)) ||| x^(-7 * 2^(-1)) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (-7 * 2^(-1)), e); } x^3 * (-1) (-x)^3 (-x)^3 (-x)^3 (-x)^3 This is a test (-x)^3 ||| (-x)^3 proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((-(x)) ^ (3), e); } (x * (-1))^(7 * 2^(-1)) (-x)^(7 * 2^(-1)) (-x)^(7 * 2^(-1)) (-x)^(7 * 2^(-1)) (-x)^(7 * 2^(-1)) This is a test (-x)^(7 * 2^(-1)) ||| (-x)^(7 * 2^(-1)) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((-(x)) ^ (7 * 2^(-1)), e); } (x * (-1))^(-3) (-x)^(-3) (-x)^(-3) (-x)^(-3) (-x)^(-3) This is a test (-x)^(-3) ||| (-x)^(-3) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((-(x)) ^ (-3), e); } (x * (-1))^(-7 * 2^(-1)) (-x)^(-7 * 2^(-1)) (-x)^(-7 * 2^(-1)) (-x)^(-7 * 2^(-1)) (-x)^(-7 * 2^(-1)) This is a test (-x)^(-7 * 2^(-1)) ||| (-x)^(-7 * 2^(-1)) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((-(x)) ^ (-7 * 2^(-1)), e); } Display mode is binary numbers. [|x, x^(1.1_2 * 2^(1)), x^(1.11_2 * 2^(1)), x^(-1.1_2 * 2^(1)), x^(-1.11_2 * 2^(1)), x^(1.1_2 * 2^(1)) * (-1_2), (x * (-1_2))^(1.11_2 * 2^(1)), (x * (-1_2))^(-1.1_2 * 2^(1)), (x * (-1_2))^(-1.11_2 * 2^(1))|] proc(n) { var res; res = (n) * ((x) ^ (1)); return res; } proc(n) { var res; res = (n) * ((x) ^ (3)); return res; } proc(n) { var res; res = (n) * ((x) ^ (3.5)); return res; } proc(n) { var res; res = (n) * ((x) ^ (-(3))); return res; } proc(n) { var res; res = (n) * ((x) ^ (-(3.5))); return res; } proc(n) { var res; res = (n) * ((-(x)) ^ (3)); return res; } proc(n) { var res; res = (n) * ((-(x)) ^ (3.5)); return res; } proc(n) { var res; res = (n) * ((-(x)) ^ (-(3))); return res; } proc(n) { var res; res = (n) * ((-(x)) ^ (-(3.5))); return res; } x x x x x This is a test x ||| x proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (1_2), e); } x^(1.1_2 * 2^(1)) x^(1.1_2 * 2^(1)) x^(1.1_2 * 2^(1)) x^(1.1_2 * 2^(1)) x^(1.1_2 * 2^(1)) This is a test x^(1.1_2 * 2^(1)) ||| x^(1.1_2 * 2^(1)) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (1.1_2 * 2^(1)), e); } x^(1.11_2 * 2^(1)) x^(1.11_2 * 2^(1)) x^(1.11_2 * 2^(1)) x^(1.11_2 * 2^(1)) x^(1.11_2 * 2^(1)) This is a test x^(1.11_2 * 2^(1)) ||| x^(1.11_2 * 2^(1)) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (1.11_2 * 2^(1)), e); } x^(-1.1_2 * 2^(1)) x^(-1.1_2 * 2^(1)) x^(-1.1_2 * 2^(1)) x^(-1.1_2 * 2^(1)) x^(-1.1_2 * 2^(1)) This is a test x^(-1.1_2 * 2^(1)) ||| x^(-1.1_2 * 2^(1)) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (-1.1_2 * 2^(1)), e); } x^(-1.11_2 * 2^(1)) x^(-1.11_2 * 2^(1)) x^(-1.11_2 * 2^(1)) x^(-1.11_2 * 2^(1)) x^(-1.11_2 * 2^(1)) This is a test x^(-1.11_2 * 2^(1)) ||| x^(-1.11_2 * 2^(1)) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((x) ^ (-1.11_2 * 2^(1)), e); } x^(1.1_2 * 2^(1)) * (-1_2) (-x)^(1.1_2 * 2^(1)) (-x)^(1.1_2 * 2^(1)) (-x)^(1.1_2 * 2^(1)) (-x)^(1.1_2 * 2^(1)) This is a test (-x)^(1.1_2 * 2^(1)) ||| (-x)^(1.1_2 * 2^(1)) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((-(x)) ^ (1.1_2 * 2^(1)), e); } (x * (-1_2))^(1.11_2 * 2^(1)) (-x)^(1.11_2 * 2^(1)) (-x)^(1.11_2 * 2^(1)) (-x)^(1.11_2 * 2^(1)) (-x)^(1.11_2 * 2^(1)) This is a test (-x)^(1.11_2 * 2^(1)) ||| (-x)^(1.11_2 * 2^(1)) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((-(x)) ^ (1.11_2 * 2^(1)), e); } (x * (-1_2))^(-1.1_2 * 2^(1)) (-x)^(-1.1_2 * 2^(1)) (-x)^(-1.1_2 * 2^(1)) (-x)^(-1.1_2 * 2^(1)) (-x)^(-1.1_2 * 2^(1)) This is a test (-x)^(-1.1_2 * 2^(1)) ||| (-x)^(-1.1_2 * 2^(1)) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((-(x)) ^ (-1.1_2 * 2^(1)), e); } (x * (-1_2))^(-1.11_2 * 2^(1)) (-x)^(-1.11_2 * 2^(1)) (-x)^(-1.11_2 * 2^(1)) (-x)^(-1.11_2 * 2^(1)) (-x)^(-1.11_2 * 2^(1)) This is a test (-x)^(-1.11_2 * 2^(1)) ||| (-x)^(-1.11_2 * 2^(1)) proc(e) { nop; return (proc(n, e) { var res; res = (n) * (e); return res; })((-(x)) ^ (-1.11_2 * 2^(1)), e); } The tool has been restarted. =============== Test number 248 ================ The tool has been restarted. The verbosity level has been set to 1. Warning: the degree of the given polynomial is larger than the largest multiprecision integer that can be held in memory. The polynomial's degree will be returned as -1. -1 0 -1 =============== Test number 249 ================ The tool has been restarted. =============== Test number 250 ================ false true true false true true false false true true Warning: the tool is unable to decide an equality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal. true Warning: the tool is unable to decide an inequality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal. true Warning: the tool is unable to decide an inequality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal. false Warning: the tool is unable to decide an inequality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal. true Warning: the tool is unable to decide an inequality test by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal. false The tool has been restarted. =============== Test number 251 ================ 55.3427734375 55.3427734375 The tool has been restarted. =============== Test number 252 ================ 0 The tool has been restarted. =============== Test number 253 ================ false false false false false false false false true false false The tool has been restarted. =============== Test number 254 ================ true The tool has been restarted. =============== Test number 255 ================ { .a = 5, .b = exp(x) } 5 exp(x) 148.41315910257660342111558004055227962348766759388 5 5 + exp(x) sin(x * 3.1415926535897932384626433832795028841971693993751) -0.70710678118654752440084436210484903928483593768847 { .e = { .f = { .g = "Salut" } }, .d = sin(x * 3.1415926535897932384626433832795028841971693993751), .a = 5, .b = exp(x) } { .f = { .g = "Salut" } } { .f = { .g = "Salut" } } Salut and hello true { .h = { .a = 17, .n = true }, .e = { .f = { .g = "Salut" } }, .d = sin(x * 3.1415926535897932384626433832795028841971693993751), .a = 5, .b = exp(x) } { .a = { .b = { .c = "Hallo" } } } { .a = { .b = { .c = 17 } } } { .a = { .b = "Blub" } } { .a = { .b = { .a = "Blub" } } } { .a = { .b = { .d = { .e = { .f = "Blib" } }, .a = "Blub" } } } { .a = { .b = { .f = { .h = 17 }, .d = { .e = { .f = "Blib" } }, .a = "Blub" } } } Warning: cannot modify an element of something that is not a structure. Warning: the last assignment will have no effect. exp(x) { .a = 17, .b = exp(x) } { .toto = { .u = 1 } } { .a = { .toto = 0.25 } } Warning: a literal structure contains at least one entry twice. This is not allowed. Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. The tool has been restarted. =============== Test number 256 ================ The verbosity level has been set to 0. Test 1: (-3)^(+0) = 1 IEEE 754-2008: 1 Test 2: 3^(+0) = 1 IEEE 754-2008: 1 Test 3: NaN^(+0) = NaN IEEE 754-2008: 1 Test 4: NaN^(-0) = NaN IEEE 754-2008: 1 Test 5: (-infty)^(+0) = 1 IEEE 754-2008: 1 Test 6: (-infty)^(-0) = 1 IEEE 754-2008: 1 Test 7: (infty)^(+0) = 1 IEEE 754-2008: 1 Test 8: (infty)^(-0) = 1 IEEE 754-2008: 1 Test 9: (+0)^(-5) = NaN IEEE 754-2008: +infty Test 10: (-0)^(-5) = NaN IEEE 754-2008: -infty Test 11: (+0)^(-4) = NaN IEEE 754-2008: +infty Test 12: (-0)^(-4) = NaN IEEE 754-2008: +infty Test 13: (+0)^(+5) = 0 IEEE 754-2008: +0 Test 14: (-0)^(+5) = 0 IEEE 754-2008: -0 Test 15: (+0)^(+4) = 0 IEEE 754-2008: +0 Test 16: (-0)^(+4) = 0 IEEE 754-2008: +0 Test 17: (+0)^(-5.5) = infty IEEE 754-2008: +infty Test 18: (-0)^(-5.5) = infty IEEE 754-2008: +infty Test 19: (+0)^(-4.5) = infty IEEE 754-2008: +infty Test 20: (-0)^(-4.5) = infty IEEE 754-2008: +infty Test 21: (+0)^(+5.5) = 0 IEEE 754-2008: +0 Test 22: (-0)^(+5.5) = 0 IEEE 754-2008: +0 Test 23: (+0)^(+4.5) = 0 IEEE 754-2008: +0 Test 24: (-0)^(+4.5) = 0 IEEE 754-2008: +0 Test 25: (+0)^(-infty) = infty IEEE 754-2008: +infty Test 26: (-0)^(-infty) = infty IEEE 754-2008: +infty Test 27: (+0)^(+infty) = 0 IEEE 754-2008: +0 Test 28: (-0)^(+infty) = 0 IEEE 754-2008: +0 Test 29: (-1)^(+infty) = 1 IEEE 754-2008: 1 Test 30: (-1)^(-infty) = 1 IEEE 754-2008: 1 Test 31: (+1)^(+infty) = 1 IEEE 754-2008: 1 Test 32: (+1)^(-infty) = 1 IEEE 754-2008: 1 Test 33: (+1)^(-3) = 1 IEEE 754-2008: 1 Test 34: (+1)^(-3.5) = 1 IEEE 754-2008: 1 Test 35: (+1)^(-4) = 1 IEEE 754-2008: 1 Test 36: (+1)^(-3.5) = 1 IEEE 754-2008: 1 Test 37: (-1)^(-3) = -1 IEEE 754-2008: -1 Test 38: (-1)^(-3.5) = NaN IEEE 754-2008: NaN Test 39: (-1)^(-4) = 1 IEEE 754-2008: 1 Test 40: (-1)^(-4.5) = NaN IEEE 754-2008: NaN Test 41: (+1)^(+0) = 1 IEEE 754-2008: 1 Test 42: (+1)^(-0) = 1 IEEE 754-2008: 1 Test 43: (-1)^(+0) = 1 IEEE 754-2008: 1 Test 44: (-1)^(-0) = 1 IEEE 754-2008: 1 Test 45: (+1)^(+2) = 1 IEEE 754-2008: 1 Test 46: (-1)^(+2) = 1 IEEE 754-2008: 1 Test 47: (+1)^(+2.5) = 1 IEEE 754-2008: 1 Test 48: (-1)^(+2.5) = NaN IEEE 754-2008: NaN Test 49: (+1)^(+infty) = 1 IEEE 754-2008: 1 Test 50: (+1)^(-infty) = 1 IEEE 754-2008: 1 Test 51: (-1)^(+infty) = 1 IEEE 754-2008: 1 Test 52: (-1)^(-infty) = 1 IEEE 754-2008: 1 Test 53: (+1)^NaN = NaN IEEE 754-2008: 1 Test 54: (-1)^NaN = NaN IEEE 754-2008: NaN Test 55: (-5)^(-5.5) = NaN IEEE 754-2008: NaN Test 56: (-5)^(-4.5) = NaN IEEE 754-2008: NaN Test 57: (-5)^(+5.5) = NaN IEEE 754-2008: NaN Test 58: (-5)^(+4.5) = NaN IEEE 754-2008: NaN Test 59: (+5)^(-5.5) = 1.4310835055998654057018711479880167906819957501514e-4 IEEE 754-2008: real Test 60: (+5)^(-4.5) = 7.1554175279993270285093557399400839534099787507569e-4 IEEE 754-2008: real Test 61: (+5)^(+5.5) = 6987.7124296868428012786677147852382357519323737861 IEEE 754-2008: real Test 62: (+5)^(+4.5) = 1397.5424859373685602557335429570476471503864747572 IEEE 754-2008: real Test 63: NaN^NaN = NaN IEEE 754-2008: NaN Test 64: (+infty)^(+infty) = infty IEEE 754-2008: +infty Test 65: (+infty)^(-infty) = 0 IEEE 754-2008: +0 Test 66: (-infty)^(+infty) = NaN IEEE 754-2008: NaN Test 67: (-infty)^(-infty) = 0 IEEE 754-2008: NaN Test 68: (+infty)^NaN = NaN IEEE 754-2008: NaN Test 69: (-infty)^NaN = NaN IEEE 754-2008: NaN Test 70: NaN^(+infty) = NaN IEEE 754-2008: NaN Test 71: NaN^(-infty) = NaN IEEE 754-2008: NaN Test 72: infty = infty Test 73: -infty = -infty Test 74: exp(-infty) = 0 Test 75: infty^infty = infty Test 76: infty^(-infty) = 0 The tool has been restarted. =============== Test number 257 ================ [infty;infty] [infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [infty;infty] [infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] Warning: one bound of a range is NaN while the other is not. Will normalize the range to have two NaN endpoints. [NaN;NaN] [NaN;NaN] Warning: one bound of a range is NaN while the other is not. Will normalize the range to have two NaN endpoints. [NaN;NaN] [NaN;NaN] Warning: the bounds of the given range are in wrong order. Will reverse them. [-2;2] Warning: the bounds of the given range are in wrong order. Will reverse them. [-infty;infty] [1;1] [1;1] [1;1] [1;1] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [infty;infty] [infty;infty] [0;infty] [0;infty] [infty;infty] [infty;infty] [1;infty] [1;infty] [0;2] [0;2] [0;0] [0;0] [0;0] [0;0] [0;0] [0;0] [0;0] [0;0] [0;0] [0;0] [0;0] [0;0] [0;0] [0;0] The tool has been restarted. =============== Test number 258 ================ false The tool has been restarted. =============== Test number 259 ================ -1.3862943611198906188344642429163531361510002687205 17 1 1 -1.3862943611198906188344642429163531361510002687205 sin(62) Warning: the tool is unable to decide a minimum computation by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal. 17 + log(13) / log(9) 148.41315910257660342111558004055227962348766759388 17 2 2 148.41315910257660342111558004055227962348766759388 exp(17) Warning: the tool is unable to decide a maximum computation by evaluation even though faithful evaluation of the terms has been possible. The terms will be considered to be equal. 17 + log2(13) / log2(9) The tool has been restarted. =============== Test number 260 ================ sollya-6.0+ds/tests-tool/check014.sollya000066400000000000000000000433541300174114700201370ustar00rootroot00000000000000/* Set of tests for TMandAD */ check = proc(L) { var i; for i in L do sup(i)-inf(i); }; constructPoly = proc(L) { var i,res,n; res = 0; n=length(L); for i in revert(L) do {res := mid(i)+x*res/n; n := n-1;}; return res; }; print("=============== Check TMandAD #1 ================"); L=taylorform(x, 5, 1, [0,2], relative); constructPoly(autodiff(x, 5, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #2 ================"); L=taylorform(pi, 6, 2, [1,2]); constructPoly(autodiff(pi, 6, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #3 ================"); L=taylorform(0.1, 5, pi, [0, 4]); constructPoly(autodiff(0.1, 5, pi)); L[0]; check(L[1]); print("=============== Check TMandAD #4 ================"); L=taylorform(-x, 6, 0.4, [0.4], absolute); constructPoly(autodiff(-x, 6, 0.4)); L[0]; check(L[1]); print("=============== Check TMandAD #5 ================"); L=taylorform(-sin(x), 5, 3, [1,4]); constructPoly(autodiff(-sin(x), 5, 3)); L[0]; check(L[1]); print("=============== Check TMandAD #6 ================"); L=taylorform(x+cos(x), 6, 0.2, [0, 0.3], relative); constructPoly(autodiff(x+cos(x), 6, 0.2)); L[0]; check(L[1]); print("=============== Check TMandAD #7 ================"); L=taylorform(exp(x)+sin(x+log(x)), 5, [0.8], [0.7, 0.9]); constructPoly(autodiff(exp(x)+sin(x+log(x)), 5, [0.8])); L[0]; check(L[1]); print("=============== Check TMandAD #8 ================"); L=taylorform(x-cos(x), 6, pi, [3,4]); constructPoly(autodiff(x-cos(x), 6, pi)); L[0]; check(L[1]); print("=============== Check TMandAD #9 ================"); L=taylorform(exp(x)-sin(x-log(x)), 5, 1.3, [1,1.5]); constructPoly(autodiff(exp(x)-sin(x-log(x)), 5, 1.3)); L[0]; check(L[1]); print("=============== Check TMandAD #10 ================"); L=taylorform(x*x, 6, [pi], [2,5], relative); constructPoly(autodiff(x*x, 6, [pi])); L[0]; check(L[1]); print("=============== Check TMandAD #11 ================"); L=taylorform(exp(x)*asin(log(x)), 5, 1.1, [1.1, 1.2]); constructPoly(autodiff(exp(x)*asin(log(x)), 5, 1.1)); L[0]; check(L[1]); print("=============== Check TMandAD #12 ================"); L=taylorform(x/cos(x), 6, 0, [-1, 1]); constructPoly(autodiff(x/cos(x), 6, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #13 ================"); L=taylorform(sinh(x)/cos(x/cosh(x)), 5, 0.2, [-1,1]); constructPoly(autodiff(sinh(x)/cos(x/cosh(x)), 5, 0.2)); L[0]; check(L[1]); print("=============== Check TMandAD #14 ================"); L=taylorform(sqrt(x), 6, [pi], [1,4], relative); constructPoly(autodiff(sqrt(x), 6, [pi])); L[0]; check(L[1]); print("=============== Check TMandAD #15 ================"); L=taylorform(sqrt(exp(x)), 5, 0.25, [0.25]); constructPoly(autodiff(sqrt(exp(x)), 5, 0.25)); L[0]; check(L[1]); print("=============== Check TMandAD #16 ================"); L=taylorform(acosh(sqrt(x)), 6, 7, [6,8]); constructPoly(autodiff(acosh(sqrt(x)), 6, 7)); L[0]; check(L[1]); print("=============== Check TMandAD #17 ================"); L=taylorform(exp(x), 5, [0.1], [-2,2]); constructPoly(autodiff(exp(x), 5, [0.1])); L[0]; check(L[1]); print("=============== Check TMandAD #18 ================"); L=taylorform(exp(cos(x)), 6, 2, [2], absolute); constructPoly(autodiff(exp(cos(x)), 6, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #19 ================"); L=taylorform(sin(exp(x)), 5, 2, [1,3], absolute); constructPoly(autodiff(sin(exp(x)), 5, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #20 ================"); L=taylorform(log(x), 6, 2, [1.5,2.5]); constructPoly(autodiff(log(x), 6, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #21 ================"); L=taylorform(log(cosh(x)), 5, [1.1], [1,1.2], relative); constructPoly(autodiff(log(cosh(x)), 5, [1.1])); L[0]; check(L[1]); print("=============== Check TMandAD #22 ================"); L=taylorform(cosh(log(x)), 6, [exp(2)], [7,8]); constructPoly(autodiff(cosh(log(x)), 6, [exp(2)])); L[0]; check(L[1]); print("=============== Check TMandAD #23 ================"); L=taylorform(log2(x), 5, 3, [2,4]); constructPoly(autodiff(log2(x), 5, 3)); L[0]; check(L[1]); print("=============== Check TMandAD #24 ================"); L=taylorform(log2(cosh(x)), 6, 0.25, [0.25, 0.5], absolute); constructPoly(autodiff(log2(cosh(x)), 6, 0.25)); L[0]; check(L[1]); print("=============== Check TMandAD #25 ================"); L=taylorform(cosh(log2(x)), 5, 0.25, [0.2, 0.6]); constructPoly(autodiff(cosh(log2(x)), 5, 0.25)); L[0]; check(L[1]); print("=============== Check TMandAD #26 ================"); L=taylorform(log10(x), 6, 0.25, [0.25], absolute); constructPoly(autodiff(log10(x), 6, 0.25)); L[0]; check(L[1]); print("=============== Check TMandAD #27 ================"); L=taylorform(log10(cosh(x)), 5, 0.25, [0.2, 0.3]); constructPoly(autodiff(log10(cosh(x)), 5, 0.25)); L[0]; check(L[1]); print("=============== Check TMandAD #28 ================"); L=taylorform(cosh(log10(x)), 6, 0.25, [0.21, 0.26], relative); constructPoly(autodiff(cosh(log10(x)), 6, 0.25)); L[0]; check(L[1]); print("=============== Check TMandAD #29 ================"); L=taylorform(sin(x), 5, [3], [2, pi], relative); constructPoly(autodiff(sin(x), 5, [3])); L[0]; check(L[1]); print("=============== Check TMandAD #30 ================"); L=taylorform(sin(cosh(x)), 6, [3], [2,3]); constructPoly(autodiff(sin(cosh(x)), 6, [3])); L[0]; check(L[1]); print("=============== Check TMandAD #31 ================"); L=taylorform(cosh(sin(x)), 5, [2], [1,5], absolute); constructPoly(autodiff(cosh(sin(x)), 5, [2])); L[0]; check(L[1]); print("=============== Check TMandAD #32 ================"); L=taylorform(cos(x), 6, [2], [-2, 2]); constructPoly(autodiff(cos(x), 6, [2])); L[0]; check(L[1]); print("=============== Check TMandAD #33 ================"); L=taylorform(cos(log(x)), 5, pi, [3,4]); constructPoly(autodiff(cos(log(x)), 5, pi)); L[0]; check(L[1]); print("=============== Check TMandAD #34 ================"); L=taylorform(log(cos(x)), 6, 0, [-0.5, 0.5], relative); constructPoly(autodiff(log(cos(x)), 6, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #35 ================"); L=taylorform(tan(x), 5, [pi], [pi-0.5, pi+0.6]); constructPoly(autodiff(tan(x), 5, [pi])); L[0]; check(L[1]); print("=============== Check TMandAD #36 ================"); L=taylorform(tan(asin(x)), 6, 0.5, [0.4, 0.7]); constructPoly(autodiff(tan(asin(x)), 6, 0.5)); L[0]; check(L[1]); print("=============== Check TMandAD #37 ================"); L=taylorform(asin(tan(x)), 5, 0.1, [-0.1, 0.2], relative); constructPoly(autodiff(asin(tan(x)), 5, 0.1)); L[0]; check(L[1]); print("=============== Check TMandAD #38 ================"); L=taylorform(asin(x), 6, 0, [-0.2, 0.1]); constructPoly(autodiff(asin(x), 6, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #39 ================"); L=taylorform(acos(x), 5, 0.2, [0.2]); constructPoly(autodiff(acos(x), 5, 0.2)); L[0]; check(L[1]); print("=============== Check TMandAD #40 ================"); L=taylorform(acos(exp(x)), 6, -3, [-5, -1]); constructPoly(autodiff(acos(exp(x)), 6, -3)); L[0]; check(L[1]); print("=============== Check TMandAD #41 ================"); L=taylorform(exp(acos(x)), 5, 0.5, [0, 0.9], absolute); constructPoly(autodiff(exp(acos(x)), 5, 0.5)); L[0]; check(L[1]); print("=============== Check TMandAD #42 ================"); L=taylorform(atan(x), 6, 0.5, [0.3, 1], relative); constructPoly(autodiff(atan(x), 6, 0.5)); L[0]; check(L[1]); print("=============== Check TMandAD #43 ================"); L=taylorform(atan(sinh(x)), 5, [pi], [3,4]); constructPoly(autodiff(atan(sinh(x)), 5, [pi])); L[0]; check(L[1]); print("=============== Check TMandAD #44 ================"); L=taylorform(sinh(atan(x)), 6, [pi], [pi]); constructPoly(autodiff(sinh(atan(x)), 6, [pi])); L[0]; check(L[1]); print("=============== Check TMandAD #45 ================"); L=taylorform(sinh(x), 5, 0.3); constructPoly(autodiff(sinh(x), 5, 0.3)); L[0]; check(L[1]); print("=============== Check TMandAD #46 ================"); L=taylorform(cosh(x), 6, 0.3, [0.1, 0.5], absolute); constructPoly(autodiff(cosh(x), 6, 0.3)); L[0]; check(L[1]); print("=============== Check TMandAD #47 ================"); L=taylorform(asinh(x), 5, 0.1, [0,0.25], relative); constructPoly(autodiff(asinh(x), 5, 0.1)); L[0]; check(L[1]); print("=============== Check TMandAD #48 ================"); L=taylorform(asinh(exp(x)), 6, 2, [1.75, 2.25]); constructPoly(autodiff(asinh(exp(x)), 6, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #49 ================"); L=taylorform(exp(asinh(x)), 5, 0.1, [0.05, 0.125]); constructPoly(autodiff(exp(asinh(x)), 5, 0.1)); L[0]; check(L[1]); print("=============== Check TMandAD #50 ================"); L=taylorform(acosh(x), 6, 3, [3, pi]); constructPoly(autodiff(acosh(x), 6, 3)); L[0]; check(L[1]); print("=============== Check TMandAD #51 ================"); L=taylorform(atan(acosh(x)), 5, 1.3, absolute); constructPoly(autodiff(atan(acosh(x)), 5, 1.3)); L[0]; check(L[1]); print("=============== Check TMandAD #52 ================"); L=taylorform(acosh(atan(x)), 6, 10, [10, 12]); constructPoly(autodiff(acosh(atan(x)), 6, 10)); L[0]; check(L[1]); print("=============== Check TMandAD #53 ================"); L=taylorform(atanh(x), 5, 0.5, [0.5, 0.75], relative); constructPoly(autodiff(atanh(x), 5, 0.5)); L[0]; check(L[1]); print("=============== Check TMandAD #54 ================"); L=taylorform(atanh(acos(x)), 6, 0.75); constructPoly(autodiff(atanh(acos(x)), 6, 0.75)); L[0]; check(L[1]); print("=============== Check TMandAD #55 ================"); L=taylorform(acos(atanh(x)), 5, 0.01, [0.01], absolute); constructPoly(autodiff(acos(atanh(x)), 5, 0.01)); L[0]; check(L[1]); print("=============== Check TMandAD #56 ================"); L=taylorform(erf(x), 6, 2, [1,3], relative); constructPoly(autodiff(erf(x), 6, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #57 ================"); L=taylorform(erf(atan(x)), 5, [pi], [2, 4]); constructPoly(autodiff(erf(atan(x)), 5, [pi])); L[0]; check(L[1]); print("=============== Check TMandAD #58 ================"); L=taylorform(asinh(erf(x)), 6, [pi], [3, 3.5]); constructPoly(autodiff(asinh(erf(x)), 6, [pi])); L[0]; check(L[1]); print("=============== Check TMandAD #59 ================"); L=taylorform(erfc(acos(x)), 5, [0.1], [0.01, 1], absolute); constructPoly(autodiff(erfc(acos(x)), 5, [0.1])); L[0]; check(L[1]); print("=============== Check TMandAD #60 ================"); L=taylorform(acosh(erfc(x)), 6, -1, [-2,0], absolute); constructPoly(autodiff(acosh(erfc(x)), 6, -1)); L[0]; check(L[1]); print("=============== Check TMandAD #61 ================"); L=taylorform(log1p(x), 5, 0.1); L[0]; check(L[1]); print("=============== Check TMandAD #62 ================"); L=taylorform(log1p(cos(x)), 6, 1.5, [1,2]); constructPoly(autodiff(log1p(cos(x)), 6, 1.5)); L[0]; check(L[1]); print("=============== Check TMandAD #63 ================"); L=taylorform(cos(log1p(x)), 5, 1.5, [1,2], relative); constructPoly(autodiff(cos(log1p(x)), 5, 1.5)); L[0]; check(L[1]); print("=============== Check TMandAD #64 ================"); L=taylorform(expm1(x), 6, 1, [0,2], absolute); constructPoly(autodiff(expm1(x), 6, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #65 ================"); L=taylorform(expm1(cos(x)), 5, 1, [1,3], absolute); constructPoly(autodiff(expm1(cos(x)), 5, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #66 ================"); L=taylorform(atanh(expm1(x)), 6, [0.1], [0,0.25], relative); constructPoly(autodiff(atanh(expm1(x)), 6, [0.1])); L[0]; check(L[1]); print("=============== Check TMandAD #67 ================"); L=taylorform(x^0.1, 5, 2, [1,3]); constructPoly(autodiff(x^0.1, 5, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #68 ================"); L=taylorform(0.1^x, 6, 2, [2, pi]); constructPoly(autodiff(0.1^x, 6, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #69 ================"); L=taylorform(0.1^0.1, 5, 3, [1,pi]); constructPoly(autodiff(0.1^0.1, 5, 3)); L[0]; check(L[1]); print("=============== Check TMandAD #70 ================"); L=taylorform(x^x, 6, [pi]); constructPoly(autodiff(x^x, 6, [pi])); L[0]; check(L[1]); print("=============== Check TMandAD #71 ================"); L=taylorform(exp(x)^x, 5, [pi], [3,4]); constructPoly(autodiff(exp(x)^x, 5, [pi])); L[0]; check(L[1]); print("=============== Check TMandAD #72 ================"); L=taylorform(x^exp(x), 6, pi, [3,4]); constructPoly(autodiff(x^exp(x), 6, pi)); L[0]; check(L[1]); print("=============== Check TMandAD #73 ================"); L=taylorform(exp(x)^exp(x), 5, 1, [0.9,1.1]); constructPoly(autodiff(exp(x)^exp(x), 5, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #74 ================"); L=taylorform(exp(x)^0.1, 6, 2); constructPoly(autodiff(exp(x)^0.1, 6, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #75 ================"); L=taylorform(0.1^exp(x), 5, -3, [-4,-2]); constructPoly(autodiff(0.1^exp(x), 5, -3)); L[0]; check(L[1]); print("=============== Check TMandAD #76 ================"); L=taylorform(exp(cos(x)^sin(x)), 6, 0.2, [0.1,0.25]); constructPoly(autodiff(exp(cos(x)^sin(x)), 6, 0.2)); L[0]; check(L[1]); print("=============== Check TMandAD #77 ================"); L=taylorform(sin(x)*tan(x)/log(1+x^2), 5, 0, relative); constructPoly(autodiff(sin(x)*tan(x)/log(1+x^2), 5, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #78 ================"); L=taylorform(sin(x)*tan(x)/log(1+x^2), 6, 0, relative); constructPoly(autodiff(sin(x)*tan(x)/log(1+x^2), 6, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #79 ================"); L=taylorform(abs(x), 6, 1, [0,2], absolute); constructPoly(autodiff(abs(x), 6, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #80 ================"); L=taylorform(abs(exp(x)), 5, 0, [0,2]); constructPoly(autodiff(abs(exp(x)), 5, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #81 ================"); L=taylorform(exp(abs(x)), 6, 2, [0,2], relative); constructPoly(autodiff(exp(abs(x)), 6, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #82 ================"); L=taylorform(single(x), 5, 1, [0,2], absolute); constructPoly(autodiff(single(x), 5, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #83 ================"); L=taylorform(single(exp(x)), 6, 0, [0,2]); constructPoly(autodiff(single(exp(x)), 6, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #84 ================"); L=taylorform(exp(single(x)), 5, 1, [0,2], relative); constructPoly(autodiff(exp(single(x)), 5, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #85 ================"); L=taylorform(double(x), 6, 2, [0,2]); constructPoly(autodiff(double(x), 6, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #86 ================"); L=taylorform(double(exp(x)), 5, 1, [0,2]); constructPoly(autodiff(double(exp(x)), 5, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #87 ================"); L=taylorform(exp(double(x)), 6, 0, [0,2], absolute); constructPoly(autodiff(exp(double(x)), 6, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #88 ================"); L=taylorform(DD(x), 5, 1, [0,2]); constructPoly(autodiff(DD(x), 5, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #89 ================"); L=taylorform(DD(exp(x)), 6, 0, [0,2], relative); constructPoly(autodiff(DD(exp(x)), 6, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #90 ================"); L=taylorform(exp(DD(x)), 5, 1, [0,2]); constructPoly(autodiff(exp(DD(x)), 5, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #91 ================"); L=taylorform(TD(x), 6, 1, [0,2], absolute); constructPoly(autodiff(TD(x), 6, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #92 ================"); L=taylorform(TD(exp(x)), 5, 2, [0,2]); constructPoly(autodiff(TD(exp(x)), 5, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #93 ================"); L=taylorform(exp(TD(x)), 6, 0, [0,2], relative); constructPoly(autodiff(exp(TD(x)), 6, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #94 ================"); L=taylorform(DE(x), 5, 1, [0,2], relative); constructPoly(autodiff(DE(x), 5, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #95 ================"); L=taylorform(DE(exp(x)), 6, 1, [0,2]); constructPoly(autodiff(DE(exp(x)), 6, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #96 ================"); L=taylorform(exp(DE(x)), 5, 2, [0,2]); constructPoly(autodiff(exp(DE(x)), 5, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #97 ================"); L=taylorform(ceil(x), 6, 1, [0,2], absolute); constructPoly(autodiff(ceil(x), 6, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #98 ================"); L=taylorform(ceil(exp(x)), 5, 0, [0,2]); constructPoly(autodiff(ceil(exp(x)), 5, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #99 ================"); L=taylorform(exp(ceil(x)), 6, 0, [0,2], relative); constructPoly(autodiff(exp(ceil(x)), 6, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #100 ================"); L=taylorform(floor(x), 5, 0, [0,2]); constructPoly(autodiff(floor(x), 5, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #101 ================"); L=taylorform(floor(exp(x)), 6, 2, [0,2], relative); constructPoly(autodiff(floor(exp(x)), 6, 2)); L[0]; check(L[1]); print("=============== Check TMandAD #102 ================"); L=taylorform(exp(floor(x)), 5, 1, [0,2], absolute); constructPoly(autodiff(exp(floor(x)), 5, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #103 ================"); L=taylorform(nearestint(x), 6, 0, [0,2]); constructPoly(autodiff(nearestint(x), 6, 0)); L[0]; check(L[1]); print("=============== Check TMandAD #104 ================"); L=taylorform(nearestint(exp(x)), 5, 1, [0,2], relative); constructPoly(autodiff(nearestint(exp(x)), 5, 1)); L[0]; check(L[1]); print("=============== Check TMandAD #105 ================"); L=taylorform(exp(nearestint(x)), 6, 1, [0,2]); constructPoly(autodiff(exp(nearestint(x)), 6, 1)); L[0]; check(L[1]); sollya-6.0+ds/tests-tool/check014.sollya.reference000066400000000000000000002723621300174114700220770ustar00rootroot00000000000000=============== Check TMandAD #1 ================ 1 + x 1 + x 0 0 0 0 0 0 =============== Check TMandAD #2 ================ 3.14159265358979323846264338327950288419716939937512 3.1415926535897932384626433832795028841971693993752 8.5528470722950260676497166948847420122086300163362e-50 0 0 0 0 0 0 =============== Check TMandAD #3 ================ 0.1 0.1 0 0 0 0 0 0 =============== Check TMandAD #4 ================ -0.4 + x * (-1) -0.4 + x * (-1) 0 0 0 0 0 0 0 =============== Check TMandAD #5 ================ -0.141120008059867222100744802808110279846933264252264 + x * (0.9899924966004454572715727947312613023936790966156 + x * (7.0560004029933611050372401404055139923466632126132e-2 + x * (-0.16499874943340757621192879912187688373227984943593 + x * (-5.8800003358278009208643667836712616602888860105112e-3 + x * 8.2499374716703788105964399560938441866139924717966e-3)))) -0.14112000805986722210074480280811027984693326425226 + x * (0.98999249660044545727157279473126130239367909661559 + x * (7.056000402993361105037240140405513992346663212613e-2 + x * (-0.164998749433407576211928799121876883732279849435935 + x * (-5.880000335827800920864366783671261660288886010511e-3 + x * 8.2499374716703788105964399560938441866139924717966e-3)))) 5.3455294201843912922810729343029637576303937602101e-51 2.13821176807375651691242917372118550305215750408404e-50 2.67276471009219564614053646715148187881519688010505e-51 5.3455294201843912922810729343029637576303937602101e-51 3.3409558876152445576756705839393523485189961001313e-52 6.6819117752304891153513411678787046970379922002626e-52 =============== Check TMandAD #6 ================ 1.18006657784124163112419651674816887739352436080658 + x * (0.8013306692049387845405873728816102496297932704598 + x * (-0.49003328892062081556209825837408443869676218040329 + x * (3.31115551325102025765687711863982917283677882567e-2 + x * (4.0836107410051734630174854864507036558063515033607e-2 + x * (-1.6555777566255101288284385593199145864183894128351e-3 + x * (-1.3612035803350578210058284954835678852687838344536e-3)))))) 1.1800665778412416311241965167481688773935243608066 + x * (0.8013306692049387845405873728816102496297932704598 + x * (-0.49003328892062081556209825837408443869676218040328 + x * (3.3111555132510202576568771186398291728367788256702e-2 + x * (4.0836107410051734630174854864507036558063515033607e-2 + x * (-1.65557775662551012882843855931991458641838941283506e-3 + x * (-1.36120358033505782100582849548356788526878383445355e-3)))))) 4.2764235361475130338248583474423710061043150081681e-50 2.13821176807375651691242917372118550305215750408404e-50 1.06910588403687825845621458686059275152607875204202e-50 1.33638235504609782307026823357574093940759844005252e-51 2.67276471009219564614053646715148187881519688010505e-51 8.3523897190381113941891764598483808712974902503283e-53 1.25285845785571670912837646897725713069462353754924e-52 =============== Check TMandAD #7 ================ 2.7709326985918855675769559282840760702718858503623 + x * (4.1114487534161453334349901285207814948976167736307 + x * (-0.92258155969419490573336759209638861147493211414941 + x * (0.284076153244172146111135186079683090901244703934 + x * (0.85573582810333867222143907440222889006071955665403 + x * (-0.80641876554932905385071891593962138720768470075044))))) 2.7709326985918855675769559282840760702718858503623 + x * (4.1114487534161453334349901285207814948976167736307 + x * (-0.92258155969419490573336759209638861147493211414941 + x * (0.28407615324417214611113518607968309090124470393401 + x * (0.855735828103338672221439074402228890060719556654 + x * (-0.80641876554932905385071891593962138720768470075042))))) 3.4211388289180104270598866779538968048834520065345e-49 6.842277657836020854119773355907793609766904013069e-49 7.6975623650655234608847450253962678109877670147025e-49 1.14394329591945973654814960794083424413290426468496e-48 1.66780517909753008319169475550252469238068285318555e-48 2.4375614156040824292801692580421514734794595546558e-48 =============== Check TMandAD #8 ================ 4.1415926535897932384626433832795028841971693993751 + x * (1.00000000000000000000000000000000000000000000000002 + x * (-0.499999999999999999999999999999999999999999999999995 + x * (-4.2861585605643788583724990999682603394576868045173e-51 + x * (4.1666666666666666666666666666666666666666666666668e-2 + x * (2.1430792802821894291862495499841301697288434022588e-52 + x * (-1.3888888888888888888888888888888888888888888888889e-3)))))) 4.141592653589793238462643383279502884197169399375 + x * (1 + x * (-0.5 + x * (-4.2861585605643788583724990999682603394576868045174e-51 + x * (4.1666666666666666666666666666666666666666666666666e-2 + x * (2.1430792802821894291862495499841301697288434022587e-52 + x * (-1.3888888888888888888888888888888888888888888888889e-3)))))) 1.71056941445900521352994333897694840244172600326723e-49 4.2764235361475130338248583474423710061043150081681e-50 1.06910588403687825845621458686059275152607875204202e-50 2.2859747825645499644315670966106819189038199896456e-100 2.67276471009219564614053646715148187881519688010505e-51 1.4287342391028437277697294353816761993148874935285e-101 1.25285845785571670912837646897725713069462353754924e-52 =============== Check TMandAD #9 ================ 2.80809168813717242846728231667236708900295391522115 + x * (3.5520064078845816499131820989490810971728300259239 + x * (1.7072076994811749669113242903538984677761891641213 + x * (0.74850309551277312223289161589184154760564852321808 + x * (0.119839085559863760790491081595426230483212105905815 + x * 3.9248674097918231609632130738866752825965969279098e-2)))) 2.8080916881371724284672823166723670890029539152212 + x * (3.5520064078845816499131820989490810971728300259239 + x * (1.7072076994811749669113242903538984677761891641213 + x * (0.7485030955127731222328916158918415476056485232181 + x * (0.119839085559863760790491081595426230483212105905818 + x * 3.9248674097918231609632130738866752825965969279098e-2)))) 2.56585412168850782029491500846542260366258900490085e-49 1.71056941445900521352994333897694840244172600326723e-49 8.5528470722950260676497166948847420122086300163362e-50 8.5528470722950260676497166948847420122086300163362e-50 2.94004118110141521075459011386663006669671656811555e-50 2.13821176807375651691242917372118550305215750408404e-50 =============== Check TMandAD #10 ================ 9.869604401089358618834490999876151135313699407241 + x * (6.28318530717958647692528676655900576839433879875025 + x) 9.8696044010893586188344909998761511353136994072408 + x * (6.2831853071795864769252867665590057683943387987503 + x) 1.02634164867540312811796600338616904146503560196034e-48 1.71056941445900521352994333897694840244172600326723e-49 0 0 0 0 0 =============== Check TMandAD #11 ================ 0.286762887060830869590338442464591048412382328454773 + x * (3.0303125820639503555538376207559002133135761291595 + x * (1.75981098504766860527584819648670840648547749247826 + x * (1.3310557476616243752649553044144113726519163591765 + x * (6.163835351962572301643982802748161952591842221212e-2 + x * 0.44983413498834195034476918929343125096096962049606)))) 0.28676288706083086959033844246459104841238232845477 + x * (3.03031258206395035555383762075590021331357612915946 + x * (1.75981098504766860527584819648670840648547749247826 + x * (1.3310557476616243752649553044144113726519163591766 + x * (6.1638353519625723016439828027481619525918422212184e-2 + x * 0.44983413498834195034476918929343125096096962049608)))) 3.2073176521106347753686437605817782545782362561261e-50 5.9869929506065182473548016864193194085460410114353e-49 8.5528470722950260676497166948847420122086300163362e-49 1.06910588403687825845621458686059275152607875204202e-48 1.2749087667139773232090358948312568561948489118101e-48 1.72126047329937399611450548484555432995698679078765e-48 =============== Check TMandAD #12 ================ x * (1 + x^2 * (0.5 + x^2 * 0.208333333333333333333333333333333333333333333333335)) x * (1 + x^2 * (0.5 + x^2 * 0.20833333333333333333333333333333333333333333333333)) 0 0 0 0 0 5.3455294201843912922810729343029637576303937602101e-51 0 =============== Check TMandAD #13 ================ 0.205268822826511123720790985134368497296575512313805 + x * (1.07838250791290241004340868928662344189696811356958 + x * (0.383746020340648829473957512269208147475116242680403 + x * (0.58466125992623567326245422609590105977189014951887 + x * (-0.209066721896021466207223286491656285951560914116834 + x * (-0.22154483664427250166832681236374123267363849191316))))) 0.2052688228265111237207909851343684972965755123138 + x * (1.07838250791290241004340868928662344189696811356958 + x * (0.3837460203406488294739575122692081474751162426804 + x * (0.58466125992623567326245422609590105977189014951885 + x * (-0.20906672189602146620722328649165628595156091411684 + x * (-0.221544836644272501668326812363741232673638491913175))))) 2.67276471009219564614053646715148187881519688010505e-50 2.56585412168850782029491500846542260366258900490085e-49 1.49674823765162956183870042160482985213651025285883e-49 3.8487811825327617304423725126981339054938835073513e-49 5.3455294201843912922810729343029637576303937602101e-49 9.461587073726372587337499093716245851005796955572e-49 =============== Check TMandAD #14 ================ 1.7724538509055160272981674833411451827975494561224 + x * (0.2820947917738781434740397257803862929220253146645 + x * (-2.2448390265645820211135247953461594410273242929353e-2 + x * (3.5727722752335177348239427820807666997143249791235e-3 + x * (-7.1078046018136491829217079580242629743895444620676e-4 + x * (1.58373913167394837191045683604522674436479419433053e-4 + x * (-3.7808986706096248048777418852390687159945413257485e-5)))))) 1.7724538509055160272981674833411451827975494561224 + x * (0.2820947917738781434740397257803862929220253146645 + x * (-2.2448390265645820211135247953461594410273242929353e-2 + x * (3.5727722752335177348239427820807666997143249791235e-3 + x * (-7.1078046018136491829217079580242629743895444620678e-4 + x * (1.58373913167394837191045683604522674436479419433053e-4 + x * (-3.7808986706096248048777418852390687159945413257485e-5)))))) 4.2764235361475130338248583474423710061043150081681e-50 1.06910588403687825845621458686059275152607875204202e-50 1.33638235504609782307026823357574093940759844005252e-51 3.3409558876152445576756705839393523485189961001313e-52 1.04404871487976392427364705748104760891218628129103e-52 2.6101217871994098106841176437026190222804657032276e-53 7.8303653615982294320523529311078570668413971096828e-54 =============== Check TMandAD #15 ================ 1.13314845306682631682900722781179387256550313174518 + x * (0.56657422653341315841450361390589693628275156587259 + x * (0.141643556633353289603625903476474234070687891468147 + x * (2.36072594388922149339376505794123723451146485780214e-2 + x * (2.9509074298615268667422063224265465431393310722558e-3 + x * 2.95090742986152686674220632242654654313933107226e-4)))) 1.13314845306682631682900722781179387256550313174516 + x * (0.56657422653341315841450361390589693628275156587258 + x * (0.14164355663335328960362590347647423407068789146815 + x * (2.3607259438892214933937650579412372345114648578027e-2 + x * (2.9509074298615268667422063224265465431393310722557e-3 + x * 2.9509074298615268667422063224265465431393310722731e-4)))) 4.2764235361475130338248583474423710061043150081681e-50 6.4146353042212695507372875211635565091564725122521e-50 6.4146353042212695507372875211635565091564725122521e-50 6.9491882462397086799653948145938528849195118882731e-50 7.6173794237627575915005289313817233546233111082994e-50 9.9560485450934287818734983401392699985866083783913e-50 =============== Check TMandAD #16 ================ 1.62830697740002620465811368029998926146547295971074 + x * (7.7151674981045955130547231381999960210776241750695e-2 + x * (-5.9700700878190322422447262378928540639291139449944e-3 + x * (6.1778197795196945363887734879294185826372699247654e-4 + x * (-7.2129885910795422144467532848691299454358980131915e-5 + x * (9.0090493264250496994561843325301664003807041091898e-6 + x * (-1.17545139159253990696782015213175625463620021414877e-6)))))) 1.62830697740002620465811368029998926146547295971074 + x * (7.7151674981045955130547231381999960210776241750694e-2 + x * (-5.9700700878190322422447262378928540639291139449944e-3 + x * (6.1778197795196945363887734879294185826372699247652e-4 + x * (-7.2129885910795422144467532848691299454358980131912e-5 + x * (9.0090493264250496994561843325301664003807041091898e-6 + x * (-1.17545139159253990696782015213175625463620021414873e-6)))))) 8.5528470722950260676497166948847420122086300163362e-50 1.33638235504609782307026823357574093940759844005252e-50 1.8375257381883845067216188211666437916854478550722e-51 2.9233364016633389879662117609469333049541215876149e-52 4.1761948595190556970945882299241904356487451251641e-53 7.1778349147983769793813235201822023112712806838759e-54 1.22349458774972334875818014548560266669396829838793e-54 =============== Check TMandAD #17 ================ 1.10517091807564762481170782649024666822454719473752 + x * (1.10517091807564762481170782649024666822454719473752 + x * (0.55258545903782381240585391324512333411227359736876 + x * (0.18419515301260793746861797108170777803742453245626 + x * (4.6048788253151984367154492770426944509356133114065e-2 + x * 9.2097576506303968734308985540853889018712266228128e-3)))) 1.10517091807564762481170782649024666822454719473754 + x * (1.10517091807564762481170782649024666822454719473754 + x * (0.55258545903782381240585391324512333411227359736877 + x * (0.184195153012607937468617971081707778037424532456256 + x * (4.6048788253151984367154492770426944509356133114064e-2 + x * 9.2097576506303968734308985540853889018712266228128e-3)))) 4.2764235361475130338248583474423710061043150081681e-50 4.2764235361475130338248583474423710061043150081681e-50 2.13821176807375651691242917372118550305215750408404e-50 1.06910588403687825845621458686059275152607875204202e-50 2.67276471009219564614053646715148187881519688010505e-51 6.6819117752304891153513411678787046970379922002626e-52 =============== Check TMandAD #18 ================ 0.65958341242257887594422792131603529590877949319504 + x * (-0.59975749969275334640222688551602704664507781163706 + x * (0.4099207508543252673953699899321157029427823492904 + x * (-0.107482773433491893728984006925648627163415142149265 + x * (-1.2526300250141198409273291761931858027225121782788e-2 + x * (3.39278853918957681604088184891090650231302310796e-2 + x * (-1.47251361376790372113219567857934670120202387442053e-2)))))) 0.65958341242257887594422792131603529590877949319504 + x * (-0.59975749969275334640222688551602704664507781163707 + x * (0.4099207508543252673953699899321157029427823492904 + x * (-0.107482773433491893728984006925648627163415142149265 + x * (-1.25263002501411984092732917619318580272251217827897e-2 + x * (3.39278853918957681604088184891090650231302310796e-2 + x * (-1.47251361376790372113219567857934670120202387442063e-2)))))) 4.2764235361475130338248583474423710061043150081681e-50 6.4146353042212695507372875211635565091564725122521e-50 6.4146353042212695507372875211635565091564725122521e-50 5.0782529491751717276670192875878155697488740721996e-50 4.3432426538998179249783717591211580530746949301707e-50 2.94004118110141521075459011386663006669671656811555e-50 1.70388750268377472441459199780906969774468801106697e-50 =============== Check TMandAD #19 ================ 0.89385495491281015978128132199907346703148228791767 + x * (3.31292942310433398046836876203602243658895736152283 + x * (-22.744948756547327185788822075898850791128190808835 + x * (-53.995894846226841373275781312368314084700273901796 + x * (51.706595909277761336938157162129547664951392697606 + x * 260.58682648694560181424218602226804164242596875406)))) 0.89385495491281015978128132199907346703148228791767 + x * (3.3129294231043339804683687620360224365889573615229 + x * (-22.7449487565473271857888220758988507911281908088354 + x * (-53.995894846226841373275781312368314084700273901796 + x * (51.706595909277761336938157162129547664951392697603 + x * 260.58682648694560181424218602226804164242596875407)))) 8.5528470722950260676497166948847420122086300163362e-50 1.28292706084425391014745750423271130183129450245042e-48 6.158049892052418768707796020317014248790213611762e-48 2.0526832973508062562359320067723380829300712039207e-47 6.7054321046793004370373778887896377375715659328075e-47 1.75162308040602133865466197911239516410032742734564e-46 =============== Check TMandAD #20 ================ 0.69314718055994530941723212145817656807550013436026 + x * (0.5 + x * (-0.125 + x * (4.1666666666666666666666666666666666666666666666668e-2 + x * (-1.5625e-2 + x * (6.2500000000000000000000000000000000000000000000002e-3 + x * (-2.6041666666666666666666666666666666666666666666666e-3)))))) 0.69314718055994530941723212145817656807550013436025 + x * (0.5 + x * (-0.125 + x * (4.1666666666666666666666666666666666666666666666668e-2 + x * (-1.5625e-2 + x * (6.25e-3 + x * (-2.6041666666666666666666666666666666666666666666667e-3)))))) 2.13821176807375651691242917372118550305215750408404e-50 0 0 1.33638235504609782307026823357574093940759844005252e-51 0 1.67047794380762227883783529196967617425949805006566e-52 8.3523897190381113941891764598483808712974902503283e-53 =============== Check TMandAD #21 ================ 0.51193613920875060810325975776105526951578708077679 + x * (0.80049902176062970601146133060069645804715910186353 + x * (0.1796006580801374442050286152412440968898393357978 + x * (-9.5846767400476906257684973947481999053298679253323e-2 + x * (2.7610489643894041975931342704388087496595758474717e-2 + x * 1.48761751988003897143014023650580128532683920576166e-3)))) 0.51193613920875060810325975776105526951578708077679 + x * (0.80049902176062970601146133060069645804715910186353 + x * (0.1796006580801374442050286152412440968898393357978 + x * (-9.5846767400476906257684973947481999053298679253323e-2 + x * (2.76104896438940419759313427043880874965957584747184e-2 + x * 1.487617519880038971430140236505801285326839205759e-3)))) 8.5528470722950260676497166948847420122086300163362e-50 1.71056941445900521352994333897694840244172600326723e-49 2.03130117967006869106680771503512622789954962887984e-49 2.40548823908297608152648282043633369093367719209454e-49 3.180590005009712818907238395910263435790084287325e-49 4.0358747122392154256722100653987376370109472889586e-49 =============== Check TMandAD #22 ================ 3.7621956910836314595622134777737461082939735582308 + x * (0.49084218055563290985314098936337937889404396622328 + x * (1.23937608833317921152258371540833394575323979276574e-3 + x * (-1.6773131395125591941069456289043050965545006686021e-4 + x * (2.269996488124242576779575778027530511895904443327e-5 + x * (-3.0721061766641048793411540894027661556119946574442e-6 + x * 4.1576435955178394203199257128263114730382918249207e-7))))) 3.76219569108363145956221347777374610829397355823076 + x * (0.49084218055563290985314098936337937889404396622327 + x * (1.2393760883331792115225837154083339457532397927664e-3 + x * (-1.67731313951255919410694562890430509655450066860293e-4 + x * (2.26999648812424257677957577802753051189590444332713e-5 + x * (-3.0721061766641048793411540894027661556119946574448e-6 + x * 4.1576435955178394203199257128263114730382918249224e-7))))) 5.9869929506065182473548016864193194085460410114353e-49 1.17601647244056608430183604554665202667868662724622e-49 2.0045735325691467346054023503636114091113976600788e-50 3.1321461446392917728209411724431428267365588438731e-51 4.8417759152549051988190382290683582863302638794872e-52 7.6182929663882773849342683725570192712811092712955e-53 1.15824154306973810349107720439303719113695665580724e-53 =============== Check TMandAD #23 ================ 1.58496250072115618145373894394781650875981440769247 + x * (0.48089834696298780245330822700063071247554865138433 + x * (-8.0149724493831300408884704500105118745924775230722e-2 + x * (1.78110498875180667575299343333566930546499500512716e-2 + x * (-4.4527624718795166893824835833391732636624875128179e-3 + x * 1.18740332583453778383532895555711287030999667008475e-3)))) 1.58496250072115618145373894394781650875981440769247 + x * (0.48089834696298780245330822700063071247554865138433 + x * (-8.0149724493831300408884704500105118745924775230722e-2 + x * (1.78110498875180667575299343333566930546499500512716e-2 + x * (-4.4527624718795166893824835833391732636624875128179e-3 + x * 1.18740332583453778383532895555711287030999667008475e-3)))) 1.71056941445900521352994333897694840244172600326723e-49 4.2764235361475130338248583474423710061043150081681e-50 5.3455294201843912922810729343029637576303937602101e-51 2.0045735325691467346054023503636114091113976600788e-51 5.011433831422866836513505875909028522778494150197e-52 1.67047794380762227883783529196967617425949805006566e-52 =============== Check TMandAD #24 ================ 4.46222742984763182139820683128822979611486383936885e-2 + x * (0.35334293967098936706823882294534063380903092859601 + x * (0.67807738036747510042515551669866072111522691166961 + x * (-0.110715870003875399150380304345420650078639842835907 + x * (-9.2675609636753437949181540268739651326646314289507e-2 + x * (4.030156308052063800460141517200281947442012125259e-2 + x * 1.73918712273581354021153621125817292297273195173706e-2))))) 4.4622274298476318213982068312882297961148638393688e-2 + x * (0.35334293967098936706823882294534063380903092859601 + x * (0.67807738036747510042515551669866072111522691166962 + x * (-0.110715870003875399150380304345420650078639842835912 + x * (-9.2675609636753437949181540268739651326646314289505e-2 + x * (4.0301563080520638004601415172002819474420121252591e-2 + x * 1.7391871227358135402115362112581729229727319517371e-2))))) 6.2809970687166597684302606978059824152157126682469e-50 6.4146353042212695507372875211635565091564725122521e-50 1.49674823765162956183870042160482985213651025285883e-49 7.2164647172489282445794484613090010728010315762836e-50 1.17601647244056608430183604554665202667868662724622e-49 7.7510176592673673738075557547392974485640709523046e-50 8.4860279545427211764962032832059549652382500943335e-50 =============== Check TMandAD #25 ================ 3.7621956910836314595622134777737461082939735582307 + x * (-20.929814097589668964321346369912132640841684717715 + x * (104.50376749033474936664233154145486777810959232589 + x * (-478.36934127693191760252319827858294564769140086406 + x * (2124.5078131730142589143026171171421501216537464281 + x * (-9249.514983293283341357628113187748195356441792682))))) 3.76219569108363145956221347777374610829397355823076 + x * (-20.929814097589668964321346369912132640841684717715 + x * (104.50376749033474936664233154145486777810959232589 + x * (-478.36934127693191760252319827858294564769140086406 + x * (2124.5078131730142589143026171171421501216537464281 + x * (-9249.5149832932833413576281131877481953564417926825))))) 8.5528470722950260676497166948847420122086300163362e-50 2.7369110631344083416479093423631174439067616052276e-48 2.4632199568209675074831184081268056995160854447048e-47 1.42319375282989233765691285802882107083151603471834e-46 7.8823038618270960239459789060057782384514734230554e-46 4.5542200090556554805021211456922274266608513110987e-45 =============== Check TMandAD #26 ================ -0.60205999132796239042747778944898605353637976292422 + x * (1.73717792761300731060451567566642032917758802321466 + x * (-3.4743558552260146212090313513328406583551760464293 + x * (9.264948947269372323224083603554241755613802790478 + x * (-27.794846841808116969672250810662725266841408371435 + x * (88.94350989378597430295120259412072085389250678859 + x * (-296.4783663126199143431706753137357361796416892953)))))) -0.6020599913279623904274777894489860535363797629242 + x * (1.73717792761300731060451567566642032917758802321464 + x * (-3.4743558552260146212090313513328406583551760464293 + x * (9.264948947269372323224083603554241755613802790478 + x * (-27.794846841808116969672250810662725266841408371434 + x * (88.943509893785974302951202594120720853892506788593 + x * (-296.4783663126199143431706753137357361796416892953)))))) 6.4146353042212695507372875211635565091564725122521e-50 1.28292706084425391014745750423271130183129450245042e-49 2.56585412168850782029491500846542260366258900490085e-49 1.02634164867540312811796600338616904146503560196034e-48 2.0526832973508062562359320067723380829300712039207e-48 8.2107331894032250249437280270893523317202848156827e-48 3.2842932757612900099774912108357409326881139262731e-47 =============== Check TMandAD #27 ================ 1.34326430385873056014310389898861767258244040976294e-2 + x * (0.106366823597056298216684653692285123525800495555305 + x * (0.204121630871864757107406229196483796645321231999896 + x * (-3.3328797867200517081164117107260935048397754154428e-2 + x * (-2.78981383671087012958483753427251587860148734683375e-2 + x * 1.21319793593807922791079599791785115619415593852275e-2)))) 1.34326430385873056014310389898861767258244040976292e-2 + x * (0.106366823597056298216684653692285123525800495555305 + x * (0.204121630871864757107406229196483796645321231999894 + x * (-3.3328797867200517081164117107260935048397754154429e-2 + x * (-2.78981383671087012958483753427251587860148734683375e-2 + x * 1.2131979359380792279107959979178511561941559385227e-2)))) 1.90434485594068939787513223284543083865582777707485e-50 2.13821176807375651691242917372118550305215750408404e-50 4.810976478165952163052965640872667381867354384189e-50 2.2718500035783662992194559970787595969929173480893e-50 3.3409558876152445576756705839393523485189961001313e-50 2.4054882390829760815264828204363336909336771920945e-50 =============== Check TMandAD #28 ================ 1.18677923532779447482948204950173429839841579022164 + x * (-1.11022517209862603231454193262050515607809250158065 + x * (4.0111739086238187622581129639036020498587484745605 + x * (-13.6424990522976935865675263439036804673290898474723 + x * (47.828306839380430375772566444070370272662403043039 + x * (-171.671033042173578484980410941355563340250752831606 + x * 626.7025015533512511550808022500122208761610158462))))) 1.18677923532779447482948204950173429839841579022164 + x * (-1.11022517209862603231454193262050515607809250158063 + x * (4.0111739086238187622581129639036020498587484745604 + x * (-13.642499052297693586567526343903680467329089847473 + x * (47.828306839380430375772566444070370272662403043039 + x * (-171.67103304217357848498041094135556334025075283161 + x * 626.70250155335125115508080225001222087616101584619))))) 8.5528470722950260676497166948847420122086300163362e-50 1.71056941445900521352994333897694840244172600326723e-49 1.02634164867540312811796600338616904146503560196034e-48 3.7632527118098114697658753457492864853717972071879e-48 1.64214663788064500498874560541787046634405696313654e-47 6.5685865515225800199549824216714818653762278525462e-47 3.0653403907105373426456584634466915371755729978549e-46 =============== Check TMandAD #29 ================ 0.141120008059867222100744802808110279846933264252264 + x * (-0.9899924966004454572715727947312613023936790966156 + x * (-7.0560004029933611050372401404055139923466632126132e-2 + x * (0.16499874943340757621192879912187688373227984943593 + x * (5.8800003358278009208643667836712616602888860105112e-3 + x * (-8.2499374716703788105964399560938441866139924717966e-3))))) 0.14112000805986722210074480280811027984693326425226 + x * (-0.98999249660044545727157279473126130239367909661559 + x * (-7.056000402993361105037240140405513992346663212613e-2 + x * (0.164998749433407576211928799121876883732279849435935 + x * (5.880000335827800920864366783671261660288886010511e-3 + x * (-8.2499374716703788105964399560938441866139924717966e-3))))) 5.3455294201843912922810729343029637576303937602101e-51 2.13821176807375651691242917372118550305215750408404e-50 2.67276471009219564614053646715148187881519688010505e-51 5.3455294201843912922810729343029637576303937602101e-51 3.3409558876152445576756705839393523485189961001313e-52 6.6819117752304891153513411678787046970379922002626e-52 =============== Check TMandAD #30 ================ -0.59950622676939746550101197688795673414269419043562 + x * (-8.0180074766486466932862656675879563168688526709273 + x * (26.0536406377805126082053193696164887997172858643804 + x * (163.007361479269715308184931649392039087533031555873 + x * (-32.130517630528138816477880458288278420841750190907 + x * (-1002.4953316113895146332309511903863579025149950103 + x * (-1294.1553878811333746069842556598433398071249333166)))))) -0.59950622676939746550101197688795673414269419043562 + x * (-8.0180074766486466932862656675879563168688526709275 + x * (26.053640637780512608205319369616488799717285864381 + x * (163.00736147926971530818493164939203908753303155587 + x * (-32.130517630528138816477880458288278420841750190907 + x * (-1002.49533161138951463323095119038635790251499501033 + x * (-1294.15538788113337460698425565984333980712493331657)))))) 2.99349647530325912367740084320965970427302050571765e-49 3.079024946026209384353898010158507124395106805881e-48 2.12110607392916646477712974033141601902774024405137e-47 9.3054976146569883616028917640345993092829894577737e-47 3.1200786119732255094786166502939538860537082299594e-46 9.8528798272838700299324736325072227980643417788193e-46 2.62743462060903200798199296866859274615049114101847e-45 =============== Check TMandAD #31 ================ 1.44269242706926427999198473638621746662403122467097 + x * (-0.43274497836044127077333958151233827102056413171055 + x * (-0.34786108286010429061867176462735410778168634399805 + x * (0.33259213826917641590468925464078768455764336120443 + x * (0.107729256976942715059497263942816220929603612631536 + x * (-0.102555740676947391942303344600548144160354881545386))))) 1.44269242706926427999198473638621746662403122467097 + x * (-0.43274497836044127077333958151233827102056413171055 + x * (-0.34786108286010429061867176462735410778168634399805 + x * (0.33259213826917641590468925464078768455764336120443 + x * (0.10772925697694271505949726394281622092960361263154 + x * (-0.102555740676947391942303344600548144160354881545386))))) 8.5528470722950260676497166948847420122086300163362e-50 6.4146353042212695507372875211635565091564725122521e-50 7.4837411882581478091935021080241492606825512642941e-50 8.5528470722950260676497166948847420122086300163362e-50 5.6128058911936108568951265810181119455119134482206e-50 4.0091470651382934692108047007272228182227953201576e-50 =============== Check TMandAD #32 ================ -0.41614683654714238699756822950076218976600077107554 + x * (-0.90929742682568169539601986591174484270225497144789 + x * (0.20807341827357119349878411475038109488300038553777 + x * (0.151549571137613615899336644318624140450375828574645 + x * (-1.7339451522797599458232009562531757906916698794815e-2 + x * (-7.5774785568806807949668322159312070225187914287324e-3 + x * 5.779817174265866486077336520843919302305566264938e-4))))) -0.41614683654714238699756822950076218976600077107554 + x * (-0.9092974268256816953960198659117448427022549714479 + x * (0.20807341827357119349878411475038109488300038553777 + x * (0.15154957113761361589933664431862414045037582857465 + x * (-1.7339451522797599458232009562531757906916698794814e-2 + x * (-7.5774785568806807949668322159312070225187914287324e-3 + x * 5.7798171742658664860773365208439193023055662649381e-4))))) 1.06910588403687825845621458686059275152607875204202e-50 2.13821176807375651691242917372118550305215750408404e-50 5.3455294201843912922810729343029637576303937602101e-51 5.3455294201843912922810729343029637576303937602101e-51 6.6819117752304891153513411678787046970379922002626e-52 3.3409558876152445576756705839393523485189961001313e-52 4.1761948595190556970945882299241904356487451251641e-53 =============== Check TMandAD #33 ================ 0.41329211610159433662662839427669756498559068708353 + x * (-0.289852504643497986837775895936002661484621751429506 + x * (2.5193835684849239060880452335760520344511359118788e-2 + x * (1.76995264801432186309815111928697257094710962948592e-3 + x * (-1.7678539707916272747348366428442524884169104747206e-3 + x * 6.9814870608129282066768327982890102940468253118344e-4)))) 0.41329211610159433662662839427669756498559068708354 + x * (-0.2898525046434979868377758959360026614846217514295 + x * (2.5193835684849239060880452335760520344511359118788e-2 + x * (1.76995264801432186309815111928697257094710962948617e-3 + x * (-1.76785397079162727473483664284425248841691047472053e-3 + x * 6.981487060812928206676832798289010294046825311834e-4)))) 5.3455294201843912922810729343029637576303937602101e-50 3.2073176521106347753686437605817782545782362561261e-50 1.0022867662845733673027011751818057045556988300394e-50 4.8443860370421046086297223467120609053525443451904e-51 1.46166820083166949398310588047346665247706079380745e-51 5.8466728033266779759324235218938666099082431752298e-52 =============== Check TMandAD #34 ================ x^2 * (-0.5 + x^2 * (-8.3333333333333333333333333333333333333333333333332e-2 + x^2 * (-2.22222222222222222222222222222222222222222222222235e-2))) x^2 * (-0.5 + x^2 * (-8.3333333333333333333333333333333333333333333333335e-2 + x^2 * (-2.2222222222222222222222222222222222222222222222222e-2))) 0 0 0 0 2.67276471009219564614053646715148187881519688010505e-51 0 2.67276471009219564614053646715148187881519688010505e-51 =============== Check TMandAD #35 ================ 1.7047283998088857188013588874614148024297029254576e-50 + x * (1.00000000000000000000000000000000000000000000000001 + x * (1.7047283998088857188013588874614148024297029254577e-50 + x * (0.33333333333333333333333333333333333333333333333334 + x * (1.13648559987259047920090592497427653495313528363844e-50 + x * 0.133333333333333333333333333333333333333333333333333)))) 1.7047283998088857188013588874614148024297029254576e-50 + x * (1 + x * (1.7047283998088857188013588874614148024297029254577e-50 + x * (0.33333333333333333333333333333333333333333333333334 + x * (1.13648559987259047920090592497427653495313528363844e-50 + x * 0.133333333333333333333333333333333333333333333333333)))) 8.5528470722950260676497166948847420122086300163365e-50 6.4146353042212695507372875211635565091564725122521e-50 8.552847072295026067649716694884742012208630016337e-50 3.2073176521106347753686437605817782545782362561261e-50 5.7018980481966840450998111299231613414724200108913e-50 2.13821176807375651691242917372118550305215750408404e-50 =============== Check TMandAD #36 ================ 0.57735026918962576450914878050195745564760175127013 + x * (1.53960071783900203869106341467188654839360467005367 + x * (1.53960071783900203869106341467188654839360467005365 + x * (2.7370679428248925132285571816389094193664083023176 + x * (4.5617799047081541887142619693981823656106805038627 + x * (8.2112038284746775396856715449167282580992249069524 + x * 14.9018143553799703497999224333673957276615563126172))))) 0.57735026918962576450914878050195745564760175127013 + x * (1.53960071783900203869106341467188654839360467005367 + x * (1.53960071783900203869106341467188654839360467005362 + x * (2.73706794282489251322855718163890941936640830231765 + x * (4.5617799047081541887142619693981823656106805038626 + x * (8.2112038284746775396856715449167282580992249069524 + x * 14.9018143553799703497999224333673957276615563126172))))) 4.2764235361475130338248583474423710061043150081681e-50 2.56585412168850782029491500846542260366258900490085e-49 4.7040658897622643372073441821866081067147465089849e-49 1.1118701193983533887944631703350164615871219021237e-48 2.7369110631344083416479093423631174439067616052276e-48 5.8159360091606177260018073525216245683018684111086e-48 1.26582136669966385801215807084294181780687724241775e-47 =============== Check TMandAD #37 ================ 0.100503784955021086531450941583993587977239312854616 + x * (1.01518995437301806013398253159583195750750861520895 + x * (0.153823971437731178405746208286913410613101545222288 + x * (0.5387419961868695367452840270205364586392731407465 + x * (0.20008154793606619984157582042743162671980725858031 + x * 0.4524584738820214985205839746786770308797206435682)))) 0.100503784955021086531450941583993587977239312854616 + x * (1.01518995437301806013398253159583195750750861520893 + x * (0.153823971437731178405746208286913410613101545222285 + x * (0.53874199618686953674528402702053645863927314074653 + x * (0.20008154793606619984157582042743162671980725858031 + x * 0.4524584738820214985205839746786770308797206435682)))) 5.3455294201843912922810729343029637576303937602101e-51 1.28292706084425391014745750423271130183129450245042e-49 3.7418705941290739045967510540120746303412756321471e-50 1.49674823765162956183870042160482985213651025285883e-49 9.087400014313465196877823988315038387971669392357e-50 2.56585412168850782029491500846542260366258900490085e-49 =============== Check TMandAD #38 ================ x * (1 + x^2 * (0.16666666666666666666666666666666666666666666666667 + x^2 * 7.5e-2)) x * (1 + x^2 * (0.16666666666666666666666666666666666666666666666667 + x^2 * 7.5e-2)) 0 0 0 5.3455294201843912922810729343029637576303937602101e-51 0 5.3455294201843912922810729343029637576303937602101e-51 0 =============== Check TMandAD #39 ================ 1.3694384060045658277761961394221280318585466182853 + x * (-1.0206207261596575409155350311274547466524781169403 + x * (-0.106314658974964327178701565742443202776299803847949 + x * (-0.1993399855780581134600654357670810052055621322149 + x * (-8.8826266721704136206163417558247901625163681600393e-2 + x * (-0.11934827936687844707787000313697485916411332327585))))) 1.36943840600456582777619613942212803185854661828533 + x * (-1.0206207261596575409155350311274547466524781169403 + x * (-0.106314658974964327178701565742443202776299803847949 + x * (-0.199339985578058113460065435767081005205562132214905 + x * (-8.882626672170413620616341755824790162516368160039e-2 + x * (-0.11934827936687844707787000313697485916411332327585))))) 4.2764235361475130338248583474423710061043150081681e-50 8.5528470722950260676497166948847420122086300163362e-50 1.60365882605531738768432188029088912728911812806303e-50 6.9491882462397086799653948145938528849195118882731e-50 4.5437000071567325984389119941575191939858346961786e-50 7.2164647172489282445794484613090010728010315762836e-50 =============== Check TMandAD #40 ================ 1.52098866714976960099053821539057889864221386133446 + x * (-4.9848888220747567105670772745510450750000046412323e-2 + x * (-2.49863791520840227433547016862102185842844050963185e-2 + x * (-8.3908819955120263672843403531174105161540138762695e-3 + x * (-2.14448006441944295456840909376307467781121211348955e-3 + x * (-4.5714528006257403733250621911281868581674905370033e-4 + x * (-9.047757205837852771515992410481425342170280661914e-5)))))) 1.52098866714976960099053821539057889864221386133444 + x * (-4.9848888220747567105670772745510450750000046412323e-2 + x * (-2.49863791520840227433547016862102185842844050963185e-2 + x * (-8.3908819955120263672843403531174105161540138762698e-3 + x * (-2.1444800644194429545684090937630746778112121134896e-3 + x * (-4.5714528006257403733250621911281868581674905370032e-4 + x * (-9.047757205837852771515992410481425342170280661914e-5)))))) 4.2764235361475130338248583474423710061043150081681e-50 6.6819117752304891153513411678787046970379922002626e-51 4.0091470651382934692108047007272228182227953201576e-51 2.0045735325691467346054023503636114091113976600788e-51 5.8466728033266779759324235218938666099082431752298e-52 1.14845358636774031670101176322915236980340490942014e-52 4.1761948595190556970945882299241904356487451251641e-53 =============== Check TMandAD #41 ================ 2.84965390822636149747412731985290439396400610278115 + x * (-3.29049690202351784878367544956425560214850822442744 + x * (0.80293697147640171538819306338051772859316799371155 + x * (-0.9271517532484067892006159353304351152261138817156 + x * (-0.32655036577567137134040602200840830235889046047874 + x * (-0.92288151022289780605145624409480449235237368425713))))) 2.84965390822636149747412731985290439396400610278115 + x * (-3.2904969020235178487836754495642556021485082244274 + x * (0.80293697147640171538819306338051772859316799371157 + x * (-0.92715175324840678920061593533043511522611388171557 + x * (-0.3265503657756713713404060220084083023588904604788 + x * (-0.92288151022289780605145624409480449235237368425711))))) 1.71056941445900521352994333897694840244172600326723e-49 4.2764235361475130338248583474423710061043150081681e-49 5.5593505969917669439723158516750823079356095106185e-49 1.09048800171761582362533887859780460655660032708286e-48 1.9564637677874872129748726939548847352927241162369e-48 3.5708136526831733832437567201143797900971030318203e-48 =============== Check TMandAD #42 ================ 0.46364760900080611621425623146121440202853705428612 + x * (0.8 + x * (-0.32 + x * (-4.2666666666666666666666666666666666666666666666667e-2 + x * (0.1536 + x * (-7.7824000000000000000000000000000000000000000000004e-2 + x * (-3.0037333333333333333333333333333333333333333333334e-2)))))) 0.46364760900080611621425623146121440202853705428611 + x * (0.8 + x * (-0.32 + x * (-4.2666666666666666666666666666666666666666666666668e-2 + x * (0.1536 + x * (-7.7824000000000000000000000000000000000000000000004e-2 + x * (-3.00373333333333333333333333333333333333333333333336e-2)))))) 1.06910588403687825845621458686059275152607875204202e-50 2.13821176807375651691242917372118550305215750408404e-50 1.06910588403687825845621458686059275152607875204202e-50 6.6819117752304891153513411678787046970379922002626e-51 2.13821176807375651691242917372118550305215750408404e-50 2.94004118110141521075459011386663006669671656811555e-50 4.8777955959182570542064790525514544288377343061917e-50 =============== Check TMandAD #43 ================ 1.48442222974533236696109679396603853862170792666087 + x * (8.6266738334054414696554046331336803913919401857361e-2 + x * (-4.29725712544302754529199840636843911167560283397665e-2 + x * (1.4163792133787842505279899380187624407483183694156e-2 + x * (-3.421147738144242364818267548806913069979232027542e-3 + x * 6.1284622747066114202431065830814767195406303041028e-4)))) 1.4844222297453323669610967939660385386217079266609 + x * (8.6266738334054414696554046331336803913919401857361e-2 + x * (-4.2972571254430275452919984063684391116756028339765e-2 + x * (1.41637921337878425052798993801876244074831836941546e-2 + x * (-3.421147738144242364818267548806913069979232027542e-3 + x * 6.1284622747066114202431065830814767195406303040816e-4)))) 4.2764235361475130338248583474423710061043150081681e-50 3.7418705941290739045967510540120746303412756321471e-50 1.13592500178918314960972799853937979849645867404465e-49 2.4322158861838980379878881851078485097218291608956e-49 4.8109764781659521630529656408726673818673543841891e-49 8.6597576606987138934953381535708012873612378915404e-49 =============== Check TMandAD #44 ================ 1.62589303788256247683376349645246030442163951007557 + x * (0.17560922554268377331604520902733786882311070790268 + x * (-4.3874811367606267169993214778226641227730244525566e-2 + x * (1.04445079906022737580279106872687043714346772770025e-2 + x * (-2.3347171259343082973640714314785292620201215411443e-3 + x * (4.7656391409687518023030583049678934579133735636422e-4 + x * (-8.323453463155915433870147582928577968637858535531e-5)))))) 1.62589303788256247683376349645246030442163951007555 + x * (0.17560922554268377331604520902733786882311070790268 + x * (-4.3874811367606267169993214778226641227730244525566e-2 + x * (1.04445079906022737580279106872687043714346772770028e-2 + x * (-2.3347171259343082973640714314785292620201215411444e-3 + x * (4.7656391409687518023030583049678934579133735636424e-4 + x * (-8.3234534631559154338701475829285779686378585355314e-5)))))) 1.28292706084425391014745750423271130183129450245042e-49 4.2764235361475130338248583474423710061043150081681e-50 2.13821176807375651691242917372118550305215750408404e-50 1.06910588403687825845621458686059275152607875204202e-50 4.7608621398517234946878305821135770966395694426871e-51 1.5973945337660388041386799979460028416356450103753e-51 6.3164947250225717418555646977603380339187270018108e-52 =============== Check TMandAD #45 ================ 0.304520293447142618958435267005095229098024232680175 + x * (1.04533851412886048502530904632291210128027546467917 + x * (0.152260146723571309479217633502547614549012116340088 + x * (0.174223085688143414170884841053818683546712577446536 + x * (1.2688345560297609123268136125212301212417676361674e-2 + x * 8.7111542844071707085442420526909341773356288723263e-3)))) 0.30452029344714261895843526700509522909802423268017 + x * (1.0453385141288604850253090463229121012802754646792 + x * (0.152260146723571309479217633502547614549012116340085 + x * (0.17422308568814341417088484105381868354671257744653 + x * (1.2688345560297609123268136125212301212417676361674e-2 + x * 8.7111542844071707085442420526909341773356288723267e-3)))) 1.06910588403687825845621458686059275152607875204202e-50 4.2764235361475130338248583474423710061043150081681e-50 5.3455294201843912922810729343029637576303937602101e-51 1.06910588403687825845621458686059275152607875204202e-50 6.6819117752304891153513411678787046970379922002626e-52 1.0022867662845733673027011751818057045556988300394e-51 =============== Check TMandAD #46 ================ 1.04533851412886048502530904632291210128027546467917 + x * (0.304520293447142618958435267005095229098024232680175 + x * (0.52266925706443024251265452316145605064013773233959 + x * (5.0753382241190436493072544500849204849670705446696e-2 + x * (4.3555771422035853542721210263454670886678144361634e-2 + x * (2.5376691120595218246536272250424602424835352723348e-3 + x * 1.4518590474011951180907070087818223628892714787211e-3))))) 1.0453385141288604850253090463229121012802754646792 + x * (0.30452029344714261895843526700509522909802423268017 + x * (0.5226692570644302425126545231614560506401377323396 + x * (5.0753382241190436493072544500849204849670705446696e-2 + x * (4.3555771422035853542721210263454670886678144361633e-2 + x * (2.5376691120595218246536272250424602424835352723348e-3 + x * 1.4518590474011951180907070087818223628892714787211e-3))))) 4.2764235361475130338248583474423710061043150081681e-50 1.06910588403687825845621458686059275152607875204202e-50 2.13821176807375651691242917372118550305215750408404e-50 2.67276471009219564614053646715148187881519688010505e-51 2.67276471009219564614053646715148187881519688010505e-51 2.5057169157114334182567529379545142613892470750985e-52 1.25285845785571670912837646897725713069462353754924e-52 =============== Check TMandAD #47 ================ 9.9834078899207563327303124704769443267712911708825e-2 + x * (0.99503719020998913566527375373857189969752707624023 + x * (-4.9259266842078670082439294739533262361263716645557e-2 + x * (-0.159320401007383157362344913679018472323559215553286 + x * (3.5975055188068433694164566788503362865544033821134e-2 + x * 6.5997695769299841679081358222938457172698497291104e-2)))) 9.9834078899207563327303124704769443267712911708827e-2 + x * (0.99503719020998913566527375373857189969752707624025 + x * (-4.9259266842078670082439294739533262361263716645557e-2 + x * (-0.159320401007383157362344913679018472323559215553286 + x * (3.5975055188068433694164566788503362865544033821133e-2 + x * 6.5997695769299841679081358222938457172698497291107e-2)))) 2.67276471009219564614053646715148187881519688010505e-51 6.4146353042212695507372875211635565091564725122521e-50 1.06910588403687825845621458686059275152607875204202e-50 5.3455294201843912922810729343029637576303937602101e-50 1.7372970615599271699913487036484632212298779720683e-50 4.2764235361475130338248583474423710061043150081681e-50 =============== Check TMandAD #48 ================ 2.69769495687543017236521208641087484873616570062596 + x * (0.99096608924720952934247899912381945790207634518843 + x * (8.9118620732565360085557071132096303853149233120465e-3 + x * (-5.78095075976823137145862839378829504980387238624e-3 + x * (2.7337885334681867579188646695842232383494646965468e-3 + x * (-9.7239972185858950457545518693553416869375448387511e-4 + x * 2.4750468601781364094822440227453328770413098811069e-4))))) 2.697694956875430172365212086410874848736165700626 + x * (0.99096608924720952934247899912381945790207634518843 + x * (8.911862073256536008555707113209630385314923312052e-3 + x * (-5.7809507597682313714586283937882950498038723862328e-3 + x * (2.7337885334681867579188646695842232383494646965541e-3 + x * (-9.72399721858589504575455186935534168693754483876e-4 + x * 2.4750468601781364094822440227453328770413098811714e-4))))) 8.5528470722950260676497166948847420122086300163362e-50 1.28292706084425391014745750423271130183129450245042e-49 2.13821176807375651691242917372118550305215750408404e-49 3.741870594129073904596751054012074630341275632147e-49 6.36118001001942563781447679182052687158016857465e-49 1.03168717809558751941024707632047200522266599572055e-48 1.65711412025716130060713260963391876486542206566513e-48 =============== Check TMandAD #49 ================ 1.10498756211208902702192649127595761869450234700266 + x * (1.09950371902099891356652737537385718996975270762403 + x * (0.49259266842078670082439294739533262361263716645556 + x * (-4.8771551328790762457860687860924022139865065985705e-2 + x * (-0.115892795236730524652342228580413517956115008282852 + x * 3.5379813727384731123239789253096536009705076786015e-2)))) 1.10498756211208902702192649127595761869450234700264 + x * (1.09950371902099891356652737537385718996975270762403 + x * (0.49259266842078670082439294739533262361263716645557 + x * (-4.8771551328790762457860687860924022139865065985703e-2 + x * (-0.115892795236730524652342228580413517956115008282855 + x * 3.5379813727384731123239789253096536009705076786014e-2)))) 4.2764235361475130338248583474423710061043150081681e-50 1.71056941445900521352994333897694840244172600326723e-49 1.49674823765162956183870042160482985213651025285883e-49 1.55020353185347347476151115094785948971281419046093e-49 1.65711412025716130060713260963391876486542206566513e-49 1.5902950025048564094536191979551317178950421436625e-49 =============== Check TMandAD #50 ================ 1.7627471740390860504652186499595846180563206565233 + x * (0.35355339059327376220042218105242451964241796884424 + x * (-6.6291260736238830412579158947329597432953369158292e-2 + x * (1.7493527138729691358875055833323088211473805750105e-2 + x * (-5.437954982269591557281884132398131039421956063766e-3 + x * (1.87091546413799042863626727888459508380112536003385e-3 + x * (-6.8985961642631351228910806887937599867666927743457e-4)))))) 1.7627471740390860504652186499595846180563206565233 + x * (0.35355339059327376220042218105242451964241796884424 + x * (-6.6291260736238830412579158947329597432953369158292e-2 + x * (1.7493527138729691358875055833323088211473805750105e-2 + x * (-5.437954982269591557281884132398131039421956063766e-3 + x * (1.8709154641379904286362672788845950838011253600338e-3 + x * (-6.898596164263135122891080688793759986766692774346e-4)))))) 4.2764235361475130338248583474423710061043150081681e-50 2.13821176807375651691242917372118550305215750408404e-50 1.06910588403687825845621458686059275152607875204202e-50 5.3455294201843912922810729343029637576303937602101e-51 2.8398125044729578740243199963484494962411466851116e-51 1.4199062522364789370121599981742247481205733425558e-51 9.187628690941922533608094105833218958427239275361e-52 =============== Check TMandAD #51 ================ 0.64760547517221496235923109008076500790093843586699 + x * (0.76572040123542134701987058356640843219962203531773 + x * (-1.16484840644761053339622917137963105107378233141993 + x * (2.116923473804014600868989052001282674160404236185 + x * (-4.3620398440940958922766694790174106887746100918414 + x * 9.8862216459728023352220696577137372044653193691336)))) 0.64760547517221496235923109008076500790093843586699 + x * (0.76572040123542134701987058356640843219962203531773 + x * (-1.16484840644761053339622917137963105107378233141998 + x * (2.116923473804014600868989052001282674160404236185 + x * (-4.3620398440940958922766694790174106887746100918414 + x * 9.8862216459728023352220696577137372044653193691333)))) 4.2764235361475130338248583474423710061043150081681e-50 1.28292706084425391014745750423271130183129450245042e-49 3.8487811825327617304423725126981339054938835073513e-49 1.28292706084425391014745750423271130183129450245042e-48 4.1053665947016125124718640135446761658601424078414e-48 1.26582136669966385801215807084294181780687724241775e-47 =============== Check TMandAD #52 ================ 0.93613899863153495339519960002913413923379099020642 + x * (9.1761758178050451941464556325698903901268886984557e-3 + x * (-9.6593424565485053928587795552616545060153741749607e-4 + x * (1.01609959179480051433920143119531807541319308319753e-4 + x * (-1.0684290891856436579115356217125009387440111910691e-5 + x * (1.12329518241955280120919388707574953579999387511887e-6 + x * (-1.181134414476100260185196398027604181756630975456e-7)))))) 0.9361389986315349533951996000291341392337909902064 + x * (9.1761758178050451941464556325698903901268886984555e-3 + x * (-9.6593424565485053928587795552616545060153741749606e-4 + x * (1.01609959179480051433920143119531807541319308319753e-4 + x * (-1.0684290891856436579115356217125009387440111910691e-5 + x * (1.12329518241955280120919388707574953579999387511895e-6 + x * (-1.18113441447610026018519639802760418175663097545604e-7)))))) 6.4146353042212695507372875211635565091564725122521e-50 2.3386691213306711903729694087575466439632972700919e-51 2.7145266586873862031114823494507237831716843313567e-52 3.6541705020791737349577647011836666311926519845186e-53 4.8939783509988933950327205819424106667758731935517e-54 6.9331359972484323096296874910850817779324870241983e-55 7.9017358792169632940632467729278505557318785937554e-56 =============== Check TMandAD #53 ================ 0.54930614433405484569762261846126285232374527891137 + x * (1.33333333333333333333333333333333333333333333333334 + x * (0.8888888888888888888888888888888888888888888888889 + x * (1.38271604938271604938271604938271604938271604938274 + x * (1.9753086419753086419753086419753086419753086419753 + x * 3.2131687242798353909465020576131687242798353909465)))) 0.54930614433405484569762261846126285232374527891139 + x * (1.33333333333333333333333333333333333333333333333336 + x * (0.8888888888888888888888888888888888888888888888889 + x * (1.3827160493827160493827160493827160493827160493827 + x * (1.9753086419753086419753086419753086419753086419753 + x * 3.2131687242798353909465020576131687242798353909465)))) 2.13821176807375651691242917372118550305215750408404e-50 4.2764235361475130338248583474423710061043150081681e-50 2.13821176807375651691242917372118550305215750408404e-50 8.5528470722950260676497166948847420122086300163362e-50 1.71056941445900521352994333897694840244172600326723e-49 4.2764235361475130338248583474423710061043150081681e-49 =============== Check TMandAD #54 ================ 0.91334577306419501621513183444466219040496595317348 + x * (-3.1651657299278086331415098750335133304179358762914 + x * (4.5275505974602233918317666131222514097673741328981 + x * (-20.577385815114918679314575470832625770326885196463 + x * (58.154243690550404412584512678204613261367923312413 + x * (-265.15580414889194012839459620234499044694423825286 + x * 923.77244777741208854348057718018113116907975707604))))) 0.91334577306419501621513183444466219040496595317348 + x * (-3.1651657299278086331415098750335133304179358762914 + x * (4.5275505974602233918317666131222514097673741328981 + x * (-20.577385815114918679314575470832625770326885196462 + x * (58.154243690550404412584512678204613261367923312412 + x * (-265.15580414889194012839459620234499044694423825286 + x * 923.77244777741208854348057718018113116907975707593))))) 8.5528470722950260676497166948847420122086300163362e-50 7.6975623650655234608847450253962678109877670147025e-49 4.7895943604852145978838413491354555268368328091482e-48 3.2842932757612900099774912108357409326881139262731e-47 2.285320737717230965276004300873203065662145940365e-46 1.5107749068501934045896459569844408290365324060856e-45 1.04659479054259774984616053251965611054994563783902e-44 =============== Check TMandAD #55 ================ 1.56079582675072527146076965435799855861577366412268 + x * (-1.00015002208661021573279396365965778159996742142558 + x * (-1.50044176497807451183947500020749804526434363661693e-2 + x * (-0.50044183053217637990372358191044051447945609922692 + x * (-2.20997221881349062871885715755981113574916728520673e-2 + x * (-0.44265027445974606502221823845969960359017085863432))))) 1.5607958267507252714607696543579985586157736641227 + x * (-1.0001500220866102157327939636596577815999674214256 + x * (-1.5004417649780745118394750002074980452643436366169e-2 + x * (-0.50044183053217637990372358191044051447945609922694 + x * (-2.20997221881349062871885715755981113574916728520673e-2 + x * (-0.44265027445974606502221823845969960359017085863433))))) 4.2764235361475130338248583474423710061043150081681e-50 2.13821176807375651691242917372118550305215750408404e-49 4.3432426538998179249783717591211580530746949301707e-51 2.13821176807375651691242917372118550305215750408404e-49 1.2695632372937929319167548218969538924372185180499e-50 3.10040706370694694952302230189571897942562838092186e-49 =============== Check TMandAD #56 ================ 0.99532226501895273416206925636725292861089179704006 + x * (2.06669853540920538570689413065854757693296031819814e-2 + x * (-4.1333970708184107714137882613170951538659206363963e-2 + x * (4.822296582621479233316086304869944346176907409129e-2 + x * (-3.4444975590153423095114902177642459615549338636636e-2 + x * (1.30890907242583007761436628275041346539087486819212e-2 + x * 4.592663412020456412681986957018994615406578484882e-4))))) 0.99532226501895273416206925636725292861089179704005 + x * (2.0666985354092053857068941306585475769329603181981e-2 + x * (-4.1333970708184107714137882613170951538659206363962e-2 + x * (4.822296582621479233316086304869944346176907409129e-2 + x * (-3.4444975590153423095114902177642459615549338636636e-2 + x * (1.30890907242583007761436628275041346539087486819216e-2 + x * 4.5926634120204564126819869570189946154065784848818e-4))))) 2.13821176807375651691242917372118550305215750408404e-50 2.0045735325691467346054023503636114091113976600788e-51 4.0091470651382934692108047007272228182227953201576e-51 8.0182941302765869384216094014544456364455906403151e-51 8.0182941302765869384216094014544456364455906403151e-51 9.3546764853226847614918776350301865758531890803677e-51 9.8244984070185785274150188108966579998636729069486e-51 =============== Check TMandAD #57 ================ 0.92583993718302973069137620151043602364569656151431 + x * (2.108031408030347559583866293928349317683733350119e-2 + x * (-8.5414643937552371524216041110099271709928800381777e-3 + x * (3.2471246963440128570720038731339952890470307048872e-3 + x * (-1.17074890190460706099099427214629269302024500755867e-3 + x * 4.0269551590099414195067387538482153497778060603368e-4)))) 0.9258399371830297306913762015104360236456965615143 + x * (2.108031408030347559583866293928349317683733350119e-2 + x * (-8.541464393755237152421604111009927170992880038178e-3 + x * (3.2471246963440128570720038731339952890470307048872e-3 + x * (-1.17074890190460706099099427214629269302024500755867e-3 + x * 4.0269551590099414195067387538482153497778060603367e-4)))) 2.13821176807375651691242917372118550305215750408404e-50 8.0182941302765869384216094014544456364455906403151e-51 4.3432426538998179249783717591211580530746949301707e-51 2.4221930185210523043148611733560304526762721725952e-51 1.2110965092605261521574305866780152263381360862976e-51 4.9070289599348904440861411701609237618872755220679e-52 =============== Check TMandAD #58 ================ 0.88136731062232811672817828835243689591968513469742 + x * (4.1269314863386784162878275234127051442013759926163e-5 + x * (-1.2965197854752955251211435945474330272229722619309e-4 + x * (2.5778855290049596786852672613902652731853139745896e-4 + x * (-3.6172370916076718418352506076614453318842500712624e-4 + x * (3.7723725515684155510295569806250359199108587266678e-4 + x * (-2.9861772627022998371632329812301073162592357308278e-4)))))) 0.8813673106223281167281782883524368959196851346974 + x * (4.1269314863386784162878275234127051442013759926163e-5 + x * (-1.2965197854752955251211435945474330272229722619309e-4 + x * (2.5778855290049596786852672613902652731853139745896e-4 + x * (-3.6172370916076718418352506076614453318842500712623e-4 + x * (3.7723725515684155510295569806250359199108587266676e-4 + x * (-2.9861772627022998371632329812301073162592357308277e-4)))))) 2.13821176807375651691242917372118550305215750408404e-50 5.0897374850388491308340294052201070934469081212938e-53 1.77488281529559867126519999771778093515071667819476e-52 3.8629802450551265198124941126798761529750892407768e-52 5.7422679318387015835050588161457618490170245471007e-52 6.99512638969441829263343528512301897971164808465e-52 6.4731020322545363304966117563824951752555549440044e-52 =============== Check TMandAD #59 ================ 3.75454095426690505486765510480870332902748833046595e-2 + x * (0.13042695085322747736169199260190180921349387237934 + x * (0.199363165289835974351379028335464284533185880367248 + x * (0.18813369961172968654229465796608813883974244532509 + x * (0.137585298381499688156392138419420577517129938379786 + x * 9.635664545273223254677869066450756393450432904721e-2)))) 3.754540954266905054867655104808703329027488330466e-2 + x * (0.13042695085322747736169199260190180921349387237934 + x * (0.19936316528983597435137902833546428453318588036725 + x * (0.188133699611729686542294657966088138839742445325087 + x * (0.137585298381499688156392138419420577517129938379797 + x * 9.6356645452732232546778690664507563934504329047206e-2)))) 6.6819117752304891153513411678787046970379922002626e-51 4.810976478165952163052965640872667381867354384189e-50 9.087400014313465196877823988315038387971669392357e-50 1.49674823765162956183870042160482985213651025285883e-49 1.44329294344978564891588969226180021456020631525673e-49 1.7372970615599271699913487036484632212298779720683e-49 =============== Check TMandAD #60 ================ 1.22096442861113072425856507872909589412676845277933 + x * (-0.26819970807422208503884867010315029968619556375251 + x * (-0.31101896753052164898541483442053517706036858200279 + x * (-0.185495670746673659727113886224299253680191076597567 + x * (-6.1184414137243551249665807200480880992870786212844e-2 + x * (-2.5059277215057806110669551730119000291685520821566e-2 + x * (-2.81870142796477760129504757523915986553655328090386e-2)))))) 1.2209644286111307242585650787290958941267684527793 + x * (-0.2681997080742220850388486701031502996861955637525 + x * (-0.31101896753052164898541483442053517706036858200279 + x * (-0.185495670746673659727113886224299253680191076597567 + x * (-6.1184414137243551249665807200480880992870786212843e-2 + x * (-2.50592772150578061106695517301190002916855208215634e-2 + x * (-2.8187014279647776012950475752391598655365532809038e-2)))))) 4.2764235361475130338248583474423710061043150081681e-50 7.4837411882581478091935021080241492606825512642941e-50 1.06910588403687825845621458686059275152607875204202e-49 9.621952956331904326105931281745334763734708768378e-50 1.08246970758733923668691726919635016092015473644254e-49 1.17601647244056608430183604554665202667868662724622e-49 1.2896089726194843992628088454005900065283324946507e-49 =============== Check TMandAD #61 ================ 9.5310179804324860043952123280765092220605365308645e-2 + x * (0.90909090909090909090909090909090909090909090909093 + x * (-0.41322314049586776859504132231404958677685950413223 + x * (0.25043826696719258702729777109942399198597545704984 + x * (-0.17075336384126767297315757120415272180861962980671 + x * 0.124184264611831034889569142693929252224450639859427)))) 2.67276471009219564614053646715148187881519688010505e-51 6.4146353042212695507372875211635565091564725122521e-50 4.2764235361475130338248583474423710061043150081681e-50 4.2764235361475130338248583474423710061043150081681e-50 3.2073176521106347753686437605817782545782362561261e-50 2.94004118110141521075459011386663006669671656811555e-50 =============== Check TMandAD #62 ================ 6.8347384761734728508227134176462910446388696284674e-2 + x * (-0.93159645994407246116520275657393642818869133997221 + x * (-0.466967991045081951403277154003289890834039351884755 + x * (-0.14500857578826455862780131894182586745766403253396 + x * (-7.0115553076583039494557725092003451621389391408708e-2 + x * (-3.3378189202679419200012578219191629237299112295215e-2 + x * (-1.7067748597564210746573112072499637736422841992755e-2)))))) 6.8347384761734728508227134176462910446388696284674e-2 + x * (-0.93159645994407246116520275657393642818869133997222 + x * (-0.46696799104508195140327715400328989083403935188476 + x * (-0.145008575788264558627801318941825867457664032533956 + x * (-7.011555307658303949455772509200345162138939140871e-2 + x * (-3.3378189202679419200012578219191629237299112295215e-2 + x * (-1.7067748597564210746573112072499637736422841992754e-2)))))) 5.3455294201843912922810729343029637576303937602101e-51 1.06910588403687825845621458686059275152607875204202e-49 9.621952956331904326105931281745334763734708768378e-50 1.22947176664240999722464677488968166425499056484832e-49 1.30965470794517586660886286890422612061944647125147e-49 1.38983764924794173599307896291877057698390237765463e-49 1.52347588475255151830010578627634467092466222165988e-49 =============== Check TMandAD #63 ================ 0.60876708197129996592051372053836378603013915090404 + x * (-0.31733960103539515176766987617244216406417401692404 + x * (1.4766553649375033079892877591419329930423671312485e-2 + x * (1.1018157262137728195651909025962516777919812377621e-2 + x * (-6.4935155410271996364854796857425470509881509429763e-3 + x * 2.7549161220042135407797159019388250063197795378572e-3)))) 0.60876708197129996592051372053836378603013915090404 + x * (-0.31733960103539515176766987617244216406417401692404 + x * (1.4766553649375033079892877591419329930423671312485e-2 + x * (1.10181572621377281956519090259625167779198123776217e-2 + x * (-6.4935155410271996364854796857425470509881509429764e-3 + x * 2.754916122004213540779715901938825006319779537857e-3)))) 4.2764235361475130338248583474423710061043150081681e-50 4.2764235361475130338248583474423710061043150081681e-50 1.7372970615599271699913487036484632212298779720683e-50 8.3523897190381113941891764598483808712974902503283e-51 4.1761948595190556970945882299241904356487451251641e-51 2.17162132694990896248918587956057902653734746508535e-51 =============== Check TMandAD #64 ================ 1.71828182845904523536028747135266249775724709369994 + x * (2.71828182845904523536028747135266249775724709369994 + x * (1.35914091422952261768014373567633124887862354684997 + x * (0.45304697140984087256004791189211041629287451561664 + x * (0.11326174285246021814001197797302760407321862890416 + x * (2.26523485704920436280023955946055208146437257808326e-2 + x * 3.7753914284153406046670659324342534691072876301387e-3))))) 1.71828182845904523536028747135266249775724709369994 + x * (2.7182818284590452353602874713526624977572470937 + x * (1.35914091422952261768014373567633124887862354685 + x * (0.45304697140984087256004791189211041629287451561665 + x * (0.113261742852460218140011977973027604073218628904163 + x * (2.26523485704920436280023955946055208146437257808326e-2 + x * 3.7753914284153406046670659324342534691072876301387e-3))))) 8.5528470722950260676497166948847420122086300163362e-50 8.5528470722950260676497166948847420122086300163362e-50 4.2764235361475130338248583474423710061043150081681e-50 2.13821176807375651691242917372118550305215750408404e-50 5.3455294201843912922810729343029637576303937602101e-51 1.33638235504609782307026823357574093940759844005252e-51 2.5057169157114334182567529379545142613892470750985e-52 =============== Check TMandAD #65 ================ 0.71652569954890351798018669178974755548847353198133 + x * (-1.4444065708474793156406513204450572318923475411023 + x * (0.143991713042915494860125081827712894913130548460104 + x * (0.46048487922844237002843378517080629917602434816592 + x * (-0.22960575757220174212021850338865898145387905002452 + x * (-3.7053001751761134843335280686053414662122301023599e-2))))) 0.71652569954890351798018669178974755548847353198133 + x * (-1.44440657084747931564065132044505723189234754110227 + x * (0.143991713042915494860125081827712894913130548460104 + x * (0.46048487922844237002843378517080629917602434816591 + x * (-0.22960575757220174212021850338865898145387905002452 + x * (-3.7053001751761134843335280686053414662122301023599e-2))))) 8.5528470722950260676497166948847420122086300163362e-50 1.28292706084425391014745750423271130183129450245042e-49 1.60365882605531738768432188029088912728911812806303e-49 1.49674823765162956183870042160482985213651025285883e-49 1.06910588403687825845621458686059275152607875204202e-49 6.9491882462397086799653948145938528849195118882731e-50 =============== Check TMandAD #66 ================ 0.10556127443064142289432992281060414894332171536258 + x * (1.11753185071888245822381027562597411350340878457667 + x * (0.6901115120117293583476916736675307876648509665753 + x * (0.79825828962392246953363796608285809468600465827366 + x * (1.01001709068987466209237741899816572306454414595333 + x * (1.36204227902902517392543533282039613394759147283616 + x * 1.91356586728218506593248460089816844950869726652285))))) 0.105561274430641422894329922810604148943321715362573 + x * (1.11753185071888245822381027562597411350340878457667 + x * (0.6901115120117293583476916736675307876648509665753 + x * (0.79825828962392246953363796608285809468600465827366 + x * (1.01001709068987466209237741899816572306454414595333 + x * (1.36204227902902517392543533282039613394759147283616 + x * 1.9135658672821850659324846008981684495086972665229))))) 8.0182941302765869384216094014544456364455906403151e-51 1.28292706084425391014745750423271130183129450245042e-49 1.28292706084425391014745750423271130183129450245042e-49 2.77967529849588347198615792583754115396780475530925e-49 4.7040658897622643372073441821866081067147465089849e-49 8.980489425909777371032202529628979112819061517153e-49 1.3684555315672041708239546711815587219533808026138e-48 =============== Check TMandAD #67 ================ 1.07177346253629316421300632502334202290638460497755 + x * (5.35886731268146582106503162511671011453192302488785e-2 + x * (-1.20574514535332980973963211565125977576968268059975e-2 + x * (3.8181929602855443975088350328956559566039951552325e-3 + x * (-1.38409494810350984409695269942467528426894824377177e-3 + x * 5.3979702976036883919781155277562336086488981507102e-4)))) 1.07177346253629316421300632502334202290638460497753 + x * (5.3588673126814658210650316251167101145319230248879e-2 + x * (-1.20574514535332980973963211565125977576968268059974e-2 + x * (3.8181929602855443975088350328956559566039951552325e-3 + x * (-1.38409494810350984409695269942467528426894824377177e-3 + x * 5.3979702976036883919781155277562336086488981507102e-4)))) 4.2764235361475130338248583474423710061043150081681e-50 4.0091470651382934692108047007272228182227953201576e-51 1.67047794380762227883783529196967617425949805006566e-51 9.187628690941922533608094105833218958427239275361e-52 4.1761948595190556970945882299241904356487451251641e-52 2.5057169157114334182567529379545142613892470750985e-52 =============== Check TMandAD #68 ================ 1.00000000000000000000000000000000000000000000000003e-2 + x * (-2.30258509299404568401799145468436420760110148862885e-2 + x * (2.6509490552391990052808331942970088457987250395665e-2 + x * (-2.0346785922934761968309911917138105302410550264778e-2 + x * (1.17125514891226696317825761603265234076100689858147e-2 + x * (-5.3938292919558141019969155571017253478007614081819e-3 + x * 2.0699584869686809669966601589738494188245922773012e-3))))) 1.00000000000000000000000000000000000000000000000005e-2 + x * (-2.3025850929940456840179914546843642076011014886289e-2 + x * (2.6509490552391990052808331942970088457987250395665e-2 + x * (-2.0346785922934761968309911917138105302410550264778e-2 + x * (1.17125514891226696317825761603265234076100689858144e-2 + x * (-5.3938292919558141019969155571017253478007614081817e-3 + x * 2.0699584869686809669966601589738494188245922773012e-3))))) 3.3409558876152445576756705839393523485189961001313e-52 2.0045735325691467346054023503636114091113976600788e-51 4.0091470651382934692108047007272228182227953201576e-51 5.3455294201843912922810729343029637576303937602101e-51 3.6750514763767690134432376423332875833708957101444e-51 2.17162132694990896248918587956057902653734746508535e-51 1.0022867662845733673027011751818057045556988300394e-51 =============== Check TMandAD #69 ================ 0.79432823472428150206591828283638793258896063175547 0.79432823472428150206591828283638793258896063175546 2.13821176807375651691242917372118550305215750408404e-50 0 0 0 0 0 =============== Check TMandAD #70 ================ 36.462159607207911770990826022692123666365508402231 + x * (78.201483412189634503695143521234055943802084236164 + x * (89.663662233232398004969245008229619028912259905242 + x * (71.783148921959433180561687785017716768327478821765 + x * (44.731637086997995425575005323497495002221768298902 + x * (22.998255329450560935591809147458675279179581012706 + x * 10.119007907316276138165135695985073910945053780455))))) 36.462159607207911770990826022692123666365508402231 + x * (78.201483412189634503695143521234055943802084236166 + x * (89.66366223323239800496924500822961902891225990524 + x * (71.783148921959433180561687785017716768327478821767 + x * (44.731637086997995425575005323497495002221768298903 + x * (22.998255329450560935591809147458675279179581012706 + x * 10.119007907316276138165135695985073910945053780455))))) 1.09476442525376333665916373694524697756270464209103e-47 3.5579843820747308441422821450720526770787900867958e-47 6.0212043388956983516254005531988583765948755315007e-47 6.0212043388956983516254005531988583765948755315007e-47 4.7895943604852145978838413491354555268368328091482e-47 2.9421793928694889672715025430403512521997687256196e-47 1.57372386130228479644754787185879253024638792300585e-47 =============== Check TMandAD #71 ================ 19333.6890743651453229168330250109156728478081361232 + x * (1.21477151125629580552704960680767967490169960150605e5 + x * (4.0096541462966011794836743206704387041172475235494e5 + x * (9.2076476804650347559490221760908918515800733173528e5 + x * (1.6468166228044327168123644950520690566747707309675e6 + x * 2.4377567088233851454733583686559173501394946804362e6)))) 19333.689074365145322916833025010915672847808136123 + x * (1.21477151125629580552704960680767967490169960150603e5 + x * (4.0096541462966011794836743206704387041172475235494e5 + x * (9.2076476804650347559490221760908918515800733173528e5 + x * (1.64681662280443271681236449505206905667477073096747e6 + x * 2.4377567088233851454733583686559173501394946804362e6)))) 2.7325320054333932883012726874153364559965107866592e-44 1.98984381934124024071169600827168090641797195746465e-43 8.183583031656931694194580766413110206676729740559e-43 2.2420775429197073134779673332638658100484191070024e-42 4.9774121452817502359210874798457820983074904175454e-42 9.5064087819795590091465814930387910346052970136903e-42 =============== Check TMandAD #72 ================ 3.19442279626557392785578005160426388798275984225375e11 + x * (1.08149591321461578880323745937253504257012916577474e13 + x * (1.8928377854032381579722946911583246100686917928969e14 + x * (2.2785579313439284882837533139857043527715733731672e15 + x * (2.1184082434113534479779983850765183882179206098248e16 + x * (1.6198899147815186534042786057428928938011414595308e17 + x * 1.0597270646853284768882841185584929779481735185886e18))))) 3.1944227962655739278557800516042638879827598422538e11 + x * (1.08149591321461578880323745937253504257012916577476e13 + x * (1.8928377854032381579722946911583246100686917928969e14 + x * (2.2785579313439284882837533139857043527715733731672e15 + x * (2.1184082434113534479779983850765183882179206098248e16 + x * (1.6198899147815186534042786057428928938011414595308e17 + x * 1.05972706468532847688828411855849297794817351858863e18))))) 8.8162076311671563097655240291668425836399916757907e-37 3.1973446342366220216749633812445082436667703144201e-35 6.0185310762101120407999310705778978704315676506731e-34 7.7037197775489434122239117703397092741524065928616e-33 7.4726081842224751098571944172295179959278343950757e-32 6.0397163055983716351835468279463320709354867688035e-31 4.1415197524103119784115749677346277057843337843224e-30 =============== Check TMandAD #73 ================ 15.1542622414792641897604302726299119055285485368556 + x * (82.387111349432247126376575368728663955715366085724 + x * (285.74172119246783174567143285507682047346391229711 + x * (769.23144369693517755359466767190748397356441363211 + x * (1748.59650850868284292865299129051471322793068020615 + x * 3505.9394793266914592905113080735727111343422042029)))) 15.1542622414792641897604302726299119055285485368556 + x * (82.387111349432247126376575368728663955715366085726 + x * (285.74172119246783174567143285507682047346391229712 + x * (769.2314436969351775535946676719074839735644136321 + x * (1748.5965085086828429286529912905147132279306802061 + x * 3505.9394793266914592905113080735727111343422042028)))) 6.842277657836020854119773355907793609766904013069e-48 5.7475132325822575174606096189625466322041993709779e-47 2.5179581780836556743160765949740680483942206768094e-46 8.9770682870808593606051426429510252160141780651464e-46 2.4522723125684298741165267707573532297404583982839e-45 6.1306807814210746852913169268933830743511459957098e-45 =============== Check TMandAD #74 ================ 1.2214027581601698339210719946396741703075809415205 + x * (0.122140275816016983392107199463967417030758094152054 + x * (6.1070137908008491696053599731983708515379047076063e-3 + x * (2.0356712636002830565351199910661236171793015692124e-4 + x * (5.0891781590007076413377999776653090429482539227775e-6 + x * (1.01783563180014152826755999553306180858965078488124e-7 + x * 1.69639271966690254711259999255510301431608503890327e-9))))) 1.22140275816016983392107199463967417030758094152047 + x * (0.122140275816016983392107199463967417030758094152054 + x * (6.1070137908008491696053599731983708515379047076056e-3 + x * (2.03567126360028305653511999106612361717930156921457e-4 + x * (5.0891781590007076413377999776653090429482539227357e-6 + x * (1.0178356318001415282675599955330618085896507798698e-7 + x * 1.69639271966690254711259999255510301431608714440153e-9))))) 4.2764235361475130338248583474423710061043150081681e-50 2.13821176807375651691242917372118550305215750408404e-50 3.0736794166060249930616169372242041606374764121208e-50 4.5437000071567325984389119941575191939858346961786e-50 6.4146353042212695507372875211635565091564725122521e-50 9.5551338385795994349524178700665477167643288463755e-50 1.3965195610231722251084303040866492816809403698549e-49 =============== Check TMandAD #75 ================ 0.89168801955024168354772242695304104159466775660212 + x * (-0.102222188496612979772943348027618266412495533076183 + x * (-4.525177148522415460245983269673080030168467816761e-2 + x * (-1.1401610878468740564851554333202624839169493983593e-2 + x * (-1.1707559340863899832303268695108654696354460839657e-3 + x * 3.4578817027349160073156759588679729076030365678268e-4)))) 0.8916880195502416835477224269530410415946677566021 + x * (-0.102222188496612979772943348027618266412495533076184 + x * (-4.5251771485224154602459832696730800301684678167609e-2 + x * (-1.14016108784687405648515543332026248391694939835932e-2 + x * (-1.17075593408638998323032686951086546963544608396576e-3 + x * 3.457881702734916007315675958867972907603036567827e-4)))) 2.13821176807375651691242917372118550305215750408404e-50 1.33638235504609782307026823357574093940759844005252e-50 9.3546764853226847614918776350301865758531890803677e-51 5.3455294201843912922810729343029637576303937602101e-51 2.08809742975952784854729411496209521782437256258207e-51 9.083223819453946141180729400085114197536020647232e-52 =============== Check TMandAD #76 ================ 2.7074516125588556449105512781831886215040867999969 + x * (-0.16181391103050688702189927512209622329145998852813 + x * (-0.79953366056409798708987149989302892096034947528851 + x * (-1.25382468681300893255409008660692481077242408329826 + x * (0.3869934927128813831942421262437634324543886898641 + x * (0.73160074302808038476236630242776434854201081233263 + x * 0.45229762379620212896118440074185268515673628348351))))) 2.7074516125588556449105512781831886215040867999969 + x * (-0.16181391103050688702189927512209622329145998852813 + x * (-0.79953366056409798708987149989302892096034947528851 + x * (-1.25382468681300893255409008660692481077242408329834 + x * (0.38699349271288138319424212624376343245438868986412 + x * (0.73160074302808038476236630242776434854201081233263 + x * 0.45229762379620212896118440074185268515673628348352))))) 8.5528470722950260676497166948847420122086300163362e-50 9.621952956331904326105931281745334763734708768378e-50 3.20731765211063477536864376058177825457823625612606e-49 7.6975623650655234608847450253962678109877670147025e-49 5.5593505969917669439723158516750823079356095106185e-49 1.1118701193983533887944631703350164615871219021237e-48 1.15463435475982851913271175380944017164816505220538e-48 =============== Check TMandAD #77 ================ x^2 * (NaN + x^2 * 0.5 * NaN) 1 + x^2 * (0.66666666666666666666666666666666666666666666666668 + x^2 * 8.611111111111111111111111111111111111111111111111e-2) 0 0 2.13821176807375651691242917372118550305215750408404e-50 0 4.2764235361475130338248583474423710061043150081681e-50 0 =============== Check TMandAD #78 ================ x^2 * (NaN + x^2 * (0.5 * NaN + x^2 * 0.5 * (0.25 * NaN / 5) / 3)) 1 + x^2 * (0.66666666666666666666666666666666666666666666666668 + x^2 * (8.611111111111111111111111111111111111111111111111e-2 + x^2 * 0.105158730158730158730158730158730158730158730158728)) 0 0 2.13821176807375651691242917372118550305215750408404e-50 0 4.2764235361475130338248583474423710061043150081681e-50 0 4.5437000071567325984389119941575191939858346961786e-50 =============== Check TMandAD #79 ================ Warning: the absolute value is not twice differentiable. Will return [@NaN@, @NaN@]. Warning: the absolute value is not twice differentiable. Will return [@NaN@, @NaN@]. 1 + x * (1 + x * (NaN + x * (0.5 * NaN + x * (0.5 * NaN + x * (0.5 * (0.25 * NaN) / 3 + x * 0.5 * (0.25 * NaN / 5) / 3))))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) NaN NaN NaN NaN NaN NaN NaN =============== Check TMandAD #80 ================ Warning: the absolute value is not twice differentiable. Will return [@NaN@, @NaN@]. Warning: the absolute value is not twice differentiable. Will return [@NaN@, @NaN@]. 1 + x * (1 + x * (NaN + x * (0.5 * NaN + x * (0.5 * NaN + x * 0.5 * (0.25 * NaN) / 3)))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) NaN NaN NaN NaN NaN NaN =============== Check TMandAD #81 ================ Warning: the absolute value is not twice differentiable. Will return [@NaN@, @NaN@]. Warning: the absolute value is not twice differentiable. Will return [@NaN@, @NaN@]. 7.3890560989306502272304274605750078131803155705518 + x * (7.389056098930650227230427460575007813180315570551771061601381924994362524866748393927777524445667334352 + x * (NaN + x * (0.5 * NaN + x * (0.5 * NaN + x * (0.5 * (0.25 * NaN) / 3 + x * 0.5 * (0.25 * NaN / 5) / 3))))) 7.3890560989306502272304274605750078131803155705517 + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) 1.71056941445900521352994333897694840244172600326723e-49 NaN NaN NaN NaN NaN NaN =============== Check TMandAD #82 ================ Warning: the single rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the single rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * 1 * 0.5 * (0.25 * NaN / 5) / 3)))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) NaN NaN NaN NaN NaN NaN =============== Check TMandAD #83 ================ Warning: the single rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the single rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * (0.25 * NaN / 5) / 3 + x * 1 * 0.5 * (0.25 * NaN / 6 / 5) / 3))))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) NaN NaN NaN NaN NaN NaN NaN =============== Check TMandAD #84 ================ Warning: the single rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the single rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * 1 * 0.5 * (0.25 * NaN / 5) / 3)))) 2.7182818284590452353602874713526624977572470937 + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) 8.5528470722950260676497166948847420122086300163362e-50 NaN NaN NaN NaN NaN =============== Check TMandAD #85 ================ Warning: the double rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the double rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * (0.25 * NaN / 5) / 3 + x * 1 * 0.5 * (0.25 * NaN / 6 / 5) / 3))))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) NaN NaN NaN NaN NaN NaN NaN =============== Check TMandAD #86 ================ Warning: the double rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the double rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * 1 * 0.5 * (0.25 * NaN / 5) / 3)))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) NaN NaN NaN NaN NaN NaN =============== Check TMandAD #87 ================ Warning: the double rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the double rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * (0.25 * NaN / 5) / 3 + x * 1 * 0.5 * (0.25 * NaN / 6 / 5) / 3))))) 1 + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) 0 NaN NaN NaN NaN NaN NaN =============== Check TMandAD #88 ================ Warning: the doubledouble rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the doubledouble rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * 1 * 0.5 * (0.25 * NaN / 5) / 3)))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) NaN NaN NaN NaN NaN NaN =============== Check TMandAD #89 ================ Warning: the doubledouble rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the doubledouble rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * (0.25 * NaN / 5) / 3 + x * 1 * 0.5 * (0.25 * NaN / 6 / 5) / 3))))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) NaN NaN NaN NaN NaN NaN NaN =============== Check TMandAD #90 ================ Warning: the doubledouble rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the doubledouble rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * 1 * 0.5 * (0.25 * NaN / 5) / 3)))) 2.7182818284590452353602874713526624977572470937 + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) 8.5528470722950260676497166948847420122086300163362e-50 NaN NaN NaN NaN NaN =============== Check TMandAD #91 ================ Warning: the tripledouble rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the tripledouble rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * (0.25 * NaN / 5) / 3 + x * 1 * 0.5 * (0.25 * NaN / 6 / 5) / 3))))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) NaN NaN NaN NaN NaN NaN NaN =============== Check TMandAD #92 ================ Warning: the tripledouble rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the tripledouble rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * 1 * 0.5 * (0.25 * NaN / 5) / 3)))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) NaN NaN NaN NaN NaN NaN =============== Check TMandAD #93 ================ Warning: the tripledouble rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the tripledouble rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * (0.25 * NaN / 5) / 3 + x * 1 * 0.5 * (0.25 * NaN / 6 / 5) / 3))))) 1 + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) 0 NaN NaN NaN NaN NaN NaN =============== Check TMandAD #94 ================ Warning: the doubleextended rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the doubleextended rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * 1 * 0.5 * (0.25 * NaN / 5) / 3)))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) NaN NaN NaN NaN NaN NaN =============== Check TMandAD #95 ================ Warning: the doubleextended rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the doubleextended rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * (0.25 * NaN / 5) / 3 + x * 1 * 0.5 * (0.25 * NaN / 6 / 5) / 3))))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) NaN NaN NaN NaN NaN NaN NaN =============== Check TMandAD #96 ================ Warning: the doubleextended rounding operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the doubleextended rounding operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * 1 * 0.5 * (0.25 * NaN / 5) / 3)))) 7.3890560989306502272304274605750078131803155705517 + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) 1.71056941445900521352994333897694840244172600326723e-49 NaN NaN NaN NaN NaN =============== Check TMandAD #97 ================ Warning: the ceil operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the ceil operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * (0.25 * NaN / 5) / 3 + x * 1 * 0.5 * (0.25 * NaN / 6 / 5) / 3))))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) NaN NaN NaN NaN NaN NaN NaN =============== Check TMandAD #98 ================ Warning: the ceil operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the ceil operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * 1 * 0.5 * (0.25 * NaN / 5) / 3)))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) NaN NaN NaN NaN NaN NaN =============== Check TMandAD #99 ================ Warning: the ceil operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the ceil operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * (0.25 * NaN / 5) / 3 + x * 1 * 0.5 * (0.25 * NaN / 6 / 5) / 3))))) 1 + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) 0 NaN NaN NaN NaN NaN NaN =============== Check TMandAD #100 ================ Warning: the floor operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the floor operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * 1 * 0.5 * (0.25 * NaN / 5) / 3)))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) NaN NaN NaN NaN NaN NaN =============== Check TMandAD #101 ================ Warning: the floor operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the floor operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * (0.25 * NaN / 5) / 3 + x * 1 * 0.5 * (0.25 * NaN / 6 / 5) / 3))))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) NaN NaN NaN NaN NaN NaN NaN =============== Check TMandAD #102 ================ Warning: the floor operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the floor operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * 1 * 0.5 * (0.25 * NaN / 5) / 3)))) 2.7182818284590452353602874713526624977572470937 + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) 8.5528470722950260676497166948847420122086300163362e-50 NaN NaN NaN NaN NaN =============== Check TMandAD #103 ================ Warning: the nearestint operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the nearestint operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * (0.25 * NaN / 5) / 3 + x * 1 * 0.5 * (0.25 * NaN / 6 / 5) / 3))))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) NaN NaN NaN NaN NaN NaN NaN =============== Check TMandAD #104 ================ Warning: the nearestint operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the nearestint operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * 1 * 0.5 * (0.25 * NaN / 5) / 3)))) NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN)))) NaN NaN NaN NaN NaN NaN =============== Check TMandAD #105 ================ Warning: the nearestint operator is not differentiable. Will return [@NaN@, @NaN@]. Warning: the nearestint operator is not differentiable. Will return [@NaN@, @NaN@]. NaN + x * (1 * NaN + x * (1 * NaN + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * NaN / 3 + x * (1 * 0.5 * (0.25 * NaN / 5) / 3 + x * 1 * 0.5 * (0.25 * NaN / 6 / 5) / 3))))) 2.7182818284590452353602874713526624977572470937 + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * (NaN + x * NaN))))) 8.5528470722950260676497166948847420122086300163362e-50 NaN NaN NaN NaN NaN NaN sollya-6.0+ds/tests-tool/check015.sollya000066400000000000000000001143251300174114700201350ustar00rootroot00000000000000/* Set of tests for supnorm */ print("=============== Check Supnorm #1 ================");//passes p = 11692536319630510474283968587625525849426869787677b-163 + x * (23384922893552793741208186896732057180708286140565b-164 + x * (46692941277611593554424973690517694800554713844979b-166 + x * (3891678517537147456387754739468835779118224484425b-164 + x * (1024072943597638219514404758611859127188920401873b-164 + x * 26154763285557255659575812244171511366994513699585b-171)))); midpointmode=on!; supnorm(p, exp(x), [-1;1], absolute, 2^(-40)); print("=============== Check Supnorm #2 ================");//passes p = 23384026197294909850223840992809340481141545456185b-164 + x * (46768052394366389249957592514757698261837941537431b-165 + x * (1461501637882931916249380248092291325347144984355b-161 + x * (15589350524874704484650079886308075573528112666971b-166 + x * (31178718928032908530740508502853005869373616353571b-169 + x * (6235660318693530982722236353851527754167773984285b-169 + x * (16632313913972289150146538028615958190382830813395b-173 + x * (4737564581099604249852567829707944940460501354987b-174 + x * (19508173607844763061526398982921782866373719408881b-179 + x * (28028384585901080300830750040726581293938320938545b-183 + x * 44836930378672942548678299103511494860025777760483b-186))))))))); midpointmode=on!; supnorm(p, exp(x), [0;1], absolute, 2^(-40)); print("=============== Check Supnorm #3 ================");//passes mode=relative; theta=1b-135; d = [-1b-2;1b-2]; f = expm1(x); p = x * (1 + x * ( 2097145 * 2^(-22) + x * ( 349527 * 2^(-21) + x * (87609 * 2^(-21) + x * 4369 * 2^(-19))))); theta=1b-40; supnorm(p,f,d,mode,theta); print("=============== Check Supnorm #4 ================");//passes mode=relative; d = [-1b-9;1b-9]; f = log2(1 + x); p = x * (117045327009867803036301574157545b-106 + x * ((-58522663504933901606981166592605b-106) + x * (8663094464742397b-54 + x * ((-6497320848515433b-54) + x * (2598928339549937b-53 + x * ((-541446114948727b-51) + x * 3712726891772213b-54)))))); theta=1b-205; supnorm(p,f,d,mode,theta); print("=============== Check Supnorm #5 ================");//passes mode=relative; d = [-205674681606191b-53;205674681606835b-53]; f = asin(x + 0x3fe5e58f08291918); p = 15651770362713997207607972106972745b-114 + (x *(3476698806776688943652103662933b-101 + (x *(17894972500311187082269807705171b-104 + (x *(126976607296441025269345153102591b-106 + (x *(249107378895562413495151944042799b-106 + (x *(139053951649796304768149995225589b-104 + (x *(165428664168251249501887921888847b-103 + (x *(206167601873884163281098618631159b-102 + (x *(66386611260133347295510390653099b-99 + (x * (2433556521489987b-43 + (x* (409716955440671b-39 + (x * (2242518346998655b-40 + (x *(3108616106416871b-39 + (x * (4356285307071455b-38 + (x *(6161286268548935b-37 + (x * (8783550111623067b-36 + (x *(788026560267325b-31 + (x * (1138037795125313b-30 + (x *(3304615966282565b-30 + (x * (602367826671283b-26 + (x *(1765006192104851b-26 + (x * (1337636086941861b-24 + (x *986777691264547b-22))))))))))))))))))))))))))))))))))))))))))); theta=1b-60; prec=400!; supnorm(p,f,d,mode,theta); print("=============== Check Supnorm #6 ================"); //passes mode=relative; prec=300!; d = [-1/2;1/4]; f = cos(x); p = 127314748520905380391777835589720039729342145097661090748478447318618529015203604765566689b-296 + x * (-1176183728229793751637043660065847579890970982973992202018192057755975433302793198324426573b-376 + x * (-127314748520905380391738345892360756681131303903716098475473212933227449963198807170652229b-297 + x * (411157279064246494121991117766105005568223464883775477360093918816839730397410047916370811b-366 + x * (21219124753484230053862417678170235538726463899369620274583864671581237263849631540786577b-298 + x * (-1410502123645648389482990176064909235877375828877296670824273606862416549384926673212331083b-361 + x * (-724279458252261210504349594121335100771624524830702920999146885115456299525648100748351663b-308 + x * (134774797018080532192428177850854993385334368268780691241634121499347615118037692190732043b-352 + x * (1655495904576160557613610377255708869921184205441524773073593312341561508689495751645348449b-315 + x * (-1594094643995802407650998956215005582984707081147652766864332919805511367571909433687622335b-351 + x * (-294310383550327313556374414541449084070746487392752536766971007548680728836036254508146929b-319 + x * (512235774726334150822554392967816790007421386839936546743269207769528982853397644167067871b-346 + x * (1141573461565483381928707239907860736890956525739802194008371659491759020277390103225113401b-328 + x * (-1569482484524507248868121030716379419120450572564469525806037183646518163382197401885965253b-347 + x * (-1614534504445457486506762534809318663084383593349434912234239957430266631356959991774123565b-336 + x * (-1712106093024186385498521252470153327699204358233691202131099406230733496689604124499970149b-343))))))))))))))); prec=default!; theta=1b-100; supnorm(p,f,d,mode,theta); print("=============== Check Supnorm #7 ================");//passes mode=relative; prec=400!; d = [-1/8;1/8]; f = exp(x); p=1291124939043454294827959586001505937164852896414611756415643039531479680609629260097919725377401206658955423510867812933b-399 + x * (1291124939043454294827959586001505937164852896414611756407759293348856964764186953322986589460672969435069958748491718283b-399 + x * (1291124939043454294827959586001505937164852896414611742842916313201487217248242990712587184030633906090137602556193308777b-400 + x * (1721499918724605726437279448002007916219803861886149410406732804556694110264268799366882772800656159765418763369767923869b-402 + x * (1721499918724605726437279448002007916219803861886928049851542292580594202097368397525596049532723601180890716568841852971b-404 + x * (688599967489842290574911779200803166487921544748146677805317095693650672977111381945276005270502268669363247750562141109b-405 + x * (918133289986456387433215705601070888650562042107828893577378984985802017340780034420418039342182577636371604545753247685b-408 + x * (2098590377111900314133064469945304888344142586006558021664462294500550566006715853849729548335450138563444975611072384915b-412 + x * (2098590377111900314133064469945304888345787506900621321180727067543258071161052823401917797089874824160141551745303600509b-415 + x * (932706834271955695170250875531246617029863789325186530775644670361528998993026253332715955100711707177976542185420125885b-417 + x * (186541366854391139034050175106249317675194606310468992601212125887714941698557011635643430617148947777325881970320599911b-418 + x * (2170663177942005981487129310327265817430136743794322761791212108289168199121016399511022765792217934974290164512400558051b-425 + x * (723554392647335327162376436776575188728320134851889625237160943201761614313054850997686096169392444013734775049800364135b-427 + x * (445264241629129432099923961086461053843117889043738115595645570179588863813466486158437851805221549064027305469772175195b-430 + x * (1017746838009438701942683300338197780799042429908471623542287463474569859335113951279406783547674904661405075222370152653b-435 + x * (271399156802516987184715668022449290765604321334910931946270618816084433310692805993200010568980374341586319016626039405b-437 + x * (2171193254420135897480301350825607712011172107075923446450599655895677713120365969751962821314954760562289074188094789451b-444 + x * (2043476004160127903487494000509588015818708867395743746978714423885089009799059654843663103804548054018562648174876580061b-448 + x * (908211557404501261461971507657492862559270740528797479096948806118152290717219182619080722630251277564118402740142879215b-451 + x * (1529619465102318290396191335466982351668824576419822769979570691542070957164975362583515486255615591549174162951007028183b-456 + x * (1223695572082734528475377304206308178928295327141464300806858140000189195058732384055167155268721672655962320814134386585b-460 + x * (466169741743865438694533850917589402256859012268885527875904121812833883515506233431119922322746057508112973882086354899b-463 + x * (339032535142399295985553596850309623127346596956633233039500677601672953959025144616613616695701925012721839172059538925b-467 + x * (1886789853182169718590609346799899921135706970254622139162686047099233945700405342620686331475908007094622992876398666851b-474 + x * (2516112710027923243369908368888976324181415757063417914589335963128261275982808145367994972728592019136949818934599107321b-479 + x * 1609827695620693077847485865687191912593223271819829393342670614997995102920099238219568170602045477783711943005139617211b-483)))))))))))))))))))))))); prec=300!; theta=1b-250; supnorm(p,f,d,mode,theta); print("=============== Check Supnorm #8 ================");//passes prec=200!; d = [-1/2;1/2]; f = sin(x); p = -347829885687651467b-246 + x * (803469022129285046899203980724876839838081336629987901112093b-199 + x * (109096980796689175283906477509258920482015377728962864177675b-376 + x * (-1071292029371495160966220394362561448878316413905740061801453b-202 + x * (-895936839379960786335981881158765658035426638215168714136065b-374 + x * (107129196922888615341858264807183824745523003519500238173771b-203 + x * (549328822047401762664326673644414324304203438857246608800061b-370 + x * (-163240970783780006076567571219952019240960058303028805468663b-209 + x * (-1596659384420598775289000423725712515716892556010679852042289b-370 + x * 288403825950454274847258834876617249588530907170098884348709b-216)))))))); prec=default!; mode=absolute; theta=1b-60; supnorm(p,f,d,mode,theta); print("=============== Check Supnorm #9 ================");//passes prec=200!; d = [1;2]; f = exp(cos(x)^2 + 1); p = 714564886172317927063761490159801881657790980941829344505187b-196 + x * (1258278747211590164438565899307058663065266457630726920586347b-198 + x * (-1202878917246296858587934180920738608442450059984305974754429b-195 + x * (1347350830264911057006851046105206644501121822225011999522971b-194 + x * (-1411317735908160715166251154609539762583930758208235515249453b-193 + x * (73796213723185208671599520928107052835549956637208706117423b-188 + x * (-1400829552020409071501690715419925186599874208109719920625025b-192 + x * (1180386509055370140909826097725837306233406594495350257599181b-192 + x * (-1440803466241145176052471822037050974100822411994796391357023b-193 + x * (1285581190272567034084556062052191954533209585841927847519185b-194 + x * (-832171048091233324734778875003324601584470829671170926930407b-195 + x * (1516396334943608786362280214735888311251638283061986162266693b-198 + x * (-113252562973107828059488836912840143838508857783935522775583b-197 + x * (296982459360723712812328947424418991885288241395500095736051b-202 + x * (-1304662018163848750887736589024039856901512907618757724445671b-210 + x * (-1458138089985030045170976059909283198365479948394215945263081b-213))))))))))))))); theta=1b-60; prec=default!; mode=relative; supnorm(p,f,d,mode,theta); print("=============== Check Supnorm #10 ================");//passes prec=200!; d=[1/4;1/2]; f=tan(x); p = 273663424726598609884436588659142529896812070463680189713577b-217 + x * (803437057336964936961730558645726525457791801950137631592037b-199 + x * (225505423592202238519775811845273269657276115111137681553489b-208 + x * (528444817941611504637035117719962221857671105434203759656937b-200 + x * (1239694968725463472760134669503154963255295977288296254470181b-205 + x * (1130131417499222086385911795575835445432295919090159931462145b-204 + x * (1491287505779580922293205133224642959388076368487724135077821b-202 + x * (-1171551728340426070339628381549725358789127811584978046693913b-201 + x * (406987388528718637810250849111810189760762571987387168281935b-199 + x * (-143338466912831507573865657425240839471014755173174001588205b-198 + x * 909290520151942024628769491295084023281483044413748718543747b-202))))))))); prec=default!; mode=relative; theta=1b-60; supnorm(p,f,d,mode,theta); print("=============== Check Supnorm #11 ================");//passes d=[1;2]; f=x^2.5; p=30384532462332540461916109637629717389849711316821b-171 + x * (-31904713954983344143590115593939596870834806750785b-168 + x * (3202922742084579220140950796580716782899394760489b-162 + x * (15112977993516225491652585788177447394030781112913b-164 + x * (-7069971332398015962219468854462076062374294828243b-165 + x * (7083002129884149408404809852482217256950901287813b-167 + x * (-37227478455235357414551691036580021152370979146031b-172 + x * 45273032627293166114769155909287202062101002901785b-176)))))); mode=relative; theta=1b-35; supnorm(p,f,d,mode,theta); print("=============== Check Supnorm #12 ================");//passes restart; mode=relative; d=[-1/8;1/8]; f=sin(x); verbosity=0!; print("Computing remez polynomial..."); p =fpminimax(sin(x), [|3,5|],[|D,D|], [-1/8; 1/8],x); print("... done."); verbosity=1!; theta = 2^(-16); supnorm(p,f,d,mode,theta); print("=============== Check Supnorm #13 ================");//passes restart; mode=absolute; d=[-347,348]/1000; f=exp(x); p=1.86264514923095703125e-9 + 1.99542657355777919292449951171875e-4 * x^7 + 1.384407165460288524627685546875e-3 * x^6 + 8.33319686353206634521484375e-3 * x^5+ 4.16684038937091827392578125e-2 * x^4 + 0.16666667163372039794921875 * x^3 + 0.49999988079071044921875 * x^2 + x + 1; theta = 2^(-40); supnorm(p,f,d,mode,theta); print("=============== Check Supnorm #14 ================"); testSupnorm = proc(p,f,I,mode,theta) { var oldPrec, r, s; var oldDisplay; oldDisplay = display; display=dyadic!; oldPrec = prec; prec = -ceil(log2(theta))+30; if (mode == absolute) then r = dirtyinfnorm(p-f,I) else r = dirtyinfnorm(p/f-1,I); prec = oldPrec!; s = supnorm(p,f,I,mode,theta); print("Testing example: supnorm(",p,",",f,",",I,",",mode,",",theta,")"); if !(r in s) then print(" --> testSupnorm detected an error: true infnorm not in the interval, r = ", r, ", s = ", s); if (inf(s) < 0) then print(" --> testSupnorm error: computed interval contains negative numbers"); if (sup(s)-inf(s)) > inf(s)*theta then print(" --> testSupnorm: error on the accuracy of the result on"); display=oldDisplay!; return void; }; p = 11692536319630510474283968587625525849426869787677b-163 + x * (23384922893552793741208186896732057180708286140565b-164 + x * (46692941277611593554424973690517694800554713844979b-166 + x * (3891678517537147456387754739468835779118224484425b-164 + x * (1024072943597638219514404758611859127188920401873b-164 + x * 26154763285557255659575812244171511366994513699585b-171)))); testSupnorm(p, exp(x), [-1;1], absolute, 2^(-40)); p = 23384026197294909850223840992809340481141545456185b-164 + x * (46768052394366389249957592514757698261837941537431b-165 + x * (1461501637882931916249380248092291325347144984355b-161 + x * (15589350524874704484650079886308075573528112666971b-166 + x * (31178718928032908530740508502853005869373616353571b-169 + x * (6235660318693530982722236353851527754167773984285b-169 + x * (16632313913972289150146538028615958190382830813395b-173 + x * (4737564581099604249852567829707944940460501354987b-174 + x * (19508173607844763061526398982921782866373719408881b-179 + x * (28028384585901080300830750040726581293938320938545b-183 + x * 44836930378672942548678299103511494860025777760483b-186))))))))); testSupnorm(p, exp(x), [0;1], absolute, 2^(-40)); mode=relative; theta=1b-135; d = [-1b-2;1b-2]; f = expm1(x); p = x * (1 + x * ( 2097145 * 2^(-22) + x * ( 349527 * 2^(-21) + x * (87609 * 2^(-21) + x * 4369 * 2^(-19))))); theta=1b-40; testSupnorm(p,f,d,mode,theta); mode=relative; d = [-1b-9;1b-9]; f = log2(1 + x); p = x * (117045327009867803036301574157545b-106 + x * ((-58522663504933901606981166592605b-106) + x * (8663094464742397b-54 + x * ((-6497320848515433b-54) + x * (2598928339549937b-53 + x * ((-541446114948727b-51) + x * 3712726891772213b-54)))))); theta=1b-205; testSupnorm(p,f,d,mode,theta); mode=relative; d = [-205674681606191b-53;205674681606835b-53]; f = asin(x + 0x3fe5e58f08291918); p = 15651770362713997207607972106972745b-114 + (x *(3476698806776688943652103662933b-101 + (x *(17894972500311187082269807705171b-104 + (x *(126976607296441025269345153102591b-106 + (x *(249107378895562413495151944042799b-106 + (x *(139053951649796304768149995225589b-104 + (x *(165428664168251249501887921888847b-103 + (x *(206167601873884163281098618631159b-102 + (x *(66386611260133347295510390653099b-99 + (x * (2433556521489987b-43 + (x* (409716955440671b-39 + (x * (2242518346998655b-40 + (x *(3108616106416871b-39 + (x * (4356285307071455b-38 + (x *(6161286268548935b-37 + (x * (8783550111623067b-36 + (x *(788026560267325b-31 + (x * (1138037795125313b-30 + (x *(3304615966282565b-30 + (x * (602367826671283b-26 + (x *(1765006192104851b-26 + (x * (1337636086941861b-24 + (x *986777691264547b-22))))))))))))))))))))))))))))))))))))))))))); theta=1b-60; prec=400!; testSupnorm(p,f,d,mode,theta); mode=relative; prec=300!; d = [-1/2;1/4]; f = cos(x); p = 127314748520905380391777835589720039729342145097661090748478447318618529015203604765566689b-296 + x * (-1176183728229793751637043660065847579890970982973992202018192057755975433302793198324426573b-376 + x * (-127314748520905380391738345892360756681131303903716098475473212933227449963198807170652229b-297 + x * (411157279064246494121991117766105005568223464883775477360093918816839730397410047916370811b-366 + x * (21219124753484230053862417678170235538726463899369620274583864671581237263849631540786577b-298 + x * (-1410502123645648389482990176064909235877375828877296670824273606862416549384926673212331083b-361 + x * (-724279458252261210504349594121335100771624524830702920999146885115456299525648100748351663b-308 + x * (134774797018080532192428177850854993385334368268780691241634121499347615118037692190732043b-352 + x * (1655495904576160557613610377255708869921184205441524773073593312341561508689495751645348449b-315 + x * (-1594094643995802407650998956215005582984707081147652766864332919805511367571909433687622335b-351 + x * (-294310383550327313556374414541449084070746487392752536766971007548680728836036254508146929b-319 + x * (512235774726334150822554392967816790007421386839936546743269207769528982853397644167067871b-346 + x * (1141573461565483381928707239907860736890956525739802194008371659491759020277390103225113401b-328 + x * (-1569482484524507248868121030716379419120450572564469525806037183646518163382197401885965253b-347 + x * (-1614534504445457486506762534809318663084383593349434912234239957430266631356959991774123565b-336 + x * (-1712106093024186385498521252470153327699204358233691202131099406230733496689604124499970149b-343))))))))))))))); prec=default!; theta=1b-100; testSupnorm(p,f,d,mode,theta); mode=relative; prec=400!; d = [-1/8;1/8]; f = exp(x); p=1291124939043454294827959586001505937164852896414611756415643039531479680609629260097919725377401206658955423510867812933b-399 + x * (1291124939043454294827959586001505937164852896414611756407759293348856964764186953322986589460672969435069958748491718283b-399 + x * (1291124939043454294827959586001505937164852896414611742842916313201487217248242990712587184030633906090137602556193308777b-400 + x * (1721499918724605726437279448002007916219803861886149410406732804556694110264268799366882772800656159765418763369767923869b-402 + x * (1721499918724605726437279448002007916219803861886928049851542292580594202097368397525596049532723601180890716568841852971b-404 + x * (688599967489842290574911779200803166487921544748146677805317095693650672977111381945276005270502268669363247750562141109b-405 + x * (918133289986456387433215705601070888650562042107828893577378984985802017340780034420418039342182577636371604545753247685b-408 + x * (2098590377111900314133064469945304888344142586006558021664462294500550566006715853849729548335450138563444975611072384915b-412 + x * (2098590377111900314133064469945304888345787506900621321180727067543258071161052823401917797089874824160141551745303600509b-415 + x * (932706834271955695170250875531246617029863789325186530775644670361528998993026253332715955100711707177976542185420125885b-417 + x * (186541366854391139034050175106249317675194606310468992601212125887714941698557011635643430617148947777325881970320599911b-418 + x * (2170663177942005981487129310327265817430136743794322761791212108289168199121016399511022765792217934974290164512400558051b-425 + x * (723554392647335327162376436776575188728320134851889625237160943201761614313054850997686096169392444013734775049800364135b-427 + x * (445264241629129432099923961086461053843117889043738115595645570179588863813466486158437851805221549064027305469772175195b-430 + x * (1017746838009438701942683300338197780799042429908471623542287463474569859335113951279406783547674904661405075222370152653b-435 + x * (271399156802516987184715668022449290765604321334910931946270618816084433310692805993200010568980374341586319016626039405b-437 + x * (2171193254420135897480301350825607712011172107075923446450599655895677713120365969751962821314954760562289074188094789451b-444 + x * (2043476004160127903487494000509588015818708867395743746978714423885089009799059654843663103804548054018562648174876580061b-448 + x * (908211557404501261461971507657492862559270740528797479096948806118152290717219182619080722630251277564118402740142879215b-451 + x * (1529619465102318290396191335466982351668824576419822769979570691542070957164975362583515486255615591549174162951007028183b-456 + x * (1223695572082734528475377304206308178928295327141464300806858140000189195058732384055167155268721672655962320814134386585b-460 + x * (466169741743865438694533850917589402256859012268885527875904121812833883515506233431119922322746057508112973882086354899b-463 + x * (339032535142399295985553596850309623127346596956633233039500677601672953959025144616613616695701925012721839172059538925b-467 + x * (1886789853182169718590609346799899921135706970254622139162686047099233945700405342620686331475908007094622992876398666851b-474 + x * (2516112710027923243369908368888976324181415757063417914589335963128261275982808145367994972728592019136949818934599107321b-479 + x * 1609827695620693077847485865687191912593223271819829393342670614997995102920099238219568170602045477783711943005139617211b-483)))))))))))))))))))))))); prec=300!; theta=1b-250; testSupnorm(p,f,d,mode,theta); prec=200!; d = [-1/2;1/2]; f = sin(x); p = -347829885687651467b-246 + x * (803469022129285046899203980724876839838081336629987901112093b-199 + x * (109096980796689175283906477509258920482015377728962864177675b-376 + x * (-1071292029371495160966220394362561448878316413905740061801453b-202 + x * (-895936839379960786335981881158765658035426638215168714136065b-374 + x * (107129196922888615341858264807183824745523003519500238173771b-203 + x * (549328822047401762664326673644414324304203438857246608800061b-370 + x * (-163240970783780006076567571219952019240960058303028805468663b-209 + x * (-1596659384420598775289000423725712515716892556010679852042289b-370 + x * 288403825950454274847258834876617249588530907170098884348709b-216)))))))); prec=default!; mode=absolute; theta=1b-60; testSupnorm(p,f,d,mode,theta); prec=200!; d = [1;2]; f = exp(cos(x)^2 + 1); p = 714564886172317927063761490159801881657790980941829344505187b-196 + x * (1258278747211590164438565899307058663065266457630726920586347b-198 + x * (-1202878917246296858587934180920738608442450059984305974754429b-195 + x * (1347350830264911057006851046105206644501121822225011999522971b-194 + x * (-1411317735908160715166251154609539762583930758208235515249453b-193 + x * (73796213723185208671599520928107052835549956637208706117423b-188 + x * (-1400829552020409071501690715419925186599874208109719920625025b-192 + x * (1180386509055370140909826097725837306233406594495350257599181b-192 + x * (-1440803466241145176052471822037050974100822411994796391357023b-193 + x * (1285581190272567034084556062052191954533209585841927847519185b-194 + x * (-832171048091233324734778875003324601584470829671170926930407b-195 + x * (1516396334943608786362280214735888311251638283061986162266693b-198 + x * (-113252562973107828059488836912840143838508857783935522775583b-197 + x * (296982459360723712812328947424418991885288241395500095736051b-202 + x * (-1304662018163848750887736589024039856901512907618757724445671b-210 + x * (-1458138089985030045170976059909283198365479948394215945263081b-213))))))))))))))); theta=1b-60; prec=default!; mode=relative; testSupnorm(p,f,d,mode,theta); prec=200!; d=[1/4;1/2]; f=tan(x); p = 273663424726598609884436588659142529896812070463680189713577b-217 + x * (803437057336964936961730558645726525457791801950137631592037b-199 + x * (225505423592202238519775811845273269657276115111137681553489b-208 + x * (528444817941611504637035117719962221857671105434203759656937b-200 + x * (1239694968725463472760134669503154963255295977288296254470181b-205 + x * (1130131417499222086385911795575835445432295919090159931462145b-204 + x * (1491287505779580922293205133224642959388076368487724135077821b-202 + x * (-1171551728340426070339628381549725358789127811584978046693913b-201 + x * (406987388528718637810250849111810189760762571987387168281935b-199 + x * (-143338466912831507573865657425240839471014755173174001588205b-198 + x * 909290520151942024628769491295084023281483044413748718543747b-202))))))))); prec=default!; mode=relative; theta=1b-60; testSupnorm(p,f,d,mode,theta); d=[1;2]; f=x^2.5; p=30384532462332540461916109637629717389849711316821b-171 + x * (-31904713954983344143590115593939596870834806750785b-168 + x * (3202922742084579220140950796580716782899394760489b-162 + x * (15112977993516225491652585788177447394030781112913b-164 + x * (-7069971332398015962219468854462076062374294828243b-165 + x * (7083002129884149408404809852482217256950901287813b-167 + x * (-37227478455235357414551691036580021152370979146031b-172 + x * 45273032627293166114769155909287202062101002901785b-176)))))); mode=relative; theta=1b-35; testSupnorm(p,f,d,mode,theta); mode=relative; d=[-1/8;1/8]; f=sin(x); verbosity=0!; p =fpminimax(sin(x), [|3,5|],[|D,D|], [-1/8; 1/8],x); verbosity=1!; theta = 2^(-16); testSupnorm(p,f,d,mode,theta); /* Example by Florent de Dinechin, that used to lead to a bug */ /* before revision #1852 */ mode=absolute; I=[-347,348]/1000; f=exp(x); p=1.86264514923095703125e-9 + 1.99542657355777919292449951171875e-4 * x^7 + 1.384407165460288524627685546875e-3 * x^6 + 8.33319686353206634521484375e-3 * x^5+ 4.16684038937091827392578125e-2 * x^4 + 0.16666667163372039794921875 * x^3 + 0.49999988079071044921875 * x^2 + x + 1; theta = 2^(-40); verbosity=1!; testSupnorm(p,f,d,mode,theta); /* Example by Florent de Dinechin, that used to lead to a bug */ /* before revision #1425 */ prec=300; /* should be enough for anybody */ M=32768; isize=1/M; d=4; f=exp(x)/2; /* The following polynomials were obtained by the following line. */ /* for i from 0 to 20 do { I=[1+i*isize, 1+(i+1)*isize]; p = remez(f,d, I); }; */ I = [1;32769b-15]; p = 519116931250074582514616920029812964033041191732166366208315683368591845444321107391435481b-299 + x * (461432969284079015555143407908324792312068012734235836652935285714259885748478589922847529b-299 + x * (346082648236258546966032322765771598479520265273144739387947665823565730921236322003050251b-299 + x * (-1845774007687049558287217203353987444440450373590070022669568374961280228727054054051744831b-318 + x * 1845774123550678624355073867555708750724188033665817979913979575189149376462087383277483735b-304))); testSupnorm(p,f,I,absolute,1b-5); I = [32769b-15;16385b-14]; p = 259559345879600238994341752459837595545898720439675950801653623776773076903600946303425701b-298 + x * (461425927462476339021923881761660260730722077159602256751190602125239693445609261724005265b-299 + x * (173046605323160776594250612156380219803360425927054552866876177566765761644836318442542137b-298 + x * (-1384372810757865863246870774013473664314069086622551199217497615213803454026373438271894305b-316 + x * 922915226483104741726827502416104539849150495728611277321715440071753646193388254121647135b-303))); testSupnorm(p,f,I,absolute,1b-5); I = [16385b-14;32771b-15]; p = 1038240905073938809564185146674779242326355205294558935393649861808689793476646895917998267b-300 + x * (1845675539125013381333631624704875717580705390911799805070033763505954280685015813184580603b-301 + x * (346103774023416837754962784984162191045292920130593796757336225574631447590348180153720899b-299 + x * (-576839612789582407852511079083681823850070896509088950771773952643899923582045367370743271b-314 + x * 1845886784100803912445798173029574729693497483658677219270101727506998653158623117662166741b-304))); testSupnorm(p,f,I,absolute,1b-5); I = [32771b-15;8193b-13]; p = 259561106791707898293039710633779037559822312544256220625440469079039924536763394805587147b-298 + x * (922823682480649549181635253331914708804520679107862064077300309229451099522323876193792447b-300 + x * (692228676735226522485987916737252642808432088179842657020342965630357539103964428753876415b-300 + x * (-1615200212850920429100564708444107526276999411623835378169119182171976132997095979778353947b-315 + x * 1845943116954514373788808938428499536418675482610443460189101910631877163996812552600989749b-304))); testSupnorm(p,f,I,absolute,1b-5); I = [8193b-13;32773b-15]; p = 259561987449287045372398701594868201437910171545243585338079477748382151643808715566064285b-298 + x * (461404796839605360090310517684534574578803789973564267751021643064931898303836675409485003b-299 + x * (1384499614715918752531672507766016877483227007979622376860398775113317547154472447117451495b-301 + x * (-519187342120898954534613462928357592655366197366771351797841056730732196163723897029023901b-313 + x * 461499862881848332885261109186422889231489482986384996333218781467310163853332033421724343b-302))); testSupnorm(p,f,I,absolute,1b-5); I = [32773b-15;16387b-14]; p = 1038251472964957456511274192114220005337879717080719570375573248266731133533241225649522435b-300 + x * (1845591006316039313290133964477145081689851856783638624326715045513174026252404653737886631b-301 + x * (692270939915169973615995000980032897935311272581302256923437696401939708362861132946356933b-300 + x * (-1269163346883319747703475308401267430788360043492450542435418710231856874897867418320603237b-314 + x * 1846055787819493251361962234095780806068142607601605103638827981559814019954344633044560891b-304))); testSupnorm(p,f,I,absolute,1b-5); I = [16387b-14;32775b-15]; p = 519127498335164153769545486623552954988858606273181999481850530462359154784932201346547583b-299 + x * (57673838182306612371522122429243846436523792555944999449682277907052548272208183655835053b-296 + x * (1384584148813992118218502092824141150820996752581358234459863858555017921829378462850028367b-301 + x * (-749983047497388110438910296743146915050879640660709438285264950717168395163254780340785913b-313 + x * 923056062915433300256084594722183984064011594047292071874020456477159522961651084828636705b-303))); testSupnorm(p,f,I,absolute,1b-5); I = [32775b-15;4097b-12]; p = 1038258520913329631182690364241114017060837400037458356533335658790054633062991223135847083b-300 + x * (922767316955698569835057986917688386448502196160618545538697046612402761485504819176131747b-300 + x * (1384626421667150770250077157787397840104496347465470608587010281772184260559770572844451389b-301 + x * (-1730782929220944054148482567938745159575983219937856205356812931355746976103146441344064741b-314 + x * 923084232780782923926735159276129795162580209945750248756228435482594096783073927189113911b-303))); testSupnorm(p,f,I,absolute,1b-5); I = [4097b-12;32777b-15]; p = 1038262045694030331360107288571033481310845936055396192569911648051621914710101903264082523b-300 + x * (1845506442548454768920116619308727687991614007806277523964786136086245050686512829575540843b-301 + x * (173083587298761427962455984082138996639756712278337144683760477571124473370811720671440019b-298 + x * (-1961613850206626209203908481303935475641262125973990140990420781913512806725438551266796249b-314 + x * 28847262609556929122639338428295863535850904646269632285682528473324343941472711236120323b-298))); testSupnorm(p,f,I,absolute,1b-5); I = [32777b-15;16389b-14]; p = 519132785506249659649202446742857299970401223489329249721092671862612630646516898175534471b-299 + x * (922739123872321640347645406112487210240542424232485865309181772337452142304813401978565157b-300 + x * (1384710978983089614554980944010000553236544926984416074420180493723390468154027020533019691b-301 + x * (-274057357324581485608201308026878795188066463784519077329794224330771414587511991256451199b-311 + x * 923140575090575960281429569584646159509857496569850532443973947641407848668443675573329097b-303))); testSupnorm(p,f,I,absolute,1b-5); I = [16389b-14;32779b-15]; p = 1038269096868805513534313111478982447499567985886901087470013707112958430927074529916221503b-300 + x * (461362512374905361205314477272078740242543628543999160703908952120861344496842228577269743b-299 + x * (1384753263446420894419446876259873246324214849677181076946472494396922068919278640451755047b-301 + x * (-151457372189742282380564974932184695701528669865661181732727523471584812692104667365872837b-310 + x * 1846337495070143691660987442551713494094189875111533870425503384713132809361507336644501653b-304))); testSupnorm(p,f,I,absolute,1b-5); I = [32779b-15;8195b-13]; p = 1038272623263017839914867268472181816124048738689268437118348367906699145773870774240355785b-300 + x * (922710923906524001945445745152899793118890970496765030462083763852500822751224932752694597b-300 + x * (346198887945090207628197443350771030623367818935766056578607553395243487815009400001806777b-299 + x * (-1327095570084590892482248321617848024550507093692816293544367981217834754916826593017873595b-313 + x * 1846393841678671252410388881767503175569108331880463934519747356162465088383552611134742243b-304))); testSupnorm(p,f,I,absolute,1b-5); I = [8195b-13;32781b-15]; p = 1038276150195205231598046738711326787177258175938486395650936392494584531982139206239184115b-300 + x * (1845393642684581673262535084218842151923675663720046624798283948403833291890563117846027567b-301 + x * (692418921992592502835948587721625658789940441742669912865045829664790944938388346827005581b-300 + x * (-90158700457546112553689981541875410522556478042701804576870900283483380686066639012347575b-309 + x * 1846450190006787079679592267911737638039999300863927226721933815878236131218424338147248637b-304))); testSupnorm(p,f,I,absolute,1b-5); I = [32781b-15;16391b-14]; p = 259569919416359157263353411595457107631487782846370515248264225272015360527824594363826399b-298 + x * (115335339632117571316138611855828589074790000759090941028960355593604439013749368475305519b-297 + x * (173110017507646127293946241187089077523281184437658863294068384210744593210320374774470417b-298 + x * (-389497472387211515714083349816328582000148764030707683808210862949049454218666003932452401b-311 + x * 923253270027271825969308891928787425004862776651570518692548000594247064900609481273701205b-303))); testSupnorm(p,f,I,absolute,1b-5); I = [16391b-14;32783b-15]; p = 259570801418445245015687903485943574498601360020182138502329261108536813923730828200157649b-298 + x * (922668611050302534080934898631305920411094546122620794898781179178634855962297002938501693b-300 + x * (692461220004294241312646047790092524767520494616918667790850352278478544328296882325785843b-300 + x * (-836723808545697939112234873358000218526157193537343518615496583467554964894103029621900829b-312 + x * 1846562891821993449259025858640069344956107939816934711188318981197769300250836168040094629b-304))); testSupnorm(p,f,I,absolute,1b-5); I = [32783b-15;2049b-11]; p = 259571683555076809930176139297683386955685058287604850979903763489274736505396093554902655b-298 + x * (230663625830551511027192226102459351920295795989831299121279326548326987787810106349780085b-298 + x * (1384964743827719028186000887082096548757082279105992481526183914645467274070385228978366589b-301 + x * (-894456195135440284141609327212459558817515685541830444876237823904260130502919981948908811b-312 + x * 230827405663648619164245755416442209740139242492784744544396974938886538140919673352686421b-301))); testSupnorm(p,f,I,absolute,1b-5); I = [2049b-11;32785b-15]; p = 1038290263305084370435415527035061707258965208781125421881811017400775982836689287832498437b-300 + x * (922640393872480403813800177925378752771650649922883158877492845194018352634074411452631987b-300 + x * (346251762879709075086714161479764494408878621778635937736199289312967985107888531917047479b-299 + x * (-1904384209409806576422326601306777292609996776581303101650200507548829594497052950791270799b-313 + x * 115417225032261415461139118025532499176730999418087825463225707062475600857604464856136861b-300))); testSupnorm(p,f,I,absolute,1b-5); I = [32785b-15;16393b-14]; p = 519146896464090670964582799011339625361876312484969902057815620146269561200434887534159019b-299 + x * (1845252565401909805550983016207725648118133331833299293068913447565582599940098460236009525b-301 + x * (692524681541107980021006426189471824108643433249699138962602974659896609355108049907080037b-300 + x * (-2019863074830693468602081973853455808051455628892417786481781217095104791718307892255975487b-313 + x * 1846731957443027016328279822610383179119522193788621019425224466359105936867359776524053851b-304))); testSupnorm(p,f,I,absolute,1b-5); I = [16393b-14;32787b-15]; p = 519148661544833565619506401790149170652856917396709726481254733925537369008626326938023379b-299 + x * (461306084903729408475343382353118217458409264416593990336519465374065414570142746343644699b-299 + x * (692545839259066841913693084826024353050072653235181386446947448934842222203991510311351165b-300 + x * (-533837246714018483463474683374017527963804145912645028413910010347015603890072616225241919b-311 + x * 230848539511221818330292254161201408213505190039127578629236006613941351929211061163522149b-301))); testSupnorm(p,f,I,absolute,1b-5); I = [32787b-15;8197b-13]; p = 1038300853789610722717431117998072253672745354894008819884081084657821028564524445454214615b-300 + x * (1845196110383642817345436810488640607378390169031036789043227353450295491835812658289636905b-301 + x * (692566998913432581940713261525895859800522806638943732672249466782621346213478048459687287b-300 + x * (-1125420972904246892390459207958219498521812206768675803782281061311812650143794730019899921b-312 + x * 461711169114119431600098837063457091400141886505066126250922281425831581589518701106964503b-302))); testSupnorm(p,f,I,absolute,1b-5); I = [8197b-13;32789b-15]; p = 519152192514040554016474742575321083410893084087098308865742453759215532184957245983602373b-299 + x * (1845167877707743853301029862315370528448617293542570314524618753478073223326233590600403577b-301 + x * (692588160504343054002943606963215449206110461234668475778759373903297649222417605048086595b-300 + x * (-1183170976005255979029315231480326390896172552224746358319575240469607883060061798171116925b-312 + x * 57715657454474657665133753721862497061635908198782446418079866976955624534919461456070095b-299))); testSupnorm(p,f,I,absolute,1b-5); sollya-6.0+ds/tests-tool/check015.sollya.reference000066400000000000000000000646221300174114700220760ustar00rootroot00000000000000=============== Check Supnorm #1 ================ 0.452055210438~2/7~e-4 =============== Check Supnorm #2 ================ 0.19806747803~2/4~e-13 =============== Check Supnorm #3 ================ 0.98349131972~2/3~e-7 =============== Check Supnorm #4 ================ 0.21506063323225200140627704573738261516804472792804345397057465~4/9~e-21 =============== Check Supnorm #5 ================ 0.25592360697351127~2/3~e-34 =============== Check Supnorm #6 ================ 0.230837749722228471996224448457~2/5~e-24 =============== Check Supnorm #7 ================ 0.244473007268597435777759018427526238220949802075798422683204541993260792417~3/5~e-57 =============== Check Supnorm #8 ================ 0.118837098347994659~3/5~e-13 =============== Check Supnorm #9 ================ 0.30893006200251428~5/6~e-13 =============== Check Supnorm #10 ================ 0.354286999761833306~0/4~e-13 =============== Check Supnorm #11 ================ 0.2182585220~3/4~e-8 =============== Check Supnorm #12 ================ The tool has been restarted. Computing remez polynomial... ... done. [2.9150195594381163050751171184060694940853863954544e-11;2.9150626491170440039760348051691990088531841740505e-11] =============== Check Supnorm #13 ================ The tool has been restarted. [1.86264514923095702963441286610736782251677989830085e-9;1.86264514923259815596971807301288924717139784082315e-9] =============== Check Supnorm #14 ================ The precision has been set to 70 bits. Testing example: supnorm( 11692536319630510474283968587625525849426869787677b-163 + x * (23384922893552793741208186896732057180708286140565b-164 + x * (46692941277611593554424973690517694800554713844979b-166 + x * (3891678517537147456387754739468835779118224484425b-164 + x * (1024072943597638219514404758611859127188920401873b-164 + x * 26154763285557255659575812244171511366994513699585b-171)))) , exp(x) , [-1;1] , absolute , 1b-40 ) The precision has been set to 70 bits. Testing example: supnorm( 23384026197294909850223840992809340481141545456185b-164 + x * (46768052394366389249957592514757698261837941537431b-165 + x * (1461501637882931916249380248092291325347144984355b-161 + x * (15589350524874704484650079886308075573528112666971b-166 + x * (31178718928032908530740508502853005869373616353571b-169 + x * (6235660318693530982722236353851527754167773984285b-169 + x * (16632313913972289150146538028615958190382830813395b-173 + x * (4737564581099604249852567829707944940460501354987b-174 + x * (19508173607844763061526398982921782866373719408881b-179 + x * (28028384585901080300830750040726581293938320938545b-183 + x * 44836930378672942548678299103511494860025777760483b-186))))))))) , exp(x) , [0;1] , absolute , 1b-40 ) The precision has been set to 70 bits. Testing example: supnorm( x * (1 + x * (2097145b-22 + x * (349527b-21 + x * (87609b-21 + 4369b-19 * x)))) , expm1(x) , [-1b-2;1b-2] , relative , 1b-40 ) The precision has been set to 235 bits. Testing example: supnorm( x * (117045327009867803036301574157545b-106 + x * (-58522663504933901606981166592605b-106 + x * (8663094464742397b-54 + x * (-6497320848515433b-54 + x * (2598928339549937b-53 + x * (-541446114948727b-51 + x * 3712726891772213b-54)))))) , log2(1 + x) , [-1b-9;1b-9] , relative , 1b-205 ) The precision has been set to 90 bits. Testing example: supnorm( 15651770362713997207607972106972745b-114 + x * (3476698806776688943652103662933b-101 + x * (17894972500311187082269807705171b-104 + x * (126976607296441025269345153102591b-106 + x * (249107378895562413495151944042799b-106 + x * (139053951649796304768149995225589b-104 + x * (165428664168251249501887921888847b-103 + x * (206167601873884163281098618631159b-102 + x * (66386611260133347295510390653099b-99 + x * (2433556521489987b-43 + x * (409716955440671b-39 + x * (2242518346998655b-40 + x * (3108616106416871b-39 + x * (4356285307071455b-38 + x * (6161286268548935b-37 + x * (8783550111623067b-36 + x * (788026560267325b-31 + x * (1138037795125313b-30 + x * (3304615966282565b-30 + x * (602367826671283b-26 + x * (1765006192104851b-26 + x * (1337636086941861b-24 + x * 986777691264547b-22))))))))))))))))))))) , asin(x + 770422123864867b-50) , [-205674681606191b-53;205674681606835b-53] , relative , 1b-60 ) The precision has been set to 130 bits. Testing example: supnorm( 127314748520905380391777835589720039729342145097661090748478447318618529015203604765566689b-296 + x * (-1176183728229793751637043660065847579890970982973992202018192057755975433302793198324426573b-376 + x * (-127314748520905380391738345892360756681131303903716098475473212933227449963198807170652229b-297 + x * (411157279064246494121991117766105005568223464883775477360093918816839730397410047916370811b-366 + x * (21219124753484230053862417678170235538726463899369620274583864671581237263849631540786577b-298 + x * (-1410502123645648389482990176064909235877375828877296670824273606862416549384926673212331083b-361 + x * (-724279458252261210504349594121335100771624524830702920999146885115456299525648100748351663b-308 + x * (134774797018080532192428177850854993385334368268780691241634121499347615118037692190732043b-352 + x * (1655495904576160557613610377255708869921184205441524773073593312341561508689495751645348449b-315 + x * (-1594094643995802407650998956215005582984707081147652766864332919805511367571909433687622335b-351 + x * (-294310383550327313556374414541449084070746487392752536766971007548680728836036254508146929b-319 + x * (512235774726334150822554392967816790007421386839936546743269207769528982853397644167067871b-346 + x * (1141573461565483381928707239907860736890956525739802194008371659491759020277390103225113401b-328 + x * (-1569482484524507248868121030716379419120450572564469525806037183646518163382197401885965253b-347 + x * (-1614534504445457486506762534809318663084383593349434912234239957430266631356959991774123565b-336 + x * (-1712106093024186385498521252470153327699204358233691202131099406230733496689604124499970149b-343))))))))))))))) , cos(x) , [-1b-1;1b-2] , relative , 1b-100 ) The precision has been set to 280 bits. Testing example: supnorm( 1291124939043454294827959586001505937164852896414611756415643039531479680609629260097919725377401206658955423510867812933b-399 + x * (1291124939043454294827959586001505937164852896414611756407759293348856964764186953322986589460672969435069958748491718283b-399 + x * (1291124939043454294827959586001505937164852896414611742842916313201487217248242990712587184030633906090137602556193308777b-400 + x * (1721499918724605726437279448002007916219803861886149410406732804556694110264268799366882772800656159765418763369767923869b-402 + x * (1721499918724605726437279448002007916219803861886928049851542292580594202097368397525596049532723601180890716568841852971b-404 + x * (688599967489842290574911779200803166487921544748146677805317095693650672977111381945276005270502268669363247750562141109b-405 + x * (918133289986456387433215705601070888650562042107828893577378984985802017340780034420418039342182577636371604545753247685b-408 + x * (2098590377111900314133064469945304888344142586006558021664462294500550566006715853849729548335450138563444975611072384915b-412 + x * (2098590377111900314133064469945304888345787506900621321180727067543258071161052823401917797089874824160141551745303600509b-415 + x * (932706834271955695170250875531246617029863789325186530775644670361528998993026253332715955100711707177976542185420125885b-417 + x * (186541366854391139034050175106249317675194606310468992601212125887714941698557011635643430617148947777325881970320599911b-418 + x * (2170663177942005981487129310327265817430136743794322761791212108289168199121016399511022765792217934974290164512400558051b-425 + x * (723554392647335327162376436776575188728320134851889625237160943201761614313054850997686096169392444013734775049800364135b-427 + x * (445264241629129432099923961086461053843117889043738115595645570179588863813466486158437851805221549064027305469772175195b-430 + x * (1017746838009438701942683300338197780799042429908471623542287463474569859335113951279406783547674904661405075222370152653b-435 + x * (271399156802516987184715668022449290765604321334910931946270618816084433310692805993200010568980374341586319016626039405b-437 + x * (2171193254420135897480301350825607712011172107075923446450599655895677713120365969751962821314954760562289074188094789451b-444 + x * (2043476004160127903487494000509588015818708867395743746978714423885089009799059654843663103804548054018562648174876580061b-448 + x * (908211557404501261461971507657492862559270740528797479096948806118152290717219182619080722630251277564118402740142879215b-451 + x * (1529619465102318290396191335466982351668824576419822769979570691542070957164975362583515486255615591549174162951007028183b-456 + x * (1223695572082734528475377304206308178928295327141464300806858140000189195058732384055167155268721672655962320814134386585b-460 + x * (466169741743865438694533850917589402256859012268885527875904121812833883515506233431119922322746057508112973882086354899b-463 + x * (339032535142399295985553596850309623127346596956633233039500677601672953959025144616613616695701925012721839172059538925b-467 + x * (1886789853182169718590609346799899921135706970254622139162686047099233945700405342620686331475908007094622992876398666851b-474 + x * (2516112710027923243369908368888976324181415757063417914589335963128261275982808145367994972728592019136949818934599107321b-479 + x * 1609827695620693077847485865687191912593223271819829393342670614997995102920099238219568170602045477783711943005139617211b-483)))))))))))))))))))))))) , exp(x) , [-1b-3;1b-3] , relative , 1b-250 ) The precision has been set to 90 bits. Testing example: supnorm( -347829885687651467b-246 + x * (803469022129285046899203980724876839838081336629987901112093b-199 + x * (109096980796689175283906477509258920482015377728962864177675b-376 + x * (-1071292029371495160966220394362561448878316413905740061801453b-202 + x * (-895936839379960786335981881158765658035426638215168714136065b-374 + x * (107129196922888615341858264807183824745523003519500238173771b-203 + x * (549328822047401762664326673644414324304203438857246608800061b-370 + x * (-163240970783780006076567571219952019240960058303028805468663b-209 + x * (-1596659384420598775289000423725712515716892556010679852042289b-370 + x * 288403825950454274847258834876617249588530907170098884348709b-216)))))))) , sin(x) , [-1b-1;1b-1] , absolute , 1b-60 ) The precision has been set to 90 bits. Testing example: supnorm( 714564886172317927063761490159801881657790980941829344505187b-196 + x * (1258278747211590164438565899307058663065266457630726920586347b-198 + x * (-1202878917246296858587934180920738608442450059984305974754429b-195 + x * (1347350830264911057006851046105206644501121822225011999522971b-194 + x * (-1411317735908160715166251154609539762583930758208235515249453b-193 + x * (73796213723185208671599520928107052835549956637208706117423b-188 + x * (-1400829552020409071501690715419925186599874208109719920625025b-192 + x * (1180386509055370140909826097725837306233406594495350257599181b-192 + x * (-1440803466241145176052471822037050974100822411994796391357023b-193 + x * (1285581190272567034084556062052191954533209585841927847519185b-194 + x * (-832171048091233324734778875003324601584470829671170926930407b-195 + x * (1516396334943608786362280214735888311251638283061986162266693b-198 + x * (-113252562973107828059488836912840143838508857783935522775583b-197 + x * (296982459360723712812328947424418991885288241395500095736051b-202 + x * (-1304662018163848750887736589024039856901512907618757724445671b-210 + x * (-1458138089985030045170976059909283198365479948394215945263081b-213))))))))))))))) , exp(cos(x)^2 + 1) , [1;2] , relative , 1b-60 ) The precision has been set to 90 bits. Testing example: supnorm( 273663424726598609884436588659142529896812070463680189713577b-217 + x * (803437057336964936961730558645726525457791801950137631592037b-199 + x * (225505423592202238519775811845273269657276115111137681553489b-208 + x * (528444817941611504637035117719962221857671105434203759656937b-200 + x * (1239694968725463472760134669503154963255295977288296254470181b-205 + x * (1130131417499222086385911795575835445432295919090159931462145b-204 + x * (1491287505779580922293205133224642959388076368487724135077821b-202 + x * (-1171551728340426070339628381549725358789127811584978046693913b-201 + x * (406987388528718637810250849111810189760762571987387168281935b-199 + x * (-143338466912831507573865657425240839471014755173174001588205b-198 + x * 909290520151942024628769491295084023281483044413748718543747b-202))))))))) , tan(x) , [1b-2;1b-1] , relative , 1b-60 ) The precision has been set to 65 bits. Testing example: supnorm( 30384532462332540461916109637629717389849711316821b-171 + x * (-31904713954983344143590115593939596870834806750785b-168 + x * (3202922742084579220140950796580716782899394760489b-162 + x * (15112977993516225491652585788177447394030781112913b-164 + x * (-7069971332398015962219468854462076062374294828243b-165 + x * (7083002129884149408404809852482217256950901287813b-167 + x * (-37227478455235357414551691036580021152370979146031b-172 + x * 45273032627293166114769155909287202062101002901785b-176)))))) , x^5b-1 , [1;2] , relative , 1b-35 ) The precision has been set to 46 bits. Testing example: supnorm( x + 4801351491244397b-59 * x^5 + -1501199687800369b-53 * x^3 , sin(x) , [-1b-3;1b-3] , relative , 1b-16 ) The precision has been set to 70 bits. Testing example: supnorm( 1b-29 + 13712467b-36 * x^7 + 11891967b-33 * x^6 + 4473851b-29 * x^5 + 11185277b-28 * x^4 + 11184811b-26 * x^3 + 4194303b-23 * x^2 + x + 1 , exp(x) , [-1b-3;1b-3] , absolute , 1b-40 ) The precision has been set to 300 bits. The precision has been set to 35 bits. Testing example: supnorm( 519116931250074582514616920029812964033041191732166366208315683368591845444321107391435481b-299 + x * (461432969284079015555143407908324792312068012734235836652935285714259885748478589922847529b-299 + x * (346082648236258546966032322765771598479520265273144739387947665823565730921236322003050251b-299 + x * (-1845774007687049558287217203353987444440450373590070022669568374961280228727054054051744831b-318 + x * 1845774123550678624355073867555708750724188033665817979913979575189149376462087383277483735b-304))) , exp(x) / 2 , [1;32769b-15] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 259559345879600238994341752459837595545898720439675950801653623776773076903600946303425701b-298 + x * (461425927462476339021923881761660260730722077159602256751190602125239693445609261724005265b-299 + x * (173046605323160776594250612156380219803360425927054552866876177566765761644836318442542137b-298 + x * (-1384372810757865863246870774013473664314069086622551199217497615213803454026373438271894305b-316 + x * 922915226483104741726827502416104539849150495728611277321715440071753646193388254121647135b-303))) , exp(x) / 2 , [32769b-15;16385b-14] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 1038240905073938809564185146674779242326355205294558935393649861808689793476646895917998267b-300 + x * (1845675539125013381333631624704875717580705390911799805070033763505954280685015813184580603b-301 + x * (346103774023416837754962784984162191045292920130593796757336225574631447590348180153720899b-299 + x * (-576839612789582407852511079083681823850070896509088950771773952643899923582045367370743271b-314 + x * 1845886784100803912445798173029574729693497483658677219270101727506998653158623117662166741b-304))) , exp(x) / 2 , [16385b-14;32771b-15] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 259561106791707898293039710633779037559822312544256220625440469079039924536763394805587147b-298 + x * (922823682480649549181635253331914708804520679107862064077300309229451099522323876193792447b-300 + x * (692228676735226522485987916737252642808432088179842657020342965630357539103964428753876415b-300 + x * (-1615200212850920429100564708444107526276999411623835378169119182171976132997095979778353947b-315 + x * 1845943116954514373788808938428499536418675482610443460189101910631877163996812552600989749b-304))) , exp(x) / 2 , [32771b-15;8193b-13] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 259561987449287045372398701594868201437910171545243585338079477748382151643808715566064285b-298 + x * (461404796839605360090310517684534574578803789973564267751021643064931898303836675409485003b-299 + x * (1384499614715918752531672507766016877483227007979622376860398775113317547154472447117451495b-301 + x * (-519187342120898954534613462928357592655366197366771351797841056730732196163723897029023901b-313 + x * 461499862881848332885261109186422889231489482986384996333218781467310163853332033421724343b-302))) , exp(x) / 2 , [8193b-13;32773b-15] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 1038251472964957456511274192114220005337879717080719570375573248266731133533241225649522435b-300 + x * (1845591006316039313290133964477145081689851856783638624326715045513174026252404653737886631b-301 + x * (692270939915169973615995000980032897935311272581302256923437696401939708362861132946356933b-300 + x * (-1269163346883319747703475308401267430788360043492450542435418710231856874897867418320603237b-314 + x * 1846055787819493251361962234095780806068142607601605103638827981559814019954344633044560891b-304))) , exp(x) / 2 , [32773b-15;16387b-14] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 519127498335164153769545486623552954988858606273181999481850530462359154784932201346547583b-299 + x * (57673838182306612371522122429243846436523792555944999449682277907052548272208183655835053b-296 + x * (1384584148813992118218502092824141150820996752581358234459863858555017921829378462850028367b-301 + x * (-749983047497388110438910296743146915050879640660709438285264950717168395163254780340785913b-313 + x * 923056062915433300256084594722183984064011594047292071874020456477159522961651084828636705b-303))) , exp(x) / 2 , [16387b-14;32775b-15] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 1038258520913329631182690364241114017060837400037458356533335658790054633062991223135847083b-300 + x * (922767316955698569835057986917688386448502196160618545538697046612402761485504819176131747b-300 + x * (1384626421667150770250077157787397840104496347465470608587010281772184260559770572844451389b-301 + x * (-1730782929220944054148482567938745159575983219937856205356812931355746976103146441344064741b-314 + x * 923084232780782923926735159276129795162580209945750248756228435482594096783073927189113911b-303))) , exp(x) / 2 , [32775b-15;4097b-12] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 1038262045694030331360107288571033481310845936055396192569911648051621914710101903264082523b-300 + x * (1845506442548454768920116619308727687991614007806277523964786136086245050686512829575540843b-301 + x * (173083587298761427962455984082138996639756712278337144683760477571124473370811720671440019b-298 + x * (-1961613850206626209203908481303935475641262125973990140990420781913512806725438551266796249b-314 + x * 28847262609556929122639338428295863535850904646269632285682528473324343941472711236120323b-298))) , exp(x) / 2 , [4097b-12;32777b-15] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 519132785506249659649202446742857299970401223489329249721092671862612630646516898175534471b-299 + x * (922739123872321640347645406112487210240542424232485865309181772337452142304813401978565157b-300 + x * (1384710978983089614554980944010000553236544926984416074420180493723390468154027020533019691b-301 + x * (-274057357324581485608201308026878795188066463784519077329794224330771414587511991256451199b-311 + x * 923140575090575960281429569584646159509857496569850532443973947641407848668443675573329097b-303))) , exp(x) / 2 , [32777b-15;16389b-14] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 1038269096868805513534313111478982447499567985886901087470013707112958430927074529916221503b-300 + x * (461362512374905361205314477272078740242543628543999160703908952120861344496842228577269743b-299 + x * (1384753263446420894419446876259873246324214849677181076946472494396922068919278640451755047b-301 + x * (-151457372189742282380564974932184695701528669865661181732727523471584812692104667365872837b-310 + x * 1846337495070143691660987442551713494094189875111533870425503384713132809361507336644501653b-304))) , exp(x) / 2 , [16389b-14;32779b-15] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 1038272623263017839914867268472181816124048738689268437118348367906699145773870774240355785b-300 + x * (922710923906524001945445745152899793118890970496765030462083763852500822751224932752694597b-300 + x * (346198887945090207628197443350771030623367818935766056578607553395243487815009400001806777b-299 + x * (-1327095570084590892482248321617848024550507093692816293544367981217834754916826593017873595b-313 + x * 1846393841678671252410388881767503175569108331880463934519747356162465088383552611134742243b-304))) , exp(x) / 2 , [32779b-15;8195b-13] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 1038276150195205231598046738711326787177258175938486395650936392494584531982139206239184115b-300 + x * (1845393642684581673262535084218842151923675663720046624798283948403833291890563117846027567b-301 + x * (692418921992592502835948587721625658789940441742669912865045829664790944938388346827005581b-300 + x * (-90158700457546112553689981541875410522556478042701804576870900283483380686066639012347575b-309 + x * 1846450190006787079679592267911737638039999300863927226721933815878236131218424338147248637b-304))) , exp(x) / 2 , [8195b-13;32781b-15] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 259569919416359157263353411595457107631487782846370515248264225272015360527824594363826399b-298 + x * (115335339632117571316138611855828589074790000759090941028960355593604439013749368475305519b-297 + x * (173110017507646127293946241187089077523281184437658863294068384210744593210320374774470417b-298 + x * (-389497472387211515714083349816328582000148764030707683808210862949049454218666003932452401b-311 + x * 923253270027271825969308891928787425004862776651570518692548000594247064900609481273701205b-303))) , exp(x) / 2 , [32781b-15;16391b-14] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 259570801418445245015687903485943574498601360020182138502329261108536813923730828200157649b-298 + x * (922668611050302534080934898631305920411094546122620794898781179178634855962297002938501693b-300 + x * (692461220004294241312646047790092524767520494616918667790850352278478544328296882325785843b-300 + x * (-836723808545697939112234873358000218526157193537343518615496583467554964894103029621900829b-312 + x * 1846562891821993449259025858640069344956107939816934711188318981197769300250836168040094629b-304))) , exp(x) / 2 , [16391b-14;32783b-15] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 259571683555076809930176139297683386955685058287604850979903763489274736505396093554902655b-298 + x * (230663625830551511027192226102459351920295795989831299121279326548326987787810106349780085b-298 + x * (1384964743827719028186000887082096548757082279105992481526183914645467274070385228978366589b-301 + x * (-894456195135440284141609327212459558817515685541830444876237823904260130502919981948908811b-312 + x * 230827405663648619164245755416442209740139242492784744544396974938886538140919673352686421b-301))) , exp(x) / 2 , [32783b-15;2049b-11] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 1038290263305084370435415527035061707258965208781125421881811017400775982836689287832498437b-300 + x * (922640393872480403813800177925378752771650649922883158877492845194018352634074411452631987b-300 + x * (346251762879709075086714161479764494408878621778635937736199289312967985107888531917047479b-299 + x * (-1904384209409806576422326601306777292609996776581303101650200507548829594497052950791270799b-313 + x * 115417225032261415461139118025532499176730999418087825463225707062475600857604464856136861b-300))) , exp(x) / 2 , [2049b-11;32785b-15] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 519146896464090670964582799011339625361876312484969902057815620146269561200434887534159019b-299 + x * (1845252565401909805550983016207725648118133331833299293068913447565582599940098460236009525b-301 + x * (692524681541107980021006426189471824108643433249699138962602974659896609355108049907080037b-300 + x * (-2019863074830693468602081973853455808051455628892417786481781217095104791718307892255975487b-313 + x * 1846731957443027016328279822610383179119522193788621019425224466359105936867359776524053851b-304))) , exp(x) / 2 , [32785b-15;16393b-14] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 519148661544833565619506401790149170652856917396709726481254733925537369008626326938023379b-299 + x * (461306084903729408475343382353118217458409264416593990336519465374065414570142746343644699b-299 + x * (692545839259066841913693084826024353050072653235181386446947448934842222203991510311351165b-300 + x * (-533837246714018483463474683374017527963804145912645028413910010347015603890072616225241919b-311 + x * 230848539511221818330292254161201408213505190039127578629236006613941351929211061163522149b-301))) , exp(x) / 2 , [16393b-14;32787b-15] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 1038300853789610722717431117998072253672745354894008819884081084657821028564524445454214615b-300 + x * (1845196110383642817345436810488640607378390169031036789043227353450295491835812658289636905b-301 + x * (692566998913432581940713261525895859800522806638943732672249466782621346213478048459687287b-300 + x * (-1125420972904246892390459207958219498521812206768675803782281061311812650143794730019899921b-312 + x * 461711169114119431600098837063457091400141886505066126250922281425831581589518701106964503b-302))) , exp(x) / 2 , [32787b-15;8197b-13] , absolute , 1b-5 ) The precision has been set to 35 bits. Testing example: supnorm( 519152192514040554016474742575321083410893084087098308865742453759215532184957245983602373b-299 + x * (1845167877707743853301029862315370528448617293542570314524618753478073223326233590600403577b-301 + x * (692588160504343054002943606963215449206110461234668475778759373903297649222417605048086595b-300 + x * (-1183170976005255979029315231480326390896172552224746358319575240469607883060061798171116925b-312 + x * 57715657454474657665133753721862497061635908198782446418079866976955624534919461456070095b-299))) , exp(x) / 2 , [8197b-13;32789b-15] , absolute , 1b-5 ) sollya-6.0+ds/tests-tool/check016.sollya000066400000000000000000000717621300174114700201450ustar00rootroot00000000000000/* Set of tests for pattern matching support */ /* Pattern matching in Sollya Let's look at syntax and typing first. match-with constructs in Sollya are, like in Ocaml, expressions that evaluate to the value of the matching expression. Concerning syntax, please pay attention to the fact that the parentheses around the expression to return in the case of a match are mandatory. */ match exp(x) with exp(x) : (1) sin(x) : (2) default : (3); match sin(x) with exp(x) : (1) sin(x) : (2) default : (3); (match exp(x) with exp(x) : (1) sin(x) : (2) default : (3)) + 16; /* Nevertheless, as Sollya basically is an imperative language, pattern expressions can also be blocks of code, finished by a return statement. */ match exp(x) with exp(x) : { print("We are matching an exponential function."); return 1; } sin(x) : { print("We are matching a sine function."); return 2; } default : { print("We are matching something else."); return 1; }; (match exp(x) with exp(x) : { print("We are matching an exponential function."); return 1; } sin(x) : { print("We are matching a sine function."); return 2; } default : { print("We are matching something else."); return 1; }) + 16; /* In the case when no return statement is given, the matching code block evaluates to void. void is not autoprinted on the Sollya prompt. */ match exp(x) with exp(x) : { print("We are matching an exponential function."); } sin(x) : { print("We are matching a sine function."); } default : { print("We are matching something else."); }; /* As already illustrated by examples, default matches any expression when the whole expression given to match is correctly typed. */ match exp(x) with sin(x) : ("Sine") default : ("Something else"); match "Hello" with sin(x) : ("Sine") default : ("Something else"); match sin(exp(x)) with sin(default) : ("Sine") default : ("Something else"); /* If no default case is given and no other pattern matches, the match-with construct evaluates to error and an warning message is printed. */ match "Hello" with exp(x) : (1) sin(x) : (2); /* Pattern matching allows free variables to be bound, as long as they are different from the free mathematical variable. This is the main feature of pattern matching. The following examples illustrate that behavior. */ match [| 1, 2, 3, 4 |] with [||] : { print("Empty list"); } [| 1, a, 3, 4 |] : { print("List of four elements, starting with 1, ending with 3, 4 and ", a, " in second position"); } b : { print("Something else, for instance ", b); }; match [| 1, exp(x), 3, 4 |] with [||] : { print("Empty list"); } [| 1, a, 3, 4 |] : { print("List of four elements, starting with 1, ending with 3, 4 and ", a, " in second position"); } b : { print("Something else, for instance ", b); }; match exp(sin(x)) with exp(a) : { print("Exponential of ", a); } sin(b) : { print("Sine of ", b); } default : { print("Something else"); }; match sin(exp(atan(x + 3))) with exp(a) : { print("Exponential of ", a); } sin(b) : { print("Sine of ", b); } default : { print("Something else"); }; match exp(sin(atan(x + 3))) with exp(f(atan(x + 3))) : (f) exp(g(x + 2)) : (g); match exp(sin(atan(x + 2))) with exp(f(atan(x + 3))) : (f) exp(g(x + 2)) : (g); /* All variables in the patterns are new local variables that shadow other variables of the same name defined in the context. The variables in the patterns are *not* evaluated before evaluating the match-with construct (otherwise shadowing would make no sense and the semantics of the match-with construct would depend on the context). */ a = 5; b = 6; match exp(x + 3) with exp(a + b) : { print("Exponential"); print("a = ", a); print("b = ", b); } sin(x) : { print("Sine of x"); }; print("a = ", a); print("b = ", b); /* It is possible to declare other auxilliary local variables in the block evaluated for each pattern. These variables shadow the variables bound by pattern evaluation. */ a = 5; b = 6; match exp(x + 3) with exp(a + b) : { var a, c; a = 17; c = "Hallo"; print("Exponential"); print("a = ", a); print("b = ", b); print("c = ", c); } sin(x) : { print("Sine of x"); }; print("a = ", a); print("b = ", b); /* The use of variables in the pattern does not need to be linear. In other words, a free variable may appear twice or more times in a same pattern. The pattern will match only if in both occurences of the same variable the same subtree is found. Sollya will apply structural identity for these tests; not mathematical or floating-point identity. This means it will not be able to discover that a = 5 + 1 may also match the subtree 6. */ match exp(sin(x)) + sin(x) with exp(a) + a : { print("Winner"); print("a = ", a); } default : { print("Loser"); }; match exp(sin(x)) + cos(x) with exp(a) + a : { print("Winner"); print("a = ", a); } default : { print("Loser"); }; match exp(atan(x + 17)/19) + atan(x + 17)/19 with exp(a) + a : { print("Winner"); print("a = ", a); } default : { print("Loser"); }; /* The following symbolic operations are allowed in patterns: - .: (prepend), :. (append) and @ (concat) on lists. - @ (concat) on strings. - [| a, b, c |] (symbolic instantiation) on lists - [| a, 1, ..., 5, b |] (sequences of natural numbers) on lists Symbolic sequences of natural numbers are however excluded, i.e. [| a, ..., b |] will never match, even if there exists two integers a and b in the beginning and in the end of the list for which the expansion were possible. - Instantiation of symbolic ranges. If at least one bound is explicitly given, outward rounding is correctly applied. While it is possible to match point intervals using the expression [a], there is no support for symbolic midpointconstants (things like 1.2345~a/b~ which would match all ranges between 1.23450 and 1.23459 and would bind a and b to the appropriate number) - Instantiation of symbolic structures, see below. Currently there is a limitation for the concat operator @. Matches can only be found if there (recursively) is a prefix or a postfix of the list or string that is not symbolic. This means a @ b is not allowed as it would have to cut the matching list or string at an arbitrary length. */ match [| 1, 2, 3, 4 |] with a .: [| 2, 3, 4 |] : { print(a," prepended to a list of elements 2, 3 and 4"); } a .: b : { print(a," prepended to ", b); } default : { print("something else"); }; match [| 1, 2, 3, 5 |] with a .: [| 2, 3, 4 |] : { print(a," prepended to a list of elements 2, 3 and 4"); } a .: b : { print(a," prepended to ", b); } default : { print("something else"); }; match [| 1, ..., 17 |] with a .: [| 2 , ... , 16, c |] : { print(a," prepended to a list ending in ", c); } a .: b : { print(a," prepended to ", b); } default : { print("something else"); }; match [| 1, ..., 17 |] with [| 1 , ... , 16 |] :. a : { print(a," appended to a list"); } a :. b : { print(b," appended to ", b); } default : { print("something else"); }; match "Hello world" with "Hello" @ a : { print("Salut", a); } default : { print("something else"); }; match "Hello world" with a @ "world" : { print("Salut =", a); } default : { print("something else"); }; match [| 1, 2, 3, 4, 5 |] with a @ [| 4, 5 |] : { print(a); } b @ [| 5, c |] : { print(b,c); } default : { print("something else"); }; match [| 1, 2, 3, 4, 5, 6 |] with a @ [| 4, 5 |] : { print(a); } b @ [| 5, c |] : { print(b,c); } default : { print("something else"); }; match [1;2] with [3;4] : { print("Interval between 3 and 4"); } [a;2] : { print("Interval between ",a," and 2"); } default : { print("something else"); }; match exp([1;2]) with [a;b] : { print(a,b); } default : { print("something else"); }; /* Pattern matching is possible on literate structures with variable binding. It is not possible on structure dereferentiation, regardless of binding the matched structure or not. (No support for "match thing with a.b.c : ...") */ structure.f = exp(x); structure.dom = [1;2]; structure.formats = [| DD, D, D, D |]; match structure with { .f = sin(x); .dom = [a;b] } : { print("Sine",a,b); } { .f = exp(c); .dom = [a;b]; .point = default } : { print("Exponential",a,b,c); } { .f = exp(x); .dom = [a;b] } : { print("Exponential",a,b); } default : { print("Something else"); }; structure.f = sin(x); match structure with { .f = sin(x); .dom = [a;b] } : { print("Sine",a,b); } { .f = exp(c); .dom = [a;b]; .point = default } : { print("Exponential",a,b,c); } { .f = exp(x); .dom = [a;b] } : { print("Exponential",a,b); } default : { print("Something else"); }; structure.f = exp(x + 2); structure.point = 23; match structure with { .f = sin(x); .dom = [a;b] } : { print("Sine",a,b); } { .f = exp(c); .dom = [a;b]; .point = default } : { print("Exponential",a,b,c); } { .f = exp(x); .dom = [a;b] } : { print("Exponential",a,b); } default : { print("Something else"); }; /* Shall we match variable content ? Yes of course! */ f = exp(x); match f with sin(x) : (1) cos(x) : (2) exp(x) : (3) default : (4); /* It works even for more complicated expressions */ f = sin(x)+cos(exp(x)); match f with a + b : { print("Addition of ", a, " and ", b); } default : { printf("Failure"); }; /* Does a match look into variables, or are they simply rebound? If so, do the variables recover their previous value, when exiting the match? Answer: they are rebound, and they recover their old value after the match. */ a = 2; match f with a + b : { print("Addition of ", a, " and ", b); } default : { printf("Failure"); }; a; b; /* If a pattern does not match in a list, we look at the next one, as expected */ match [| 1, 2, 3, 5 |] with [||] : { print("Empty list"); } [| 1, a, 3, 4 |] : { print("List of four elements, starting with 1, ending with 3, 4 and ", a, " in second position"); } b : { print("Something else, for instance ", b); }; /* If several pattern match the expression, only the first matching one is considered */ match [| 1, 2, 3, 4 |] with [||] : { print("Empty list"); } b : { print("Something else, for instance ", b); } [| 1, a, 3, 4 |] : { print("List of four elements, starting with 1, ending with 3, 4 and ", a, " in second position"); }; /* If a variable exists and is not used in a pattern, does it keep its old value, or is it shadowed? Answer: it keeps its old value. */ a = 5; b = 6; match exp(x + 3) with exp(a + 3) : { print("We matched exp(a+3)"); print("with a = ", a); print("b remains ", b); } sin(x) : { print("Sine of x"); }; /* We cannot use an existing variable in a pattern (since it would immediately be rebound), but we can test the equality a posteriori. */ b = 4; match exp(x + 6) with exp(a + c) : { if (b==c) then { print("Exponential : a+b with a = ",a); } else { print("Exponential : a+c with a = ",a, " and c = ", c); }; } sin(x) : { print("Sine of x"); }; b = 6; match exp(x + 6) with exp(a + c) : { if (b==c) then { print("Exponential : a+b with a = ",a); } else { print("Exponential : a+c with a = ",a, " and c = ", c); }; } sin(x) : { print("Sine of x"); }; /* Can we use "@" arbitrarily in lists? Answer: no. */ match [|1,2,3,4|] with a@b: {print(a); print(b);} default: {print("nothing");}; /* Is the interval [pi] matched as an exact [pi; pi]? Answer: no, it is evaluated first. */ match [pi] with [a, b] : { if (a==b) then { print("It works!"); } else { print("It does not work, though pi==pi returns ", pi==pi); }; } default: { print("nothing"); }; /* Can we match a constant expression inside an interval? Answer: yes */ match [1;pi] with [a; pi] : { print("We detected [",a,", pi]"); } default : { print("Failure"); }; /* We can use a match to affect several variables simultaneously. However, the variables are bound only until the end of the match. */ d=[1;2]; match d with [a;b]: {print("a=", a,"and b=",b);}; /* An expression involving intervals is evaluated before being matched. */ match exp([1;2]) with [a;b] : { print(a,b); } default : { print("something else"); }; /* Can we match an expression involving intervals, as an expression? Answer: no. */ match exp([1;2]) with exp([a;b]) : { print(a,b); } default : { print("something else"); }; /* Can we at least recover that it was exp of an interval? Answer: no. */ match exp([1;2]) with exp(a) : { print(a,b); } default : { print("something else"); }; /* Can we see that [pi] is a point interval? Answer: no, the information is lost in the evaluation of [pi], performed before the pattern matching. */ match [pi] with [a;a] : { print("[a, a] with a = ",a); } default: { print("Failure"); }; /* But of course, it works when the point-interval is exactly representable. */ match [3] with [a;a] : { print("[a, a] with a = ",a); } default: { print("Failure"); }; /* default appears to be an allowed keyword when matching structures, with the same behavior as "_" in OCaml. Does it work everywhere? */ match (1/17)+2 with a+default : { print("a + something with a = ",a); } default : { print("Failure"); }; /* Some additional tests for lists and end-elliptic lists */ match [| 1, 2, 3, 4, D... |] with a @ [| 4, D...|] : (a); match [| 1, 2, 3, 4, D... |] with a @ [| D...|] : (a); match [| 1, 2, 3, 4... |] with a @ [| 3...|] : (a); match [| 1, 2, 3, 4... |] with a @ [| 4...|] : (a); match [| 1, 2, 3, 4... |] with a @ [| 17...|] : (a); match [| 1, 2, 3, 19... |] with a @ [| 171...|] : (a); match [| exp(sin(x)), sin(x), 4, DE(x), 9... |] with exp(a) .: (a .: (([||] :. 4) @ (b @ [| 13... |]))) : { print("a = ", a, ", b = ", b); }; /* The examples from the documentation */ match exp(x) with exp(x) : (1) sin(x) : (2) default : (3); match sin(x) with exp(x) : (1) sin(x) : (2) default : (3); match exp(sin(x)) with exp(x) : ("Exponential of x") exp(sin(x)) : ("Exponential of sine of x") default : ("Something else"); match exp(sin(x)) with exp(x) : ("Exponential of x") exp(a) : ("Exponential of " @ a) default : ("Something else"); procedure differentiate(f) { return match f with g + h : (differentiate(g) + differentiate(h)) g * h : (differentiate(g) * h + differentiate(h) * g) g / h : ((differentiate(g) * h - differentiate(h) * g) / (h^2)) exp(x) : (exp(x)) sin(x) : (cos(x)) cos(x) : (-sin(x)) g(h) : ((differentiate(g))(h) * differentiate(h)) x : (1) h(x) : (NaN) c : (0); }; differentiate(exp(sin(x + x))); diff(exp(sin(x + x))); restart; match exp(sin(x)) with exp(a) : { write("Exponential of ", a, "\n"); return a; } sin(x) : { var foo; foo = 17; write("Sine of x\n"); return foo; } default : { write("Something else\n"); return true; }; match sin(x) with exp(a) : { write("Exponential of ", a, "\n"); return a; } sin(x) : { var foo; foo = 17; write("Sine of x\n"); return foo; } default : { write("Something else\n"); return true; }; match acos(17 * pi * x) with exp(a) : { write("Exponential of ", a, "\n"); return a; } sin(x) : { var foo; foo = 17; write("Sine of x\n"); return foo; } default : { write("Something else\n"); return true; }; restart; a = 5; b = 6; match exp(x + 3) with exp(a + b) : { print("Exponential"); print("a = ", a); print("b = ", b); } sin(x) : { print("Sine of x"); }; print("a = ", a, ", b = ", b); a = 5; b = 6; match exp(x + 3) with exp(a + b) : { var a, c; a = 17; c = "Hallo"; print("Exponential"); print("a = ", a); print("b = ", b); print("c = ", c); } sin(x) : { print("Sine of x"); }; print("a = ", a, ", b = ", b); restart; match exp(sin(x)) + sin(x) with exp(a) + a : { print("Winner"); print("a = ", a); } default : { print("Loser"); }; match exp(sin(x)) + sin(3 * x) with exp(a) + a : { print("Winner"); print("a = ", a); } default : { print("Loser"); }; f = exp(x); match f with sin(x) : (1) cos(x) : (2) exp(x) : (3) default : (4); restart; match 5 + (1/3) with (1/3) + 5 : ("One third plus five") 16/3 : ("Sixteen thirds") 5 + (1/3) : ("Five plus one third"); match 16/3 with (1/3) + 5 : ("One third plus five") 16/3 : ("Sixteen thirds") 5 + (1/3) : ("Five plus one third"); match (1/3) + 5 with (1/3) + 5 : ("One third plus five") 16/3 : ("Sixteen thirds") 5 + (1/3) : ("Five plus one third"); match [1; 5 + 1] with [1; 1 + 5] : ("Interval from one to one plus five") [1; 6] : ("Interval from one to six") [1; 5 + 1] : ("Interval from one to five plus one"); match [1; 6] with [1; 1 + 5] : ("Interval from one to one plus five") [1; 6] : ("Interval from one to six") [1; 5 + 1] : ("Interval from one to five plus one"); restart; match exp(x) with sin(x) : ("Sine of x") atan(x^2) : ("Arctangent of square of x") default : ("Something else") exp(x) : ("Exponential of x"); match atan(x^2) with sin(x) : ("Sine of x") atan(default^2) : ("Arctangent of the square of something") default : ("Something else"); match atan(exp(x)^2) with sin(x) : ("Sine of x") atan(default^2) : ("Arctangent of the square of something") default : ("Something else"); match exp("Hello world") with exp(default) : ("A miracle has happened") default : ("Something else"); restart; procedure detector(obj) { match obj with exp(a * x) : { "Exponential of ", a, " times x"; } [ a; 17 ] : { "An interval from ", a, " to 17"; } [| |] : { "Empty list"; } [| a, b, 2, exp(c) |] : { "A list of ", a, ", ", b, ", 2 and ", "exponential of ", c; } a @ [| 2, 3 |] : { "Concatenation of the list ", a, " and ", "the list of 2 and 3"; } a .: [| 9 ... |] : { a, " prepended to all integers >= 9"; } "Hello" @ w : { "Hello concatenated with ", w; } { .a = sin(b); .b = [c;d] } : { "A structure containing as .a the ", "sine of ", b, " and as .b the range from ", c, " to ", d; } perturb : { "The special object perturb"; } default : { "Something else"; }; }; detector(exp(5 * x)); detector([3.25;17]); detector([||]); detector([| sin(x), nearestint(x), 2, exp(5 * atan(x)) |]); detector([| sin(x), cos(5 * x), "foo", 2, 3 |]); detector([| DE, 9... |]); detector("Hello world"); detector({ .a = sin(x); .c = "Hello"; .b = [9;10] }); detector(perturb); detector([13;19]); restart; match exp([1;2]) with [a;b] : { a,", ",b; } default : { "Something else"; }; match exp([1;2]) with exp([a;b]) : { a,", ", b; } default : { "Something else"; }; match exp([1;2]) with exp(a) : { "Exponential of ", a; } default : { "Something else"; }; restart; match [| exp(sin(x)), sin(x), 4, DE(x), 9... |] with exp(a) .: (a .: (([||] :. 4) @ (b @ [| 13... |]))) : { "a = ", a, ", b = ", b; }; match [| 1, 2, 3, 4, D... |] with a @ [| 4, D...|] : (a); match [| 1, 2, 3, 4, D... |] with a @ [| D...|] : (a); match [| 1, 2, 3, 4... |] with a @ [| 3...|] : (a); match [| 1, 2, 3, 4... |] with a @ [| 4...|] : (a); match [| 1, 2, 3, 4... |] with a @ [| 17...|] : (a); match [| 1, 2, 3, 4... |] with a @ [| 17, 18, 19 |] : (a) default : ("Something else"); restart; structure.f = exp(x); structure.dom = [1;2]; structure.formats = [| DD, D, D, D |]; match structure with { .f = sin(x); .dom = [a;b] } : { "Sine, ",a,", ",b; } { .f = exp(c); .dom = [a;b]; .point = default } : { "Exponential, ",a, ", ", b, ", ", c; } { .f = exp(x); .dom = [a;b] } : { "Exponential, ",a, ", ", b; } default : { "Something else"; }; structure.f = sin(x); match structure with { .f = sin(x); .dom = [a;b] } : { "Sine, ",a,", ",b; } { .f = exp(c); .dom = [a;b]; .point = default } : { "Exponential, ",a, ", ", b, ", ", c; } { .f = exp(x); .dom = [a;b] } : { "Exponential, ",a, ", ", b; } default : { "Something else"; }; structure.f = exp(x + 2); structure.point = 23; match structure with { .f = sin(x); .dom = [a;b] } : { "Sine, ",a,", ",b; } { .f = exp(c); .dom = [a;b]; .point = default } : { "Exponential, ",a, ", ", b, ", ", c; } { .f = exp(x); .dom = [a;b] } : { "Exponential, ",a, ", ", b; } default : { "Something else"; }; restart; /* Some additional checks */ match [1;2] with [1;default] : (1) default : (2); match [1;2] with [default;2] : (1) default : (2); match "Hallo du da" with ("Hall" @ default) @ "da" : (1) default : (2); match [|1,...,6,18...|] with default @ [| 6, 18, 19, 20... |] : (1) default : (2); match [|1,...,6,18...|] with default @ [| 20... |] : (1) default : (2); match [|1,...,6,18...|] with [|1 |] @ default : (1) default : (2); match [|1,...,6|] with [||] @ default : (1) default : (2); match [|1,...,6|] with default @ [| 5,6 |] : (1) default : (2); /* Non-regression test for [#18746] Bug with pattern matching */ match [|0,1,2,3,4|] with [a,b] : ( [1;3] ) default : ( [0;2] ); sollya-6.0+ds/tests-tool/check016.sollya.reference000066400000000000000000000111711300174114700220660ustar00rootroot000000000000001 2 17 We are matching an exponential function. 1 We are matching an exponential function. 17 We are matching an exponential function. Something else Something else Sine Warning: no matching expression found in a match-with construct and no default case given. Warning: the given expression or command could not be handled. error List of four elements, starting with 1, ending with 3, 4 and 2 in second position List of four elements, starting with 1, ending with 3, 4 and exp(x) in second position Exponential of sin(x) Sine of exp(atan(x + 3)) sin(x) sin(atan(x)) Exponential a = x b = 3 a = 5 b = 6 Exponential a = 17 b = 3 c = Hallo a = 5 b = 6 Winner a = sin(x) Loser Winner a = atan(x + 17) / 19 1 prepended to a list of elements 2, 3 and 4 1 prepended to [|2, 3, 5|] 1 prepended to a list ending in 17 17 appended to a list Salut world Salut = Hello [|1, 2, 3|] [|1, 2, 3, 4|] 6 Interval between 1 and 2 2.7182818284590452353602874713526624977572470936999 7.3890560989306502272304274605750078131803155705519 Exponential 1 2 Sine 1 2 Exponential 1 2 x + 2 3 Addition of sin(x) and cos(exp(x)) Addition of sin(x) and cos(exp(x)) 2 6 Something else, for instance [|1, 2, 3, 5|] Something else, for instance [|1, 2, 3, 4|] We matched exp(a+3) with a = x b remains 6 Exponential : a+c with a = x and c = 6 Exponential : a+b with a = x Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error It does not work, though pi==pi returns true We detected [ 1 , pi] a= 1 and b= 2 2.7182818284590452353602874713526624977572470936999 7.3890560989306502272304274605750078131803155705519 Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error something else Failure [a, a] with a = 3 a + something with a = 1 / 17 [|1, 2, 3|] [|1, 2, 3, 4|] [|1, 2|] [|1, 2, 3|] [|1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16|] [|1, 2, 3, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170|] a = sin(x) , b = [|doubleextended(x), 9, 10, 11, 12|] 1 2 Exponential of sine of x Exponential of sin(x) exp(sin(x * 2)) * cos(x * 2) * 2 exp(sin(x * 2)) * cos(x * 2) * 2 The tool has been restarted. Exponential of sin(x) sin(x) Sine of x 17 Something else true The tool has been restarted. Exponential a = x b = 3 a = 5 , b = 6 Exponential a = 17 b = 3 c = Hallo a = 5 , b = 6 The tool has been restarted. Winner a = sin(x) Loser 3 The tool has been restarted. Five plus one third Sixteen thirds One third plus five Interval from one to one plus five Interval from one to one plus five The tool has been restarted. Something else Arctangent of the square of something Arctangent of the square of something Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error The tool has been restarted. Exponential of 5 times x An interval from 3.25 to 17 Empty list A list of sin(x), nearestint(x), 2 and exponential of 5 * atan(x) Concatenation of the list [|sin(x), cos(x * 5), "foo"|] and the list of 2 and 3 doubleextended prepended to all integers >= 9 Hello concatenated with world A structure containing as .a the sine of x and as .b the range from 9 to 10 The special object perturb Something else The tool has been restarted. 2.7182818284590452353602874713526624977572470936999, 7.3890560989306502272304274605750078131803155705519 Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error Something else The tool has been restarted. a = sin(x), b = [|doubleextended(x), 9, 10, 11, 12|] [|1, 2, 3|] [|1, 2, 3, 4|] [|1, 2|] [|1, 2, 3|] [|1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16|] Something else The tool has been restarted. Exponential, 1, 2 Sine, 1, 2 Exponential, 1, 2, 2 + x The tool has been restarted. 1 1 1 1 1 1 1 1 [0;2] sollya-6.0+ds/tests-tool/check017.sollya000066400000000000000000000020501300174114700201260ustar00rootroot00000000000000/* Set of tests for bashevaluate */ bashevaluate("echo 1 + 2"); bashevaluate("echo Salut | cat"); [| bashevaluate("echo 1 + 2"), bashevaluate("echo Salut | cat") |]; [| bashevaluate("cat","This is some text\nAnd some other text") |]; [| bashevaluate("cat","This is some text\nAnd some other text\n") |]; bashevaluate("sed -e 's/a/e/g;'", "Hallo"); bashevaluate("false"); bashevaluate("true"); bashevaluate("caca 2> /dev/null"); restart; verbosity = 2; bashevaluate("echo 1 + 2"); bashevaluate("echo Salut | cat"); [| bashevaluate("echo 1 + 2"), bashevaluate("echo Salut | cat") |]; [| bashevaluate("cat","This is some text\nAnd some other text") |]; [| bashevaluate("cat","This is some text\nAnd some other text\n") |]; bashevaluate("sed -e 's/a/e/g;'", "Hallo"); bashevaluate("false"); bashevaluate("true"); bashevaluate("caca 2> /dev/null"); /* A test for [#15162] Comparison of accesses to structures yields a wrong result or segfaults */ procedure a(n) { return n.a.b; }; procedure b(n) { return n.a.b; }; a == b; c = a; d = b; c == d; sollya-6.0+ds/tests-tool/check017.sollya.reference000066400000000000000000000022221300174114700220640ustar00rootroot000000000000001 + 2 Salut [|"1 + 2", "Salut"|] [|"This is some text\nAnd some other text"|] [|"This is some text\nAnd some other text"|] Hello Warning in bashevaluate: the exit code of the child process is 1. Warning in bashevaluate: the exit code of the child process is 127. The tool has been restarted. The verbosity level has been set to 2. Information in bashevaluate: the exit code of the child process is 0. 1 + 2 Information in bashevaluate: the exit code of the child process is 0. Salut Information in bashevaluate: the exit code of the child process is 0. Information in bashevaluate: the exit code of the child process is 0. [|"1 + 2", "Salut"|] Information in bashevaluate: the exit code of the child process is 0. [|"This is some text\nAnd some other text"|] Information in bashevaluate: the exit code of the child process is 0. [|"This is some text\nAnd some other text"|] Information in bashevaluate: the exit code of the child process is 0. Hello Warning in bashevaluate: the exit code of the child process is 1. Information in bashevaluate: the exit code of the child process is 0. Warning in bashevaluate: the exit code of the child process is 127. true true sollya-6.0+ds/tests-tool/check018.sollya000066400000000000000000000261501300174114700201360ustar00rootroot00000000000000/* Set of tests for QD */ w=15; p=113; infinity = 2^(2^(w-1)); /* smallest power of two not representable */ largest = ( (2^p-1)/2^(p-1) )*infinity/2; /* largest representable number */ smallest = 2^(2-2^(w-1)); /* smallest normalized number */ smallestdenorm = smallest*2^(1-p); /* smallest denormalized number */ round(smallestdenorm/2, QD, RD) == 0; round(smallestdenorm/2, QD, RZ) == 0; round(smallestdenorm/2, QD, RN) == 0; round(smallestdenorm/2, QD, RU) == smallestdenorm; round(-smallestdenorm/2, QD, RD) == -smallestdenorm; round(-smallestdenorm/2, QD, RZ) == 0; round(-smallestdenorm/2, QD, RN) == 0; round(-smallestdenorm/2, QD, RU) == 0; round(smallestdenorm/2*(1+1b-164), QD, RN) == smallestdenorm; round(-smallestdenorm/2*(1+1b-164), QD, RN) == -smallestdenorm; round(smallestdenorm, QD, RD) == smallestdenorm; round(smallestdenorm, QD, RZ) == smallestdenorm; round(smallestdenorm, QD, RN) == smallestdenorm; round(smallestdenorm, QD, RU) == smallestdenorm; round(-smallestdenorm, QD, RD) == -smallestdenorm; round(-smallestdenorm, QD, RZ) == -smallestdenorm; round(-smallestdenorm, QD, RN) == -smallestdenorm; round(-smallestdenorm, QD, RU) == -smallestdenorm; round(0, QD, RD) == 0; round(0, QD, RZ) == 0; round(0, QD, RN) == 0; round(0, QD, RU) == 0; round(smallestdenorm/1024, QD, RU) == smallestdenorm; round(-smallestdenorm/1024, QD, RD) == -smallestdenorm; round(round(1873489789623786986976897912387b-137, QD, RN), QD, RN) == round(1873489789623786986976897912387b-137, p, RN); round(infinity, QD, RD) == largest; round(infinity, QD, RZ) == largest; round(infinity, QD, RN) == @Inf@; round(infinity, QD, RU) == @Inf@; round(-infinity, QD, RD) == -@Inf@; round(-infinity, QD, RZ) == -largest; round(-infinity, QD, RN) == -@Inf@; round(-infinity, QD, RU) == -largest; round(largest, QD, RD) == largest; round(largest, QD, RZ) == largest; round(largest, QD, RN) == largest; round(largest, QD, RU) == largest; round(-largest, QD, RD) == -largest; round(-largest, QD, RZ) == -largest; round(-largest, QD, RN) == -largest; round(-largest, QD, RU) == -largest; round((largest+infinity)/2, QD, RD) == largest; round((largest+infinity)/2, QD, RZ) == largest; round((largest+infinity)/2, QD, RN) == @Inf@; round((largest+infinity)/2, QD, RU) == @Inf@; round(-(largest+infinity)/2, QD, RD) == -@Inf@; round(-(largest+infinity)/2, QD, RZ) == -largest; round(-(largest+infinity)/2, QD, RN) == -@Inf@; round(-(largest+infinity)/2, QD, RU) == -largest; round((largest+infinity)/2*(1+1b-164), QD, RD) == largest; round((largest+infinity)/2*(1+1b-164), QD, RZ) == largest; round((largest+infinity)/2*(1+1b-164), QD, RN) == @Inf@; round((largest+infinity)/2*(1+1b-164), QD, RU) == @Inf@; round(-(largest+infinity)/2*(1+1b-164), QD, RD) == -@Inf@; round(-(largest+infinity)/2*(1+1b-164), QD, RZ) == -largest; round(-(largest+infinity)/2*(1+1b-164), QD, RN) == -@Inf@; round(-(largest+infinity)/2*(1+1b-164), QD, RU) == -largest; round((largest+infinity)/2*(1-1b-164), QD, RD) == largest; round((largest+infinity)/2*(1-1b-164), QD, RZ) == largest; round((largest+infinity)/2*(1-1b-164), QD, RN) == largest; round((largest+infinity)/2*(1-1b-164), QD, RU) == @Inf@; round(-(largest+infinity)/2*(1-1b-164), QD, RD) == -@Inf@; round(-(largest+infinity)/2*(1-1b-164), QD, RZ) == -largest; round(-(largest+infinity)/2*(1-1b-164), QD, RN) == -largest; round(-(largest+infinity)/2*(1-1b-164), QD, RU) == -largest; /* Set of tests for HP */ w=5; p=11; infinity = 2^(2^(w-1)); /* smallest power of two not representable */ largest = ( (2^p-1)/2^(p-1) )*infinity/2; /* largest representable number */ smallest = 2^(2-2^(w-1)); /* smallest normalized number */ smallestdenorm = smallest*2^(1-p); /* smallest denormalized number */ round(smallestdenorm/2, HP, RD) == 0; round(smallestdenorm/2, HP, RZ) == 0; round(smallestdenorm/2, HP, RN) == 0; round(smallestdenorm/2, HP, RU) == smallestdenorm; round(-smallestdenorm/2, HP, RD) == -smallestdenorm; round(-smallestdenorm/2, HP, RZ) == 0; round(-smallestdenorm/2, HP, RN) == 0; round(-smallestdenorm/2, HP, RU) == 0; round(smallestdenorm/2*(1+1b-164), HP, RN) == smallestdenorm; round(-smallestdenorm/2*(1+1b-164), HP, RN) == -smallestdenorm; round(smallestdenorm, HP, RD) == smallestdenorm; round(smallestdenorm, HP, RZ) == smallestdenorm; round(smallestdenorm, HP, RN) == smallestdenorm; round(smallestdenorm, HP, RU) == smallestdenorm; round(-smallestdenorm, HP, RD) == -smallestdenorm; round(-smallestdenorm, HP, RZ) == -smallestdenorm; round(-smallestdenorm, HP, RN) == -smallestdenorm; round(-smallestdenorm, HP, RU) == -smallestdenorm; round(0, HP, RD) == 0; round(0, HP, RZ) == 0; round(0, HP, RN) == 0; round(0, HP, RU) == 0; round(smallestdenorm/1024, HP, RU) == smallestdenorm; round(-smallestdenorm/1024, HP, RD) == -smallestdenorm; round(round(1873b-12, HP, RN), HP, RN) == round(1873b-12, p, RN); round(infinity, HP, RD) == largest; round(infinity, HP, RZ) == largest; round(infinity, HP, RN) == @Inf@; round(infinity, HP, RU) == @Inf@; round(-infinity, HP, RD) == -@Inf@; round(-infinity, HP, RZ) == -largest; round(-infinity, HP, RN) == -@Inf@; round(-infinity, HP, RU) == -largest; round(largest, HP, RD) == largest; round(largest, HP, RZ) == largest; round(largest, HP, RN) == largest; round(largest, HP, RU) == largest; round(-largest, HP, RD) == -largest; round(-largest, HP, RZ) == -largest; round(-largest, HP, RN) == -largest; round(-largest, HP, RU) == -largest; round((largest+infinity)/2, HP, RD) == largest; round((largest+infinity)/2, HP, RZ) == largest; round((largest+infinity)/2, HP, RN) == @Inf@; round((largest+infinity)/2, HP, RU) == @Inf@; round(-(largest+infinity)/2, HP, RD) == -@Inf@; round(-(largest+infinity)/2, HP, RZ) == -largest; round(-(largest+infinity)/2, HP, RN) == -@Inf@; round(-(largest+infinity)/2, HP, RU) == -largest; round((largest+infinity)/2*(1+1b-164), HP, RD) == largest; round((largest+infinity)/2*(1+1b-164), HP, RZ) == largest; round((largest+infinity)/2*(1+1b-164), HP, RN) == @Inf@; round((largest+infinity)/2*(1+1b-164), HP, RU) == @Inf@; round(-(largest+infinity)/2*(1+1b-164), HP, RD) == -@Inf@; round(-(largest+infinity)/2*(1+1b-164), HP, RZ) == -largest; round(-(largest+infinity)/2*(1+1b-164), HP, RN) == -@Inf@; round(-(largest+infinity)/2*(1+1b-164), HP, RU) == -largest; round((largest+infinity)/2*(1-1b-164), HP, RD) == largest; round((largest+infinity)/2*(1-1b-164), HP, RZ) == largest; round((largest+infinity)/2*(1-1b-164), HP, RN) == largest; round((largest+infinity)/2*(1-1b-164), HP, RU) == @Inf@; round(-(largest+infinity)/2*(1-1b-164), HP, RD) == -@Inf@; round(-(largest+infinity)/2*(1-1b-164), HP, RZ) == -largest; round(-(largest+infinity)/2*(1-1b-164), HP, RN) == -largest; round(-(largest+infinity)/2*(1-1b-164), HP, RU) == -largest; /* Test for a nasty bug with substitution in polynomials */ restart; p = x * (35075959548088382976405608668755193338674883419681b-163 + x * (-42086437883432000582784192785873419614087226350999b-165 + x * (6305164210920614639652779299557670286468422732771b-163 + x * (-9393944093750410651940191621405810850640998071215b-164 + x * (15415134511238209224970388325432729247409270589207b-165 + x * (-26157173752570834429858647099539259501314358843629b-166 + x * (43881912789153516491333129265841018968298397822271b-167 + x * (-17597629421926460459390225831873864200720777073233b-166 + x * (26371671923673917521582700087408786301495850183925b-167 + x * (-568519934538854956776995360555316677425708956673b-162 + x * (22919122446304402024517231711564232123592173587333b-168 + x * (-26259025112053702417460500315529776563807394337645b-169 + x * (27325429597118712236350268843548673923948974835257b-170 + x * (-807307892802220923533002811460969912804873806975b-166 + x * (22216033265583031226337645139893576664414087406439b-172 + x * (-17407181023767045342103997548797784772466988690895b-173 + x * (3112704999717065356931139366771158221465954500187b-172 + x * (-32582361130244386534106375475709753190330442340477b-177 + x * (39068186684277987306424324661064788662489242511871b-179 + x * (-43007148679394744899466444414443653566356379129397b-181 + x * (5442288170592514462515364456089275622778176416763b-180 + x * (-40596797729493102382008208611758971956071909231047b-185 + x * (34915094521358798203406269897179935622739481211939b-187 + x * (-13866042770369231299553250746486768753347709516873b-188 + x * (1272803896463444371470256168178709943188046154401b-187 + x * (-6919867357044963000564701699610292434723394052629b-192 + x * (34844645457769983185179376481470035739795831158009b-197 + x * (-40654532828004341497687544303620845675143893478791b-200 + x * (43985335202182205551498877390856773842786450943955b-203 + x * (-5518402994492305929387557801974768357099996928253b-203 + x * (5139433322631852153878831260732760059159501450367b-206 + x * (-35535455403086378565673803431130067325745730201873b-212 + x * (1781310494523690360859044110321144369562210395805b-211 + x * (-42418046226633401112392881579204953240887937106205b-219 + x * (14638648877490999465225540785824765357371226949061b-221 + x * (-37466833948258520119587173709383353960828198830505b-226 + x * (5552536616399393462341601384919300123296709358489b-227 + x * (-24374632254129885691320677458587189874132167957901b-233 + x * (12367880366589476731326807532875751982701839134369b-236 + x * (-11591448670312179616276269973355664695019938832229b-240 + x * (10018123606948444130408565493795172236499583820515b-244 + x * (-31881305262572147072874583960133862881860803391033b-250 + x * (46601514616512486247555737486762800626766818325445b-255 + x * (-15606317634283494586189081513049713331981056924605b-258 + x * (19104440662669639455367911017699670904709884887667b-263 + x * (-42603245208576406169620972873800764349000722942887b-269 + x * (43101350384310809485726781051940124196250181256569b-274 + x * (-39385560864604543053261371085586271477835384240125b-279 + x * (32332823444291916953227729385214348158891405072431b-284 + x * (-23692722711144363095731888862967414320431642791281b-289 + x * (30753819122669311181418983886253592754954912316585b-295 + x * (-17509955875342672111490934461061742679287598284239b-300 + x * (4320999031572684438763704790763693079004005105273b-304 + x * (-14564845647582049607503995840067369395622129268083b-312 + x * (41074034876163570181662338350751895326622964362479b-320 + x * (-11782286397291604755666322207873441236996257272769b-325 + x * (2641392161064709702437897321160772956210965676813b-330 + x * (-27778050306429783806538813839145555488712478088645b-341 + x * (23800236875362639623045093022848239637436710708129b-349 + x * (-9972059785289929452697198892711451778301663837749b-357)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) ; h = (pi) * x * (1 + x / 10) ; q = h(p); display = dyadic!; q(20); print(q); restart; /* Tests for the bug #13930 Sollya crashes unexpectedly with message Error: getMaxPowerDividerUnsafe: an error occurred. The exponent in a power operator is not constant. */ x^(0+1)/1; (x^(0+1))/1; x^((0+1)/1); /* Tests for the bug #14259 An overflow in GMP makes Sollya crash (on 64bit machines only) */ restart; display = hexadecimal; 1.87^1.52e10; 2^(2^62); 3^(2^29); 3^(2^30); /* Tests for the bug #13943 Rationalapprox with low approximation accuracy makes MPFR assertion fail, killing the tool's execution */ rationalapprox(D(pi),-0); sollya-6.0+ds/tests-tool/check018.sollya.reference000066400000000000000000016406061300174114700221040ustar00rootroot00000000000000true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true The tool has been restarted. 17217910526430820955192472364046235623665759880875b-156 x * ((pi) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) / 10 * 35075959548088382976405608668755193338674883419681b-163 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-42086437883432000582784192785873419614087226350999b-165) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 35075959548088382976405608668755193338674883419681b-163 + x * ((pi) / 10 * (-42086437883432000582784192785873419614087226350999b-165) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 6305164210920614639652779299557670286468422732771b-163 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-42086437883432000582784192785873419614087226350999b-165) + x * ((pi) / 10 * 6305164210920614639652779299557670286468422732771b-163 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-9393944093750410651940191621405810850640998071215b-164) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 6305164210920614639652779299557670286468422732771b-163 + x * ((pi) / 10 * (-9393944093750410651940191621405810850640998071215b-164) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 15415134511238209224970388325432729247409270589207b-165 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-9393944093750410651940191621405810850640998071215b-164) + x * ((pi) / 10 * 15415134511238209224970388325432729247409270589207b-165 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-26157173752570834429858647099539259501314358843629b-166) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 15415134511238209224970388325432729247409270589207b-165 + x * ((pi) / 10 * (-26157173752570834429858647099539259501314358843629b-166) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 43881912789153516491333129265841018968298397822271b-167 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-26157173752570834429858647099539259501314358843629b-166) + x * ((pi) / 10 * 43881912789153516491333129265841018968298397822271b-167 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-17597629421926460459390225831873864200720777073233b-166) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 43881912789153516491333129265841018968298397822271b-167 + x * ((pi) / 10 * (-17597629421926460459390225831873864200720777073233b-166) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 26371671923673917521582700087408786301495850183925b-167 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-17597629421926460459390225831873864200720777073233b-166) + x * ((pi) / 10 * 26371671923673917521582700087408786301495850183925b-167 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-568519934538854956776995360555316677425708956673b-162) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 26371671923673917521582700087408786301495850183925b-167 + x * ((pi) / 10 * (-568519934538854956776995360555316677425708956673b-162) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 22919122446304402024517231711564232123592173587333b-168 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-568519934538854956776995360555316677425708956673b-162) + x * ((pi) / 10 * 22919122446304402024517231711564232123592173587333b-168 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-26259025112053702417460500315529776563807394337645b-169) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 22919122446304402024517231711564232123592173587333b-168 + x * ((pi) / 10 * (-26259025112053702417460500315529776563807394337645b-169) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 27325429597118712236350268843548673923948974835257b-170 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-26259025112053702417460500315529776563807394337645b-169) + x * ((pi) / 10 * 27325429597118712236350268843548673923948974835257b-170 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-807307892802220923533002811460969912804873806975b-166) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 27325429597118712236350268843548673923948974835257b-170 + x * ((pi) / 10 * (-807307892802220923533002811460969912804873806975b-166) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 22216033265583031226337645139893576664414087406439b-172 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-807307892802220923533002811460969912804873806975b-166) + x * ((pi) / 10 * 22216033265583031226337645139893576664414087406439b-172 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-17407181023767045342103997548797784772466988690895b-173) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 22216033265583031226337645139893576664414087406439b-172 + x * ((pi) / 10 * (-17407181023767045342103997548797784772466988690895b-173) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 3112704999717065356931139366771158221465954500187b-172 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-17407181023767045342103997548797784772466988690895b-173) + x * ((pi) / 10 * 3112704999717065356931139366771158221465954500187b-172 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-32582361130244386534106375475709753190330442340477b-177) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 3112704999717065356931139366771158221465954500187b-172 + x * ((pi) / 10 * (-32582361130244386534106375475709753190330442340477b-177) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 39068186684277987306424324661064788662489242511871b-179 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-32582361130244386534106375475709753190330442340477b-177) + x * ((pi) / 10 * 39068186684277987306424324661064788662489242511871b-179 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-43007148679394744899466444414443653566356379129397b-181) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 39068186684277987306424324661064788662489242511871b-179 + x * ((pi) / 10 * (-43007148679394744899466444414443653566356379129397b-181) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 5442288170592514462515364456089275622778176416763b-180 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-43007148679394744899466444414443653566356379129397b-181) + x * ((pi) / 10 * 5442288170592514462515364456089275622778176416763b-180 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-40596797729493102382008208611758971956071909231047b-185) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 5442288170592514462515364456089275622778176416763b-180 + x * ((pi) / 10 * (-40596797729493102382008208611758971956071909231047b-185) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 34915094521358798203406269897179935622739481211939b-187 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-40596797729493102382008208611758971956071909231047b-185) + x * ((pi) / 10 * 34915094521358798203406269897179935622739481211939b-187 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-13866042770369231299553250746486768753347709516873b-188) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 34915094521358798203406269897179935622739481211939b-187 + x * ((pi) / 10 * (-13866042770369231299553250746486768753347709516873b-188) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 1272803896463444371470256168178709943188046154401b-187 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-13866042770369231299553250746486768753347709516873b-188) + x * ((pi) / 10 * 1272803896463444371470256168178709943188046154401b-187 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-6919867357044963000564701699610292434723394052629b-192) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 1272803896463444371470256168178709943188046154401b-187 + x * ((pi) / 10 * (-6919867357044963000564701699610292434723394052629b-192) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 34844645457769983185179376481470035739795831158009b-197 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-6919867357044963000564701699610292434723394052629b-192) + x * ((pi) / 10 * 34844645457769983185179376481470035739795831158009b-197 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-40654532828004341497687544303620845675143893478791b-200) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 34844645457769983185179376481470035739795831158009b-197 + x * ((pi) / 10 * (-40654532828004341497687544303620845675143893478791b-200) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 43985335202182205551498877390856773842786450943955b-203 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-40654532828004341497687544303620845675143893478791b-200) + x * ((pi) / 10 * 43985335202182205551498877390856773842786450943955b-203 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-5518402994492305929387557801974768357099996928253b-203) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 43985335202182205551498877390856773842786450943955b-203 + x * ((pi) / 10 * (-5518402994492305929387557801974768357099996928253b-203) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 5139433322631852153878831260732760059159501450367b-206 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-5518402994492305929387557801974768357099996928253b-203) + x * ((pi) / 10 * 5139433322631852153878831260732760059159501450367b-206 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-35535455403086378565673803431130067325745730201873b-212) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 5139433322631852153878831260732760059159501450367b-206 + x * ((pi) / 10 * (-35535455403086378565673803431130067325745730201873b-212) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 1781310494523690360859044110321144369562210395805b-211 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-35535455403086378565673803431130067325745730201873b-212) + x * ((pi) / 10 * 1781310494523690360859044110321144369562210395805b-211 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-42418046226633401112392881579204953240887937106205b-219) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 1781310494523690360859044110321144369562210395805b-211 + x * ((pi) / 10 * (-42418046226633401112392881579204953240887937106205b-219) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 14638648877490999465225540785824765357371226949061b-221 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-42418046226633401112392881579204953240887937106205b-219) + x * ((pi) / 10 * 14638648877490999465225540785824765357371226949061b-221 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-37466833948258520119587173709383353960828198830505b-226) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 14638648877490999465225540785824765357371226949061b-221 + x * ((pi) / 10 * (-37466833948258520119587173709383353960828198830505b-226) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 5552536616399393462341601384919300123296709358489b-227 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-37466833948258520119587173709383353960828198830505b-226) + x * ((pi) / 10 * 5552536616399393462341601384919300123296709358489b-227 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-24374632254129885691320677458587189874132167957901b-233) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 5552536616399393462341601384919300123296709358489b-227 + x * ((pi) / 10 * (-24374632254129885691320677458587189874132167957901b-233) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 12367880366589476731326807532875751982701839134369b-236 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-24374632254129885691320677458587189874132167957901b-233) + x * ((pi) / 10 * 12367880366589476731326807532875751982701839134369b-236 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-11591448670312179616276269973355664695019938832229b-240) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 12367880366589476731326807532875751982701839134369b-236 + x * ((pi) / 10 * (-11591448670312179616276269973355664695019938832229b-240) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 10018123606948444130408565493795172236499583820515b-244 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-11591448670312179616276269973355664695019938832229b-240) + x * ((pi) / 10 * 10018123606948444130408565493795172236499583820515b-244 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-31881305262572147072874583960133862881860803391033b-250) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 10018123606948444130408565493795172236499583820515b-244 + x * ((pi) / 10 * (-31881305262572147072874583960133862881860803391033b-250) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 46601514616512486247555737486762800626766818325445b-255 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-31881305262572147072874583960133862881860803391033b-250) + x * ((pi) / 10 * 46601514616512486247555737486762800626766818325445b-255 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-15606317634283494586189081513049713331981056924605b-258) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 46601514616512486247555737486762800626766818325445b-255 + x * ((pi) / 10 * (-15606317634283494586189081513049713331981056924605b-258) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 19104440662669639455367911017699670904709884887667b-263 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-15606317634283494586189081513049713331981056924605b-258) + x * ((pi) / 10 * 19104440662669639455367911017699670904709884887667b-263 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-42603245208576406169620972873800764349000722942887b-269) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 19104440662669639455367911017699670904709884887667b-263 + x * ((pi) / 10 * (-42603245208576406169620972873800764349000722942887b-269) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 43101350384310809485726781051940124196250181256569b-274 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-42603245208576406169620972873800764349000722942887b-269) + x * ((pi) / 10 * 43101350384310809485726781051940124196250181256569b-274 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-39385560864604543053261371085586271477835384240125b-279) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 43101350384310809485726781051940124196250181256569b-274 + x * ((pi) / 10 * (-39385560864604543053261371085586271477835384240125b-279) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 32332823444291916953227729385214348158891405072431b-284 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-39385560864604543053261371085586271477835384240125b-279) + x * ((pi) / 10 * 32332823444291916953227729385214348158891405072431b-284 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-23692722711144363095731888862967414320431642791281b-289) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 32332823444291916953227729385214348158891405072431b-284 + x * ((pi) / 10 * (-23692722711144363095731888862967414320431642791281b-289) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 30753819122669311181418983886253592754954912316585b-295 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-23692722711144363095731888862967414320431642791281b-289) + x * ((pi) / 10 * 30753819122669311181418983886253592754954912316585b-295 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-17509955875342672111490934461061742679287598284239b-300) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 30753819122669311181418983886253592754954912316585b-295 + x * ((pi) / 10 * (-17509955875342672111490934461061742679287598284239b-300) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 4320999031572684438763704790763693079004005105273b-304 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-17509955875342672111490934461061742679287598284239b-300) + x * ((pi) / 10 * 4320999031572684438763704790763693079004005105273b-304 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-14564845647582049607503995840067369395622129268083b-312) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 4320999031572684438763704790763693079004005105273b-304 + x * ((pi) / 10 * (-14564845647582049607503995840067369395622129268083b-312) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 41074034876163570181662338350751895326622964362479b-320 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-14564845647582049607503995840067369395622129268083b-312) + x * ((pi) / 10 * 41074034876163570181662338350751895326622964362479b-320 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-11782286397291604755666322207873441236996257272769b-325) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 41074034876163570181662338350751895326622964362479b-320 + x * ((pi) / 10 * (-11782286397291604755666322207873441236996257272769b-325) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 2641392161064709702437897321160772956210965676813b-330 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-11782286397291604755666322207873441236996257272769b-325) + x * ((pi) / 10 * 2641392161064709702437897321160772956210965676813b-330 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-27778050306429783806538813839145555488712478088645b-341) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 2641392161064709702437897321160772956210965676813b-330 + x * ((pi) / 10 * (-27778050306429783806538813839145555488712478088645b-341) * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * 23800236875362639623045093022848239637436710708129b-349 + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-27778050306429783806538813839145555488712478088645b-341) + x * ((pi) / 10 * 23800236875362639623045093022848239637436710708129b-349 * (-9972059785289929452697198892711451778301663837749b-357) + (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * 23800236875362639623045093022848239637436710708129b-349 + x * (pi) / 10 * (-9972059785289929452697198892711451778301663837749b-357) * (-9972059785289929452697198892711451778301663837749b-357)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) The tool has been restarted. x x x The tool has been restarted. Display mode is hexadecimal numbers. Warning: the given expression is undefined or numerically unstable. infty Warning: the given expression is undefined or numerically unstable. infty 0x1.30022c06bcffeab3d0165b14c516dfa7ee0f87c8ap850920263 Warning: the given expression is undefined or numerically unstable. infty Error in rationalapprox: the second argument of rationalapprox must be greater or equal to 2. Warning: the given expression or command could not be handled. error sollya-6.0+ds/tests-tool/check019.sollya000066400000000000000000000074701300174114700201430ustar00rootroot00000000000000restart; checkComposePolynomials = proc(p,q) { var r,s,i,err, EXPECTED_NUMBER_OF_BITS; var okay; okay = true; EXPECTED_NUMBER_OF_BITS = prec-10; r = p(q); s = composepolynomials(p,q); for i from 0 to degree(r) do { if ! ( coeff(r, i) in coeff(s.poly, i)+s.radii[i] ) then { print("Check fail in composepolynomials(",p,",",q,") : coefficient ",i," = ",coeff(r,i)," and does not lie in ",coeff(s.poly, i),"+",s.radii[i]); okay = false; }; if (coeff(r,i) != 0) then { if ( abs(coeff(s.poly,i)/coeff(r,i)-1) > 2^(-EXPECTED_NUMBER_OF_BITS) ) then { err := -log2( abs(coeff(s.poly,i)/coeff(r,i)-1)); print("Check fail in composepolynomials(",p,",",q,") : exact coefficient ",i," = ",coeff(r,i), "and the computed approximate value is ",coeff(s.poly,i)," which corresponds to only ~ ", err, "correct bits"); okay = false; }; }; }; if (okay) then "OKAY!"; return void; }; checkComposePolynomials(1+x, x^4); checkComposePolynomials(1+x/3, x^4); p=11692536319630510474283968587625525849426869787677b-163 + x * (23384922893552793741208186896732057180708286140565b-164 + x * (46692941277611593554424973690517694800554713844979b-166 + x * (3891678517537147456387754739468835779118224484425b-164 + x * (1024072943597638219514404758611859127188920401873b-164 + x * 26154763285557255659575812244171511366994513699585b-171)))); q=17718778180354651383863675962713604666010364485019b-171 + x * (11285277392540280818073220803494664327743210300889b-163 + x * (14059659517842917521277573489957716260107438465415b-167 + x * (-45540662462117273602262338480450403246420473477993b-167 + x * 3624010771221772523305976483479451079148459719227b-166))); checkComposePolynomials(p,q); checkComposePolynomials(1+2*x^20,3*x^17); checkComposePolynomials(1+2*x^5,p); checkComposePolynomials(p, 1+2*x^20); checkComposePolynomials(exp(5) * x + sin(16) + log(19) * x^2 + asin(0.5) * x^7,erf(0.5) + 1/5 * x + atanh(1/2) * x^7); prec = 3000; print(composepolynomials(1 + x, x^4)); print(composepolynomials(5 * x + 17 + 19 * x^2 + 0.5 * x^7,0.25 + 1/4 * x + 177 * x^7)); print(composepolynomials(1 + 17 * x + 13 * x^44, 2 + 1001 * x^2 + x^77)); prec = 300; checkComposePolynomials(1+x, x^4); checkComposePolynomials(1+x/3, x^4); p=127320445892597569233192084573816508818883486078679099554120447022081703359819068009205547b-296 + x * (1018557044797143666503767416322855867839491631117818135205555253332674508098291366773725959b-299 + x * (508441106512784560521103888523310670303733435407883686814016285688113354381980961005656571b-299 + x * (1356052046777263815902350693610623816222104351491496878169889792980744642403155011929747871b-302 + x * (1427349359299711414482673569219142091501984527550101477773398194525418017639951550600094011b-304 + x * 142400076760410063419384360841976625466855068476814073302706323729266395387747260369551141b-303)))); q=771761635395839434377129531728754385222063722650731773025337381349894526273800455320994121b-306 + x * (983086311046602665020193955808933540240886933805254554081204274414484972714644572789529703b-299 + x * (76548067490437194072378457129688613050755939490186799978176875461592935525688706282740277b-299 + x * (-1983575604919226129310884695050125857481118988868047284422761383554783357868809833784652613b-302 + x * 315695862515659025289961779855922792366704584708683921548700851798936806281466374297543777b-302))); checkComposePolynomials(p,q); checkComposePolynomials(1+2*x^20,3*x^17); checkComposePolynomials(1+2*x^5,p); checkComposePolynomials(p, 1+2*x^20); checkComposePolynomials(exp(5) * x + sin(16) + log(19) * x^2 + asin(0.5) * x^7,erf(0.5) + 1/5 * x + atanh(1/2) * x^7); prec = 5000; print(composepolynomials(1 + x, x^4)); print(composepolynomials(5 * x + 17 + 19 * x^2 + 0.5 * x^7,0.25 + 1/4 * x + 177 * x^7)); print(composepolynomials(1 + 17 * x + 13 * x^44, 2 + 1001 * x^2 + x^77)); sollya-6.0+ds/tests-tool/check019.sollya.reference000066400000000000000000006340051300174114700221000ustar00rootroot00000000000000The tool has been restarted. OKAY! OKAY! OKAY! OKAY! OKAY! OKAY! OKAY! The precision has been set to 3000 bits. { .radii = [|[0;0], [0;0], [0;0], [0;0], [0;0]|], .poly = 1 + x^4 } { .radii = [|[0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0]|], .poly = 19.437530517578125 + x * (3.625213623046875 + x * (1.188140869140625 + x * (1.068115234375e-3 + x * (1.068115234375e-3 + x * (6.40869140625e-4 + x * (2.13623046875e-4 + x * (2566.651275634765625 + x * (1682.407470703125 + x * (2.2686767578125 + x * (3.02490234375 + x * (2.2686767578125 + x * (0.907470703125 + x * (0.1512451171875 + x * (5.9557224462890625e5 + x * (1606.22314453125 + x * (3212.4462890625 + x * (3212.4462890625 + x * (1606.22314453125 + x * (321.24462890625 + x^2 * (3.79068662109375e5 + x * (1.5162746484375e6 + x * (2.27441197265625e6 + x * (1.5162746484375e6 + x * (3.79068662109375e5 + x^3 * (2.683806127734375e8 + x * (8.051418383203125e8 + x * (8.051418383203125e8 + x * (2.683806127734375e8 + x^4 * (1.1400808430615625e11 + x * (2.280161686123125e11 + x * (1.1400808430615625e11 + x^5 * (2.6905907896252875e13 + x * (2.6905907896252875e13 + x^6 * 2.7213403986495765e15))))))))))))))))))))))))))))))))) } { .radii = [|[0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0]|], .poly = 228698418577443 + x^2 * (5036396573911695993 + x^2 * (54195404432720099540992 + x^2 * (379747198860069737483730944 + x^2 * (1948150598552015262008725209088 + x^2 * (7800394996602269109082935737188352 + x^2 * (25376635022696331979124060687008006144 + x^2 * (6.8948317356665933987280072886600752693248e40 + x^2 * (1.59602426871177262317930753718814504843739136e44 + x^2 * (3.19524058596096879160497368945066638697165750272e47 + x^2 * (5.59726269645712708069401266049520484337760103038976e50 + x^2 * (8.65896539141917559383363758578608189270514879401295872e53 + x^2 * (1.191798349061456780796277293213631846507204917135958605824e57 + x^2 * (1.468295566043714753941013625239194434896876457911501002375168e60 + x^2 * (1.627238561067946876055128350171337232474463334480420985882279936e63 + x^2 * (1.628865799629014822931183478521508569706937797814901406868162215936e66 + x^2 * (1.477635790544708477964666412437527258438209291649024154374246280200192e69 + x^2 * (1.218093409923149682952755006111735705867827353715848499964746315925028864e72 + x^2 * (9.14483627499804624476780820838385581180271385802173261348533296680715419648e74 + x^2 * (6.26325023402892504121913095872100608836782712812825297364655988931902618730496e77 + x^2 * (3.9184459276643462289127188060498294340351218470352382666376290307552157584326656e80 + x^2 * (2.2413510706240060429380751570605024362680896965041562885167238055919834138234847232e83 + x^2 * (1.1727869477040111619673478259319078997772779336957997779663757312760053212831383814144e86 + x^2 * (5.614590035290811697574985613624451254107655359967152763125114424817432431586363790327808e88 + x^2 * (2.458839523580169847806745262166658121095771319205614963201104798418484315507853192426684416e91 + x^2 * (9.845193452415000070618208029715299116867468362099282312657223612867611199293444182476444401664e93 + x^2 * (3.600879505220786275828609586868370651994276553437812505854379536406328796141577209740759539908608e96 + x^2 * (1.201493461575335687368146065485079674215423609997083439453411305314245041645906262316833433149505536e99 + x^2 * (3.65103825636205131998995385649278586002211849487863730163905360402366212030149765461527759498305994752e101 + x^2 * (1.00819015023956230932688105113083548851921120368924577625950142279384435377153080062617734415946013999104e104 + x^2 * (2.5229958509745046790905198304549158100193260372323375550894023105415954953132558285670088037590490003275776e106 + x^2 * (5.702784492831727189157184661934708090582392755769996531777884512891922463116123738957751834819243982353334272e108 + x^2 * (1.159536478206551029882850687589943068480448077044296326062900174472852922070783097110269134789106592849436545024e111 + x^2 * (2.11035639033592287438678825141369638463441550022061931343447831754059231816882523674068982531617399898597451194368e113 + x^2 * (3.4172256197042421720401360935759133663543454519013587147392706991822738257877845120223140686112341033580243163252736e115 + x^2 * (4.886632636177066306017394613813556113886713996218942962077157099830651570876531852191909118114064767801974772345141248e117 + x^2 * (6.11439908601655421540426501053421208750075088776895238129904282116310277805926048005512628404022354071222093389685798656e119 + x^2 * (6.6167713352460224536428857032916176211764882580072663066814506637667739252295348546326285517019067721653331403575728049152e121 + x^2 * (6.100489045535378859562592121442679562050480687349594080383805894870234854484651411369845823917797467442432804537567453163264e123 + x * (5031365208702993 + x * (4.69737656506224172186319593351086326277887012925918744189553053905008083795318158675478128441670404993067325949392693893571328e125 + x * (108282526339101097984 + x * (2.9387962135170649772406619559027338287760306246177791433358912934932068242444592302134600410632004712378774579708880411716556208e127 + x * (1138103493087122090360832 + x * (1.434992687673454654740440301394456859807222758654827767063037651115463429789611555826182195660616425223958700209199477664793793376e129 + x * (7784817576631429618416484352 + x * (5.1300988584326003906970740774851832738108213621910092672503596027377817614978613120786013494867037201756523532478881326516378113192e130 + x * (38963011971040305240174504181760 + x * (1.194239292393263486299481663154108943508053996175162855004095340079190591455664924044344174613067540440890233860729307159137081193144e132 + x * (152107702433744247627117246875172864 + x * (1.3584471950973372156656603918377989232404114206492477475671584493400792977808188511004414986223643272515126410165795868935184298572013e133 + x * (4.82156065431230307603357153053152116736e38 + x^2 * (1.275543871098319778764681348402113924825088e42 + x^2 * (2.872843683681190721722753566938661087187304448e45 + x^2 * (5.59167102543169538530870395653866617720040062976e48 + x^2 * (9.515346583977116037179821522841848233741921751662592e51 + x^2 * (1.4287292895841639729825502016547035122963495510121381888e55 + x^2 * (1.9068773584983308492740436691418109544115278674175337693184e58 + x^2 * (2.2758581273677578686085711191207513740901585097628265536815104e61 + x^2 * (2.440857841601920314082692525257005848711695001720631478823419904e64 + x^2 * (2.3618554094620714932502160438561874260750598068316070399588352131072e67 + x^2 * (2.0686901067625918691505329774125381618134930083086338161239447922802688e70 + x^2 * (1.6444261033962520719862192582508432029215669275163954749524075264987889664e73 + x^2 * (1.1888287157497460118198150670899012555343528015428252397530932856849300455424e76 + x^2 * (7.8290627925361563015239136984012576104597839101603162170581998616487827341312e78 + x^2 * (4.70213511319721547469526256725979532084214621644228591996515483690625891011919872e81 + x^2 * (2.57755373121760694937878643061957780170830315097977973179423237643078092589700743168e84 + x^2 * (1.29006564247441227816408260852509868975500572706537975576301330440360585341145221955584e87 + x^2 * (5.8953195370553522824537348943056738168130381279655104012813701460583040531656819798441984e89 + x^2 * (2.458839523580169847806745262166658121095771319205614963201104798418484315507853192426684416e92 + x^2 * (9.3529337797942500670872976282295341610240949439943181970243624322242306393287719733526221815808e94 + x^2 * (3.2407915546987076482457486281815335867948488980940312552689415827656959165274194887666835859177472e97 + x^2 * (1.0212694423390353342629241556623177230831100684975209235353996095171082853990203229693084181770797056e100 + x^2 * (2.920830605089641055991963085194228688017694795902909841311242883218929696241198123692222075986447958016e102 + x^2 * (7.5614261267967173199516078834812661638940840276693433219462606709538326532864810046963300811959510499328e104 + x^2 * (1.76609709568215327536336388131844106701352822606263628856258161737911684671927907999690616263133430022930432e107 + x^2 * (3.7068099203406226729521700302575602588785552912504977456556249333797496010254804303225386926325085885296672768e109 + x^2 * (6.957218869239306179297104125539658410882688462265777956377401046837117532424698582661614808734639557096619270144e111 + x^2 * (1.160696014684757580912733538277533011548928525121340622388963074647325774992853880207379403923895699442285981569024e114 + x^2 * (1.7086128098521210860200680467879566831771727259506793573696353495911369128938922560111570343056170516790121581626368e116 + x^2 * (2.1989846862796798377078275762161002512490212982985243329347206949237932068944393334863591031513291455108886475553135616e118 + x^2 * (2.445759634406621686161706004213684835000300355107580952519617128465241111223704192022050513616089416284888373558743194624e120 + x^2 * (2.31586996733610785877500999615206616741177089030254320733850773231837087383033719912141999309566737025786659912515048172032e122 + x^2 * (1.8301467136606136578687776364328038686151442062048782241151417684610704563453954234109537471753392402327298413612702359489792e124 + x * (54087175993556992 + x * (1.17434414126556043046579898337771581569471753231479686047388263476252020948829539668869532110417601248266831487348173473392832e126 + x * (1136966526560561528832 + x * (5.8775924270341299544813239118054676575520612492355582866717825869864136484889184604269200821264009424757549159417760823433112416e127 + x * (11665560804143001426198528 + x * (2.152489031510181982110660452091685289710834137982241650594556476673195144684417333739273293490924637835938050313799216497190690064e129 + x * (77848175766314296184164843520 + x * (5.1300988584326003906970740774851832738108213621910092672503596027377817614978613120786013494867037201756523532478881326516378113192e130 + x * (379889366717642976091701415772160 + x * (5.97119646196631743149740831577054471754026998087581427502047670039595295727832462022172087306533770220445116930364653579568540596572e131 + x * (1445023173120570352457613845314142208 + x^2 * (4.459943605238880345331053665741657079808e39 + x^2 * (1.1479894839884878008882132135619025323425792e43 + x^2 * (2.513738223221041881507409371071328451288891392e46 + x^2 * (4.752920371616941077512398363057866250620340535296e49 + x^2 * (7.8501609317811207306733527563445247928370854451216384e52 + x^2 * (1.14298343166733117838604016132376280983707964080971055104e56 + x^2 * (1.47782995283620640818738384358490348966893409724858867122176e59 + x^2 * (1.7068935955258184014564283393405635305676188823221199152611328e62 + x^2 * (1.7696219351613922277099520808113292403159788762474578221469794304e65 + x^2 * (1.65329878662345004527515123069933119825254186478212492797118464917504e68 + x^2 * (1.39636582206474951167660975975346325922410778060832782588366273478918144e71 + x^2 * (1.06887696720756384679104251786304808189901850288565705871906489222421282816e74 + x^2 * (7.43017947343591257387384416931188284708970500964265774845683303553081278464e76 + x^2 * (4.69743767552169378091434821904075456627587034609618973023491991698926964047872e79 + x^2 * (2.703727690088398897949775976174382309484234074454314403979964031221098873318539264e82 + x^2 * (1.417654552169683822158332536840767790939566733038878852486827807036929509243354087424e85 + x^2 * (6.77284462299066446036143369475676812121378006709324371775581984811893073041012415266816e87 + x^2 * (2.9476597685276761412268674471528369084065190639827552006406850730291520265828409899220992e90 + x^2 * (1.1679487737005806777082039995291626075204913766226671075205247792487800498662302664026750976e93 + x^2 * (4.20882020090741253018928393270329037246084272479744318866096309450090378769794738800867998171136e95 + x^2 * (1.37733641074695075050444316697715177438781078168996328348930017267542076452415328272584052401504256e98 + x^2 * (4.0850777693561413370516966226492708923324402739900836941415984380684331415960812918772336727083188224e100 + x^2 * (1.095311476908615395996986156947835758006635548463591190491716081207098636090449296384583278494917984256e103 + x^2 * (2.64649914437885106198306275921844315736292940968427016268119123483384142865026835164371552841858286747648e105 + x^2 * (5.73981556096699814493093261428493346779396673470356793782839025648212975183765700998994502855183647574523904e107 + x^2 * (1.11204297610218680188565100907726807766356658737514932369668748001392488030764412909676160778975257655890018304e110 + x^2 * (1.9132351890408091993067036345234060629927393271230889380037852878802073214167921102319440724020258782015702992896e112 + x^2 * (2.90174003671189395228183384569383252887232131280335155597240768661831443748213470051844850980973924860571495392256e114 + x^2 * (3.8443788221672724435451531052729025371486386333890285540816795365800580540112575760251033271876383662777773558659328e116 + x^2 * (4.3979693725593596754156551524322005024980425965970486658694413898475864137888786669727182063026582910217772951106271232e118 + x^2 * (4.280079360211587950782985507373948461250525621438266666909329974814171944641482336038588398828156478498554653727800590592e120 + x^2 * (3.47380495100416178816251499422809925111765633545381481100776159847755631074550579868212998964350105538679989868772572258048e122 + x^2 * (2.287683392075767072335972045541004835768930257756097780143927210576338070431744279263692183969174050290912301701587794936224e124 + x * (378610231954898944 + x * (1.17434414126556043046579898337771581569471753231479686047388263476252020948829539668869532110417601248266831487348173473392832e126 + x * (7769271264830503780352 + x * (4.4081943202755974658609929338541007431640459369266687150038369402398102363666888453201900615948007068568161869563320617574834312e127 + x * (77770405360953342841323520 + x * (1.076244515755090991055330226045842644855417068991120825297278238336597572342208666869636646745462318917969025156899608248595345032e129 + x * (506013142481042925197071482880 + x * (1.2825247146081500976742685193712958184527053405477523168125899006844454403744653280196503373716759300439130883119720331629094528298e130 + x * (2405965989211738848580775633223680 + x^2 * (8910976234243517173488618712770543616 + x^2 * (2.6759661631433282071986321994449942478848e40 + x^2 * (6.696605323266178838514577079111098105331712e43 + x^2 * (1.4244516598252570661875319769404194557303717888e47 + x^2 * (2.6141062043893175926318190996818264378411872944128e50 + x^2 * (4.18675249694993105635912147005041322284644557073154048e53 + x^2 * (5.90541439694787775499454083350610785082491147751683784704e56 + x^2 * (7.3891497641810320409369192179245174483446704862429433561088e59 + x^2 * (8.2499857117081222737060703068127237310768245978902462570954752e62 + x^2 * (8.2582356974198303959797763771195364548079014224881365033525706752e65 + x^2 * (7.43984453980552520373818053814699039213643839151956217587033092128768e68 + x^2 * (6.05091856228058121726530895893167412330446704930275391216253851741978624e71 + x^2 * (4.453654030031516028296010491096033674579243762023571077996103717600886784e74 + x^2 * (2.972071789374365029549537667724753138835882003857063099382733214212325113856e77 + x^2 * (1.800684442283315949350500150632289250405750299336872729923385968179220028850176e80 + x^2 * (9.913668196990795959149178579306068468108858272999152814593201447810695868834643968e82 + x^2 * (4.961790932593893377554163878942687268288483565636075983703897324629253282351739305984e85 + x^2 * (2.25761487433022148678714456491892270707126002236441457258527328270631024347004138422272e88 + x^2 * (9.3342559336709744472184135826506502099539770359453914686955027312589814175123298014199808e90 + x^2 * (3.5038463211017420331246119985874878225614741298680013225615743377463401495986907992080252928e93 + x^2 * (1.192499056923766883553630447599265605530572105359275570120606210108589406514418426602459328151552e96 + x^2 * (3.67289709532520200134518177860573806503416208450656875597146712713445537206440875393557473070678016e98 + x^2 * (1.0212694423390353342629241556623177230831100684975209235353996095171082853990203229693084181770797056e101 + x^2 * (2.555726779453435923992967699544950102015482946415046111147337522816563484211048358230694316488141963264e103 + x^2 * (5.73408147948751063429663597830662684095301372098258535247591434213998976207558142856138364490692954619904e105 + x^2 * (1.147963112193399628986186522856986693558793346940713587565678051296425950367531401997989005710367295149047808e108 + x^2 * (2.03874545618734247012369351664165814238320541018777376011059371335886228056401423667739628094787972369131700224e110 + x^2 * (3.188725315068015332177839390872343438321232211871814896672975479800345535694653517053240120670043130335950498816e112 + x^2 * (4.35261005506784092842275076854074879330848196920502733395861152992747165622320205077767276471460887290857243088384e114 + x^2 * (5.1258384295563632580602041403638700495315181778520380721089060487734107386816767680334711029168511550370364744879104e116 + x^2 * (5.1309642679859196213182643445042339195810496960298901101810149548221841494203584448015045740197680061920735109623983104e118 + x^2 * (4.280079360211587950782985507373948461250525621438266666909329974814171944641482336038588398828156478498554653727800590592e120 + x^2 * (2.8948374591701348234687624951900827092647136128781790091731346653979635922879214989017749913695842128223332489064381021504e122 + x^2 * (1.525122261383844714890648030360669890512620171837398520095951473717558713621162852842461455979449366860608201134391863290816e124 + x * (1940377438768857088 + x * (5.8717207063278021523289949168885790784735876615739843023694131738126010474414769834434766055208800624133415743674086736696416e125 + x * (38846356324152518901760 + x * (1.4693981067585324886203309779513669143880153123088895716679456467466034121222296151067300205316002356189387289854440205858278104e127 + x * (379130726134647546351452160 + x * (1.79374085959181831842555037674307107475902844831853470882879706389432928723701444478272774457577053152994837526149934708099224172e128 + x * (2403562426784953894686089543680 + x^2 * (11127592700104292174686087303659520 + x^2 * (40099393054095827280698784207467446272 + x^2 * (1.1707351963752060906494015872571849834496e41 + x^2 * (2.8460572623881260063686952586222166947659776e44 + x^2 * (5.8758630967791853980235694048792302548877836288e47 + x^2 * (1.04564248175572703705272763987273057513647491776512e51 + x^2 * (1.622366592568098284339159569644535123852997658658471936e54 + x^2 * (2.21453039885545415812295281256479044405934180406881419264e57 + x^2 * (2.67856678951562411483963321649763757502494305126306696658944e60 + x^2 * (2.88749499909784279579712460738445330587688860926158618998341632e63 + x^2 * (2.78715454787919275864317452727784355349766673008974606988149260288e66 + x^2 * (2.417949475436795691214908674897771877444342477243857707157857549418496e69 + x^2 * (1.8909120507126816303954090496661481635326459529071105975507932866936832e72 + x^2 * (1.3360962090094548084888031473288101023737731286070713233988311152802660352e75 + x^2 * (8.544706394451299459954920794708665274153160761089056410725357990860434702336e77 + x^2 * (4.951882216279118860713875414238795438615813323176400007289311412492855079337984e80 + x^2 * (2.6023379017100839392766593770678429728785752966622776138307153800503076655690940416e83 + x^2 * (1.240447733148473344388540969735671817072120891409018995925974331157313320587934826496e86 + x^2 * (5.36183532653427603111946834168244142929424255311548460989002404642748682824134828752896e88 + x^2 * (2.10020758507596925062414305609639629723964483308771308045648811453327081894027420531949568e91 + x^2 * (7.4456734323412018203898004969984116229431325259695028104433454677109728178972179483170537472e93 + x^2 * (2.384998113847533767107260895198531211061144210718551140241212420217178813028836853204918656303104e96 + x^2 * (6.8866820537347537525222158348857588719390539084498164174465008633771038226207664136292026200752128e98 + x^2 * (1.7872215240933118349601172724090560153954426198706616161869493166549394994482855651962897318098894848e101 + x^2 * (4.153056016611833376488572511760543915775159787924449930614423474576915661842953582124878264293230690304e103 + x^2 * (8.60112221923126595144495396745994026142952058147387802871387151320998464311337214284207546736039431929856e105 + x^2 * (1.578449279265924489856006468928356703643340852043481182902807320532585681755355677747234882851755030829940736e108 + x^2 * (2.5484318202341780876546168958020726779790067627347172001382421416985778507050177958467453511848496546141462528e110 + x^2 * (3.587315979451517248700069314731386368111386238355791758757097414775388727656485206684895135753798521627944311168e112 + x^2 * (4.35261005506784092842275076854074879330848196920502733395861152992747165622320205077767276471460887290857243088384e114 + x^2 * (4.4851086258618178508026786228183862933400784056205333130952927926767343963464671720292872150522447606574069151769216e116 + x^2 * (3.8482232009894397159886982583781754396857872720224175826357612161166381120652688336011284305148260046440551332217987328e118 + x^2 * (2.67504960013224246923936594210871778828157851339891666681833123425885746540092646002411774926759779906159665857987536912e120 + x^2 * (1.4474187295850674117343812475950413546323568064390895045865673326989817961439607494508874956847921064111666244532190510752e122 + x^2 * (5.71920848018941768083993011385251208942232564439024445035981802644084517607936069815923045992293512572728075425396948734056e123 + x * (7761509755075428352 + x * (1.4679301765819505380822487292221447696183969153934960755923532934531502618603692458608691513802200156033353935918521684174104e125 + x * (151500789664194823716864 + x * (1.836747633448165610775413722439208642985019140386111964584932058433254265152787018883412525664500294523673411231805025732284763e126 + x * (1440696759311660676135518208 + x^2 * (8893180979104329410338531311616 + x^2 * (40059333720375451828869914293174272 + x^2 * (140347875689335395482445744726136061952 + x^2 * (3.98049966767570070820796539667442894372864e41 + x^2 * (9.39198896588081582101669435345331509272772608e44 + x^2 * (1.880276190969339327367542209561353681564090761216e48 + x^2 * (3.241491693442753814863455683605464782923072245071872e51 + x^2 * (4.867099777704294853017478708933605371558992975975415808e54 + x^2 * (6.422138156680817058556563156437892287772091231799561158656e57 + x^2 * (7.499987010643747521550973006193385210069840543536587506450432e60 + x^2 * (7.796236497564175548652236439938023925867599245006282712955224064e63 + x^2 * (7.246601824485901172472253770922393239093933498233339781691880767488e66 + x^2 * (6.04487368859198922803727168724442969361085619310964426789464387354624e69 + x^2 * (4.53818892171043591294898171919875559247835028697706543412190388806483968e72 + x^2 * (3.07302128072174605952424723885626323545967819579626404381731156514461188096e75 + x^2 * (1.87983540677928588119008257483590636031369536743959241035957875798929563451392e78 + x^2 * (1.03989526541861496074991383699014704210932079786704400153075539662349956666097664e81 + x^2 * (5.2046758034201678785533187541356859457571505933245552276614307601006153311381880832e83 + x^2 * (2.3568506929820993543382278424977764524370296936771360922593512291988953091170761703424e86 + x^2 * (9.651303587761696856015043015028394572729636595607872297802043283569476290834426917552128e88 + x^2 * (3.570352894629147726061043195363873705307396216249112236776029794706560392198466149043142656e91 + x^2 * (1.191307749174592291262368079519745859670901204155120449670935274833755650863554871730728599552e94 + x^2 * (3.577497170771300650660891342797796816591716316077826710361818630325768219543255279807377984454656e96 + x^2 * (9.64135487522865525353110216884006242071467547182974298442510120872794535166907297908088366810529792e98 + x^2 * (2.32338798132130538544815245413177282001407540583186010104303411165142134928277123475517665135285633024e101 + x^2 * (4.9836672199342000517862870141126526989301917455093399167373081694922987942115442985498539171518768283648e103 + x^2 * (9.461234441154392546589449364205934287572472639621265831585258664530983107424709357126283014096433751228416e105 + x^2 * (1.578449279265924489856006468928356703643340852043481182902807320532585681755355677747234882851755030829940736e108 + x^2 * (2.29358863821076027888915520622186541018110608646124548012441792752872006563451601626207081606636468915273162752e110 + x^2 * (2.8698527835612137989600554517851090944891089906846334070056779318203109821251881653479161086030388173023554489344e112 + x^2 * (3.046827038547488649895925537978524155315937378443519133771028070949230159356241435544370935300226211036000701618688e114 + x^2 * (2.69106517551709071048160717369103177600404704337231998785717567560604063780788030321757232903134685639444414910615296e116 + x^2 * (1.9241116004947198579943491291890877198428936360112087913178806080583190560326344168005642152574130023220275666108993664e118 + x^2 * (1.070019840052896987695746376843487115312631405359566666727332493703542986160370584009647099707039119624638663431950147648e120 + x^2 * (4.3422561887552022352031437427851240638970704193172685137597019980969453884318822483526624870543763192334998733596571532256e121 + x^2 * (1.143841696037883536167986022770502417884465128878048890071963605288169035215872139631846091984587025145456150850793897468112e123 + x * (25224906703995142144 + x * (1.4679301765819505380822487292221447696183969153934960755923532934531502618603692458608691513802200156033353935918521684174104e124 + x * (479752500603283608436736 + x^2 * (4442148341210953751417847808 + x^2 * (26679542937312988231015593934848 + x^2 * (116839723351095067834203916688424960 + x^2 * (3.97652314453116953866929610057385508864e38 + x^2 * (1.094637408610817694757190484085467959525376e42 + x^2 * (2.504530390901550885604451827587550691394060288e45 + x^2 * (4.857380160004126595699484041366830344040567799808e48 + x^2 * (8.10372923360688453715863920901366195730768061267968e51 + x^2 * (1.1762157796118712561458906879922879647934233025273921536e55 + x^2 * (1.4984989032255239803298647365021748671468212874198976036864e58 + x^2 * (1.6874970773948431923489689263935116722657141222957321889513472e61 + x^2 * (1.6891845744722380355413178953199051839379798364180279211402985472e64 + x^2 * (1.50970871343456274426505286894216525814456947879861245451914182656e67 + x^2 * (1.208974737718397845607454337448885938722171238621928853578928774709248e70 + x^2 * (8.69819543327833549981888162846428155225017138337270874873364911879094272e72 + x^2 * (5.63387234798986777579445327123648259834274335895981741366507120276512178176e75 + x^2 * (3.28971196186375029208264450596283613054896689301928671812926282648126736039936e78 + x^2 * (1.7331587756976916012498563949835784035155346631117400025512589943724992777682944e81 + x^2 * (8.2407366887485991410427546940481694141154884394305457771305987034926409409687977984e83 + x^2 * (3.5352760394731490315073417637466646786555445405157041383890268437983429636756142555136e86 + x^2 * (1.3672680082662403879354644271290225644700318510444485755219561318390091412015438133198848e89 + x^2 * (4.760470526172196968081390927151831607076528288332149649034706392942080522931288198724190208e91 + x^2 * (1.48913468646824036407796009939968232458862650519390056208866909354219456357944358966341074944e94 + x^2 * (4.173746699233184092437706566597429619357002368757464495422121735380062922800464493108607648530432e96 + x^2 * (1.044480111483104319132536068291006762244089842781555489979385964278860746430816239400429064044740608e99 + x^2 * (2.32338798132130538544815245413177282001407540583186010104303411165142134928277123475517665135285633024e101 + x^2 * (4.5683616182730167141374297629365983073526757667168949236758658220346072280272489403373660907225537593344e103 + x^2 * (7.88436203429532712215787447017161190631039386635105485965438222044248592285392446427190251174702812602368e105 + x^2 * (1.183836959449443367392004851696267527732505639032610887177105490399439261316516758310426162138816273122455552e108 + x^2 * (1.52905909214050685259277013748124360678740405764083032008294528501914671042301067750804721071090979276848775168e110 + x^2 * (1.6740807904107080493933656802079803051186469112327028207533121268951814062396930964529510633517726434263740118784e112 + x^2 * (1.523413519273744324947962768989262077657968689221759566885514035474615079678120717772185467650113105518000350809344e114 + x^2 * (1.1212771564654544627006696557045965733350196014051333282738231981691835990866167930073218037630611901643517287942304e116 + x^2 * (6.413705334982399526647830430630292399476312120037362637726268693527730186775448056001880717524710007740091888702997888e117 + x^2 * (2.67504960013224246923936594210871778828157851339891666681833123425885746540092646002411774926759779906159665857987536912e119 + x^2 * (7.237093647925337058671906237975206773161784032195447522932836663494908980719803747254437478423960532055833122266095255376e120 + x^2 * (9.5320141336490294680665501897541868157038760739837407505996967107347419601322678302653840998715585428788012570899491455676e121 + x * (68467603910843957248 + x^2 * (1267917323022963822297088 + x^2 * (11422667163113881075074465792 + x^2 * (66698857343282470577538984837120 + x^2 * (283753613852659450454495226243317760 + x^2 * (9.37323312639489962686334080849551556608e38 + x^2 * (2.502028362539011873730721106481069621772288e42 + x^2 * (5.545745865567719818124143332515290816658276352e45 + x^2 * (1.040867177143741413364175151721463645151550242816e49 + x^2 * (1.678629626961426082697146693295687119728019555483648e52 + x^2 * (2.3524315592237425122917813759845759295868466050547843072e55 + x^2 * (2.8899621705063676763504534203970515294974410543098025213952e58 + x^2 * (3.1339231437332802143623708633022359627791833699777883509096448e61 + x^2 * (3.01640102584328220632378195592840211417496399360362128775053312e64 + x^2 * (2.58807208017353613302580491818656901396211910651190706488995741696e67 + x^2 * (1.986172783394510746355103554380312613614995606307454545165382987022336e70 + x^2 * (1.366859282372309864257252827330101386782169788815711374801002004381433856e73 + x^2 * (8.45080852198480166369167990685472389751411503843972612049760680414768267264e75 + x^2 * (4.6995885169482147029752064370897659007842384185989810258989468949732390862848e78 + x^2 * (2.3521440527325814588390908217634278333425113285087900034624229209341061626855424e81 + x^2 * (1.05952328855339131813406846066333606752913422792678445705964840473476812098170257408e84 + x^2 * (4.2928351907888238239732007131209499669388755134833550251866754531837021701775315959808e86 + x^2 * (1.5625920094471318719262450595760257879657506869079412291679498649588675899446215009370112e89 + x^2 * (5.10050413518449675151577599337696243615342316607016033825147113529508627456923735577591808e91 + x^2 * (1.48913468646824036407796009939968232458862650519390056208866909354219456357944358966341074944e94 + x^2 * (3.875621935002242371549298954697613217974359342417645602891970182852915571171859886457992816492544e96 + x^2 * (8.95268666985517987827888058535148653352077008098476134268045112239023496940699633771796340609777664e98 + x^2 * (1.82551912818102565999497692824639293001105924743931865081952680201183106015074882730763879749152997376e101 + x^2 * (3.263115441623583367241021259240427362394768404797782088339904158596148020019463528812404350516109828096e103 + x^2 * (5.06851845061842457853006215939603622548525319979710669549210285599874095040609429846050875755166093815808e105 + x^2 * (6.76478262542539067081145629540724301561431793732920506958345994513965292180866719034529235507895013212831744e107 + x^2 * (7.6452954607025342629638506874062180339370202882041516004147264250957335521150533875402360535545489638424387584e109 + x^2 * (7.174631958903034497400138629462772736222772476711583517514194829550777455312970413369790271507597043255888622336e111 + x^2 * (5.4407625688348011605284384606759359916356024615062841674482644124093395702790025634720909558932610911357155386048e113 + x^2 * (3.203649018472727036287627587727418780957198861157523795068066280483381711676047980020919439323031971898147796554944e115 + x^2 * (1.374365428924799898567392235135062657030638311436577708084200434327370754309024583428974439469580715944305404722070976e117 + x^2 * (3.8214994287603463846276656315838825546879693048555952383119017632269392362870378000344539275251397129451380836855362416e118 + x^2 * (5.16935260566095504190850445569657626654413145156817680209488333106779212908557410518174105601711466575416651590435375384e119 + x^3 * (158331334043826651136 + x^2 * (2852813976801668600168448 + x^2 * (24987084419311614851725393920 + x^2 * (141735071854475249977270342778880 + x^2 * (585241828571110116562396404126842880 + x^2 * (1.874646625278979925372668161699103113216e39 + x^2 * (4.847679952419335505353272143807072392183808e42 + x^2 * (1.039827349793947465898276874846617028123426816e46 + x^2 * (1.886571758573031311722567462495152856837184815104e49 + x^2 * (2.937601847182495644720006713267452459524034222096384e52 + x^2 * (3.9697282561900654894923810719739718811778036460299485184e55 + x^2 * (4.6961885270728474740694868081452087354333417132534290972672e58 + x^2 * (4.89675491208325033494120447390974369184247401559029429829632e61 + x^2 * (4.52460153876492330948567293389260317126244599040543193162579968e64 + x^2 * (3.72035361524945819122459456989319295757054621561086640577931378688e67 + x^2 * (2.730987577167452276238267387272929843720618958672749999602401607155712e70 + x^2 * (1.794002808113656696837644335870758070151597847820621179426315130750631936e73 + x^2 * (1.05635106524810020796145998835684048718926437980496576506220085051846033408e76 + x^2 * (5.5807613638760049597830576440440970071812831220862899682549994377807214149632e78 + x^2 * (2.6461620593241541411939771744838563125103252445723887538952257860508694330212352e81 + x^2 * (1.12574349408797827551744773945479457174970511717220848562587643003069112854305898496e84 + x^2 * (4.2928351907888238239732007131209499669388755134833550251866754531837021701775315959808e86 + x^2 * (1.464930008856686129930854743352524176217891268976194902344952998398938365573082657128448e89 + x^2 * (4.46294111828643465757630399420484213163424527031139029597003724338320049024808268630392832e91 + x^2 * (1.20992193275544529581334258076224188872825903547004420669704363850303308290829791660152123392e94 + x^2 * (2.906716451251681778661974216023209913480769506813234202168977637139686678378894914843494612369408e96 + x^2 * (6.15497208552543616631673040242914699179552943067702342309281014664328654146730998218109984169222144e98 + x^2 * (1.1409494551131410374968605801539955812569120296495741567622042512573944125942180170672742484322062336e101 + x^2 * (1.835502435913265644073074458322740391347057227698752424691196089210333261260948234956977447165311778304e103 + x^2 * (2.53425922530921228926503107969801811274262659989855334774605142799937047520304714923025437877583046907904e105 + x^2 * (2.95959239862360841848001212924066881933126409758152721794276372599859815329129189577606540534704068280613888e107 + x^2 * (2.8669857977634503486114440077773317627263826080765568501555224094109000820431450203275885200829558614409145344e109 + x^2 * (2.24207248715719828043754332170711648006961639897236984922318588423461795478530325417805945984612407601746519448e111 + x^2 * (1.3601906422087002901321096151689839979089006153765710418620661031023348925697506408680227389733152727839288846512e113 + x^2 * (6.00684190963636319303930172698891021429474786467035711575262427590634070939258996253922394873068494730902711854052e114 + x^2 * (1.71795678615599987320924029391882832128829788929572213510525054290921344288628072928621804933697589493038175590258872e116 + x^2 * (2.388437142975216490392291019739926596679980815534747023944938602016837022679398625021533704703212320590711302303460151e117 + x^5 * (316662668087653302272 + x^2 * (5547138288225466722549760 + x^2 * (47197826125366383608814632960 + x^2 * (259847631733204624958328961761280 + x^2 * (1040429917459751318333149162892165120 + x^2 * (3.228558076869354315919595167370677583872e39 + x^2 * (8.07946658736555917558878690634512065363968e42 + x^2 * (1.675277396890248695058334965030660767532187648e46 + x^2 * (2.934667180002493151568438274992459999524509712384e49 + x^2 * (4.406402770773743467080010069901178689286051333144576e52 + x^2 * (5.7340519256078723737112171039624038283679385998210367488e55 + x^2 * (6.52248406537895482509650945575723435476853015729642930176e58 + x^2 * (6.52900654944433377992160596521299158912329868745372573106176e61 + x^2 * (5.78143529953295756212058208219610405216868098774027413485518848e64 + x^2 * (4.54709886308267112260783780764723583703066759685772560706360573952e67 + x^2 * (3.186152173362027655611311951818418151007388785118208332869468541681664e70 + x^2 * (1.99333645345961855204182703985639785572399760868957908825146125638959104e73 + x^2 * (1.11503723553966133062598554326555384758866795646079719645454534221393035264e76 + x^2 * (5.5807613638760049597830576440440970071812831220862899682549994377807214149632e78 + x^2 * (2.4991530560283678000165339981236420729264182865405893786788243534924877978533888e81 + x^2 * (1.00066088363375846712662021284870628599973788193085198722300127113839211426049687552e84 + x^2 * (3.577362658990686519977667260934124972449062927902795854322229544319751808481276329984e86 + x^2 * (1.139390006888533656612887022607518803725026542537040479601630109865840951001286511099904e89 + x^2 * (3.22323525209575836380510844025905265062473269522489299153391578688786702073472638455283712e91 + x^2 * (8.0661462183696353054222838717482792581883935698002947113136242566868872193886527773434748928e93 + x^2 * (1.776326720209361086960095354236406058238248031941420901325486333807586303453769114626580040892416e96 + x^2 * (3.4194289364030200923981835569050816621086274614872352350515611925796036341485055456561665787179008e98 + x^2 * (5.704747275565705187484302900769977906284560148247870783811021256286972062971090085336371242161031168e100 + x^2 * (8.15778860405895841810255314810106840598692101199445522084976039649037005004865882203101087629027457024e102 + x^2 * (9.8554525428691589026973430877145148828879923329388185745679777755531074035674055803398781396837851575296e104 + x^2 * (9.8653079954120280616000404308022293977708803252717573931425457533286605109709729859202180178234689426871296e106 + x^2 * (7.96384943823180652392067779938147711868439613354599125043200669280805578345318061202107922245265517066920704e108 + x^2 * (4.9823833047937739565278740482380366223769253310497107760515241871880398995228961203956876885469423911499226544e110 + x^2 * (2.266984403681167150220182691948306663181501025627618403103443505170558154282917734780037898288858787973214807752e112 + x^2 * (6.6742687884848479922658908077654557936608309607448412397251380843403785659917666250435821652563166081211412428228e113 + x^2 * (9.544204367533332628940223855104601784934988273865122972806947460606741349368226273812322496316532749613231977236604e114 + x^7 * (554159669153393278976 + x^2 * (9430135089983293428334592 + x^2 * (77876413106854532954544144384 + x^2 * (415756210773127399933326338818048 + x^2 * (1612666372062614543416381202482855936 + x^2 * (4.842837115304031473879392751056016375808e39 + x^2 * (1.1715226551680060804603741014200424947777536e43 + x^2 * (2.3453883556463481730816689510429250745450627072e46 + x^2 * (3.9618006930033657546173916712398209993580881117184e49 + x^2 * (5.7283236020058665072040130908715322960718667330879488e52 + x^2 * (7.167564907009840467139021379953004785459923249776295936e55 + x^2 * (7.826980878454745790115811346908681225722236188755715162112e58 + x^2 * (7.508357531860983846909846859994940327491793490571784590721024e61 + x^2 * (6.359578829486253318332640290415714457385549086514301548340707328e64 + x^2 * (4.774453806236804678738229698029597628882200976700611887416786026496e67 + x^2 * (3.186152173362027655611311951818418151007388785118208332869468541681664e70 + x^2 * (1.893669630786637624439735687863577962937797728255100133838888193570111488e73 + x^2 * (1.003533511985695197563386988938998462829801160814717476809090807992537317376e76 + x^2 * (4.74364715929460421581559899743748245610409065377334647301674952211361320271872e78 + x^2 * (1.99932244482269424001322719849891365834113462923247150294305948279399023828271104e81 + x^2 * (7.5049566272531885034496515963652971449980341144813899041725095335379408569537265664e83 + x^2 * (2.5041538612934805639843670826538874807143440495319570980255606810238262659368934309888e86 + x^2 * (7.406035044775468767983765646948872224212672526490763117410595714127966181508362322149376e88 + x^2 * (1.933941151257455018283065064155431590374839617134935794920349472132720212440835830731702272e91 + x^2 * (4.43638042010329941798225612946155359200361646339016209122249334117778797066375902753891119104e93 + x^2 * (8.88163360104680543480047677118203029119124015970710450662743166903793151726884557313290020446208e95 + x^2 * (1.53874302138135904157918260060728674794888235766925585577320253666082163536682749554527496042305536e98 + x^2 * (2.2818989102262820749937211603079911625138240592991483135244085025147888251884360341345484968644124672e100 + x^2 * (2.855226011420635446335893601835373942095422354198059327297416138771629517517030587710853806701596099584e102 + x^2 * (2.95663576286074767080920292631435446486639769988164557237039333266593222107022167410196344190513554725888e104 + x^2 * (2.4663269988530070154000101077005573494427200813179393482856364383321651277427432464800545044558672356717824e106 + x^2 * (1.592769887646361304784135559876295423736879226709198250086401338561611156690636122404215844490531034133841408e108 + x^2 * (7.4735749571906609347918110723570549335653879965745661640772862807820598492843441805935315328204135867248839816e109 + x^2 * (2.266984403681167150220182691948306663181501025627618403103443505170558154282917734780037898288858787973214807752e111 + x^2 * (3.3371343942424239961329454038827278968304154803724206198625690421701892829958833125217910826281583040605706214114e112 + x^9 * (856428579600698703872 + x^2 * (14145202634974940142501888 + x^2 * (113274782700879320661155119104 + x^2 * (585838296998497699906050750152704 + x^2 * (2199090507358110741022338003385712640 + x^2 * (6.383739833809859670113744990028385222656e39 + x^2 * (1.4910288338501895569495670381709631751716864e43 + x^2 * (2.8784311637477909396911391671890444096689405952e46 + x^2 * (4.6821280917312504372750992478288793628777404956672e49 + x^2 * (6.50945863864303012182274214871765033644530310578176e52 + x^2 * (7.819161716738007782333477869039641584138098090665050112e55 + x^2 * (8.182752736566325144211984589949984917800519651880974942208e58 + x^2 * (7.508357531860983846909846859994940327491793490571784590721024e61 + x^2 * (6.070507064509605440226611186305909254777115037127287841597947904e64 + x^2 * (4.34041255112436788976202699820872511716563725154601080674253275136e67 + x^2 * (2.751676876994478429846133049297724766779108496238452651114541013270528e70 + x^2 * (1.549366061552703510905238290070200151494561777663263745868181249284636672e73 + x^2 * (7.75457713807128107208071764180135175823028169720463504807024715266960654336e75 + x^2 * (3.44992520675971215695679927086362360443933865728970652583036328880990051106816e78 + x^2 * (1.3631743941972915272817458171583502215962281562948669338248132837231751624654848e81 + x^2 * (4.7758814900702108658315964704142800013623853455790663026552333395241441816978259968e83 + x^2 * (1.4797272816734203332634896397500244204221123929052473761060131296958973389627097546752e86 + x^2 * (4.039655478968437509809326716517566667752366832631325336769415844069799735368197630263296e88 + x^2 * (9.66970575628727509141532532077715795187419808567467897460174736066360106220417915365851136e90 + x^2 * (2.0165365545924088263555709679370698145470983924500736778284060641717218048471631943358687232e93 + x^2 * (3.63339556406460222332746777002901239185096188351654275271122204642460834797361864355436826546176e95 + x^2 * (5.5954291686594874239243003658446790834504813006154758391752819514938968558793727110737271288111104e97 + x^2 * (7.260587441629079329525476419161790062543985643224562815759481598910691716508660108609927035477676032e99 + x^2 * (7.78698003114718758091607345955101984207842460235834361990204401483171686595553796648414674554980754432e101 + x^2 * (6.719626733774426524566370287078078329241812954276467209932712119695300502432321986595371458875308061952e103 + x^2 * (4.484230907005467300727291104910104271714036511487162451428429887876663868623169539054644553556122246675968e105 + x^2 * (2.17195893769958359743291212710403921418665349096708852284509273440219703185086743964211251521436050109160192e107 + x^2 * (6.794159051991509940719828247597322666877625451431423785524805709801872590258494709630483211654921442477167256e108 + x^2 * (1.03044745621871234100917395088559393780977319346709927413792886598661734285587169762728995376766308544237036716e110 + x^11 * (1177589296950960717824 + x^2 * (18860270179966586856669184 + x^2 * (146313260988635789187325362176 + x^2 * (732297871248122124882563437690880 + x^2 * (2657234363057717145401991754091069440 + x^2 * (7.447696472778169615132702488366449426432e39 + x^2 * (1.6774074380814632515682629179423335720681472e43 + x^2 * (3.1183004273934401846654007644547981104746856448e46 + x^2 * (4.87721676222005253882822838315508266966431301632e49 + x^2 * (6.50945863864303012182274214871765033644530310578176e52 + x^2 * (7.493363311873924124736249624496323184799010670220673024e55 + x^2 * (7.500856675185798048860985874120819507983809680890893697024e58 + x^2 * (6.569812840378360866046116002495572786555319304250311516880896e61 + x^2 * (5.05875588709133786685550932192159104564759586427273986799828992e64 + x^2 * (3.43615993630679124606160470691524071775612949080725855533783842816e67 + x^2 * (2.063757657745858822384599786973293575084331372178839488335905759952896e70 + x^2 * (1.097467626933164986891210455466391773975314592511478486656628384909950976e73 + x^2 * (5.16971809204752071472047842786756783882018779813642336538016476844640436224e75 + x^2 * (2.1562032542248200980979995442897647527745866608060665786439770555061878194176e78 + x^2 * (7.951850632817533909143517266757042959311330911720057113978077488385188447715328e80 + x^2 * (2.5869358071213642189921147548077350007379587288553275806049180589089114317529890816e83 + x^2 * (7.398636408367101666317448198750122102110561964526236880530065648479486694813548773376e85 + x^2 * (1.851508761193867191995941411737218056053168131622690779352648928531991545377090580537344e88 + x^2 * (4.0290440651196979547563855503238158132809158690311162394173947336098337759184079806910464e90 + x^2 * (7.562012079721533098833391129764011804551618971687776291856522740643956768176861978759507712e92 + x^2 * (1.21113185468820074110915592334300413061698729450551425090374068214153611599120621451812275515392e95 + x^2 * (1.6320001741923504986445876067046980660063903793461804530927905691857199162981503740631704125699072e97 + x^2 * (1.815146860407269832381369104790447515635996410806140703939870399727672929127165027152481758869419008e99 + x^2 * (1.6222875064889974126908486374064624670996717921579882541462591697566076804074037430175305719895432384e101 + x^2 * (1.119937788962404420761061714513013054873635492379411201655452019949216750405386997765895243145884676992e103 + x^2 * (5.60528863375683412590911388113763033964254563935895306428553735984582983577896192381830569194515280834496e104 + x^2 * (1.8099657814163196645274267725866993451555445758059071023709106120018308598757228663684270960119670842430016e106 + x^2 * (2.83089960499646247529992843649888444453234393809642657730200237908411357927437279567936800485621726769881969e107 + x^13 * (1449340673170413191168 + x^2 * (22487245214575545867567104 + x^2 * (168822993448425910600760033280 + x^2 * (816793779469059293138243834347520 + x^2 * (2861637006369849233509837273636536320 + x^2 * (7.734146337115791523407037199457466712064e39 + x^2 * (1.6774074380814632515682629179423335720681472e43 + x^2 * (2.99836579557061556217826996582192126007181312e46 + x^2 * (4.50204624204927926661067235368161477199782739968e49 + x^2 * (5.75836725726114203084319497771176760531699890126848e52 + x^2 * (6.340538186970243490161441989958427310214547490186723328e55 + x^2 * (6.058384237650067654849257821405277294910000126873414139904e58 + x^2 * (5.05370218490643143542008923268890214350409177250023962836992e61 + x^2 * (3.69678314825905459500979527371193191797324313158392528815259648e64 + x^2 * (2.37887995590470163188880325863362818921578195517425592292619583488e67 + x^2 * (1.349380006987676922328392168405615029862832051040010434681169150738432e70 + x^2 * (6.75364693497332299625360280287010322446347441545525222557925159944585216e72 + x^2 * (2.9825296684889542584925837083851352916270314220017827107962489048729255936e75 + x^2 * (1.1610325215056723605143074469252579438017005096648050808082953375802549796864e78 + x^2 * (3.975925316408766954571758633378521479655665455860028556989038744192594223857664e80 + x^2 * (1.1939703725175527164578991176035700003405963363947665756638083348810360454244564992e83 + x^2 * (3.130192326616850704980458853317359350892930061914946372531950851279782832421116788736e85 + x^2 * (7.1211875430533353538305438912969925232814158908565029975101881866615059437580406943744e87 + x^2 * (1.3946690994645108304925949981890131661357016469723094674906366385572501532025258394699776e90 + x^2 * (2.326772947606625568871812655312003632169728914365469628263545458659679005592880608849079296e92 + x^2 * (3.2607396087759250722169582551542418901226581005917691370485326057656741584378628852410997254144e94 + x^2 * (3.766154248136193458410586784703149383091670106183493353291055159659353652995731632453470182853632e96 + x^2 * (3.4906670392447496776564790476739375300692238669348859691151353840916787098599327445240033824411904e98 + x^2 * (2.495826933059996019524382519086865333999495064858443467917321799625550277549851912334662418445451136e100 + x^2 * (1.29223591034123587010891736289963044793111787582239754037167540763371163508313884357603297286063616576e102 + x^2 * (4.3117604875052570199300876008751002612634966456607331263734902768044844890607399413986966861116560064192e103 + x^2 * (6.96140685160122947895164143302576671213670990694579654758042543077627253798354948603241190773833493939616e104 + x^15 * (1604627173867243175936 + x^2 * (24093477015616656286679040 + x^2 * (174852386071583978836501463040 + x^2 * (816793779469059293138243834347520 + x^2 * (2759435684713783189455914513863802880 + x^2 * (7.181707313036092128877963113781933375488e39 + x^2 * (1.49768521257273504604309189101994068934656e43 + x^2 * (2.57002782477481333900994568499021822291869696e46 + x^2 * (3.69810941311190796900162371909561213414107250688e49 + x^2 * (4.52443141641946873851965319677353168989192770813952e52 + x^2 * (4.755403640227682617621081492468820482660910617640042496e55 + x^2 * (4.32741731260719118203518415814662663922142866205243867136e58 + x^2 * (3.42929791118650704546363197932461216880634798848230546210816e61 + x^2 * (2.37650345245224938250629696167195623298279915601823768524095488e64 + x^2 * (1.44431997322785456221820197845613140059529618707008395320519032832e67 + x^2 * (7.71074289707243955616224096231780017064475457737148819817810943279104e69 + x^2 * (3.6180251437357087479930015015375552988197184368510279779888847854174208e72 + x^2 * (1.4912648342444771292462918541925676458135157110008913553981244524364627968e75 + x^2 * (5.390508135562050245244998860724411881936466652015166446609942638765469548544e77 + x^2 * (1.703967992746614409102182271447937776995285195368583667281016604653968953081856e80 + x^2 * (4.690597892033242814656032247728310715623771321550868690107818458461213035596079104e82 + x^2 * (1.11792583093458953749302101904191405389033216496962370447569673259992244015039885312e85 + x^2 * (2.2889531388385720780169605364883190253404551077753045349139890599983411962079416517632e87 + x^2 * (3.984768855612888087121699994825751903244861848492312764258961824449286152007216684199936e89 + x^2 * (5.81693236901656392217953163828000908042432228591367407065886364664919751398220152212269824e91 + x^2 * (6.987299161662696583322053403901946907405695929839505293675427012355016053795420468373785125888e93 + x^2 * (6.7252754431003454614474764012556238983779823324705238451625984993917029517780922008097681836672e95 + x^2 * (4.986667198921070968080684353819910757241748381335551384450193405845255299799903920748576260630272e97 + x^2 * (2.67410028542142430663326698473592714357088756949118942991141621388451815451769847750142401976298336e99 + x^2 * (9.230256502437399072206552592140217485222270541588553859797681483097940250593848882685949806147401184e100 + x^2 * (1.539914459823306078546459857455392950451248802021690402276246527430173031807407121928105959325591430864e102 + x^17 * (1604627173867243175936 + x^2 * (23290361115096101077123072 + x^2 * (163195560333478380247401365504 + x^2 * (735114401522153363824419450912768 + x^2 * (2391510926751945430861792578681962496 + x^2 * (5.98475609419674344073163592815161114624e39 + x^2 * (1.198148170058188036834473512815952551477248e43 + x^2 * (1.970354665660690226574291691825833970904334336e46 + x^2 * (2.711946902948732510601190727336782231703453171712e49 + x^2 * (3.167101991493628116963757237741472182924349395697664e52 + x^2 * (3.170269093485121745080720994979213655107273745093361664e55 + x^2 * (2.740697631317887748622283300159530204840238152633211158528e58 + x^2 * (2.057578746711904227278179187594767301283808793089383277264896e61 + x^2 * (1.346685289722941316753568278280775198690252855077001354969874432e64 + x^2 * (7.70303985721522433183041055176603413650824633104044775042768175104e66 + x^2 * (3.85537144853621977808112048115890008532237728868574409908905471639552e69 + x^2 * (1.68841173374333074906340070071752580611586860386381305639481289986146304e72 + x^2 * (6.4621476150594008934005980348344597985252347476705292067252059605580054528e74 + x^2 * (2.1562032542248200980979995442897647527745866608060665786439770555061878194176e77 + x^2 * (6.247882640070919500041334995309105182316045716351473446697060883731219494633472e79 + x^2 * (1.563532630677747604885344082576103571874590440516956230035939486153737678532026368e82 + x^2 * (3.35377749280376861247906305712574216167099649490887111342709019779976732045119655936e84 + x^2 * (6.1038750369028588747118947639688507342412136207341454264373041599955765232211777380352e86 + x^2 * (9.297793996430072203283966654593421107571344313148729783270910923715001021350172263133184e88 + x^2 * (1.163386473803312784435906327656001816084864457182734814131772729329839502796440304424539648e91 + x^2 * (1.164549860277116097220342233983657817900949321639917548945904502059169342299236744728964187648e93 + x^2 * (8.9670339241337939485966352016741651978373097766273651268834646658556039357041229344130242448896e94 + x^2 * (4.986667198921070968080684353819910757241748381335551384450193405845255299799903920748576260630272e96 + x^2 * (1.78273352361428287108884465649061809571392504632745961994094414258967876967846565166761601317532224e98 + x^2 * (3.076752167479133024068850864046739161740756847196184619932560494365980083531282960895316602049133728e99 + x^19 * (1454193376317189128192 + x^2 * (20379065975709088442482688 + x^2 * (137696254031372383333744902144 + x^2 * (597280451236749608107340803866624 + x^2 * (1868367911524957367860775452095283200 + x^2 * (4.48856707064755758054872694611370835968e39 + x^2 * (8.61168997229322651474777837336465896374272e42 + x^2 * (1.354618832641724530769825538130260854996729856e46 + x^2 * (1.779715155060105710082031414814763339555391143936e49 + x^2 * (1.97943874468351757310234827358842011432771837231104e52 + x^2 * (1.882347274256791036141678090768908107719943786149183488e55 + x^2 * (1.541642417616311858600034356339735740222633960856181276672e58 + x^2 * (1.093088709190699120741532693409720128807023421328734866046976e61 + x^2 * (6.73342644861470658376784139140387599345126427538500677484937216e63 + x^2 * (3.6107999330696364055455049461403285014882404676752098830129758208e66 + x^2 * (1.68672500873459615291049021050701878732854006380001304335146143842304e69 + x^2 * (6.8591726683322811680700653466649485873457162031967405416039274056871936e71 + x^2 * (2.4233053556472753350252242630629224244469630303764484525219522352092520448e74 + x^2 * (7.411948686397819087211873433496066337662641646520853864088671128302520629248e76 + x^2 * (1.95246332502216234376291718603409536947376428635983545209283152616600609207296e79 + x^2 * (4.39743552378116513874003023224529129589728561395393939697607980480738722087132416e81 + x^2 * (8.3844437320094215311976576428143554041774912372721777835677254944994183011279913984e83 + x^2 * (1.3352226643225003788432269796181860981152654795355943120331602849990323644546326301952e86 + x^2 * (1.743336374330638538115743747736266457669627058715386834363295798196562691503157299337472e88 + x^2 * (1.8177913653176762256811036369625028376326007143480231470808948895778742231194379756633432e90 + x^2 * (1.45568732534639512152542779247957227237618665204989693618238062757396167787404593091120523456e92 + x^2 * (8.406594303875431826809345501569529872972477915588154806453248124239628689722615251012210229584e93 + x^2 * (3.11666699932566935505042772113744422327609273833471961528137087865328456237493995046786016289392e95 + x^2 * (5.571042261294633972152639551533181549106015769773311312315450445592746155245205161461300041172882e96 + x^21 * (1197571015790626340864 + x^2 * (16183375921886629057265664 + x^2 * (105297135435755351961099042816 + x^2 * (439176802379962947137750591078400 + x^2 * (1318847937547028730254665025008435200 + x^2 * (3.03638360661452424566531528707692036096e39 + x^2 * (5.57226998207208774483679777100066168242176e42 + x^2 * (8.36676337808123974887245185315749351615627264e45 + x^2 * (1.04689126768241512357766553812633137620905361408e49 + x^2 * (1.10615694555843629085131227053470535800666614923264e52 + x^2 * (9.96536792253595254427947224524716057028205533843685376e54 + x^2 * (7.70821208808155929300017178169867870111316980428090638336e57 + x^2 * (5.14394686677976056819544796898691825320952198272345819316224e60 + x^2 * (2.9706293155653117281328712020899452912284989450227971065511936e63 + x^2 * (1.4867999724404385199305020366460176182598637219839099518288723968e66 + x^2 * (6.4492426804558088199518743342915424221385355380588734010497054998528e68 + x^2 * (2.4208844711760992357894348282346877367102527775988496029190332020072448e71 + x^2 * (7.840105562388243730963960851085925490857821568864980287571021937441697792e73 + x^2 * (2.17998490776406443741525689220472539343018871956495701884960915538309430272e76 + x^2 * (5.1682852721174885570194866689137818603717289933054467849516128633806043613696e78 + x^2 * (1.03469071147792120911530123111653912844642014445975044634731289524879699314619392e81 + x^2 * (1.7262090036489985505406942205794261126247776076736836613227670135734096502322335232e83 + x^2 * (2.356275289980883021488047611090916643732821434474578197705576973527704172566998759168e85 + x^2 * (2.5637299622509390266407996290239212612788633216402747564166114679361216051517019107904e87 + x^2 * (2.138578076844324971389533690544120985450118487468262525977523399503381438964044677250992e89 + x^2 * (1.2844299929527015778165539345407990638613411635734384731021005537417308922418052331569457952e91 + x^2 * (4.94505547286790107459373264798207639586616347975773812144308713190566393513095014765424131152e92 + x^2 * (9.166667645075498103089493297463071244929684524513881221415796701921425183455705736670176949688e93 + x^23 * (898178261842969755648 + x^2 * (11687993721362565430247424 + x^2 * (73123010719274549972985446400 + x^2 * (292784534919975298091833727385600 + x^2 * (842597293432823910996035988199833600 + x^2 * (1.85556775959776481679547045321367355392e39 + x^2 * (3.25049082287538451782146536641705264807936e42 + x^2 * (4.6482018767117998604846954739763852867534848e45 + x^2 * (5.5252594683238575966599014512223044855477829632e48 + x^2 * (5.5307847277921814542565613526735267900333307461632e51 + x^2 * (4.70586818564197759035419522692227026929985946537295872e54 + x^2 * (3.42587203914735968577785412519941275605029769079151394816e57 + x^2 * (2.1433111944915669034147699870778826055039674928014409138176e60 + x^2 * (1.1552447338309545609405610230349787243666384786199766525476864e63 + x^2 * (5.368999900479361321971257354555063621493952329386341492715372544e65 + x^2 * (2.1497475601519362733172914447638474740461785126862911336832351666176e68 + x^2 * (7.397146995260303220467717530717101417725772375996484897808157006133248e70 + x^2 * (2.17780710066340103637887801419053485857161710246249452432528387151158272e73 + x^2 * (5.4499622694101610935381422305118134835754717989123925471240228884577357568e75 + x^2 * (1.1485078382483307904487748153141737467492731096234326188781361918623565247488e78 + x^2 * (2.0118986056515134621686412827266038608680391697828480901197750740948830422287104e80 + x^2 * (2.877015006081664250901157034299043521041296012789472768871278355955682750387055872e82 + x^2 * (3.2726045694178930854000661265151620051844742145480252745910791298995891285652760544e84 + x^2 * (2.848588846945487807378666254471023623643181468489194173796234964373468450168557678656e86 + x^2 * (1.78214839737027080949127807545343415454176540622355210498126949958615119913670389770916e88 + x^2 * (7.13572218307056432120307741411555035478522868651910262834500307634294940134336240642747664e89 + x^2 * (1.3736265202410836318315924022172434432961565221549272559564130921960177597585972632372892532e91 + x^25 * (614543021260979306496 + x^2 * (7689469553528003572531200 + x^2 * (46182954138489189456622387200 + x^2 * (177211692188406101476636203417600 + x^2 * (487819485671634895839810308957798400 + x^2 * (1.02544534083034371454486525046018801664e39 + x^2 * (1.7107846436186234304323501928510803410944e42 + x^2 * (2.3241009383558999302423477369881926433767424e45 + x^2 * (2.6172281692060378089441638453158284405226340352e48 + x^2 * (2.4742984308543969663779353419855251429096479653888e51 + x^2 * (1.98141818342820109067545062186200853444204609068335104e54 + x^2 * (1.3523179101897472443859950494208208247566964568913870848e57 + x^2 * (7.896409663916299117843889426076409599225143394531624419328e59 + x^2 * (3.952153036790107708480866657751243004412184268963078021873664e62 + x^2 * (1.695473652782956206938291796175283248892827051385160471383801856e65 + x^2 * (6.222953463597710264865843655895347951186306220934000650135680745472e67 + x^2 * (1.94661763033165874222834671860976353098046641473591707837056763319296e70 + x^2 * (5.1579641857817392966868163493986351913538299795164343997177775904221696e72 + x^2 * (1.1473604777705602302185562590551186281211519576657668520261100817805759488e75 + x^2 * (2.115672333615346192931953607157688480853924149306323245301829827114867282432e77 + x^2 * (3.176682008923442308687328341147269254002167110183444352820697485412973224571648e79 + x^2 * (3.7855460606337687511857329398671625276859158063019378537779978367837930926145472e81 + x^2 * (3.444846915176729563579016975279117900194183383734763446937978031473251714279237952e83 + x^2 * (2.24888593179906932161473651668765022919198536985989013720755391924221193434359816736e85 + x^2 * (9.379728407211951628901463555018074497588238980123958447269839471506058942824757356364e86 + x^2 * (1.8778216271238327161060730037146185144171654438208164811434218621955130003535164227440728e88 + x^27 * (384089388288112066560 + x^2 * (4613681732116802143518720 + x^2 * (26555198629631283937557872640 + x^2 * (97466430703623355812149911879680 + x^2 * (256105229977608320315900412202844160 + x^2 * (5.1272267041517185727243262523009400832e38 + x^2 * (8.1262270571884612945536634160426316201984e41 + x^2 * (1.04584542226015496860905648164468668951953408e45 + x^2 * (1.11232197191256606880126963425922708722211946496e48 + x^2 * (9.8971937234175878655117413679421005716385918615552e50 + x^2 * (7.4303181878557540900329398319825320041576728400625664e53 + x^2 * (4.7331126856641153553509826729728728866484375991198547968e56 + x^2 * (2.5663331407727972132992640634748331197481716032227779362816e59 + x^2 * (1.1856459110370323125442599973253729013236552806889234065620992e62 + x^2 * (4.662552545153129569080302439482028934455274391309191296305455104e64 + x^2 * (1.555738365899427566216460913973836987796576555233500162533920186368e67 + x^2 * (4.37988966824623217001378011687196794470604943315581342633377717468416e69 + x^2 * (1.03159283715634785933736326987972703827076599590328687994355551808443392e72 + x^2 * (2.0078808360984804028824734533464575992120159259150919910456926431160079104e74 + x^2 * (3.173508500423019289397930410736532721280886223959484867952744740672300923648e76 + x^2 * (3.97085251115430288585916042643408656750270888772930544102587185676621653071456e78 + x^2 * (3.7855460606337687511857329398671625276859158063019378537779978367837930926145472e80 + x^2 * (2.583635186382547172684262731459338425145637537801072585203483523604938785709428464e82 + x^2 * (1.12444296589953466080736825834382511459599268492994506860377695962110596717179908368e84 + x^2 * (2.344932101802987907225365888754518624397059745030989611817459867876514735706189339091e85 + x^29 * (219479650450349752320 + x^2 * (2526539996159201173831680 + x^2 * (13909865948854482062530314240 + x^2 * (48733215351811677906074955939840 + x^2 * (121954871417908723959952577239449600 + x^2 * (231945969949720602099433806651709194240 + x^2 * (3.4826687387950548405229986068754135515136e41 + x^2 * (4.2331838520053891586557048066570651718647808e44 + x^2 * (4.2374170358573945478143605114637222370366455808e47 + x^2 * (3.534712044077709951968479059979321632728068521984e50 + x^2 * (2.4767727292852513633443132773275106680525576133541888e53 + x^2 * (1.4650110693722261814181613035392225601530878282990026752e56 + x^2 * (7.332380402207992037997897324213808913566204580636508389376e58 + x^2 * (3.105263100335084628092109516804548074895287639899561302900736e61 + x^2 * (1.11013155836979275454292915225762593677506533126409316578701312e64 + x^2 * (3.33372506978448764189241624422965068813552118978607177685840039936e66 + x^2 * (8.3426469871356803238357716511847008470591417774396446215881469993984e68 + x^2 * (1.7193213952605797655622721164662117304512766598388114665725925301407232e71 + x^2 * (2.868401194426400575546390647637796570302879894164417130065275204451439872e73 + x^2 * (3.7779863100274039159499171556387294300962931237612915094675532627051201472e75 + x^2 * (3.7817642963374313198658670727943681595263894168850528009770208159678252673472e77 + x^2 * (2.703961471881263393704094957047973234061368433072812752698569883416995066153248e79 + x^2 * (1.23030246970597484413536320545682782149792263704812980247784929695473275509972784e81 + x^2 * (2.677245156903653954303257757961488368085696868880821591913754665764538017075712104e82 + x^31 * (114727999099046461440 + x^2 * (1263269998079600586915840 + x^2 * (6638799657407820984389468160 + x^2 * (22151461523550762684579525427200 + x^2 * (52662330839551494437252249262489600 + x^2 * (94886987706703882677041102721153761280 + x^2 * (1.3455765581708166429293403708382279630848e41 + x^2 * (1.5393395825474142395111653842389327897690112e44 + x^2 * (1.444573989496839050391259265271723489898856448e47 + x^2 * (1.124681104933816802899061519084329610413476347904e50 + x^2 * (7.317737609251879028062743773922190610155283857637376e52 + x^2 * (3.995484734651525949322258100561516073144784986270007296e55 + x^2 * (1.833095100551998009499474331053452228391551145159127097344e58 + x^2 * (7.0574161371251923365729761745557910793074719088626393247744e60 + x^2 * (2.2707236421200306342923550841633257797671790866765542027461632e63 + x^2 * (6.0613183086990684398043931713266376147918567087019486851970916352e65 + x^2 * (1.3272392934079491424284182172339296802139543736835798261617506589952e68 + x^2 * (2.344529175355336043948552886090288723342649990689288363508080722919168e70 + x^2 * (3.2595468118481824722118075541338597389805453342777467387105400050584544e72 + x^2 * (3.434533009115821741772651959671572209178448294328446826788684784277381952e74 + x^2 * (2.578475656593703172635818458723432836040720056967081455211605101796244500464e76 + x^2 * (1.22907339630966517895640679865816965184607656048764216031753176518954321188784e78 + x^2 * (2.796141976604488282125825466947335957949824175109385914722384765806210807044836e79 + x^33 * (54869912612587438080 + x^2 * (576710216514600267939840 + x^2 * (2886434633655574341038899200 + x^2 * (9149516716249228065369803980800 + x^2 * (20606999024172323910229141015756800 + x^2 * (35066930239434043598036929266513346560 + x^2 * (4.680266289289797018884662159437314654208e40 + x^2 * (5.01958559526330730275380016599651996663808e43 + x^2 * (4.39652953325124928379948472039220192577912832e46 + x^2 * (3.17844660089991705167126081480354020334243315712e49 + x^2 * (1.908975028500490181233759245371006246127465354166272e52 + x^2 * (9.55442001764495335707496502308188626186796409760219136e54 + x^2 * (3.9849893490260826293466833283770700617207633590415806464e57 + x^2 * (1.3807988094375376310686257732826547763862445039079076939776e60 + x^2 * (3.949084594991357624856269711588392660464659281176616004775936e62 + x^2 * (9.223745252368147625789293956366622457291955861068182781821661184e64 + x^2 * (1.731181687053846707515328109435560452452983965674234555863153033472e67 + x^2 * (2.5484012775601478738571227022720529601550543377057482212044355683904e69 + x^2 * (2.834388532041897801923310916638138903461343768937171077139600004398656e71 + x^2 * (2.23991283203205765767781649543798187555116193108376966964479442452872736e73 + x^2 * (1.12107637243204485766774715596670992871335654650742671965721960947662804368e75 + x^2 * (2.671898687629706910774797388387325330100166435842700348516373402585963504104e76 + x^35 * (24005586768007004160 + x^2 * (240295923547750111641600 + x^2 * (1142547042488664843327897600 + x^2 * (3431068768593460524513676492800 + x^2 * (7298312154394364718206154109747200 + x^2 * (11688976746478014532678976422171115520 + x^2 * (1.46258321540306156840145692482416082944e40 + x^2 * (1.46404579861846462996985838174898499026944e43 + x^2 * (1.19072674858888001436236044510622135489851392e46 + x^2 * (7.9461165022497926291781520370088505083560828928e48 + x^2 * (4.37473444031362333199403160397522264737544143663104e51 + x^2 * (1.9905041703426986160572843798087263045558258536671232e54 + x^2 * (7.471855029423904930025031240707006365726431298202963712e56 + x^2 * (2.301331349062562718447709622137757960643740839846512823296e59 + x^2 * (5.75908170102906320291539332939973929651096145171589834029824e61 + x^2 * (1.152968156546018453223661744545827807161494482633522847727707648e64 + x^2 * (1.8033142573477569869951334473287088046385249642439943290241177432e66 + x^2 * (2.123667731300123228214268918560044133462545281421456851003696306992e68 + x^2 * (1.77149283252618612620206932289883681466333985558573192321225000274916e70 + x^2 * (9.332970133466906906990902064324924481463174712849040290186643435536364e71 + x^2 * (2.335575775900093453474473241597312351486159471890472332619207519742975091e73 + x^37 * (9602234707202801664 + x^2 * (91312450948145042423808 + x^2 * (411316935295919343598043136 + x^2 * (1166563381321776578334650007552 + x^2 * (2335459889406196709825969315119104 + x^2 * (3506693023943404359803692926651334656 + x^2 * (4.095233003128572391524079389507650322432e39 + x^2 * (3.806519076408008037921631792547360974700544e42 + x^2 * (2.857744196613312034469665068254931251756433408e45 + x^2 * (1.748145630494954378419193448141947111838338236416e48 + x^2 * (8.74946888062724666398806320795044529475088287326208e50 + x^2 * (3.58290750661685750890311188365570734820048653660082176e53 + x^2 * (1.19549680470782478880400499851312101851622900771247419392e56 + x^2 * (3.2218638886875878058267934709928611449012371757851179526144e58 + x^2 * (6.910898041234875843498471995279687155813153742059078008357888e60 + x^2 * (1.152968156546018453223661744545827807161494482633522847727707648e63 + x^2 * (1.44265140587820558959610675786296704371081997139519546321929419456e65 + x^2 * (1.2742006387800739369285613511360264800775271688528741106022177841952e67 + x^2 * (7.08597133010474450480827729159534725865335942234292769284900001099664e68 + x^2 * (1.8665940266933813813981804128649848962926349425698080580373286871072728e70 + x^39 * (3508508835324100608 + x^2 * (31608156097434822377472 + x^2 * (134468998077512093099360256 + x^2 * (358942578868238947179892310016 + x^2 * (673690352713325973988260379361280 + x^2 * (944109660292455019947148095636897792 + x^2 * (1.023808250782143097881019847376912580608e39 + x^2 * (8.78427479171078777981915029049390994161664e41 + x^2 * (6.04522810822046776522429149053927764794630144e44 + x^2 * (3.3618185201826045738830643233498982919968043008e47 + x^2 * (1.51433115241625423030562632445296168562996049729536e50 + x^2 * (5.5121653947951653983124798210087805356930562101551104e52 + x^2 * (1.6093226217220718310823144210753552172333852026898691072e55 + x^2 * (3.717535256177985929800146312684070551809119818213597637632e57 + x^2 * (6.6450942704181498495177615339227761113588016750568057772672e59 + x^2 * (8.8689858195847573324897057272755985166268806356424834440592896e61 + x^2 * (8.322988880066570709208308218440194482947038296510743057034389584e63 + x^2 * (4.90077168761566898818677442744625569260587372635720811770083763152e65 + x^2 * (1.3626867942509124047708225560760283189717998889121014793940384636532e67 + x^41 * (1169502945108033536 + x^2 * (9950715808451703341056 + x^2 * (39842666097040620177588224 + x^2 * (99706271907844151994414530560 + x^2 * (174660461814565993256215653908480 + x^2 * (227285658959294727024313430431105024 + x^2 * (227512944618254021751337743861536129024 + x^2 * (1.78938930942256788107427135547098165477376e41 + x^2 * (1.1194866867074940305970910167665328977678336e44 + x^2 * (5.603030866971007623138440538916497153328007168e46 + x^2 * (2.2434535591351914523046315917821654601925340700672e49 + x^2 * (7.145399585845584775590251619826196990713221013164032e51 + x^2 * (1.788136246357857590091460467861505796925983558544299008e54 + x^2 * (3.4421622742388758609260614006333986590825183501977755904e56 + x^2 * (4.922292052161592481124267802905760082488001240782819094272e58 + x^2 * (4.927214344213754073605392070708665842570489242023601913366272e60 + x^2 * (3.08258847409872989229937341423710906775816233204101594704977392e62 + x^2 * (9.075503125214201829975508198974547578899766159920755773520069688e63 + x^43 * (355027679764938752 + x^2 * (2843061659557629526016 + x^2 * (10672142704564451833282560 + x^2 * (24926567976961037998603632640 + x^2 * (40546178635524248434478633943040 + x^2 * (48704069776991727219495735092379648 + x^2 * (44690042692871325701155628258516025344 + x^2 * (3.195338052540299787632627420483895812096e40 + x^2 * (1.799175032208472549173896276946213585698304e43 + x^2 * (8.00432980995858231876920076988071021904001024e45 + x^2 * (2.804316948918989315380789489727706825240667587584e48 + x^2 * (7.65578527054884083098955530695663963290702251410432e50 + x^2 * (1.5965502199623728482959468463049158901124853201288384e53 + x^2 * (2.458687338742054186375758143309570470773227392998411136e55 + x^2 * (2.63694217080085311488800060869951432990428637899079594336e57 + x^2 * (1.75971940864776931200192573953880922948946044357985782620224e59 + x^2 * (5.504622275176303379106023953994837620996718450073242762588882e60 + x^45 * (97938670279983104 + x^2 * (735274567126973153280 + x^2 * (2576034445929350442516480 + x^2 * (5586989374146439551411159040 + x^2 * (8388864545280878986443855298560 + x^2 * (9236978750808775851973329069244416 + x^2 * (7705179774632987189854418665261383680 + x^2 * (4.95828318497632725667131841109570039808e39 + x^2 * (2.48162073408065179196399486475339804923904e42 + x^2 * (9.6603980465017372812731733429594778505655296e44 + x^2 * (2.90101753336447170556633395489073119852482853888e47 + x^2 * (6.599814888404173130163409747376413476643984925952e49 + x^2 * (1.101069117215429550548928859520631648353438151812992e52 + x^2 * (1.27173483038382113088401283274632955384822106534400576e54 + x^2 * (9.092904037244321085820691754136256310014780617209641184e55 + x^2 * (3.033998980427188468968837481963464188774931799275616941728e57 + x^47 * (24484667569995776 + x^2 * (171564065662960402432 + x^2 * (558140796618025929211904 + x^2 * (1117397874829287910282231808 + x^2 * (1537958499968161147514706804736 + x^2 * (1539496458468129308662221511540736 + x^2 * (1155776966194948078478162799789207552 + x^2 * (6.61104424663510300889509121479426719744e38 + x^2 * (2.89522418976076042395799400887896439077888e41 + x^2 * (9.6603980465017372812731733429594778505655296e43 + x^2 * (2.4175146111370597546386116290756093321040237824e46 + x^2 * (4.399876592269448753442273164917608984429323283968e48 + x^2 * (5.50534558607714775274464429760315824176719075906496e50 + x^2 * (4.2391161012794037696133761091544318461607368844800192e52 + x^2 * (1.515484006207386847636781959022709385002463436201606864e54 + x^49 * (5528795902902272 + x^2 * (35973110542233632768 + x^2 * (108027250958327599202304 + x^2 * (198248010050357532469428224 + x^2 * (248057822575509862502372065280 + x^2 * (223475292358276835128386993610752 + x^2 * (149132511767090074642343587069575168 + x^2 * (74640822139428582358492965328322371584 + x^2 * (2.8018298610588004102819296860119010233344e40 + x^2 * (7.79064358588849780747836559916086923432704e42 + x^2 * (1.559686845894877261057168792952006020712273408e45 + x^2 * (2.12897254464650746134303540237948821827225320192e47 + x^2 * (1.7759179309926283073369820314848897554087712126016e49 + x^2 * (6.83728403432161898324738082121682555832376916851616e50 + x^51 * (1123036667777024 + x^2 * (6744958226668806144 + x^2 * (18567183758462556112896 + x^2 * (30976251570368364448348160 + x^2 * (34883131299681074414396071680 + x^2 * (27934411544784604391048374201344 + x^2 * (16311368474525476914006329835734784 + x^2 * (6997577075571429596108715499530222336 + x^2 * (2.18892957895218782053275756719679767448e39 + x^2 * (4.8691522411803111296739784994755432714544e41 + x^2 * (7.3110320901322371612054787169625282220887816e43 + x^2 * (6.653039202020335816696985632435900682100791256e45 + x^2 * (2.77487176717598173021403442419514024282620501969e47 + x^53 * (204188485050368 + x^2 * (1124159704444801024 + x^2 * (2813209660373114562560 + x^2 * (4224034305050231515683840 + x^2 * (4228258339355281747199523840 + x^2 * (2962740618386245920262706354688 + x^2 * (1482851679502316083091484530521344 + x^2 * (530119475422077999705205719661380480 + x^2 * (132662398724375019426227731345260465120 + x^2 * (2.213251018718323240760899317943428759752e40 + x^2 * (2.215464269737041564001660217261372188511752e42 + x^2 * (1.00803624273035391162075539885392434577284716e44 + x^55 * (33030490228736 + x^2 * (165317603594823680 + x^2 * (372336572696441633280 + x^2 * (496945212358850766551040 + x^2 * (435261887874808415152892160 + x^2 * (261418289857609934140827031296 + x^2 * (109033211728111476697903274303040 + x^2 * (31183498554239882335600336450669440 + x^2 * (5852752884898897915862988147585020520 + x^2 * (6.5095618197597742375320568174806728228e38 + x^2 * (3.2580356907897670058847944371490767478114e40 + x^57 * (4718641461248 + x^2 * (21255120462191616 + x^2 * (42552751165307615232 + x^2 * (49694521235885076655104 + x^2 * (37308161817840721298819328 + x^2 * (18672734989829281010059073664 + x^2 * (6230469241606370097023044245888 + x^2 * (1336435652324566385811442990742976 + x^2 * (167221510997111369024656804216714872 + x^2 * (9299374028228248910760081167829532604 + x^59 * (589830182656 + x^2 * (2361680051354624 + x^2 * (4137073029960462592 + x^2 * (4141210102990423054592 + x^2 * (2590844570683383423529120 + x^2 * (1037374166101626722781059648 + x^2 * (259602885066932087375960176912 + x^2 * (37123212564571288494762305298416 + x^2 * (2322520986070991236453566725232151 + x^61 * (63765425152 + x^2 * (223402167020032 + x^2 * (335438353780578048 + x^2 * (279811493445298855040 + x^2 * (140045652469372076947520 + x^2 * (42055709436552434707340256 + x^2 * (7016294190998164523674599376 + x^2 * (501665034656368763442733855384 + x^63 * (5873131264 + x^2 * (17637013185792 + x^2 * (22068312748722240 + x^2 * (14726920707647308160 + x^2 * (5528117860633108300560 + x^2 * (1106729195698748281772112 + x^2 * (92319660407870585837823676 + x^65 * (451779328 + x^2 * (1130577768320 + x^2 * (1131708346088320 + x^2 * (566420027217204160 + x^2 * (141746611811105341040 + x^2 * (14188835842291644638104 + x^67 * (28236208 + x^2 * (56528888416 + x^2 * (42439062978312 + x^2 * (14160500680430104 + x^2 * (1771832647638816763 + x^69 * (1377376 + x^2 * (2068130064 + x^2 * (1035099097032 + x^2 * (172689032688172 + x^71 * (49192 + x^2 * (49241192 + x^2 * (12322608298 + x^73 * (1144 + x^2 * (572572 + x^75 * 13))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) } The precision has been set to 300 bits. OKAY! OKAY! OKAY! OKAY! OKAY! OKAY! OKAY! The precision has been set to 5000 bits. { .radii = [|[0;0], [0;0], [0;0], [0;0], [0;0]|], .poly = 1 + x^4 } { .radii = [|[0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0]|], .poly = 19.437530517578125 + x * (3.625213623046875 + x * (1.188140869140625 + x * (1.068115234375e-3 + x * (1.068115234375e-3 + x * (6.40869140625e-4 + x * (2.13623046875e-4 + x * (2566.651275634765625 + x * (1682.407470703125 + x * (2.2686767578125 + x * (3.02490234375 + x * (2.2686767578125 + x * (0.907470703125 + x * (0.1512451171875 + x * (5.9557224462890625e5 + x * (1606.22314453125 + x * (3212.4462890625 + x * (3212.4462890625 + x * (1606.22314453125 + x * (321.24462890625 + x^2 * (3.79068662109375e5 + x * (1.5162746484375e6 + x * (2.27441197265625e6 + x * (1.5162746484375e6 + x * (3.79068662109375e5 + x^3 * (2.683806127734375e8 + x * (8.051418383203125e8 + x * (8.051418383203125e8 + x * (2.683806127734375e8 + x^4 * (1.1400808430615625e11 + x * (2.280161686123125e11 + x * (1.1400808430615625e11 + x^5 * (2.6905907896252875e13 + x * (2.6905907896252875e13 + x^6 * 2.7213403986495765e15))))))))))))))))))))))))))))))))) } { .radii = [|[0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0], [0;0]|], .poly = 228698418577443 + x^2 * (5036396573911695993 + x^2 * (54195404432720099540992 + x^2 * (379747198860069737483730944 + x^2 * (1948150598552015262008725209088 + x^2 * (7800394996602269109082935737188352 + x^2 * (25376635022696331979124060687008006144 + x^2 * (6.8948317356665933987280072886600752693248e40 + x^2 * (1.59602426871177262317930753718814504843739136e44 + x^2 * (3.19524058596096879160497368945066638697165750272e47 + x^2 * (5.59726269645712708069401266049520484337760103038976e50 + x^2 * (8.65896539141917559383363758578608189270514879401295872e53 + x^2 * (1.191798349061456780796277293213631846507204917135958605824e57 + x^2 * (1.468295566043714753941013625239194434896876457911501002375168e60 + x^2 * (1.627238561067946876055128350171337232474463334480420985882279936e63 + x^2 * (1.628865799629014822931183478521508569706937797814901406868162215936e66 + x^2 * (1.477635790544708477964666412437527258438209291649024154374246280200192e69 + x^2 * (1.218093409923149682952755006111735705867827353715848499964746315925028864e72 + x^2 * (9.14483627499804624476780820838385581180271385802173261348533296680715419648e74 + x^2 * (6.26325023402892504121913095872100608836782712812825297364655988931902618730496e77 + x^2 * (3.9184459276643462289127188060498294340351218470352382666376290307552157584326656e80 + x^2 * (2.2413510706240060429380751570605024362680896965041562885167238055919834138234847232e83 + x^2 * (1.1727869477040111619673478259319078997772779336957997779663757312760053212831383814144e86 + x^2 * (5.614590035290811697574985613624451254107655359967152763125114424817432431586363790327808e88 + x^2 * (2.458839523580169847806745262166658121095771319205614963201104798418484315507853192426684416e91 + x^2 * (9.845193452415000070618208029715299116867468362099282312657223612867611199293444182476444401664e93 + x^2 * (3.600879505220786275828609586868370651994276553437812505854379536406328796141577209740759539908608e96 + x^2 * (1.201493461575335687368146065485079674215423609997083439453411305314245041645906262316833433149505536e99 + x^2 * (3.65103825636205131998995385649278586002211849487863730163905360402366212030149765461527759498305994752e101 + x^2 * (1.00819015023956230932688105113083548851921120368924577625950142279384435377153080062617734415946013999104e104 + x^2 * (2.5229958509745046790905198304549158100193260372323375550894023105415954953132558285670088037590490003275776e106 + x^2 * (5.702784492831727189157184661934708090582392755769996531777884512891922463116123738957751834819243982353334272e108 + x^2 * (1.159536478206551029882850687589943068480448077044296326062900174472852922070783097110269134789106592849436545024e111 + x^2 * (2.11035639033592287438678825141369638463441550022061931343447831754059231816882523674068982531617399898597451194368e113 + x^2 * (3.4172256197042421720401360935759133663543454519013587147392706991822738257877845120223140686112341033580243163252736e115 + x^2 * (4.886632636177066306017394613813556113886713996218942962077157099830651570876531852191909118114064767801974772345141248e117 + x^2 * (6.11439908601655421540426501053421208750075088776895238129904282116310277805926048005512628404022354071222093389685798656e119 + x^2 * (6.6167713352460224536428857032916176211764882580072663066814506637667739252295348546326285517019067721653331403575728049152e121 + x^2 * (6.100489045535378859562592121442679562050480687349594080383805894870234854484651411369845823917797467442432804537567453163264e123 + x * (5031365208702993 + x * (4.69737656506224172186319593351086326277887012925918744189553053905008083795318158675478128441670404993067325949392693893571328e125 + x * (108282526339101097984 + x * (2.9387962135170649772406619559027338287760306246177791433358912934932068242444592302134600410632004712378774579708880411716556208e127 + x * (1138103493087122090360832 + x * (1.434992687673454654740440301394456859807222758654827767063037651115463429789611555826182195660616425223958700209199477664793793376e129 + x * (7784817576631429618416484352 + x * (5.1300988584326003906970740774851832738108213621910092672503596027377817614978613120786013494867037201756523532478881326516378113192e130 + x * (38963011971040305240174504181760 + x * (1.194239292393263486299481663154108943508053996175162855004095340079190591455664924044344174613067540440890233860729307159137081193144e132 + x * (152107702433744247627117246875172864 + x * (1.3584471950973372156656603918377989232404114206492477475671584493400792977808188511004414986223643272515126410165795868935184298572013e133 + x * (4.82156065431230307603357153053152116736e38 + x^2 * (1.275543871098319778764681348402113924825088e42 + x^2 * (2.872843683681190721722753566938661087187304448e45 + x^2 * (5.59167102543169538530870395653866617720040062976e48 + x^2 * (9.515346583977116037179821522841848233741921751662592e51 + x^2 * (1.4287292895841639729825502016547035122963495510121381888e55 + x^2 * (1.9068773584983308492740436691418109544115278674175337693184e58 + x^2 * (2.2758581273677578686085711191207513740901585097628265536815104e61 + x^2 * (2.440857841601920314082692525257005848711695001720631478823419904e64 + x^2 * (2.3618554094620714932502160438561874260750598068316070399588352131072e67 + x^2 * (2.0686901067625918691505329774125381618134930083086338161239447922802688e70 + x^2 * (1.6444261033962520719862192582508432029215669275163954749524075264987889664e73 + x^2 * (1.1888287157497460118198150670899012555343528015428252397530932856849300455424e76 + x^2 * (7.8290627925361563015239136984012576104597839101603162170581998616487827341312e78 + x^2 * (4.70213511319721547469526256725979532084214621644228591996515483690625891011919872e81 + x^2 * (2.57755373121760694937878643061957780170830315097977973179423237643078092589700743168e84 + x^2 * (1.29006564247441227816408260852509868975500572706537975576301330440360585341145221955584e87 + x^2 * (5.8953195370553522824537348943056738168130381279655104012813701460583040531656819798441984e89 + x^2 * (2.458839523580169847806745262166658121095771319205614963201104798418484315507853192426684416e92 + x^2 * (9.3529337797942500670872976282295341610240949439943181970243624322242306393287719733526221815808e94 + x^2 * (3.2407915546987076482457486281815335867948488980940312552689415827656959165274194887666835859177472e97 + x^2 * (1.0212694423390353342629241556623177230831100684975209235353996095171082853990203229693084181770797056e100 + x^2 * (2.920830605089641055991963085194228688017694795902909841311242883218929696241198123692222075986447958016e102 + x^2 * (7.5614261267967173199516078834812661638940840276693433219462606709538326532864810046963300811959510499328e104 + x^2 * (1.76609709568215327536336388131844106701352822606263628856258161737911684671927907999690616263133430022930432e107 + x^2 * (3.7068099203406226729521700302575602588785552912504977456556249333797496010254804303225386926325085885296672768e109 + x^2 * (6.957218869239306179297104125539658410882688462265777956377401046837117532424698582661614808734639557096619270144e111 + x^2 * (1.160696014684757580912733538277533011548928525121340622388963074647325774992853880207379403923895699442285981569024e114 + x^2 * (1.7086128098521210860200680467879566831771727259506793573696353495911369128938922560111570343056170516790121581626368e116 + x^2 * (2.1989846862796798377078275762161002512490212982985243329347206949237932068944393334863591031513291455108886475553135616e118 + x^2 * (2.445759634406621686161706004213684835000300355107580952519617128465241111223704192022050513616089416284888373558743194624e120 + x^2 * (2.31586996733610785877500999615206616741177089030254320733850773231837087383033719912141999309566737025786659912515048172032e122 + x^2 * (1.8301467136606136578687776364328038686151442062048782241151417684610704563453954234109537471753392402327298413612702359489792e124 + x * (54087175993556992 + x * (1.17434414126556043046579898337771581569471753231479686047388263476252020948829539668869532110417601248266831487348173473392832e126 + x * (1136966526560561528832 + x * (5.8775924270341299544813239118054676575520612492355582866717825869864136484889184604269200821264009424757549159417760823433112416e127 + x * (11665560804143001426198528 + x * (2.152489031510181982110660452091685289710834137982241650594556476673195144684417333739273293490924637835938050313799216497190690064e129 + x * (77848175766314296184164843520 + x * (5.1300988584326003906970740774851832738108213621910092672503596027377817614978613120786013494867037201756523532478881326516378113192e130 + x * (379889366717642976091701415772160 + x * (5.97119646196631743149740831577054471754026998087581427502047670039595295727832462022172087306533770220445116930364653579568540596572e131 + x * (1445023173120570352457613845314142208 + x^2 * (4.459943605238880345331053665741657079808e39 + x^2 * (1.1479894839884878008882132135619025323425792e43 + x^2 * (2.513738223221041881507409371071328451288891392e46 + x^2 * (4.752920371616941077512398363057866250620340535296e49 + x^2 * (7.8501609317811207306733527563445247928370854451216384e52 + x^2 * (1.14298343166733117838604016132376280983707964080971055104e56 + x^2 * (1.47782995283620640818738384358490348966893409724858867122176e59 + x^2 * (1.7068935955258184014564283393405635305676188823221199152611328e62 + x^2 * (1.7696219351613922277099520808113292403159788762474578221469794304e65 + x^2 * (1.65329878662345004527515123069933119825254186478212492797118464917504e68 + x^2 * (1.39636582206474951167660975975346325922410778060832782588366273478918144e71 + x^2 * (1.06887696720756384679104251786304808189901850288565705871906489222421282816e74 + x^2 * (7.43017947343591257387384416931188284708970500964265774845683303553081278464e76 + x^2 * (4.69743767552169378091434821904075456627587034609618973023491991698926964047872e79 + x^2 * (2.703727690088398897949775976174382309484234074454314403979964031221098873318539264e82 + x^2 * (1.417654552169683822158332536840767790939566733038878852486827807036929509243354087424e85 + x^2 * (6.77284462299066446036143369475676812121378006709324371775581984811893073041012415266816e87 + x^2 * (2.9476597685276761412268674471528369084065190639827552006406850730291520265828409899220992e90 + x^2 * (1.1679487737005806777082039995291626075204913766226671075205247792487800498662302664026750976e93 + x^2 * (4.20882020090741253018928393270329037246084272479744318866096309450090378769794738800867998171136e95 + x^2 * (1.37733641074695075050444316697715177438781078168996328348930017267542076452415328272584052401504256e98 + x^2 * (4.0850777693561413370516966226492708923324402739900836941415984380684331415960812918772336727083188224e100 + x^2 * (1.095311476908615395996986156947835758006635548463591190491716081207098636090449296384583278494917984256e103 + x^2 * (2.64649914437885106198306275921844315736292940968427016268119123483384142865026835164371552841858286747648e105 + x^2 * (5.73981556096699814493093261428493346779396673470356793782839025648212975183765700998994502855183647574523904e107 + x^2 * (1.11204297610218680188565100907726807766356658737514932369668748001392488030764412909676160778975257655890018304e110 + x^2 * (1.9132351890408091993067036345234060629927393271230889380037852878802073214167921102319440724020258782015702992896e112 + x^2 * (2.90174003671189395228183384569383252887232131280335155597240768661831443748213470051844850980973924860571495392256e114 + x^2 * (3.8443788221672724435451531052729025371486386333890285540816795365800580540112575760251033271876383662777773558659328e116 + x^2 * (4.3979693725593596754156551524322005024980425965970486658694413898475864137888786669727182063026582910217772951106271232e118 + x^2 * (4.280079360211587950782985507373948461250525621438266666909329974814171944641482336038588398828156478498554653727800590592e120 + x^2 * (3.47380495100416178816251499422809925111765633545381481100776159847755631074550579868212998964350105538679989868772572258048e122 + x^2 * (2.287683392075767072335972045541004835768930257756097780143927210576338070431744279263692183969174050290912301701587794936224e124 + x * (378610231954898944 + x * (1.17434414126556043046579898337771581569471753231479686047388263476252020948829539668869532110417601248266831487348173473392832e126 + x * (7769271264830503780352 + x * (4.4081943202755974658609929338541007431640459369266687150038369402398102363666888453201900615948007068568161869563320617574834312e127 + x * (77770405360953342841323520 + x * (1.076244515755090991055330226045842644855417068991120825297278238336597572342208666869636646745462318917969025156899608248595345032e129 + x * (506013142481042925197071482880 + x * (1.2825247146081500976742685193712958184527053405477523168125899006844454403744653280196503373716759300439130883119720331629094528298e130 + x * (2405965989211738848580775633223680 + x^2 * (8910976234243517173488618712770543616 + x^2 * (2.6759661631433282071986321994449942478848e40 + x^2 * (6.696605323266178838514577079111098105331712e43 + x^2 * (1.4244516598252570661875319769404194557303717888e47 + x^2 * (2.6141062043893175926318190996818264378411872944128e50 + x^2 * (4.18675249694993105635912147005041322284644557073154048e53 + x^2 * (5.90541439694787775499454083350610785082491147751683784704e56 + x^2 * (7.3891497641810320409369192179245174483446704862429433561088e59 + x^2 * (8.2499857117081222737060703068127237310768245978902462570954752e62 + x^2 * (8.2582356974198303959797763771195364548079014224881365033525706752e65 + x^2 * (7.43984453980552520373818053814699039213643839151956217587033092128768e68 + x^2 * (6.05091856228058121726530895893167412330446704930275391216253851741978624e71 + x^2 * (4.453654030031516028296010491096033674579243762023571077996103717600886784e74 + x^2 * (2.972071789374365029549537667724753138835882003857063099382733214212325113856e77 + x^2 * (1.800684442283315949350500150632289250405750299336872729923385968179220028850176e80 + x^2 * (9.913668196990795959149178579306068468108858272999152814593201447810695868834643968e82 + x^2 * (4.961790932593893377554163878942687268288483565636075983703897324629253282351739305984e85 + x^2 * (2.25761487433022148678714456491892270707126002236441457258527328270631024347004138422272e88 + x^2 * (9.3342559336709744472184135826506502099539770359453914686955027312589814175123298014199808e90 + x^2 * (3.5038463211017420331246119985874878225614741298680013225615743377463401495986907992080252928e93 + x^2 * (1.192499056923766883553630447599265605530572105359275570120606210108589406514418426602459328151552e96 + x^2 * (3.67289709532520200134518177860573806503416208450656875597146712713445537206440875393557473070678016e98 + x^2 * (1.0212694423390353342629241556623177230831100684975209235353996095171082853990203229693084181770797056e101 + x^2 * (2.555726779453435923992967699544950102015482946415046111147337522816563484211048358230694316488141963264e103 + x^2 * (5.73408147948751063429663597830662684095301372098258535247591434213998976207558142856138364490692954619904e105 + x^2 * (1.147963112193399628986186522856986693558793346940713587565678051296425950367531401997989005710367295149047808e108 + x^2 * (2.03874545618734247012369351664165814238320541018777376011059371335886228056401423667739628094787972369131700224e110 + x^2 * (3.188725315068015332177839390872343438321232211871814896672975479800345535694653517053240120670043130335950498816e112 + x^2 * (4.35261005506784092842275076854074879330848196920502733395861152992747165622320205077767276471460887290857243088384e114 + x^2 * (5.1258384295563632580602041403638700495315181778520380721089060487734107386816767680334711029168511550370364744879104e116 + x^2 * (5.1309642679859196213182643445042339195810496960298901101810149548221841494203584448015045740197680061920735109623983104e118 + x^2 * (4.280079360211587950782985507373948461250525621438266666909329974814171944641482336038588398828156478498554653727800590592e120 + x^2 * (2.8948374591701348234687624951900827092647136128781790091731346653979635922879214989017749913695842128223332489064381021504e122 + x^2 * (1.525122261383844714890648030360669890512620171837398520095951473717558713621162852842461455979449366860608201134391863290816e124 + x * (1940377438768857088 + x * (5.8717207063278021523289949168885790784735876615739843023694131738126010474414769834434766055208800624133415743674086736696416e125 + x * (38846356324152518901760 + x * (1.4693981067585324886203309779513669143880153123088895716679456467466034121222296151067300205316002356189387289854440205858278104e127 + x * (379130726134647546351452160 + x * (1.79374085959181831842555037674307107475902844831853470882879706389432928723701444478272774457577053152994837526149934708099224172e128 + x * (2403562426784953894686089543680 + x^2 * (11127592700104292174686087303659520 + x^2 * (40099393054095827280698784207467446272 + x^2 * (1.1707351963752060906494015872571849834496e41 + x^2 * (2.8460572623881260063686952586222166947659776e44 + x^2 * (5.8758630967791853980235694048792302548877836288e47 + x^2 * (1.04564248175572703705272763987273057513647491776512e51 + x^2 * (1.622366592568098284339159569644535123852997658658471936e54 + x^2 * (2.21453039885545415812295281256479044405934180406881419264e57 + x^2 * (2.67856678951562411483963321649763757502494305126306696658944e60 + x^2 * (2.88749499909784279579712460738445330587688860926158618998341632e63 + x^2 * (2.78715454787919275864317452727784355349766673008974606988149260288e66 + x^2 * (2.417949475436795691214908674897771877444342477243857707157857549418496e69 + x^2 * (1.8909120507126816303954090496661481635326459529071105975507932866936832e72 + x^2 * (1.3360962090094548084888031473288101023737731286070713233988311152802660352e75 + x^2 * (8.544706394451299459954920794708665274153160761089056410725357990860434702336e77 + x^2 * (4.951882216279118860713875414238795438615813323176400007289311412492855079337984e80 + x^2 * (2.6023379017100839392766593770678429728785752966622776138307153800503076655690940416e83 + x^2 * (1.240447733148473344388540969735671817072120891409018995925974331157313320587934826496e86 + x^2 * (5.36183532653427603111946834168244142929424255311548460989002404642748682824134828752896e88 + x^2 * (2.10020758507596925062414305609639629723964483308771308045648811453327081894027420531949568e91 + x^2 * (7.4456734323412018203898004969984116229431325259695028104433454677109728178972179483170537472e93 + x^2 * (2.384998113847533767107260895198531211061144210718551140241212420217178813028836853204918656303104e96 + x^2 * (6.8866820537347537525222158348857588719390539084498164174465008633771038226207664136292026200752128e98 + x^2 * (1.7872215240933118349601172724090560153954426198706616161869493166549394994482855651962897318098894848e101 + x^2 * (4.153056016611833376488572511760543915775159787924449930614423474576915661842953582124878264293230690304e103 + x^2 * (8.60112221923126595144495396745994026142952058147387802871387151320998464311337214284207546736039431929856e105 + x^2 * (1.578449279265924489856006468928356703643340852043481182902807320532585681755355677747234882851755030829940736e108 + x^2 * (2.5484318202341780876546168958020726779790067627347172001382421416985778507050177958467453511848496546141462528e110 + x^2 * (3.587315979451517248700069314731386368111386238355791758757097414775388727656485206684895135753798521627944311168e112 + x^2 * (4.35261005506784092842275076854074879330848196920502733395861152992747165622320205077767276471460887290857243088384e114 + x^2 * (4.4851086258618178508026786228183862933400784056205333130952927926767343963464671720292872150522447606574069151769216e116 + x^2 * (3.8482232009894397159886982583781754396857872720224175826357612161166381120652688336011284305148260046440551332217987328e118 + x^2 * (2.67504960013224246923936594210871778828157851339891666681833123425885746540092646002411774926759779906159665857987536912e120 + x^2 * (1.4474187295850674117343812475950413546323568064390895045865673326989817961439607494508874956847921064111666244532190510752e122 + x^2 * (5.71920848018941768083993011385251208942232564439024445035981802644084517607936069815923045992293512572728075425396948734056e123 + x * (7761509755075428352 + x * (1.4679301765819505380822487292221447696183969153934960755923532934531502618603692458608691513802200156033353935918521684174104e125 + x * (151500789664194823716864 + x * (1.836747633448165610775413722439208642985019140386111964584932058433254265152787018883412525664500294523673411231805025732284763e126 + x * (1440696759311660676135518208 + x^2 * (8893180979104329410338531311616 + x^2 * (40059333720375451828869914293174272 + x^2 * (140347875689335395482445744726136061952 + x^2 * (3.98049966767570070820796539667442894372864e41 + x^2 * (9.39198896588081582101669435345331509272772608e44 + x^2 * (1.880276190969339327367542209561353681564090761216e48 + x^2 * (3.241491693442753814863455683605464782923072245071872e51 + x^2 * (4.867099777704294853017478708933605371558992975975415808e54 + x^2 * (6.422138156680817058556563156437892287772091231799561158656e57 + x^2 * (7.499987010643747521550973006193385210069840543536587506450432e60 + x^2 * (7.796236497564175548652236439938023925867599245006282712955224064e63 + x^2 * (7.246601824485901172472253770922393239093933498233339781691880767488e66 + x^2 * (6.04487368859198922803727168724442969361085619310964426789464387354624e69 + x^2 * (4.53818892171043591294898171919875559247835028697706543412190388806483968e72 + x^2 * (3.07302128072174605952424723885626323545967819579626404381731156514461188096e75 + x^2 * (1.87983540677928588119008257483590636031369536743959241035957875798929563451392e78 + x^2 * (1.03989526541861496074991383699014704210932079786704400153075539662349956666097664e81 + x^2 * (5.2046758034201678785533187541356859457571505933245552276614307601006153311381880832e83 + x^2 * (2.3568506929820993543382278424977764524370296936771360922593512291988953091170761703424e86 + x^2 * (9.651303587761696856015043015028394572729636595607872297802043283569476290834426917552128e88 + x^2 * (3.570352894629147726061043195363873705307396216249112236776029794706560392198466149043142656e91 + x^2 * (1.191307749174592291262368079519745859670901204155120449670935274833755650863554871730728599552e94 + x^2 * (3.577497170771300650660891342797796816591716316077826710361818630325768219543255279807377984454656e96 + x^2 * (9.64135487522865525353110216884006242071467547182974298442510120872794535166907297908088366810529792e98 + x^2 * (2.32338798132130538544815245413177282001407540583186010104303411165142134928277123475517665135285633024e101 + x^2 * (4.9836672199342000517862870141126526989301917455093399167373081694922987942115442985498539171518768283648e103 + x^2 * (9.461234441154392546589449364205934287572472639621265831585258664530983107424709357126283014096433751228416e105 + x^2 * (1.578449279265924489856006468928356703643340852043481182902807320532585681755355677747234882851755030829940736e108 + x^2 * (2.29358863821076027888915520622186541018110608646124548012441792752872006563451601626207081606636468915273162752e110 + x^2 * (2.8698527835612137989600554517851090944891089906846334070056779318203109821251881653479161086030388173023554489344e112 + x^2 * (3.046827038547488649895925537978524155315937378443519133771028070949230159356241435544370935300226211036000701618688e114 + x^2 * (2.69106517551709071048160717369103177600404704337231998785717567560604063780788030321757232903134685639444414910615296e116 + x^2 * (1.9241116004947198579943491291890877198428936360112087913178806080583190560326344168005642152574130023220275666108993664e118 + x^2 * (1.070019840052896987695746376843487115312631405359566666727332493703542986160370584009647099707039119624638663431950147648e120 + x^2 * (4.3422561887552022352031437427851240638970704193172685137597019980969453884318822483526624870543763192334998733596571532256e121 + x^2 * (1.143841696037883536167986022770502417884465128878048890071963605288169035215872139631846091984587025145456150850793897468112e123 + x * (25224906703995142144 + x * (1.4679301765819505380822487292221447696183969153934960755923532934531502618603692458608691513802200156033353935918521684174104e124 + x * (479752500603283608436736 + x^2 * (4442148341210953751417847808 + x^2 * (26679542937312988231015593934848 + x^2 * (116839723351095067834203916688424960 + x^2 * (3.97652314453116953866929610057385508864e38 + x^2 * (1.094637408610817694757190484085467959525376e42 + x^2 * (2.504530390901550885604451827587550691394060288e45 + x^2 * (4.857380160004126595699484041366830344040567799808e48 + x^2 * (8.10372923360688453715863920901366195730768061267968e51 + x^2 * (1.1762157796118712561458906879922879647934233025273921536e55 + x^2 * (1.4984989032255239803298647365021748671468212874198976036864e58 + x^2 * (1.6874970773948431923489689263935116722657141222957321889513472e61 + x^2 * (1.6891845744722380355413178953199051839379798364180279211402985472e64 + x^2 * (1.50970871343456274426505286894216525814456947879861245451914182656e67 + x^2 * (1.208974737718397845607454337448885938722171238621928853578928774709248e70 + x^2 * (8.69819543327833549981888162846428155225017138337270874873364911879094272e72 + x^2 * (5.63387234798986777579445327123648259834274335895981741366507120276512178176e75 + x^2 * (3.28971196186375029208264450596283613054896689301928671812926282648126736039936e78 + x^2 * (1.7331587756976916012498563949835784035155346631117400025512589943724992777682944e81 + x^2 * (8.2407366887485991410427546940481694141154884394305457771305987034926409409687977984e83 + x^2 * (3.5352760394731490315073417637466646786555445405157041383890268437983429636756142555136e86 + x^2 * (1.3672680082662403879354644271290225644700318510444485755219561318390091412015438133198848e89 + x^2 * (4.760470526172196968081390927151831607076528288332149649034706392942080522931288198724190208e91 + x^2 * (1.48913468646824036407796009939968232458862650519390056208866909354219456357944358966341074944e94 + x^2 * (4.173746699233184092437706566597429619357002368757464495422121735380062922800464493108607648530432e96 + x^2 * (1.044480111483104319132536068291006762244089842781555489979385964278860746430816239400429064044740608e99 + x^2 * (2.32338798132130538544815245413177282001407540583186010104303411165142134928277123475517665135285633024e101 + x^2 * (4.5683616182730167141374297629365983073526757667168949236758658220346072280272489403373660907225537593344e103 + x^2 * (7.88436203429532712215787447017161190631039386635105485965438222044248592285392446427190251174702812602368e105 + x^2 * (1.183836959449443367392004851696267527732505639032610887177105490399439261316516758310426162138816273122455552e108 + x^2 * (1.52905909214050685259277013748124360678740405764083032008294528501914671042301067750804721071090979276848775168e110 + x^2 * (1.6740807904107080493933656802079803051186469112327028207533121268951814062396930964529510633517726434263740118784e112 + x^2 * (1.523413519273744324947962768989262077657968689221759566885514035474615079678120717772185467650113105518000350809344e114 + x^2 * (1.1212771564654544627006696557045965733350196014051333282738231981691835990866167930073218037630611901643517287942304e116 + x^2 * (6.413705334982399526647830430630292399476312120037362637726268693527730186775448056001880717524710007740091888702997888e117 + x^2 * (2.67504960013224246923936594210871778828157851339891666681833123425885746540092646002411774926759779906159665857987536912e119 + x^2 * (7.237093647925337058671906237975206773161784032195447522932836663494908980719803747254437478423960532055833122266095255376e120 + x^2 * (9.5320141336490294680665501897541868157038760739837407505996967107347419601322678302653840998715585428788012570899491455676e121 + x * (68467603910843957248 + x^2 * (1267917323022963822297088 + x^2 * (11422667163113881075074465792 + x^2 * (66698857343282470577538984837120 + x^2 * (283753613852659450454495226243317760 + x^2 * (9.37323312639489962686334080849551556608e38 + x^2 * (2.502028362539011873730721106481069621772288e42 + x^2 * (5.545745865567719818124143332515290816658276352e45 + x^2 * (1.040867177143741413364175151721463645151550242816e49 + x^2 * (1.678629626961426082697146693295687119728019555483648e52 + x^2 * (2.3524315592237425122917813759845759295868466050547843072e55 + x^2 * (2.8899621705063676763504534203970515294974410543098025213952e58 + x^2 * (3.1339231437332802143623708633022359627791833699777883509096448e61 + x^2 * (3.01640102584328220632378195592840211417496399360362128775053312e64 + x^2 * (2.58807208017353613302580491818656901396211910651190706488995741696e67 + x^2 * (1.986172783394510746355103554380312613614995606307454545165382987022336e70 + x^2 * (1.366859282372309864257252827330101386782169788815711374801002004381433856e73 + x^2 * (8.45080852198480166369167990685472389751411503843972612049760680414768267264e75 + x^2 * (4.6995885169482147029752064370897659007842384185989810258989468949732390862848e78 + x^2 * (2.3521440527325814588390908217634278333425113285087900034624229209341061626855424e81 + x^2 * (1.05952328855339131813406846066333606752913422792678445705964840473476812098170257408e84 + x^2 * (4.2928351907888238239732007131209499669388755134833550251866754531837021701775315959808e86 + x^2 * (1.5625920094471318719262450595760257879657506869079412291679498649588675899446215009370112e89 + x^2 * (5.10050413518449675151577599337696243615342316607016033825147113529508627456923735577591808e91 + x^2 * (1.48913468646824036407796009939968232458862650519390056208866909354219456357944358966341074944e94 + x^2 * (3.875621935002242371549298954697613217974359342417645602891970182852915571171859886457992816492544e96 + x^2 * (8.95268666985517987827888058535148653352077008098476134268045112239023496940699633771796340609777664e98 + x^2 * (1.82551912818102565999497692824639293001105924743931865081952680201183106015074882730763879749152997376e101 + x^2 * (3.263115441623583367241021259240427362394768404797782088339904158596148020019463528812404350516109828096e103 + x^2 * (5.06851845061842457853006215939603622548525319979710669549210285599874095040609429846050875755166093815808e105 + x^2 * (6.76478262542539067081145629540724301561431793732920506958345994513965292180866719034529235507895013212831744e107 + x^2 * (7.6452954607025342629638506874062180339370202882041516004147264250957335521150533875402360535545489638424387584e109 + x^2 * (7.174631958903034497400138629462772736222772476711583517514194829550777455312970413369790271507597043255888622336e111 + x^2 * (5.4407625688348011605284384606759359916356024615062841674482644124093395702790025634720909558932610911357155386048e113 + x^2 * (3.203649018472727036287627587727418780957198861157523795068066280483381711676047980020919439323031971898147796554944e115 + x^2 * (1.374365428924799898567392235135062657030638311436577708084200434327370754309024583428974439469580715944305404722070976e117 + x^2 * (3.8214994287603463846276656315838825546879693048555952383119017632269392362870378000344539275251397129451380836855362416e118 + x^2 * (5.16935260566095504190850445569657626654413145156817680209488333106779212908557410518174105601711466575416651590435375384e119 + x^3 * (158331334043826651136 + x^2 * (2852813976801668600168448 + x^2 * (24987084419311614851725393920 + x^2 * (141735071854475249977270342778880 + x^2 * (585241828571110116562396404126842880 + x^2 * (1.874646625278979925372668161699103113216e39 + x^2 * (4.847679952419335505353272143807072392183808e42 + x^2 * (1.039827349793947465898276874846617028123426816e46 + x^2 * (1.886571758573031311722567462495152856837184815104e49 + x^2 * (2.937601847182495644720006713267452459524034222096384e52 + x^2 * (3.9697282561900654894923810719739718811778036460299485184e55 + x^2 * (4.6961885270728474740694868081452087354333417132534290972672e58 + x^2 * (4.89675491208325033494120447390974369184247401559029429829632e61 + x^2 * (4.52460153876492330948567293389260317126244599040543193162579968e64 + x^2 * (3.72035361524945819122459456989319295757054621561086640577931378688e67 + x^2 * (2.730987577167452276238267387272929843720618958672749999602401607155712e70 + x^2 * (1.794002808113656696837644335870758070151597847820621179426315130750631936e73 + x^2 * (1.05635106524810020796145998835684048718926437980496576506220085051846033408e76 + x^2 * (5.5807613638760049597830576440440970071812831220862899682549994377807214149632e78 + x^2 * (2.6461620593241541411939771744838563125103252445723887538952257860508694330212352e81 + x^2 * (1.12574349408797827551744773945479457174970511717220848562587643003069112854305898496e84 + x^2 * (4.2928351907888238239732007131209499669388755134833550251866754531837021701775315959808e86 + x^2 * (1.464930008856686129930854743352524176217891268976194902344952998398938365573082657128448e89 + x^2 * (4.46294111828643465757630399420484213163424527031139029597003724338320049024808268630392832e91 + x^2 * (1.20992193275544529581334258076224188872825903547004420669704363850303308290829791660152123392e94 + x^2 * (2.906716451251681778661974216023209913480769506813234202168977637139686678378894914843494612369408e96 + x^2 * (6.15497208552543616631673040242914699179552943067702342309281014664328654146730998218109984169222144e98 + x^2 * (1.1409494551131410374968605801539955812569120296495741567622042512573944125942180170672742484322062336e101 + x^2 * (1.835502435913265644073074458322740391347057227698752424691196089210333261260948234956977447165311778304e103 + x^2 * (2.53425922530921228926503107969801811274262659989855334774605142799937047520304714923025437877583046907904e105 + x^2 * (2.95959239862360841848001212924066881933126409758152721794276372599859815329129189577606540534704068280613888e107 + x^2 * (2.8669857977634503486114440077773317627263826080765568501555224094109000820431450203275885200829558614409145344e109 + x^2 * (2.24207248715719828043754332170711648006961639897236984922318588423461795478530325417805945984612407601746519448e111 + x^2 * (1.3601906422087002901321096151689839979089006153765710418620661031023348925697506408680227389733152727839288846512e113 + x^2 * (6.00684190963636319303930172698891021429474786467035711575262427590634070939258996253922394873068494730902711854052e114 + x^2 * (1.71795678615599987320924029391882832128829788929572213510525054290921344288628072928621804933697589493038175590258872e116 + x^2 * (2.388437142975216490392291019739926596679980815534747023944938602016837022679398625021533704703212320590711302303460151e117 + x^5 * (316662668087653302272 + x^2 * (5547138288225466722549760 + x^2 * (47197826125366383608814632960 + x^2 * (259847631733204624958328961761280 + x^2 * (1040429917459751318333149162892165120 + x^2 * (3.228558076869354315919595167370677583872e39 + x^2 * (8.07946658736555917558878690634512065363968e42 + x^2 * (1.675277396890248695058334965030660767532187648e46 + x^2 * (2.934667180002493151568438274992459999524509712384e49 + x^2 * (4.406402770773743467080010069901178689286051333144576e52 + x^2 * (5.7340519256078723737112171039624038283679385998210367488e55 + x^2 * (6.52248406537895482509650945575723435476853015729642930176e58 + x^2 * (6.52900654944433377992160596521299158912329868745372573106176e61 + x^2 * (5.78143529953295756212058208219610405216868098774027413485518848e64 + x^2 * (4.54709886308267112260783780764723583703066759685772560706360573952e67 + x^2 * (3.186152173362027655611311951818418151007388785118208332869468541681664e70 + x^2 * (1.99333645345961855204182703985639785572399760868957908825146125638959104e73 + x^2 * (1.11503723553966133062598554326555384758866795646079719645454534221393035264e76 + x^2 * (5.5807613638760049597830576440440970071812831220862899682549994377807214149632e78 + x^2 * (2.4991530560283678000165339981236420729264182865405893786788243534924877978533888e81 + x^2 * (1.00066088363375846712662021284870628599973788193085198722300127113839211426049687552e84 + x^2 * (3.577362658990686519977667260934124972449062927902795854322229544319751808481276329984e86 + x^2 * (1.139390006888533656612887022607518803725026542537040479601630109865840951001286511099904e89 + x^2 * (3.22323525209575836380510844025905265062473269522489299153391578688786702073472638455283712e91 + x^2 * (8.0661462183696353054222838717482792581883935698002947113136242566868872193886527773434748928e93 + x^2 * (1.776326720209361086960095354236406058238248031941420901325486333807586303453769114626580040892416e96 + x^2 * (3.4194289364030200923981835569050816621086274614872352350515611925796036341485055456561665787179008e98 + x^2 * (5.704747275565705187484302900769977906284560148247870783811021256286972062971090085336371242161031168e100 + x^2 * (8.15778860405895841810255314810106840598692101199445522084976039649037005004865882203101087629027457024e102 + x^2 * (9.8554525428691589026973430877145148828879923329388185745679777755531074035674055803398781396837851575296e104 + x^2 * (9.8653079954120280616000404308022293977708803252717573931425457533286605109709729859202180178234689426871296e106 + x^2 * (7.96384943823180652392067779938147711868439613354599125043200669280805578345318061202107922245265517066920704e108 + x^2 * (4.9823833047937739565278740482380366223769253310497107760515241871880398995228961203956876885469423911499226544e110 + x^2 * (2.266984403681167150220182691948306663181501025627618403103443505170558154282917734780037898288858787973214807752e112 + x^2 * (6.6742687884848479922658908077654557936608309607448412397251380843403785659917666250435821652563166081211412428228e113 + x^2 * (9.544204367533332628940223855104601784934988273865122972806947460606741349368226273812322496316532749613231977236604e114 + x^7 * (554159669153393278976 + x^2 * (9430135089983293428334592 + x^2 * (77876413106854532954544144384 + x^2 * (415756210773127399933326338818048 + x^2 * (1612666372062614543416381202482855936 + x^2 * (4.842837115304031473879392751056016375808e39 + x^2 * (1.1715226551680060804603741014200424947777536e43 + x^2 * (2.3453883556463481730816689510429250745450627072e46 + x^2 * (3.9618006930033657546173916712398209993580881117184e49 + x^2 * (5.7283236020058665072040130908715322960718667330879488e52 + x^2 * (7.167564907009840467139021379953004785459923249776295936e55 + x^2 * (7.826980878454745790115811346908681225722236188755715162112e58 + x^2 * (7.508357531860983846909846859994940327491793490571784590721024e61 + x^2 * (6.359578829486253318332640290415714457385549086514301548340707328e64 + x^2 * (4.774453806236804678738229698029597628882200976700611887416786026496e67 + x^2 * (3.186152173362027655611311951818418151007388785118208332869468541681664e70 + x^2 * (1.893669630786637624439735687863577962937797728255100133838888193570111488e73 + x^2 * (1.003533511985695197563386988938998462829801160814717476809090807992537317376e76 + x^2 * (4.74364715929460421581559899743748245610409065377334647301674952211361320271872e78 + x^2 * (1.99932244482269424001322719849891365834113462923247150294305948279399023828271104e81 + x^2 * (7.5049566272531885034496515963652971449980341144813899041725095335379408569537265664e83 + x^2 * (2.5041538612934805639843670826538874807143440495319570980255606810238262659368934309888e86 + x^2 * (7.406035044775468767983765646948872224212672526490763117410595714127966181508362322149376e88 + x^2 * (1.933941151257455018283065064155431590374839617134935794920349472132720212440835830731702272e91 + x^2 * (4.43638042010329941798225612946155359200361646339016209122249334117778797066375902753891119104e93 + x^2 * (8.88163360104680543480047677118203029119124015970710450662743166903793151726884557313290020446208e95 + x^2 * (1.53874302138135904157918260060728674794888235766925585577320253666082163536682749554527496042305536e98 + x^2 * (2.2818989102262820749937211603079911625138240592991483135244085025147888251884360341345484968644124672e100 + x^2 * (2.855226011420635446335893601835373942095422354198059327297416138771629517517030587710853806701596099584e102 + x^2 * (2.95663576286074767080920292631435446486639769988164557237039333266593222107022167410196344190513554725888e104 + x^2 * (2.4663269988530070154000101077005573494427200813179393482856364383321651277427432464800545044558672356717824e106 + x^2 * (1.592769887646361304784135559876295423736879226709198250086401338561611156690636122404215844490531034133841408e108 + x^2 * (7.4735749571906609347918110723570549335653879965745661640772862807820598492843441805935315328204135867248839816e109 + x^2 * (2.266984403681167150220182691948306663181501025627618403103443505170558154282917734780037898288858787973214807752e111 + x^2 * (3.3371343942424239961329454038827278968304154803724206198625690421701892829958833125217910826281583040605706214114e112 + x^9 * (856428579600698703872 + x^2 * (14145202634974940142501888 + x^2 * (113274782700879320661155119104 + x^2 * (585838296998497699906050750152704 + x^2 * (2199090507358110741022338003385712640 + x^2 * (6.383739833809859670113744990028385222656e39 + x^2 * (1.4910288338501895569495670381709631751716864e43 + x^2 * (2.8784311637477909396911391671890444096689405952e46 + x^2 * (4.6821280917312504372750992478288793628777404956672e49 + x^2 * (6.50945863864303012182274214871765033644530310578176e52 + x^2 * (7.819161716738007782333477869039641584138098090665050112e55 + x^2 * (8.182752736566325144211984589949984917800519651880974942208e58 + x^2 * (7.508357531860983846909846859994940327491793490571784590721024e61 + x^2 * (6.070507064509605440226611186305909254777115037127287841597947904e64 + x^2 * (4.34041255112436788976202699820872511716563725154601080674253275136e67 + x^2 * (2.751676876994478429846133049297724766779108496238452651114541013270528e70 + x^2 * (1.549366061552703510905238290070200151494561777663263745868181249284636672e73 + x^2 * (7.75457713807128107208071764180135175823028169720463504807024715266960654336e75 + x^2 * (3.44992520675971215695679927086362360443933865728970652583036328880990051106816e78 + x^2 * (1.3631743941972915272817458171583502215962281562948669338248132837231751624654848e81 + x^2 * (4.7758814900702108658315964704142800013623853455790663026552333395241441816978259968e83 + x^2 * (1.4797272816734203332634896397500244204221123929052473761060131296958973389627097546752e86 + x^2 * (4.039655478968437509809326716517566667752366832631325336769415844069799735368197630263296e88 + x^2 * (9.66970575628727509141532532077715795187419808567467897460174736066360106220417915365851136e90 + x^2 * (2.0165365545924088263555709679370698145470983924500736778284060641717218048471631943358687232e93 + x^2 * (3.63339556406460222332746777002901239185096188351654275271122204642460834797361864355436826546176e95 + x^2 * (5.5954291686594874239243003658446790834504813006154758391752819514938968558793727110737271288111104e97 + x^2 * (7.260587441629079329525476419161790062543985643224562815759481598910691716508660108609927035477676032e99 + x^2 * (7.78698003114718758091607345955101984207842460235834361990204401483171686595553796648414674554980754432e101 + x^2 * (6.719626733774426524566370287078078329241812954276467209932712119695300502432321986595371458875308061952e103 + x^2 * (4.484230907005467300727291104910104271714036511487162451428429887876663868623169539054644553556122246675968e105 + x^2 * (2.17195893769958359743291212710403921418665349096708852284509273440219703185086743964211251521436050109160192e107 + x^2 * (6.794159051991509940719828247597322666877625451431423785524805709801872590258494709630483211654921442477167256e108 + x^2 * (1.03044745621871234100917395088559393780977319346709927413792886598661734285587169762728995376766308544237036716e110 + x^11 * (1177589296950960717824 + x^2 * (18860270179966586856669184 + x^2 * (146313260988635789187325362176 + x^2 * (732297871248122124882563437690880 + x^2 * (2657234363057717145401991754091069440 + x^2 * (7.447696472778169615132702488366449426432e39 + x^2 * (1.6774074380814632515682629179423335720681472e43 + x^2 * (3.1183004273934401846654007644547981104746856448e46 + x^2 * (4.87721676222005253882822838315508266966431301632e49 + x^2 * (6.50945863864303012182274214871765033644530310578176e52 + x^2 * (7.493363311873924124736249624496323184799010670220673024e55 + x^2 * (7.500856675185798048860985874120819507983809680890893697024e58 + x^2 * (6.569812840378360866046116002495572786555319304250311516880896e61 + x^2 * (5.05875588709133786685550932192159104564759586427273986799828992e64 + x^2 * (3.43615993630679124606160470691524071775612949080725855533783842816e67 + x^2 * (2.063757657745858822384599786973293575084331372178839488335905759952896e70 + x^2 * (1.097467626933164986891210455466391773975314592511478486656628384909950976e73 + x^2 * (5.16971809204752071472047842786756783882018779813642336538016476844640436224e75 + x^2 * (2.1562032542248200980979995442897647527745866608060665786439770555061878194176e78 + x^2 * (7.951850632817533909143517266757042959311330911720057113978077488385188447715328e80 + x^2 * (2.5869358071213642189921147548077350007379587288553275806049180589089114317529890816e83 + x^2 * (7.398636408367101666317448198750122102110561964526236880530065648479486694813548773376e85 + x^2 * (1.851508761193867191995941411737218056053168131622690779352648928531991545377090580537344e88 + x^2 * (4.0290440651196979547563855503238158132809158690311162394173947336098337759184079806910464e90 + x^2 * (7.562012079721533098833391129764011804551618971687776291856522740643956768176861978759507712e92 + x^2 * (1.21113185468820074110915592334300413061698729450551425090374068214153611599120621451812275515392e95 + x^2 * (1.6320001741923504986445876067046980660063903793461804530927905691857199162981503740631704125699072e97 + x^2 * (1.815146860407269832381369104790447515635996410806140703939870399727672929127165027152481758869419008e99 + x^2 * (1.6222875064889974126908486374064624670996717921579882541462591697566076804074037430175305719895432384e101 + x^2 * (1.119937788962404420761061714513013054873635492379411201655452019949216750405386997765895243145884676992e103 + x^2 * (5.60528863375683412590911388113763033964254563935895306428553735984582983577896192381830569194515280834496e104 + x^2 * (1.8099657814163196645274267725866993451555445758059071023709106120018308598757228663684270960119670842430016e106 + x^2 * (2.83089960499646247529992843649888444453234393809642657730200237908411357927437279567936800485621726769881969e107 + x^13 * (1449340673170413191168 + x^2 * (22487245214575545867567104 + x^2 * (168822993448425910600760033280 + x^2 * (816793779469059293138243834347520 + x^2 * (2861637006369849233509837273636536320 + x^2 * (7.734146337115791523407037199457466712064e39 + x^2 * (1.6774074380814632515682629179423335720681472e43 + x^2 * (2.99836579557061556217826996582192126007181312e46 + x^2 * (4.50204624204927926661067235368161477199782739968e49 + x^2 * (5.75836725726114203084319497771176760531699890126848e52 + x^2 * (6.340538186970243490161441989958427310214547490186723328e55 + x^2 * (6.058384237650067654849257821405277294910000126873414139904e58 + x^2 * (5.05370218490643143542008923268890214350409177250023962836992e61 + x^2 * (3.69678314825905459500979527371193191797324313158392528815259648e64 + x^2 * (2.37887995590470163188880325863362818921578195517425592292619583488e67 + x^2 * (1.349380006987676922328392168405615029862832051040010434681169150738432e70 + x^2 * (6.75364693497332299625360280287010322446347441545525222557925159944585216e72 + x^2 * (2.9825296684889542584925837083851352916270314220017827107962489048729255936e75 + x^2 * (1.1610325215056723605143074469252579438017005096648050808082953375802549796864e78 + x^2 * (3.975925316408766954571758633378521479655665455860028556989038744192594223857664e80 + x^2 * (1.1939703725175527164578991176035700003405963363947665756638083348810360454244564992e83 + x^2 * (3.130192326616850704980458853317359350892930061914946372531950851279782832421116788736e85 + x^2 * (7.1211875430533353538305438912969925232814158908565029975101881866615059437580406943744e87 + x^2 * (1.3946690994645108304925949981890131661357016469723094674906366385572501532025258394699776e90 + x^2 * (2.326772947606625568871812655312003632169728914365469628263545458659679005592880608849079296e92 + x^2 * (3.2607396087759250722169582551542418901226581005917691370485326057656741584378628852410997254144e94 + x^2 * (3.766154248136193458410586784703149383091670106183493353291055159659353652995731632453470182853632e96 + x^2 * (3.4906670392447496776564790476739375300692238669348859691151353840916787098599327445240033824411904e98 + x^2 * (2.495826933059996019524382519086865333999495064858443467917321799625550277549851912334662418445451136e100 + x^2 * (1.29223591034123587010891736289963044793111787582239754037167540763371163508313884357603297286063616576e102 + x^2 * (4.3117604875052570199300876008751002612634966456607331263734902768044844890607399413986966861116560064192e103 + x^2 * (6.96140685160122947895164143302576671213670990694579654758042543077627253798354948603241190773833493939616e104 + x^15 * (1604627173867243175936 + x^2 * (24093477015616656286679040 + x^2 * (174852386071583978836501463040 + x^2 * (816793779469059293138243834347520 + x^2 * (2759435684713783189455914513863802880 + x^2 * (7.181707313036092128877963113781933375488e39 + x^2 * (1.49768521257273504604309189101994068934656e43 + x^2 * (2.57002782477481333900994568499021822291869696e46 + x^2 * (3.69810941311190796900162371909561213414107250688e49 + x^2 * (4.52443141641946873851965319677353168989192770813952e52 + x^2 * (4.755403640227682617621081492468820482660910617640042496e55 + x^2 * (4.32741731260719118203518415814662663922142866205243867136e58 + x^2 * (3.42929791118650704546363197932461216880634798848230546210816e61 + x^2 * (2.37650345245224938250629696167195623298279915601823768524095488e64 + x^2 * (1.44431997322785456221820197845613140059529618707008395320519032832e67 + x^2 * (7.71074289707243955616224096231780017064475457737148819817810943279104e69 + x^2 * (3.6180251437357087479930015015375552988197184368510279779888847854174208e72 + x^2 * (1.4912648342444771292462918541925676458135157110008913553981244524364627968e75 + x^2 * (5.390508135562050245244998860724411881936466652015166446609942638765469548544e77 + x^2 * (1.703967992746614409102182271447937776995285195368583667281016604653968953081856e80 + x^2 * (4.690597892033242814656032247728310715623771321550868690107818458461213035596079104e82 + x^2 * (1.11792583093458953749302101904191405389033216496962370447569673259992244015039885312e85 + x^2 * (2.2889531388385720780169605364883190253404551077753045349139890599983411962079416517632e87 + x^2 * (3.984768855612888087121699994825751903244861848492312764258961824449286152007216684199936e89 + x^2 * (5.81693236901656392217953163828000908042432228591367407065886364664919751398220152212269824e91 + x^2 * (6.987299161662696583322053403901946907405695929839505293675427012355016053795420468373785125888e93 + x^2 * (6.7252754431003454614474764012556238983779823324705238451625984993917029517780922008097681836672e95 + x^2 * (4.986667198921070968080684353819910757241748381335551384450193405845255299799903920748576260630272e97 + x^2 * (2.67410028542142430663326698473592714357088756949118942991141621388451815451769847750142401976298336e99 + x^2 * (9.230256502437399072206552592140217485222270541588553859797681483097940250593848882685949806147401184e100 + x^2 * (1.539914459823306078546459857455392950451248802021690402276246527430173031807407121928105959325591430864e102 + x^17 * (1604627173867243175936 + x^2 * (23290361115096101077123072 + x^2 * (163195560333478380247401365504 + x^2 * (735114401522153363824419450912768 + x^2 * (2391510926751945430861792578681962496 + x^2 * (5.98475609419674344073163592815161114624e39 + x^2 * (1.198148170058188036834473512815952551477248e43 + x^2 * (1.970354665660690226574291691825833970904334336e46 + x^2 * (2.711946902948732510601190727336782231703453171712e49 + x^2 * (3.167101991493628116963757237741472182924349395697664e52 + x^2 * (3.170269093485121745080720994979213655107273745093361664e55 + x^2 * (2.740697631317887748622283300159530204840238152633211158528e58 + x^2 * (2.057578746711904227278179187594767301283808793089383277264896e61 + x^2 * (1.346685289722941316753568278280775198690252855077001354969874432e64 + x^2 * (7.70303985721522433183041055176603413650824633104044775042768175104e66 + x^2 * (3.85537144853621977808112048115890008532237728868574409908905471639552e69 + x^2 * (1.68841173374333074906340070071752580611586860386381305639481289986146304e72 + x^2 * (6.4621476150594008934005980348344597985252347476705292067252059605580054528e74 + x^2 * (2.1562032542248200980979995442897647527745866608060665786439770555061878194176e77 + x^2 * (6.247882640070919500041334995309105182316045716351473446697060883731219494633472e79 + x^2 * (1.563532630677747604885344082576103571874590440516956230035939486153737678532026368e82 + x^2 * (3.35377749280376861247906305712574216167099649490887111342709019779976732045119655936e84 + x^2 * (6.1038750369028588747118947639688507342412136207341454264373041599955765232211777380352e86 + x^2 * (9.297793996430072203283966654593421107571344313148729783270910923715001021350172263133184e88 + x^2 * (1.163386473803312784435906327656001816084864457182734814131772729329839502796440304424539648e91 + x^2 * (1.164549860277116097220342233983657817900949321639917548945904502059169342299236744728964187648e93 + x^2 * (8.9670339241337939485966352016741651978373097766273651268834646658556039357041229344130242448896e94 + x^2 * (4.986667198921070968080684353819910757241748381335551384450193405845255299799903920748576260630272e96 + x^2 * (1.78273352361428287108884465649061809571392504632745961994094414258967876967846565166761601317532224e98 + x^2 * (3.076752167479133024068850864046739161740756847196184619932560494365980083531282960895316602049133728e99 + x^19 * (1454193376317189128192 + x^2 * (20379065975709088442482688 + x^2 * (137696254031372383333744902144 + x^2 * (597280451236749608107340803866624 + x^2 * (1868367911524957367860775452095283200 + x^2 * (4.48856707064755758054872694611370835968e39 + x^2 * (8.61168997229322651474777837336465896374272e42 + x^2 * (1.354618832641724530769825538130260854996729856e46 + x^2 * (1.779715155060105710082031414814763339555391143936e49 + x^2 * (1.97943874468351757310234827358842011432771837231104e52 + x^2 * (1.882347274256791036141678090768908107719943786149183488e55 + x^2 * (1.541642417616311858600034356339735740222633960856181276672e58 + x^2 * (1.093088709190699120741532693409720128807023421328734866046976e61 + x^2 * (6.73342644861470658376784139140387599345126427538500677484937216e63 + x^2 * (3.6107999330696364055455049461403285014882404676752098830129758208e66 + x^2 * (1.68672500873459615291049021050701878732854006380001304335146143842304e69 + x^2 * (6.8591726683322811680700653466649485873457162031967405416039274056871936e71 + x^2 * (2.4233053556472753350252242630629224244469630303764484525219522352092520448e74 + x^2 * (7.411948686397819087211873433496066337662641646520853864088671128302520629248e76 + x^2 * (1.95246332502216234376291718603409536947376428635983545209283152616600609207296e79 + x^2 * (4.39743552378116513874003023224529129589728561395393939697607980480738722087132416e81 + x^2 * (8.3844437320094215311976576428143554041774912372721777835677254944994183011279913984e83 + x^2 * (1.3352226643225003788432269796181860981152654795355943120331602849990323644546326301952e86 + x^2 * (1.743336374330638538115743747736266457669627058715386834363295798196562691503157299337472e88 + x^2 * (1.8177913653176762256811036369625028376326007143480231470808948895778742231194379756633432e90 + x^2 * (1.45568732534639512152542779247957227237618665204989693618238062757396167787404593091120523456e92 + x^2 * (8.406594303875431826809345501569529872972477915588154806453248124239628689722615251012210229584e93 + x^2 * (3.11666699932566935505042772113744422327609273833471961528137087865328456237493995046786016289392e95 + x^2 * (5.571042261294633972152639551533181549106015769773311312315450445592746155245205161461300041172882e96 + x^21 * (1197571015790626340864 + x^2 * (16183375921886629057265664 + x^2 * (105297135435755351961099042816 + x^2 * (439176802379962947137750591078400 + x^2 * (1318847937547028730254665025008435200 + x^2 * (3.03638360661452424566531528707692036096e39 + x^2 * (5.57226998207208774483679777100066168242176e42 + x^2 * (8.36676337808123974887245185315749351615627264e45 + x^2 * (1.04689126768241512357766553812633137620905361408e49 + x^2 * (1.10615694555843629085131227053470535800666614923264e52 + x^2 * (9.96536792253595254427947224524716057028205533843685376e54 + x^2 * (7.70821208808155929300017178169867870111316980428090638336e57 + x^2 * (5.14394686677976056819544796898691825320952198272345819316224e60 + x^2 * (2.9706293155653117281328712020899452912284989450227971065511936e63 + x^2 * (1.4867999724404385199305020366460176182598637219839099518288723968e66 + x^2 * (6.4492426804558088199518743342915424221385355380588734010497054998528e68 + x^2 * (2.4208844711760992357894348282346877367102527775988496029190332020072448e71 + x^2 * (7.840105562388243730963960851085925490857821568864980287571021937441697792e73 + x^2 * (2.17998490776406443741525689220472539343018871956495701884960915538309430272e76 + x^2 * (5.1682852721174885570194866689137818603717289933054467849516128633806043613696e78 + x^2 * (1.03469071147792120911530123111653912844642014445975044634731289524879699314619392e81 + x^2 * (1.7262090036489985505406942205794261126247776076736836613227670135734096502322335232e83 + x^2 * (2.356275289980883021488047611090916643732821434474578197705576973527704172566998759168e85 + x^2 * (2.5637299622509390266407996290239212612788633216402747564166114679361216051517019107904e87 + x^2 * (2.138578076844324971389533690544120985450118487468262525977523399503381438964044677250992e89 + x^2 * (1.2844299929527015778165539345407990638613411635734384731021005537417308922418052331569457952e91 + x^2 * (4.94505547286790107459373264798207639586616347975773812144308713190566393513095014765424131152e92 + x^2 * (9.166667645075498103089493297463071244929684524513881221415796701921425183455705736670176949688e93 + x^23 * (898178261842969755648 + x^2 * (11687993721362565430247424 + x^2 * (73123010719274549972985446400 + x^2 * (292784534919975298091833727385600 + x^2 * (842597293432823910996035988199833600 + x^2 * (1.85556775959776481679547045321367355392e39 + x^2 * (3.25049082287538451782146536641705264807936e42 + x^2 * (4.6482018767117998604846954739763852867534848e45 + x^2 * (5.5252594683238575966599014512223044855477829632e48 + x^2 * (5.5307847277921814542565613526735267900333307461632e51 + x^2 * (4.70586818564197759035419522692227026929985946537295872e54 + x^2 * (3.42587203914735968577785412519941275605029769079151394816e57 + x^2 * (2.1433111944915669034147699870778826055039674928014409138176e60 + x^2 * (1.1552447338309545609405610230349787243666384786199766525476864e63 + x^2 * (5.368999900479361321971257354555063621493952329386341492715372544e65 + x^2 * (2.1497475601519362733172914447638474740461785126862911336832351666176e68 + x^2 * (7.397146995260303220467717530717101417725772375996484897808157006133248e70 + x^2 * (2.17780710066340103637887801419053485857161710246249452432528387151158272e73 + x^2 * (5.4499622694101610935381422305118134835754717989123925471240228884577357568e75 + x^2 * (1.1485078382483307904487748153141737467492731096234326188781361918623565247488e78 + x^2 * (2.0118986056515134621686412827266038608680391697828480901197750740948830422287104e80 + x^2 * (2.877015006081664250901157034299043521041296012789472768871278355955682750387055872e82 + x^2 * (3.2726045694178930854000661265151620051844742145480252745910791298995891285652760544e84 + x^2 * (2.848588846945487807378666254471023623643181468489194173796234964373468450168557678656e86 + x^2 * (1.78214839737027080949127807545343415454176540622355210498126949958615119913670389770916e88 + x^2 * (7.13572218307056432120307741411555035478522868651910262834500307634294940134336240642747664e89 + x^2 * (1.3736265202410836318315924022172434432961565221549272559564130921960177597585972632372892532e91 + x^25 * (614543021260979306496 + x^2 * (7689469553528003572531200 + x^2 * (46182954138489189456622387200 + x^2 * (177211692188406101476636203417600 + x^2 * (487819485671634895839810308957798400 + x^2 * (1.02544534083034371454486525046018801664e39 + x^2 * (1.7107846436186234304323501928510803410944e42 + x^2 * (2.3241009383558999302423477369881926433767424e45 + x^2 * (2.6172281692060378089441638453158284405226340352e48 + x^2 * (2.4742984308543969663779353419855251429096479653888e51 + x^2 * (1.98141818342820109067545062186200853444204609068335104e54 + x^2 * (1.3523179101897472443859950494208208247566964568913870848e57 + x^2 * (7.896409663916299117843889426076409599225143394531624419328e59 + x^2 * (3.952153036790107708480866657751243004412184268963078021873664e62 + x^2 * (1.695473652782956206938291796175283248892827051385160471383801856e65 + x^2 * (6.222953463597710264865843655895347951186306220934000650135680745472e67 + x^2 * (1.94661763033165874222834671860976353098046641473591707837056763319296e70 + x^2 * (5.1579641857817392966868163493986351913538299795164343997177775904221696e72 + x^2 * (1.1473604777705602302185562590551186281211519576657668520261100817805759488e75 + x^2 * (2.115672333615346192931953607157688480853924149306323245301829827114867282432e77 + x^2 * (3.176682008923442308687328341147269254002167110183444352820697485412973224571648e79 + x^2 * (3.7855460606337687511857329398671625276859158063019378537779978367837930926145472e81 + x^2 * (3.444846915176729563579016975279117900194183383734763446937978031473251714279237952e83 + x^2 * (2.24888593179906932161473651668765022919198536985989013720755391924221193434359816736e85 + x^2 * (9.379728407211951628901463555018074497588238980123958447269839471506058942824757356364e86 + x^2 * (1.8778216271238327161060730037146185144171654438208164811434218621955130003535164227440728e88 + x^27 * (384089388288112066560 + x^2 * (4613681732116802143518720 + x^2 * (26555198629631283937557872640 + x^2 * (97466430703623355812149911879680 + x^2 * (256105229977608320315900412202844160 + x^2 * (5.1272267041517185727243262523009400832e38 + x^2 * (8.1262270571884612945536634160426316201984e41 + x^2 * (1.04584542226015496860905648164468668951953408e45 + x^2 * (1.11232197191256606880126963425922708722211946496e48 + x^2 * (9.8971937234175878655117413679421005716385918615552e50 + x^2 * (7.4303181878557540900329398319825320041576728400625664e53 + x^2 * (4.7331126856641153553509826729728728866484375991198547968e56 + x^2 * (2.5663331407727972132992640634748331197481716032227779362816e59 + x^2 * (1.1856459110370323125442599973253729013236552806889234065620992e62 + x^2 * (4.662552545153129569080302439482028934455274391309191296305455104e64 + x^2 * (1.555738365899427566216460913973836987796576555233500162533920186368e67 + x^2 * (4.37988966824623217001378011687196794470604943315581342633377717468416e69 + x^2 * (1.03159283715634785933736326987972703827076599590328687994355551808443392e72 + x^2 * (2.0078808360984804028824734533464575992120159259150919910456926431160079104e74 + x^2 * (3.173508500423019289397930410736532721280886223959484867952744740672300923648e76 + x^2 * (3.97085251115430288585916042643408656750270888772930544102587185676621653071456e78 + x^2 * (3.7855460606337687511857329398671625276859158063019378537779978367837930926145472e80 + x^2 * (2.583635186382547172684262731459338425145637537801072585203483523604938785709428464e82 + x^2 * (1.12444296589953466080736825834382511459599268492994506860377695962110596717179908368e84 + x^2 * (2.344932101802987907225365888754518624397059745030989611817459867876514735706189339091e85 + x^29 * (219479650450349752320 + x^2 * (2526539996159201173831680 + x^2 * (13909865948854482062530314240 + x^2 * (48733215351811677906074955939840 + x^2 * (121954871417908723959952577239449600 + x^2 * (231945969949720602099433806651709194240 + x^2 * (3.4826687387950548405229986068754135515136e41 + x^2 * (4.2331838520053891586557048066570651718647808e44 + x^2 * (4.2374170358573945478143605114637222370366455808e47 + x^2 * (3.534712044077709951968479059979321632728068521984e50 + x^2 * (2.4767727292852513633443132773275106680525576133541888e53 + x^2 * (1.4650110693722261814181613035392225601530878282990026752e56 + x^2 * (7.332380402207992037997897324213808913566204580636508389376e58 + x^2 * (3.105263100335084628092109516804548074895287639899561302900736e61 + x^2 * (1.11013155836979275454292915225762593677506533126409316578701312e64 + x^2 * (3.33372506978448764189241624422965068813552118978607177685840039936e66 + x^2 * (8.3426469871356803238357716511847008470591417774396446215881469993984e68 + x^2 * (1.7193213952605797655622721164662117304512766598388114665725925301407232e71 + x^2 * (2.868401194426400575546390647637796570302879894164417130065275204451439872e73 + x^2 * (3.7779863100274039159499171556387294300962931237612915094675532627051201472e75 + x^2 * (3.7817642963374313198658670727943681595263894168850528009770208159678252673472e77 + x^2 * (2.703961471881263393704094957047973234061368433072812752698569883416995066153248e79 + x^2 * (1.23030246970597484413536320545682782149792263704812980247784929695473275509972784e81 + x^2 * (2.677245156903653954303257757961488368085696868880821591913754665764538017075712104e82 + x^31 * (114727999099046461440 + x^2 * (1263269998079600586915840 + x^2 * (6638799657407820984389468160 + x^2 * (22151461523550762684579525427200 + x^2 * (52662330839551494437252249262489600 + x^2 * (94886987706703882677041102721153761280 + x^2 * (1.3455765581708166429293403708382279630848e41 + x^2 * (1.5393395825474142395111653842389327897690112e44 + x^2 * (1.444573989496839050391259265271723489898856448e47 + x^2 * (1.124681104933816802899061519084329610413476347904e50 + x^2 * (7.317737609251879028062743773922190610155283857637376e52 + x^2 * (3.995484734651525949322258100561516073144784986270007296e55 + x^2 * (1.833095100551998009499474331053452228391551145159127097344e58 + x^2 * (7.0574161371251923365729761745557910793074719088626393247744e60 + x^2 * (2.2707236421200306342923550841633257797671790866765542027461632e63 + x^2 * (6.0613183086990684398043931713266376147918567087019486851970916352e65 + x^2 * (1.3272392934079491424284182172339296802139543736835798261617506589952e68 + x^2 * (2.344529175355336043948552886090288723342649990689288363508080722919168e70 + x^2 * (3.2595468118481824722118075541338597389805453342777467387105400050584544e72 + x^2 * (3.434533009115821741772651959671572209178448294328446826788684784277381952e74 + x^2 * (2.578475656593703172635818458723432836040720056967081455211605101796244500464e76 + x^2 * (1.22907339630966517895640679865816965184607656048764216031753176518954321188784e78 + x^2 * (2.796141976604488282125825466947335957949824175109385914722384765806210807044836e79 + x^33 * (54869912612587438080 + x^2 * (576710216514600267939840 + x^2 * (2886434633655574341038899200 + x^2 * (9149516716249228065369803980800 + x^2 * (20606999024172323910229141015756800 + x^2 * (35066930239434043598036929266513346560 + x^2 * (4.680266289289797018884662159437314654208e40 + x^2 * (5.01958559526330730275380016599651996663808e43 + x^2 * (4.39652953325124928379948472039220192577912832e46 + x^2 * (3.17844660089991705167126081480354020334243315712e49 + x^2 * (1.908975028500490181233759245371006246127465354166272e52 + x^2 * (9.55442001764495335707496502308188626186796409760219136e54 + x^2 * (3.9849893490260826293466833283770700617207633590415806464e57 + x^2 * (1.3807988094375376310686257732826547763862445039079076939776e60 + x^2 * (3.949084594991357624856269711588392660464659281176616004775936e62 + x^2 * (9.223745252368147625789293956366622457291955861068182781821661184e64 + x^2 * (1.731181687053846707515328109435560452452983965674234555863153033472e67 + x^2 * (2.5484012775601478738571227022720529601550543377057482212044355683904e69 + x^2 * (2.834388532041897801923310916638138903461343768937171077139600004398656e71 + x^2 * (2.23991283203205765767781649543798187555116193108376966964479442452872736e73 + x^2 * (1.12107637243204485766774715596670992871335654650742671965721960947662804368e75 + x^2 * (2.671898687629706910774797388387325330100166435842700348516373402585963504104e76 + x^35 * (24005586768007004160 + x^2 * (240295923547750111641600 + x^2 * (1142547042488664843327897600 + x^2 * (3431068768593460524513676492800 + x^2 * (7298312154394364718206154109747200 + x^2 * (11688976746478014532678976422171115520 + x^2 * (1.46258321540306156840145692482416082944e40 + x^2 * (1.46404579861846462996985838174898499026944e43 + x^2 * (1.19072674858888001436236044510622135489851392e46 + x^2 * (7.9461165022497926291781520370088505083560828928e48 + x^2 * (4.37473444031362333199403160397522264737544143663104e51 + x^2 * (1.9905041703426986160572843798087263045558258536671232e54 + x^2 * (7.471855029423904930025031240707006365726431298202963712e56 + x^2 * (2.301331349062562718447709622137757960643740839846512823296e59 + x^2 * (5.75908170102906320291539332939973929651096145171589834029824e61 + x^2 * (1.152968156546018453223661744545827807161494482633522847727707648e64 + x^2 * (1.8033142573477569869951334473287088046385249642439943290241177432e66 + x^2 * (2.123667731300123228214268918560044133462545281421456851003696306992e68 + x^2 * (1.77149283252618612620206932289883681466333985558573192321225000274916e70 + x^2 * (9.332970133466906906990902064324924481463174712849040290186643435536364e71 + x^2 * (2.335575775900093453474473241597312351486159471890472332619207519742975091e73 + x^37 * (9602234707202801664 + x^2 * (91312450948145042423808 + x^2 * (411316935295919343598043136 + x^2 * (1166563381321776578334650007552 + x^2 * (2335459889406196709825969315119104 + x^2 * (3506693023943404359803692926651334656 + x^2 * (4.095233003128572391524079389507650322432e39 + x^2 * (3.806519076408008037921631792547360974700544e42 + x^2 * (2.857744196613312034469665068254931251756433408e45 + x^2 * (1.748145630494954378419193448141947111838338236416e48 + x^2 * (8.74946888062724666398806320795044529475088287326208e50 + x^2 * (3.58290750661685750890311188365570734820048653660082176e53 + x^2 * (1.19549680470782478880400499851312101851622900771247419392e56 + x^2 * (3.2218638886875878058267934709928611449012371757851179526144e58 + x^2 * (6.910898041234875843498471995279687155813153742059078008357888e60 + x^2 * (1.152968156546018453223661744545827807161494482633522847727707648e63 + x^2 * (1.44265140587820558959610675786296704371081997139519546321929419456e65 + x^2 * (1.2742006387800739369285613511360264800775271688528741106022177841952e67 + x^2 * (7.08597133010474450480827729159534725865335942234292769284900001099664e68 + x^2 * (1.8665940266933813813981804128649848962926349425698080580373286871072728e70 + x^39 * (3508508835324100608 + x^2 * (31608156097434822377472 + x^2 * (134468998077512093099360256 + x^2 * (358942578868238947179892310016 + x^2 * (673690352713325973988260379361280 + x^2 * (944109660292455019947148095636897792 + x^2 * (1.023808250782143097881019847376912580608e39 + x^2 * (8.78427479171078777981915029049390994161664e41 + x^2 * (6.04522810822046776522429149053927764794630144e44 + x^2 * (3.3618185201826045738830643233498982919968043008e47 + x^2 * (1.51433115241625423030562632445296168562996049729536e50 + x^2 * (5.5121653947951653983124798210087805356930562101551104e52 + x^2 * (1.6093226217220718310823144210753552172333852026898691072e55 + x^2 * (3.717535256177985929800146312684070551809119818213597637632e57 + x^2 * (6.6450942704181498495177615339227761113588016750568057772672e59 + x^2 * (8.8689858195847573324897057272755985166268806356424834440592896e61 + x^2 * (8.322988880066570709208308218440194482947038296510743057034389584e63 + x^2 * (4.90077168761566898818677442744625569260587372635720811770083763152e65 + x^2 * (1.3626867942509124047708225560760283189717998889121014793940384636532e67 + x^41 * (1169502945108033536 + x^2 * (9950715808451703341056 + x^2 * (39842666097040620177588224 + x^2 * (99706271907844151994414530560 + x^2 * (174660461814565993256215653908480 + x^2 * (227285658959294727024313430431105024 + x^2 * (227512944618254021751337743861536129024 + x^2 * (1.78938930942256788107427135547098165477376e41 + x^2 * (1.1194866867074940305970910167665328977678336e44 + x^2 * (5.603030866971007623138440538916497153328007168e46 + x^2 * (2.2434535591351914523046315917821654601925340700672e49 + x^2 * (7.145399585845584775590251619826196990713221013164032e51 + x^2 * (1.788136246357857590091460467861505796925983558544299008e54 + x^2 * (3.4421622742388758609260614006333986590825183501977755904e56 + x^2 * (4.922292052161592481124267802905760082488001240782819094272e58 + x^2 * (4.927214344213754073605392070708665842570489242023601913366272e60 + x^2 * (3.08258847409872989229937341423710906775816233204101594704977392e62 + x^2 * (9.075503125214201829975508198974547578899766159920755773520069688e63 + x^43 * (355027679764938752 + x^2 * (2843061659557629526016 + x^2 * (10672142704564451833282560 + x^2 * (24926567976961037998603632640 + x^2 * (40546178635524248434478633943040 + x^2 * (48704069776991727219495735092379648 + x^2 * (44690042692871325701155628258516025344 + x^2 * (3.195338052540299787632627420483895812096e40 + x^2 * (1.799175032208472549173896276946213585698304e43 + x^2 * (8.00432980995858231876920076988071021904001024e45 + x^2 * (2.804316948918989315380789489727706825240667587584e48 + x^2 * (7.65578527054884083098955530695663963290702251410432e50 + x^2 * (1.5965502199623728482959468463049158901124853201288384e53 + x^2 * (2.458687338742054186375758143309570470773227392998411136e55 + x^2 * (2.63694217080085311488800060869951432990428637899079594336e57 + x^2 * (1.75971940864776931200192573953880922948946044357985782620224e59 + x^2 * (5.504622275176303379106023953994837620996718450073242762588882e60 + x^45 * (97938670279983104 + x^2 * (735274567126973153280 + x^2 * (2576034445929350442516480 + x^2 * (5586989374146439551411159040 + x^2 * (8388864545280878986443855298560 + x^2 * (9236978750808775851973329069244416 + x^2 * (7705179774632987189854418665261383680 + x^2 * (4.95828318497632725667131841109570039808e39 + x^2 * (2.48162073408065179196399486475339804923904e42 + x^2 * (9.6603980465017372812731733429594778505655296e44 + x^2 * (2.90101753336447170556633395489073119852482853888e47 + x^2 * (6.599814888404173130163409747376413476643984925952e49 + x^2 * (1.101069117215429550548928859520631648353438151812992e52 + x^2 * (1.27173483038382113088401283274632955384822106534400576e54 + x^2 * (9.092904037244321085820691754136256310014780617209641184e55 + x^2 * (3.033998980427188468968837481963464188774931799275616941728e57 + x^47 * (24484667569995776 + x^2 * (171564065662960402432 + x^2 * (558140796618025929211904 + x^2 * (1117397874829287910282231808 + x^2 * (1537958499968161147514706804736 + x^2 * (1539496458468129308662221511540736 + x^2 * (1155776966194948078478162799789207552 + x^2 * (6.61104424663510300889509121479426719744e38 + x^2 * (2.89522418976076042395799400887896439077888e41 + x^2 * (9.6603980465017372812731733429594778505655296e43 + x^2 * (2.4175146111370597546386116290756093321040237824e46 + x^2 * (4.399876592269448753442273164917608984429323283968e48 + x^2 * (5.50534558607714775274464429760315824176719075906496e50 + x^2 * (4.2391161012794037696133761091544318461607368844800192e52 + x^2 * (1.515484006207386847636781959022709385002463436201606864e54 + x^49 * (5528795902902272 + x^2 * (35973110542233632768 + x^2 * (108027250958327599202304 + x^2 * (198248010050357532469428224 + x^2 * (248057822575509862502372065280 + x^2 * (223475292358276835128386993610752 + x^2 * (149132511767090074642343587069575168 + x^2 * (74640822139428582358492965328322371584 + x^2 * (2.8018298610588004102819296860119010233344e40 + x^2 * (7.79064358588849780747836559916086923432704e42 + x^2 * (1.559686845894877261057168792952006020712273408e45 + x^2 * (2.12897254464650746134303540237948821827225320192e47 + x^2 * (1.7759179309926283073369820314848897554087712126016e49 + x^2 * (6.83728403432161898324738082121682555832376916851616e50 + x^51 * (1123036667777024 + x^2 * (6744958226668806144 + x^2 * (18567183758462556112896 + x^2 * (30976251570368364448348160 + x^2 * (34883131299681074414396071680 + x^2 * (27934411544784604391048374201344 + x^2 * (16311368474525476914006329835734784 + x^2 * (6997577075571429596108715499530222336 + x^2 * (2.18892957895218782053275756719679767448e39 + x^2 * (4.8691522411803111296739784994755432714544e41 + x^2 * (7.3110320901322371612054787169625282220887816e43 + x^2 * (6.653039202020335816696985632435900682100791256e45 + x^2 * (2.77487176717598173021403442419514024282620501969e47 + x^53 * (204188485050368 + x^2 * (1124159704444801024 + x^2 * (2813209660373114562560 + x^2 * (4224034305050231515683840 + x^2 * (4228258339355281747199523840 + x^2 * (2962740618386245920262706354688 + x^2 * (1482851679502316083091484530521344 + x^2 * (530119475422077999705205719661380480 + x^2 * (132662398724375019426227731345260465120 + x^2 * (2.213251018718323240760899317943428759752e40 + x^2 * (2.215464269737041564001660217261372188511752e42 + x^2 * (1.00803624273035391162075539885392434577284716e44 + x^55 * (33030490228736 + x^2 * (165317603594823680 + x^2 * (372336572696441633280 + x^2 * (496945212358850766551040 + x^2 * (435261887874808415152892160 + x^2 * (261418289857609934140827031296 + x^2 * (109033211728111476697903274303040 + x^2 * (31183498554239882335600336450669440 + x^2 * (5852752884898897915862988147585020520 + x^2 * (6.5095618197597742375320568174806728228e38 + x^2 * (3.2580356907897670058847944371490767478114e40 + x^57 * (4718641461248 + x^2 * (21255120462191616 + x^2 * (42552751165307615232 + x^2 * (49694521235885076655104 + x^2 * (37308161817840721298819328 + x^2 * (18672734989829281010059073664 + x^2 * (6230469241606370097023044245888 + x^2 * (1336435652324566385811442990742976 + x^2 * (167221510997111369024656804216714872 + x^2 * (9299374028228248910760081167829532604 + x^59 * (589830182656 + x^2 * (2361680051354624 + x^2 * (4137073029960462592 + x^2 * (4141210102990423054592 + x^2 * (2590844570683383423529120 + x^2 * (1037374166101626722781059648 + x^2 * (259602885066932087375960176912 + x^2 * (37123212564571288494762305298416 + x^2 * (2322520986070991236453566725232151 + x^61 * (63765425152 + x^2 * (223402167020032 + x^2 * (335438353780578048 + x^2 * (279811493445298855040 + x^2 * (140045652469372076947520 + x^2 * (42055709436552434707340256 + x^2 * (7016294190998164523674599376 + x^2 * (501665034656368763442733855384 + x^63 * (5873131264 + x^2 * (17637013185792 + x^2 * (22068312748722240 + x^2 * (14726920707647308160 + x^2 * (5528117860633108300560 + x^2 * (1106729195698748281772112 + x^2 * (92319660407870585837823676 + x^65 * (451779328 + x^2 * (1130577768320 + x^2 * (1131708346088320 + x^2 * (566420027217204160 + x^2 * (141746611811105341040 + x^2 * (14188835842291644638104 + x^67 * (28236208 + x^2 * (56528888416 + x^2 * (42439062978312 + x^2 * (14160500680430104 + x^2 * (1771832647638816763 + x^69 * (1377376 + x^2 * (2068130064 + x^2 * (1035099097032 + x^2 * (172689032688172 + x^71 * (49192 + x^2 * (49241192 + x^2 * (12322608298 + x^73 * (1144 + x^2 * (572572 + x^75 * 13))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) } sollya-6.0+ds/tests-tool/check020.sollya000066400000000000000000003020231300174114700201230ustar00rootroot00000000000000/* This set of tests the problem mentioned in the commit message of revision 1270 */ print("=============== Check remez #1 ================"); restart; p = horner(remez(exp(x), 5, [-1;1])); p_old_32bit = 11692536319630510474283968587625525849426869787677b-163 + x * (11692461446776396870604093448366028590354143070281b-163 + x * (11673235319402898388606243422629423700138678461245b-164 + x * (31133428140297179651102037915750686232945795875449b-167 + x * (16385167097562211512230476137789746035022726429977b-168 + x * 3269345410694656957446976530521438920874314212397b-168)))); p_old_64bit = 11692536319630510474283968587625525849426869787677b-163 + x * (11692461446776396870604093448366028590354143070281b-163 + x * (11673235319402898388606243422629423700138678461245b-164 + x * (31133428140297179651102037915750686232945795875449b-167 + x * (16385167097562211512230476137789746035022726429977b-168 + x * 3269345410694656957446976530521438920874314212397b-168)))); p_svn = 5846268159844744362743250522846987862429367629517b-162 + x * (11692461446497641124271694526853099581211451868505b-163 + x * (46692941277687010312354789479617646356383574093505b-166 + x * (31133428154210205207475891032719442864509304264413b-167 + x * (32770334189338630118937388326942173859103583586297b-169 + x * 26154763134310317818688286279981231602507327130357b-171)))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #2 ================"); restart; p = horner(remez(sin(x),4,[8602502489799048500699352110124879245308378241707b-164;7945546686039470376946513431105230628758836096031b-161])); p_old_32bit = 2214847272544331422982959495339200583251295560623b-168 + x * (22570554785080561636146441606989328655486420601777b-164 + x * (14059659517842917521277573489957716260107438465453b-167 + x * (-45540662462117273602262338480450403246420473478025b-167 + x * 28992086169774180186447811867835608633187677753845b-169))); p_old_64bit = 2214847272544331422982959495339200583251295560623b-168 + x * (22570554785080561636146441606989328655486420601777b-164 + x * (14059659517842917521277573489957716260107438465453b-167 + x * (-45540662462117273602262338480450403246420473478025b-167 + x * 28992086169774180186447811867835608633187677753845b-169))); p_svn = 35437554945294880980632330593543073201088752576427b-172 + x * (45141109621726235334917783839125819818331107328775b-165 + x * (7029829603586427223675545515975596612915570331385b-166 + x * (-11385165569957834689007715202379973379744083428327b-165 + x * 14496043012911941041556939044573938262006021182555b-168))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #3 ================"); restart; prec=300!; p=horner(remez(exp(x),5,[-1,1])); p_old_32bit = 127320445892597569233192084573816508818883486078679099554120447022081703359819068009205547b-296 + x * (1018557044797143666503767416322855867839491631117818135205555253332674508098291366773725959b-299 + x * (508441106512784560521103888523310670303733435407883686814016285688113354381980961005656571b-299 + x * (1356052046777263815902350693610623816222104351491496878169889792980744642403155011929747871b-302 + x * (1427349359299711414482673569219142091501984527550101477773398194525418017639951550600094011b-304 + x * 142400076760410063419384360841976625466855068476814073302706323729266395387747260369551141b-303)))); p_old_64bit = 23385072639206744003725553236226897950127307962451b-164 + x * (365389420211574099793611713376448329829065556119b-158 + x * (46692941283719626881488690119204107293177946206343b-166 + x * (31133428132962382466270199289173155642175257945163b-167 + x * (32770334150519966250277800665629495916849322658691b-169 + x * 13077381702228291991132998535625300995139355424413b-170)))); p_svn = 1018563567135987915012032258711626357126926844785584405249158988500045361779294524522137609b-299 + x * (63659815291914294289514095925732401040544551614636617651518742466446015741886727574488441b-295 + x * (2033764425613398113005508465663637496484258379622733425468204193164419557706436715536867277b-301 + x * (1356052049838784195049149578638111221779213254032530089671765628325726082534242762143843701b-302 + x * (713674681588234494371962064568899835020713913740079267560613729649927766384468681112736739b-303 + x * 142400072661608631070456694965201033405098147932863694799040634951915614775231369251933923b-303)))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #4 ================"); restart; prec=300!; p=horner(remez(sin(x),4,[374691828310027073697551143672108152896494840720292515058859891294604926811223524123212345b-299;346077367399210202326012086853215365101795134298550595521910142083912300379007927274911891b-296])); p_old_32bit = 771761635395839434377129531728754385222063722650731773025337381349894526273800455320994827b-306 + x * (491543155523301332510096977904466770120443466902627277040602137207242486357322286394764839b-298 + x * (306192269961748776289513828518754452203023757960747199912707501846371742102754825130961253b-301 + x * (-991787802459613064655442347525062928740559494434023642211380691777391678934404916892326387b-301 + x * 1262783450062636101159847119423691169466818338834735686194803407195747225125865497190175227b-304))); p_old_64bit = 4429694543892476662758950169267086222983904426445b-169 + x * (705329837039797126620403885467797756064876572665b-159 + x * (14059659515839393799760722484884113456401859506117b-167 + x * (-22770331230580585570448475640636477599253588269445b-166 + x * 14496043084575263078863254256762631012805774503031b-168))); p_svn = 771761604782391317266041851785945726969630324975846680133806343191685414408397696546623025b-306 + x * (983086312139836775818762885502129911710245659966259444915127631295702907925608027660771709b-299 + x * (1224769054074531902982422536607908492630645593827460997931865849686410542941640013242217675b-303 + x * (-1983575597502081965714353024113746965208457974615584377507146126565280394079564572724184361b-302 + x * 1262783444340237354442532109902524854573062009580400181046879466613800524190097257252128189b-304))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #5 ================"); restart; p = horner(remez((2^x-1)/x, 9, [-1/16;1/16])); p_old_32bit = 32417143657589090276342392320386542212634719195519b-165 + x * (22469851728064591059583753980795080887258113935177b-166 + x * (10383276248605324150931761963547736824435408824845b-167 + x * (28788554626783304799277995343333212138822726194415b-171 + x * (31927528755121801828772085911906676930045165407763b-174 + x * (29507302051812361584763105995068885830047872617559b-177 + x * (46749493035990890820236833700755803008100799330757b-181 + x * (4050534911275574634871329395893993407613062655611b-181 + x * (39932254070374564388452160149914943140225571249661b-188 + x * 44286286888723497574154492217999447288717640509613b-192)))))))); p_old_64bit = 32417143657589090276342392320386542212634719195519b-165 + x * (22469851728064591059583753980795080887258113935177b-166 + x * (10383276248605324150931761963547736824435408824845b-167 + x * (28788554626783304799277995343333212138822726194415b-171 + x * (31927528755121801828772085911906676930045165407763b-174 + x * (29507302051812361584763105995068885830047872617559b-177 + x * (46749493035990890820236833700755803008100799330757b-181 + x * (4050534911275574634871329395893993407613062655611b-181 + x * (39932254070374564388452160149914943140225571249661b-188 + x * 44286286888723497574154492217999447288717640509613b-192)))))))); p_svn = 16208571828794545138171196160198665353392027726519b-164 + x * (1404365733004036941223984624239966955522849707087b-162 + x * (20766552497210648301863523826884866697474843319139b-168 + x * (28788554626783304799277546456383385755588541941189b-171 + x * (7981882188780450457193021387137975228227525851703b-172 + x * (29507302051812361607733914252846404885311057946759b-177 + x * (23374746517995445671169652317254474972656939309419b-180 + x * (16202139645101822893887622168399062673636756653911b-183 + x * (19966127035178946160378341872570680908647845093767b-187 + x * 22143143457750640206904485509370313176196151922715b-191)))))))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #6 ================"); restart; p = horner(remez(exp(x),5,[0;1])); p_old_32bit = 11691999891702459232513188345837804387460473133465b-163 + x * (23385884215836431320692282794470362044234264759653b-164 + x * (23341752494481389797661158971731272634607100367573b-165 + x * (31877473745927764039755782208650650896265284145499b-167 + x * (13020439476544364685564705598260199073785811131065b-168 + x * 10404004557414297823136671010327185596581741545881b-169)))); p_old_64bit = 11691999891702459232513188345837804387460473133465b-163 + x * (23385884215836431320692282794470362044234264759653b-164 + x * (23341752494481389797661158971731272634607100367573b-165 + x * (31877473745927764039755782208650650896265284145499b-167 + x * (13020439476544364685564705598260199073785811131065b-168 + x * 10404004557414297823136671010327185596581741545881b-169)))); p_svn = 46767999566809558881308044468442218032103592655757b-165 + x * (11692942107914186071032289323545495195098625849317b-163 + x * (1458859530921322116893682516178375390461742133049b-161 + x * (15938736871253002006918388195626326961019565596185b-166 + x * (26040878969624894003265505832639851578483944977057b-169 + x * 41616018202667367394235807063903500749064273666975b-171)))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #7 ================"); restart; f = cos(exp(x)); p = horner(remez(f, 5, [-1b-7;1b-7])); p_old_32bit = 25268886549758389380340876080809564841766313745633b-165 + x * (-19676979553010954045662456941477966428585006577331b-164 + x * (-1009731963712275556396770797362269719145679957307b-160 + x * (-25268886572680378753378093437862180139058073796075b-166 + x * (30111938956773510352709131042243854571830406972593b-169 + x * 12980576291156057011865982562724840642811102794567b-166)))); p_old_64bit = 25268886549758389380340876080809564841766313745633b-165 + x * (-19676979553010954045662456941477966428585006577331b-164 + x * (-1009731963712275556396770797362269719145679957307b-160 + x * (-25268886572680378753378093437862180139058073796075b-166 + x * (30111938956773510352709131042243854571830406972593b-169 + x * 12980576291156057011865982562724840642811102794567b-166)))); p_svn = 25268886549758389380340964094845911511083285927847b-165 + x * (-39353959106021908091317784228352609542993628947795b-165 + x * (-8077855709698204451264858061909024193753897104777b-163 + x * (-25268886572680378560233411601948682207329758068657b-166 + x * (30111938956773161130666968507397664953869736937191b-169 + x * 12980576291149064825229651770061989288082684342499b-166)))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #8 ================"); restart; p = horner(remez(1,[|0,2,4,6,8|],[0;18365771228192875685539220798973244513816620097673b-164],1/cos(x))); p_old_32bit = 46768052391966959108624215231152264196631503496533b-165 + x^2 * (-46768051993840437443783072518668792259606171959491b-166 + x^2 * (31178661612951199203931279724159830154661317721883b-169 + x^2 * (-16625815622415464147749762639614753800875397430565b-173 + x^2 * 37351022179333407291017870331792433578970727797399b-180))); p_old_64bit = 46768052391966959108624215231152264196631503496533b-165 + x^2 * (-46768051993840437443783072518668792259606171959491b-166 + x^2 * (31178661612951199203931279724159830154661317721883b-169 + x^2 * (-16625815622415464147749762639614753800875397430565b-173 + x^2 * 37351022179333407291017870331792433578970727797399b-180))); p_svn = 23384026195983475555764083291413192636174326996971b-164 + x^2 * (-5846006499229983362883814289569946057071030537265b-163 + x^2 * (31178661612930653056505238164343085429561431777217b-169 + x^2 * (-33251631243914015813578984958842684370701439463593b-174 + x^2 * 37351022158050956678139896134233747310006229285203b-180))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #9 ================"); restart; p1 = horner(remez(exp(x),5,[0;1],default,1e-5)); p1_old_32bit = 11691999891702459232513188345837804387460473133465b-163 + x * (23385884215836431320692282794470362044234264759653b-164 + x * (23341752494481389797661158971731272634607100367573b-165 + x * (31877473745927764039755782208650650896265284145499b-167 + x * (13020439476544364685564705598260199073785811131065b-168 + x * 10404004557414297823136671010327185596581741545881b-169)))); p1_old_64bit = 11691999891702459232513188345837804387460473133465b-163 + x * (23385884215836431320692282794470362044234264759653b-164 + x * (23341752494481389797661158971731272634607100367573b-165 + x * (31877473745927764039755782208650650896265284145499b-167 + x * (13020439476544364685564705598260199073785811131065b-168 + x * 10404004557414297823136671010327185596581741545881b-169)))); p1_svn = 46767999566809558881308044468442218032103592655757b-165 + x * (11692942107914186071032289323545495195098625849317b-163 + x * (1458859530921322116893682516178375390461742133049b-161 + x * (15938736871253002006918388195626326961019565596185b-166 + x * (26040878969624894003265505832639851578483944977057b-169 + x * 41616018202667367394235807063903500749064273666975b-171)))); if ((p1 != p1_svn) && (p1 != p1_old_32bit) && (p1 != p1_old_64bit)) then p1 else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; p2 = horner(remez(exp(x),5,[0;1],default,1e-10)); p2_old_32bit = 11691999891702299312469444817572169311673890781507b-163 + x * (5846471053959190028880485661894891163596000435605b-162 + x * (2917719061827678043813769415697570710862370049051b-162 + x * (31877473743673721131764284633492051013566249115055b-167 + x * (26040878964869758854248710691789107998476450084373b-169 + x * 20808009104796731383700609709219405830023419999013b-170)))); p2_old_64bit = 11691999891702299312469444817572169311673890781507b-163 + x * (5846471053959190028880485661894891163596000435605b-162 + x * (2917719061827678043813769415697570710862370049051b-162 + x * (31877473743673721131764284633492051013566249115055b-167 + x * (26040878964869758854248710691789107998476450084373b-169 + x * 20808009104796731383700609709219405830023419999013b-170)))); p2_svn = 5845999945851149656234435605422211132352886535717b-162 + x * (23385884215836760115545970932838216522984359588165b-164 + x * (5835438123655356087555656737495441519792436822103b-163 + x * (31877473743673721133327937242850399199174475687415b-167 + x * (6510219741217439713495165031525459507010189269817b-167 + x * 10404004552398365689695293864167514071470455315299b-169)))); if ((p2 != p2_svn) && (p2 != p2_old_32bit) && (p2 != p2_old_64bit)) then p2 else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; p3 = horner(remez(exp(x),5,[0;1],default,1e-15)); p3_old_32bit = 11691999891702299312469444817572169311673890781507b-163 + x * (5846471053959190028880485661894891163596000435605b-162 + x * (2917719061827678043813769415697570710862370049051b-162 + x * (31877473743673721131764284633492051013566249115055b-167 + x * (26040878964869758854248710691789107998476450084373b-169 + x * 20808009104796731383700609709219405830023419999013b-170)))); p3_old_64bit = 11691999891702299312469444817572169311673890781507b-163 + x * (5846471053959190028880485661894891163596000435605b-162 + x * (2917719061827678043813769415697570710862370049051b-162 + x * (31877473743673721131764284633492051013566249115055b-167 + x * (26040878964869758854248710691789107998476450084373b-169 + x * 20808009104796731383700609709219405830023419999013b-170)))); p3_svn = 5845999945851149656234435605422211132352886535717b-162 + x * (23385884215836760115545970932838216522984359588165b-164 + x * (5835438123655356087555656737495441519792436822103b-163 + x * (31877473743673721133327937242850399199174475687415b-167 + x * (6510219741217439713495165031525459507010189269817b-167 + x * 10404004552398365689695293864167514071470455315299b-169)))); if ((p3 != p3_svn) && (p3 != p3_old_32bit) && (p3 != p3_old_64bit)) then p3 else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #10 ================"); restart; p = horner(remez(atan(x),10,[-1,1])); p_old_32bit = 38372544245022954071593576343710401499b-180 + x * (23380900442023710590629720276282789164224450528167b-164 + x * (-33609089175829249495416553130562627902380011341963b-215 + x * (-7723855757337398739828398738169459706253746872539b-164 + x * (14798371425256328739831059603503168717188731259649b-211 + x * (33702797323732429414901179632614772732191491283097b-167 + x * (-20026589901676225916120391461096241995653144141359b-210 + x * (-7965193355045203212490647632529296700704259316517b-166 + x * (11492309484232489173482584564890302837739876433267b-209 + x * (31196332541693159565915304978636341240498090752081b-170 + x * (-18696265896642848807310482596711689481317128284659b-211)))))))))); p_old_64bit = 38372544245022954071593576343710401499b-180 + x * (23380900442023710590629720276282789164224450528167b-164 + x * (-33609089175829249495416553130562627902380011341963b-215 + x * (-7723855757337398739828398738169459706253746872539b-164 + x * (14798371425256328739831059603503168717188731259649b-211 + x * (33702797323732429414901179632614772732191491283097b-167 + x * (-20026589901676225916120391461096241995653144141359b-210 + x * (-7965193355045203212490647632529296700704259316517b-166 + x * (11492309484232489173482584564890302837739876433267b-209 + x * (31196332541693159565915304978636341240498090752081b-170 + x * (-18696265896642848807310482596711689481317128284659b-211)))))))))); p_svn = -299518546557879520665255352509681884284993b-181 + x * (46761800881643993210141123783443178910382594686091b-165 + x * (15626932760797014273458339403729579988713039201177b-197 + x * (-30895422984424026393941474369915254415267721041803b-166 + x * (-37843049683583409517658396527903377324449648118839b-195 + x * (33702797050918309664309509947748141237482896518641b-167 + x * (14340405569685532672251459301997641076318498173369b-192 + x * (-31860772758098094375292352991903847201619947720321b-168 + x * (-34116843989195391948704554536758220176631032690829b-193 + x * (974885357098662804386862783336303497880652218429b-165 + x * 13921338801137066666041733737929563262809760263031b-193))))))))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #11 ================"); restart; f=exp(x); p=horner(remez(f,3,[0;1])); p_old_32bit = 46742573553811911796274412764391966160112581418361b-165 + x * (185720745566008984665440218961959381728519963271b-157 + x * (2465278576003452056620348681425508255554707916727b-162 + x * 26187910218233432242621629490193931328425524460129b-166)); p_old_64bit = 46742573553811911796274412764391966160112581418361b-165 + x * (185720745566008984665440218961959381728519963271b-157 + x * (2465278576003452056620348681425508255554707916727b-162 + x * 26187910218233432242621629490193931328425524460129b-166)); p_svn = 5842821694226678901701403157817208990903244674607b-162 + x * (11886127716219130633708414511730040683306080916975b-163 + x * (19722228608052746177156080281278926582286515128695b-165 + x * 26187910218226727873273123845127088231281394729319b-166)); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #12 ================"); restart; p = horner(remez(sin(x),10,[-1;1])); p_old_32bit = -1678574854834777132325060817371809361210735b-195 + x * (5846006547781923868641738892908189653030528304081b-162 + x * (5186811493742158415982843490921456281458058504887b-212 + x * (-31178700608529053074795655135118567830794991320849b-167 + x * (-17684054797287521526384201972347004604281755888439b-211 + x * (24942872635780650464194733939244297067048845011387b-171 + x * (22016393755287390814121400437369894118518307246709b-210 + x * (-4749415908268213847793669454772779765296429152301b-174 + x * (-45380107924050076762231472980106618449214871580875b-211 + x * (32950198265521156768718284738219033131726498607409b-183 + x * 33095953091156378813051015035960771162990683757215b-212))))))))); p_old_64bit = -1678574854834777132325060817371809361210735b-195 + x * (5846006547781923868641738892908189653030528304081b-162 + x * (5186811493742158415982843490921456281458058504887b-212 + x * (-31178700608529053074795655135118567830794991320849b-167 + x * (-17684054797287521526384201972347004604281755888439b-211 + x * (24942872635780650464194733939244297067048845011387b-171 + x * (22016393755287390814121400437369894118518307246709b-210 + x * (-4749415908268213847793669454772779765296429152301b-174 + x * (-45380107924050076762231472980106618449214871580875b-211 + x * (32950198265521156768718284738219033131726498607409b-183 + x * 33095953091156378813051015035960771162990683757215b-212))))))))); p_svn = -501469618235094668449707646317635919279433b-200 + x * (11692013095563848406205506363824123741381520090139b-163 + x * (35620680907110926409952304136880869962315563985327b-221 + x * (-31178700608529090497338468003375391002953276015721b-167 + x * (-1128778635011195860269996678779233379792952318519b-213 + x * (24942872635784374822466512879970305036022055002917b-171 + x * (11978333137537591148120847557596099349826247948291b-215 + x * (-9498831816665181898799354229729984976210026113385b-175 + x * (-25536101833773061591914574416528636823559165769255b-216 + x * (32950198285237698762568735027923570972010884588359b-183 + x * 19058765346681769783426726535203697116534992847419b-217))))))))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #13 ================"); restart; prec=400!; d = [-1/8;1/8]; f = exp(x); p = horner(remez(1,25,d,1/f,1e-40)); p_old_32bit = 161390617380431786853494948250188242145606612051826469551955379941434960076203657512239965672175150832369427924571327933b-396 + x * (2582249878086908589655919172003011874329705792829223512815518586697713929528373906645973178921345938870139944690922674719b-400 + x * (2582249878086908589655919172003011874329705792829223485685832626402974434496485981425174368061267812180286898481509725671b-401 + x * (1721499918724605726437279448002007916219803861886149410406732804556694110264268799366882772800656159764861209972164484205b-402 + x * (430374979681151431609319862000501979054950965471732012462885573145148550524342099381399012383180900245523589700170524133b-402 + x * (1377199934979684581149823558401606332975843089496293355610634191387301345954222763890552010541004557848043938741178151699b-406 + x * (918133289986456387433215705601070888650562042107828893577378984985802017340780034420418039342184959156809188297142744975b-408 + x * (2098590377111900314133064469945304888344142586006558021664462294500550566006715853849729548334078513627267405790955317995b-412 + x * (2098590377111900314133064469945304888345787506900621321180727067543258071161052823401917796984757736187655589072408299063b-415 + x * (466353417135977847585125437765623308514931894662593265387822335180764499496513126666357989921279120928715711788963003853b-416 + x * (1492330934835129112272401400849994541401556850483751940809697007101719533588456093085148424645368218472711086153465369745b-421 + x * (542665794485501495371782327581816454357534185948580690447803027072292049780254099877219461967508882519283166690502899997b-423 + x * (723554392647335327162376436776575188728320134851889625237160943201761614313054851000351657881568088833377803218059300269b-427 + x * (1781056966516517728399695844345844215372471556174952462382582280718355455253866004121406344397890554175851263316922607569b-432 + x * (508873419004719350971341650169098890399521214954235811771143731737284929667556652712937386546656949766148389278605087449b-434 + x * (2171193254420135897477725344179594326124834570679287455570164950528675466483358002551258133738010625366840419395002970151b-440 + x * (542798313605033974370075337706401928002793026768980861612649913973919428294315062471434161634783741775104301987170180913b-442 + x * (2043476004160127903487494000509588015818708867395743746978714423885089063524101669876222772309992862092677104256708028515b-448 + x * (454105778702250630730985753828746431279635370264398739548474403059075817085065739554350706233574401054757346846349616091b-450 + x * (1529619465102318290396191335466982351668824576419822769979570691541195457819322839083484971691416193070080717307820096573b-456 + x * (19120243313792727007427770378223565295754614486585379700107158437774929323650748483979182572831002782497789306950108115b-454 + x * (1864678966975461754778135403670357609027436049075542111503616505395034722356341051966639526803224699875841442314088899867b-465 + x * (678065070284798591971107193700619246254693193913266466079001229674269542931115396375932917051666799806461803260495692375b-468 + x * (1886789853182169718590609346799899921135706970254622139162469534096421624662899054210479361093776718465635395892988821967b-474 + x * (2516112710027923243369908368888976324181415757063417914592398528680717333744550145476637666909737722020354051992072953817b-479 + x * 50307115488146658682733933302724747268538227244369668577358664240031360337093741929589647579922106753044861061577239247b-478)))))))))))))))))))))))); p_old_64bit = 40347654345107946713373737062547060536401653012956617387988844985358740019050914378059991418043787708092356981303897685b-394 + x * (2582249878086908589655919172003011874329705792829223512815518586697713929528373906645973178921345938870139926226572530419b-400 + x * (2582249878086908589655919172003011874329705792829223485685832626402974434496485981425174368061267812180282125000422255911b-401 + x * (860749959362302863218639724001003958109901930943074705203366402278347055132134399683441386400328079882648031171242699173b-401 + x * (860749959362302863218639724001003958109901930943464024925771146290297101048684198762798024766361800519426800804325423261b-403 + x * (2689843623007196447558249137503137369093443534172447960177019905053322941316841335723734395587899493844083791919392107b-397 + x * (1836266579972912774866431411202141777301124084215657787154757969971604034681560068840836078684369856252482870680526569565b-409 + x * (524647594277975078533266117486326222086035646501639505416115573625137641501678963462432387083804078551349852471424366881b-410 + x * (2098590377111900314133064469945304888345787506900621321180727067543258071161052823401917796924550191857500025280407601681b-415 + x * (932706834271955695170250875531246617029863789325186530775644670361528998993026253332715959587593584168853466498978493359b-417 + x * (746165467417564556136200700424997270700778425241875970404848503550859766794228046542575476250648530710852883838050956953b-420 + x * (2170663177942005981487129310327265817430136743794322761791212108289168199121016399510605899167723492392769350299425793467b-425 + x * (361777196323667663581188218388287594364160067425944812618580471600880807156527425474829065505737939544865331259422833885b-426 + x * (1781056966516517728399695844345844215372471556174952462382582280718355455253865956950153988746212242282738289838998624873b-432 + x * (1017746838009438701942683300338197780799042429908471623542287463474569859335115708752954312779336577592615316744664682969b-435 + x * (2171193254420135897477725344179594326124834570679287455570164950528675466485064591832988938624819005420325820282167690501b-440 + x * (542798313605033974370075337706401928002793026768980861612649913973919428258372130710028952129061378622338285405291189611b-442 + x * (2043476004160127903487494000509588015818708867395743746978714423885089022119822083619278399482467899458468117240299862735b-448 + x * (1816423114809002522923943015314985725118541481057594958193897612236306014723991503049169276327319997307976033324504731927b-452 + x * (1529619465102318290396191335466982351668824576419822769979570691541861911335333959863748886364482689496284252774938835763b-456 + x * (611847786041367264237688652103154089464147663570732150403429069992530290695438702459754703049302351095233153303462760107b-459 + x * (116542435435966359673633462729397350564214753067221381968976030733466566923737898464146533011998759208748515650262757833b-461 + x * (678065070284798591971107193700619246254693193913266466079001447615324869593187070765855363583452756240464620094460862779b-468 + x * (943394926591084859295304673399949960567853485127311069581315469253949592743326197255792712101563256946658640743668942465b-473 + x * (1258056355013961621684954184444488162090707878531708957293674068630135446803760583617837399906318732340257693807559576789b-478 + x * 804913847810346538923742932843595956296611635909914696819171177188150929320002028022779677696622256806586637731183250781b-482)))))))))))))))))))))))); p_svn = 322781234760863573706989896500376484291213224103652939103910759882869920152407315024479931344350301664738855877716953233b-397 + x * (2582249878086908589655919172003011874329705792829223512815518586697713929528373906645973178921345938870139917496983436547b-400 + x * (322781234760863573706989896500376484291213224103652935710729078300371804312060747678146796007658476522534400639048326257b-398 + x * (215187489840575715804659931000250989527475482735768676300841600569586763783033599920860346600082019970677345421220989365b-399 + x * (215187489840575715804659931000250989527475482735866006231442786572574275262171049690699506191590450147611339571114332875b-401 + x * (86074995936230286321863972400100395810990193093518334725664636961706334122138922743159500658812783583670405968683128629b-402 + x * (229533322496614096858303926400267722162640510526957223394344746246450504335195008605104509835545644409092901087604544675b-406 + x * (524647594277975078533266117486326222086035646501639505416115573625137641501678963462432387083862534640861338611109593713b-410 + x * (1049295188555950157066532234972652444172893753450310660590363533771629035580526411700958898544937412080047978435348712663b-414 + x * (932706834271955695170250875531246617029863789325186530775644670361528998993026253332715955100711707168416780337610877655b-417 + x * (1492330934835129112272401400849994541401556850483751940809697007101719533588456093085147444937191584321384263876383340095b-421 + x * (2170663177942005981487129310327265817430136743794322761791212108289168199121016399511022765792218903652988214513312856103b-425 + x * (1447108785294670654324752873553150377456640269703779250474321886403523228626109701995372192338698312632456211997150128931b-428 + x * (55658030203641179012490495135807631730389736130467264449455696272448607976683310769804731474744691911992680097598424237b-427 + x * (2035493676018877403885366600676395561598084859816943247084574926949139718670227902558813571256713100640996854633281035007b-436 + x * (2171193254420135897477725344179594326124834570679287455570164950528675466485542447945601193415112392184189585676454336315b-440 + x * (542798313605033974370075337706401928002793026768980861612649913973919428280091492437959294874814210466569463784562330835b-442 + x * (2043476004160127903487494000509588015818708867395743746978714423885089009799059654815955419940954308858052258556151366221b-448 + x * (1816423114809002522923943015314985725118541481057594958193897612236304581434438367655186328396155237501320381759356490615b-452 + x * (1529619465102318290396191335466982351668824576419822769979570691542070957164975815069679148246384821231067099343136098321b-456 + x * (2447391144165469056950754608412616357856590654282928601613716280000378390117407187338735367488534615108410922687299482825b-461 + x * (932339483487730877389067701835178804513718024537771055751808243625667767026354230066961864474108971019815002730940286519b-464 + x * (169516267571199647992776798425154811563673298478316616519750338800836477027932354552473274172640840616069899166552838595b-466 + x * (471697463295542429647652336699974980283926742563655534790671511774808513886873528374826427763415526242932575396729201841b-472 + x * (2516112710027923243369908368888976324181415757063417914589335963128256773414910370734693737723384103402834997935138370453b-479 + x * 1609827695620693077847485865687191912593223271819829393342670614997429234517774491398970587717345702913258027881874277425b-483)))))))))))))))))))))))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #14 ================"); restart; p = horner(remez(exp(x), 10, [0;1])); p_old_32bit = 23384026197294909850223840992809340481141545456185b-164 + x * (23384026197183194624978796257378849130918970768719b-164 + x * (11692013103063455329995041984738330602777159874659b-164 + x * (31178701049749408969300159772616151147056225354243b-167 + x * (31178718928032908530740508502853005869373615788143b-169 + x * (24942641274774123930888945415406111016671104869359b-171 + x * (33264627827944578300293076057231916380765491375043b-174 + x * (18950258324398416999410271318831779761843002307777b-176 + x * (39016347215689526123052797965843565732733417180009b-180 + x * (14014192292950540150415375020363290646996307648069b-182 + x * 2802308148667058909292393693969468428746054200227b-182))))))))); p_old_64bit = 23384026197294909850223840992809340481141545456185b-164 + x * (23384026197183194624978796257378849130918970768719b-164 + x * (11692013103063455329995041984738330602777159874659b-164 + x * (31178701049749408969300159772616151147056225354243b-167 + x * (31178718928032908530740508502853005869373615788143b-169 + x * (24942641274774123930888945415406111016671104869359b-171 + x * (33264627827944578300293076057231916380765491375043b-174 + x * (18950258324398416999410271318831779761843002307777b-176 + x * (39016347215689526123052797965843565732733417180009b-180 + x * (14014192292950540150415375020363290646996307648069b-182 + x * 2802308148667058909292393693969468428746054200227b-182))))))))); p_svn = 11692013098647454925479766594890768402020389016685b-163 + x * (2923003274647899314022989689912663654170960733739b-161 + x * (23384026206126916717621326407453992440024639124631b-165 + x * (3897337631218641563117791179495583256345586131443b-164 + x * (31178718928039669757532735707023766163548760260885b-169 + x * (24942641274676881997211624204256299106764248859825b-171 + x * (33264627829661543681005336437047562199181910619221b-174 + x * (1184391144687711538704423090650991631165709423125b-172 + x * (4877043417471098209911175115217626323630091258985b-177 + x * (28028384133527983626040751345914065460389879764863b-183 + x * 44836931077334323181376267238444603759641933172525b-186))))))))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #15 ================"); restart; prec=300!; d = [-1/2;1/4]; f = cos(x); p = horner(remez(1,15,d,1/f,1e-40)); p_old_32bit = 2037035976334486086268445369435520635669474321562577451975655157097896464243257676249067023b-300 + x * (-147022966028724218954630457508230947486371372871749025252274007219232544034284648139415787b-373 + x * (-2037035976334486086267813534277772106898100862459457575607571406931639199411180914730434671b-301 + x * (1644629116256985976487964471064420022272893859535101909440375675266852682766040066939757477b-368 + x * (1358023984222990723447194731402895074478493689559655697573367338981199184886376418609600393b-304 + x * (-1410502123645648389482990176064909235877375828877296670824273606862592472726771255810394497b-361 + x * (-1448558916504522421008699188242670201543249049661405841998293770230912599051296200711718225b-309 + x * (539099188072322128769712711403419973541337473075122764966536485997508305218365952629146421b-354 + x * (827747952288080278806805188627854434960592102720762386536796656170780754344747602124202003b-314 + x * (-797047321997901203825499478107502791492353540573826383432166459902911767841610788036548779b-350 + x * (-1177241534201309254225497658165796336282985949571010147067884030194722915344294071302142951b-321 + x * (2000920995024742776650603097530534335966489792343502135715895342850001531040565868127767b-338 + x * (1141573461565483381928707239907860736890956525739802194008371659491759020811660632918762481b-328 + x * (-1569482484524507248868121030716379419120450572564469525806037183646653943119665927925997873b-347 + x * (-1614534504445457486506762534809318663084383593349434912234239957430267008365062703268491847b-336 + x * (-428026523256046596374630313117538331924801089558422800532774851557691869752368542107371539b-341))))))))))))))); p_old_64bit = 23384026197294446691258953661820219905513142999997b-164 + x * (-27003854063734750849884821333808741158467473742595b-241 + x * (-23384026197294446691251700549919982557379607705321b-165 + x * (37758832721834729315051124292478278364221823357325b-233 + x * (1948668849774537223221542671047764362309720717625b-165 + x * (-32383540589224596878145415657450161861333033785079b-226 + x * (-33257281702818745252782110178958829782540667558185b-174 + x * (6188555176873990055241491435716663097447123323431b-218 + x * (38008321946068544570195875158242165410103806748873b-180 + x * (-36598618138537720042729778331398363620481658419391b-216 + x * (-3378517512224125484327326252982467949824603981687b-183 + x * (23520713260932955827973162823434838850936138699919b-212 + x * (13104620655457709642089971023765909010985616378681b-192 + x * (-36033550669396221651928873829838168286171617182909b-212 + x * (-9266973579996565980194798904182086061308550848519b-199 + x * (-39308028131999003166237923968395842357350102726509b-208))))))))))))))); p_svn = 2037035976334486086268445369435520635669474321562577451975655157097896464243257671397097913b-300 + x * (-1176183728229793751637043660065847579890970982973992202010414015204696627262467139379764029b-376 + x * (-254629497041810760783476691784721513362262607807432196950946425866454899926397153399607781b-298 + x * (1644629116256985976487964471064420022272893859535101909434031953675864992648891286038789435b-368 + x * (1358023984222990723447194731402895074478493689559655697573367338981199184883856076285964445b-304 + x * (-705251061822824194741495088032454617938687914438648335410722373975668856478821775383473093b-360 + x * (-724279458252261210504349594121335100771624524830702920999146885115456297982352023632567717b-308 + x * (539099188072322128769712711403419973541337473075122764966008962096033302633773492746513937b-354 + x * (413873976144040139403402594313927217480296051360381193268398328085389343770403986416032953b-313 + x * (-778366525388575394360839334089358194816751504466627327570123773750386092643938586073693b-340 + x * (-1177241534201309254225497658165796336282985949571010147067884030191605631226200688044978549b-321 + x * (512235774726334150822554392967816790007421386839936546743185078349352360000905812636728755b-346 + x * (1141573461565483381928707239907860736890956525739802194008371657122260546600652960078317033b-328 + x * (-784741242262253624434060515358189709560225286282234762903248657515610266886473073544093209b-346 + x * (-201816813055682185813345316851164832885547949168679364029279847737577066398917512602560307b-333 + x * (-1712106093024186385498521252470153327699204358233691202130959727264412424137740563374441917b-343))))))))))))))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #16 ================"); restart; prec=200!; d = [-1/2;1/2]; f = sin(x); verbosity=0!; p = horner(remez(f,9,d,1,1e-40)); verbosity=1!; p_old_32bit = -86947901283126667b-244 + x * (1606938044258570093798407961449753679676162673259975802224191b-200 + x * (13636820948132726187694106438306066516729639249701307318935b-373 + x * (-1071292029371495160966220394362561448878316413905740061801861b-202 + x * (-111990244421936242081011350812209431978491985227156656276615b-371 + x * (857033575383108922734866118457470597964184028156001905494615b-206 + x * (549321510198610685060667636750153381459576297857810582292629b-370 + x * (-652963883135120024306270284879808076963840233212115246631809b-211 + x * (-1596641875356444035698494903347006028859398613195275802297331b-370 + x * 1153615303801817099389035339506468998354123628680403050940707b-218)))))))); p_old_64bit = 1101702397987b-245 + x * (1606938044258570093798407961449753679676162673259975802192261b-200 + x * (-1391143701206469558761975841650146109945844716683463572892595b-394 + x * (-1071292029371495160966220394362561448878316413905740060751103b-202 + x * (1099410985292744598667779066844465641116416435838202025648363b-390 + x * (857033575383108922734866118457470597964184028156004135919475b-206 + x * (-1161799305280053672790319311141790392778132728191469440939649b-388 + x * (-1305927766270240048612540569759616153927680466426312867749207b-212 + x * (95785462876615352149535634672062757573412322268306607987879b-384 + x * 576807651900908549694517669753234499177061814565628571151813b-217)))))))); p_svn = 5119600653300209b-246 + x * (803469022129285046899203980724876839838081336629987901096367b-199 + x * (-201900659293567833992865902103684434843931295566368931355751b-383 + x * (-1071292029371495160966220394362561448878316413905740060766587b-202 + x * (825124598372502403051371387459200482219416407231744562965875b-380 + x * (428516787691554461367433059228735298982092014078002051962743b-205 + x * (-1009147081261682703749474816682212409401787097671013031504583b-377 + x * (-326481941567560012153135142439904038481920116606570763522007b-210 + x * (366558600702259702423292890113706752781180393271089391738525b-374 + x * 576807651900908549694517669753234499177061814562399320345937b-217)))))))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #17 ================"); restart; prec=200!; d = [1;2]; f = exp(cos(x)^2 + 1); p = horner(remez(1,15,d,1/f,1e-40)); p_old_32bit = 1429129772344635854127522980319603763315581962207637816481495b-197 + x * (1258278747211590164438565899307058663065266450700796107832479b-198 + x * (-1202878917246296858587934180920738608442450055679313080135115b-195 + x * (336837707566227764251712761526301661125280453907774843967313b-192 + x * (-1411317735908160715166251154609539762583930751245877998128451b-193 + x * (1180739419570963338745592334849712845368799300827296718761131b-192 + x * (-1400829552020409071501690715419925186599874201865469197848967b-192 + x * (73774156815960633806864131107864831639587911807241292641453b-188 + x * (-720401733120572588026235911018525487050411202136172115523201b-192 + x * (80348824392035439630284753878261997158325598597726556408827b-190 + x * (-416085524045616662367389437501662300792235411427007456053439b-194 + x * (1516396334943608786362280214735888311251638266120825634313019b-198 + x * (-906020503784862624475910695302721150708070846898444362431877b-200 + x * (1187929837442894851249315789697675967541152927109058015663159b-204 + x * (-1304662018163848750887736589024039856901512670169419818894241b-210 + x * (-729069044992515022585488029954641599182740016769331847317347b-212))))))))))))))); p_old_64bit = 714564886172317927063761490159801881657790981010465303668201b-196 + x * (1258278747211590164438565899307058663065266454696322711478861b-198 + x * (-18794983081973388415436471576886540756913282158790900538475b-189 + x * (1347350830264911057006851046105206644501121819436710187690425b-194 + x * (-1411317735908160715166251154609539762583930755266304814879647b-193 + x * (590369709785481669372796167424856422684399651964417662529631b-191 + x * (-700414776010204535750845357709962593299937102737693735725465b-191 + x * (1180386509055370140909826097725837306233406592143442790143967b-192 + x * (-720401733120572588026235911018525487050411204371202279457173b-192 + x * (1285581190272567034084556062052191954533209582358572230577769b-194 + x * (-832171048091233324734778875003324601584470826805302456706021b-195 + x * (379099083735902196590570053683972077812909568986721325878589b-196 + x * (-906020503784862624475910695302721150708070855821307509854977b-200 + x * (1187929837442894851249315789697675967541152949455838970639555b-204 + x * (-163082752270481093860967073628004982112689101024071081715501b-207 + x * (-1458138089985030045170976059909283198365479984009101751117121b-213))))))))))))))); p_svn = 714564886172317927063761490159801881657790980941038093582955b-196 + x * (157284843401448770554820737413382332883158307209856051503421b-195 + x * (-601439458623148429293967090460369304221225030011602564440427b-194 + x * (1347350830264911057006851046105206644501121822298593252104795b-194 + x * (-1411317735908160715166251154609539762583930758300920035042625b-193 + x * (295184854892740834686398083712428211342199826569628293662483b-190 + x * (-350207388005102267875422678854981296649968552055066361959517b-190 + x * (1180386509055370140909826097725837306233406594606596965076293b-192 + x * (-180100433280143147006558977754631371762602801520776769328315b-190 + x * (1285581190272567034084556062052191954533209586044565215103713b-194 + x * (-832171048091233324734778875003324601584470829853727191930371b-195 + x * (758198167471804393181140107367944155625819141777467611978757b-197 + x * (-906020503784862624475910695302721150708070862754694236638027b-200 + x * (148491229680361856406164473712209495942644120860204666721477b-201 + x * (-1304662018163848750887736589024039856901512916200236511645811b-210 + x * (-1458138089985030045170976059909283198365479945115367833194563b-213))))))))))))))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #18 ================"); restart; prec=200!; d=[1/4;1/2]; f=tan(x); p = horner(remez(1,10,d,1/f,1e-40)); p_old_32bit = 1094653698906394439537746354636570119587248281854588161151645b-219 + x * (803437057336964936961730558645726525457791801950137635572287b-199 + x * (902021694368808954079103247381093078629104460444437390593653b-210 + x * (1056889635883223009274070235439924443715342210868409313160023b-201 + x * (1239694968725463472760134669503154963255295977288145886845797b-205 + x * (282532854374805521596477948893958861358073979772606588154531b-202 + x * (745643752889790461146602566612321479694038184243781141844107b-201 + x * (-1171551728340426070339628381549725358789127811584844764092781b-201 + x * (813974777057437275620501698223620379521525143974703084506525b-200 + x * (-573353867651326030295462629700963357884059020692651314615537b-200 + x * 909290520151942024628769491295084023281483044413698733753071b-202))))))))); p_old_64bit = 1094653698906394439537746354636570119587248281853335503513195b-219 + x * (100429632167120617120216319830715815682223975243767208610777b-196 + x * (112752711796101119259887905922636634828638057555448406782225b-207 + x * (528444817941611504637035117719962221857671105434210743859435b-200 + x * (1239694968725463472760134669503154963255295977287215108448943b-205 + x * (282532854374805521596477948893958861358073979772985177962475b-202 + x * (372821876444895230573301283306160739847019092121678155896023b-200 + x * (-146443966042553258792453547693715669848640976448024424165389b-198 + x * (813974777057437275620501698223620379521525143974379564626113b-200 + x * (-1146707735302652060590925259401926715768118041384923094249915b-201 + x * 113661315018992753078596186411885502910185380551687459548631b-199))))))))); p_svn = 547326849453197219768873177318285059793624140926213615540933b-218 + x * (803437057336964936961730558645726525457791801950137694214707b-199 + x * (902021694368808954079103247381093078629104460442909284056059b-210 + x * (1056889635883223009274070235439924443715342210868431674482813b-201 + x * (1239694968725463472760134669503154963255295977286397777664587b-205 + x * (141266427187402760798238974446979430679036989886667072346625b-201 + x * (372821876444895230573301283306160739847019092121472590934753b-200 + x * (-1171551728340426070339628381549725358789127811583535484887981b-201 + x * (406987388528718637810250849111810189760762571987017133695939b-199 + x * (-573353867651326030295462629700963357884059020692248788608963b-200 + x * 909290520151942024628769491295084023281483044413265206466819b-202))))))))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #19 ================"); restart; d=[1;2]; f=x^2.5; p=horner(remez(1,7,d,1/f,1e-40)); p_old_32bit = 30384532462332540461916109637629717389849715629829b-171 + x * (-3988089244372918017948764449242449608854351178857b-165 + x * (12811690968338316880563803186322867131597579395639b-164 + x * (7556488996758112745826292894088723697015390350955b-163 + x * (-28279885329592063848877875417848304249497177042921b-167 + x * (28332008519536597633619239409928869027803601428177b-169 + x * (-581679350863052459602370172446562830505796444253b-166 + x * 22636516313646583057384577954643601031050496316849b-175)))))); p_old_64bit = 30384532462332540461916109637629717389849715629829b-171 + x * (-3988089244372918017948764449242449608854351178857b-165 + x * (12811690968338316880563803186322867131597579395639b-164 + x * (7556488996758112745826292894088723697015390350955b-163 + x * (-28279885329592063848877875417848304249497177042921b-167 + x * (28332008519536597633619239409928869027803601428177b-169 + x * (-581679350863052459602370172446562830505796444253b-166 + x * 22636516313646583057384577954643601031050496316849b-175)))))); p_svn = 30384532462332540461916109637629717389849717946267b-171 + x * (-7976178488745836035897528898484899217708702741833b-166 + x * (12811690968338316880563803186322867131597579611375b-164 + x * (30225955987032450983305171576354894788061560871829b-165 + x * (-28279885329592063848877875417848304249497175487639b-167 + x * (14166004259768298816809619704964434513901799366283b-168 + x * (-4653434806904419676818961379572502644046370912779b-169 + x * 45273032627293166114769155909287202062100984362831b-176)))))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #20 ================"); restart; prec=300; /* should be enough for anybody */ M=32768; isize=1/M; d=4; f=exp(x)/2; I = [1;32769b-15] ; p = horner(remez(f, d, I)); p_old_32bit = 519116931250074582514616920029812964033041191732166366208315683368591845444321107391435481b-299 + x * (461432969284079015555143407908324792312068012734235836652935285714259885748478589922847529b-299 + x * (346082648236258546966032322765771598479520265273144739387947665823565730921236322003050251b-299 + x * (-1845774007687049558287217203353987444440450373590070022669568374961280228727054054051744831b-318 + x * 1845774123550678624355073867555708750724188033665817979913979575189149376462087383277483735b-304))); p_old_64bit = 519116931250074582514616920029812964033041191732166366208315683368591845444321107391435481b-299 + x * (461432969284079015555143407908324792312068012734235836652935285714259885748478589922847529b-299 + x * (346082648236258546966032322765771598479520265273144739387947665823565730921236322003050251b-299 + x * (-1845774007687049558287217203353987444440450373590070022669568374961280228727054054051744831b-318 + x * 1845774123550678624355073867555708750724188033665817979913979575189149376462087383277483735b-304))); p_svn = 1038233862500138128475875956868800306632428862675682390630488920717334717811797516870946673b-300 + x * (1845731877136404353345197824363965360441000443429813536018330496370929583427539223063362555b-301 + x * (1384330592944901753130528148077906569022099276087325621882837928258673245249321784698887013b-301 + x * (-1845773996114896639580051046710666959523710035868209257249170813067311098077820745452470793b-318 + x * 461443530887625512479768353802665452066045555725266067356194961948251810773107744094813571b-302))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #21 ================"); I = [32769b-15;16385b-14] ; p = horner(remez(f, d, I)); p_old_32bit = 1038237383518400955977367009839350382183594881758703803206614495107092340077049399411473967b-300 + x * (115356481865619084755480970440415065182680519289900564187797650531309907130834307553810629b-297 + x * (346093210646321553188501224312760439606720851854109105733752355133531620668552095227966953b-299 + x * (-1384372810757865863246870774013473664314069086622551199217497615222312154655846982330854047b-316 + x * 922915226483104741726827502416104539849150495728611277321715440071753905846249319975793783b-303))) ; p_old_64bit = 1038237383518400955977367009839350382183594881758703803206614495107092340077049399411473967b-300 + x * (115356481865619084755480970440415065182680519289900564187797650531309907130834307553810629b-297 + x * (346093210646321553188501224312760439606720851854109105733752355133531620668552095227966953b-299 + x * (-1384372810757865863246870774013473664314069086622551199217497615222312154655846982330854047b-316 + x * 922915226483104741726827502416104539849150495728611277321715440071753905846249319975793783b-303))) ; p_svn = 519118691759194958869938336993917153759287839591458508418456567188501184298624872726100021b-299 + x * (922851854924996828995230076840742652224275493891088804975529618856025119380957142467717349b-300 + x * (1384372842585153765895329298580219550625999434847837181868479524834573737784352062675124987b-301 + x * (-21630825122885172715474116247404241411834884929307264625155299577493640947606454518049021b-310 + x * 461457613241508225907237045562485154919767748953769588607075164270235967889768812953893733b-302))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #22 ================"); I = [16385b-14;32771b-15] ; p = horner(remez(f, d, I)); p_old_32bit = 1038240905073938809564185146674779242326355205294558935393649861808689793476646895917998267b-300 + x * (1845675539125013381333631624704875717580705390911799805070033763505954280685015813184580603b-301 + x * (346103774023416837754962784984162191045292920130593796757336225574631447590348180153720899b-299 + x * (-576839612789582407852511079083681823850070896509088950771773952643899923582045367370743271b-314 + x * 1845886784100803912445798173029574729693497483658677219270101727506998653158623117662166741b-304))) ; p_old_64bit = 1038240905073938809564185146674779242326355205294558935393649861808689793476646895917998267b-300 + x * (1845675539125013381333631624704875717580705390911799805070033763505954280685015813184580603b-301 + x * (346103774023416837754962784984162191045292920130593796757336225574631447590348180153720899b-299 + x * (-576839612789582407852511079083681823850070896509088950771773952643899923582045367370743271b-314 + x * 1845886784100803912445798173029574729693497483658677219270101727506998653158623117662166741b-304))) ; p_svn = 519120452536963884821173244848899789501807316772478296222446759249397538745336823375809823b-299 + x * (1845675539125101694015605706461280777337860878884343298135109298542343529268042667699390915b-301 + x * (1384415096093534892035237675001300304985047505891202043397431733335781664070540161603927133b-301 + x * (-72104951508279319815327385157588544245642023780291058217791044568868088235988999943887227b-311 + x * 922943392050313663616110263716550440504329578501301689158501826794379977010195644488727179b-303))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #23 ================"); I = [32771b-15;8193b-13] ; p = horner(remez(f, d, I)); p_old_32bit = 259561106791707898293039710633779037559822312544256220625440469079039924536763394805587147b-298 + x * (922823682480649549181635253331914708804520679107862064077300309229451099522323876193792447b-300 + x * (692228676735226522485987916737252642808432088179842657020342965630357539103964428753876415b-300 + x * (-1615200212850920429100564708444107526276999411623835378169119182171976132997095979778353947b-315 + x * 1845943116954514373788808938428499536418675482610443460189101910631877163996812552600989749b-304))) ; p_old_64bit = 259561106791707898293039710633779037559822312544256220625440469079039924536763394805587147b-298 + x * (922823682480649549181635253331914708804520679107862064077300309229451099522323876193792447b-300 + x * (692228676735226522485987916737252642808432088179842657020342965630357539103964428753876415b-300 + x * (-1615200212850920429100564708444107526276999411623835378169119182171976132997095979778353947b-315 + x * 1845943116954514373788808938428499536418675482610443460189101910631877163996812552600989749b-304))) ; p_svn = 1038244427166820551565755973067147360355241963809994452142709091116644179810577841611351723b-300 + x * (1845647364961387421825523150084311418659650045680119146295042340946491798656971546590638849b-301 + x * (1384457353470320573860561042760847856837132747863114232386055905953473938377168004599301501b-301 + x * (-1615200211404136432467443495420435952306923966226610031809054827327191469221677447918295401b-315 + x * 922971558477168891593098006011029689206256949520522791428989183983865797157679647198709371b-303))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #24 ================"); I = [8193b-13;32773b-15] ; p = horner(remez(f, d, I)); p_old_32bit = 519123974898574090744797403189736402875820343090487170676158955496764340486780611707469221b-299 + x * (922809593679210720180621035369069149157607579947128535502043286129863499054654321549929891b-300 + x * (692249807357959376265836253883008438741613503989811188430199387556659219846343306612461139b-300 + x * (-129796835530224738633653365732089398163841549341692837949460264183292272644176377903552073b-311 + x * 922999725763696665770522218372845778462978965972769992666437562934620922571048924718626613b-303))) ; p_old_64bit = 519123974898574090744797403189736402875820343090487170676158955496764340486780611707469221b-299 + x * (922809593679210720180621035369069149157607579947128535502043286129863499054654321549929891b-300 + x * (692249807357959376265836253883008438741613503989811188430199387556659219846343306612461139b-300 + x * (-129796835530224738633653365732089398163841549341692837949460264183292272644176377903552073b-311 + x * 922999725763696665770522218372845778462978965972769992666437562934620922571048924718626613b-303))) ; p_svn = 1038247949797137138198411810152236042027150025677663036108739190315224689959792247512160749b-300 + x * (1845619187358509774604842467695937623435744055179726882540505213863424591596696213891671669b-301 + x * (346124903678946567323148220705739125716697802928868252801660951027451205747159679274351253b-299 + x * (-129796835439795219968125879277623388697425667763867935773182028537886821315832571839139797b-311 + x * 461499862881804183887307941678648489033912962903390891925428506090593169530838666607860305b-302))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #25 ================"); I = [32773b-15;16387b-14] ; p = horner(remez(f, d, I)); p_old_32bit = 519125736482478728255637096057110002668939858540359785187786624133365569476475713671526253b-299 + x * (1845591006316039313290133964477145081689851856783638624326715045513173982902030827577833881b-301 + x * (173067734978792493403998750245008224483827818145325564230859424100484935217540396100814837b-298 + x * (-1269163346883319747703475308401267430788360043492450542435418710232211881459685542953257601b-314 + x * 923027893909746625680981117047890403034071303800802551819413990779907053305630158715234517b-303))) ; p_old_64bit = 519125736482478728255637096057110002668939858540359785187786624133365569476475713671526253b-299 + x * (1845591006316039313290133964477145081689851856783638624326715045513173982902030827577833881b-301 + x * (173067734978792493403998750245008224483827818145325564230859424100484935217540396100814837b-298 + x * (-1269163346883319747703475308401267430788360043492450542435418710232211881459685542953257601b-314 + x * 923027893909746625680981117047890403034071303800802551819413990779907053305630158715234517b-303))) ; p_svn = 129781434120618301441886891494335257230404040267358123905067326858051091215008648316707077b-297 + x * (1845591006316127658316151392181817495790692827365561158476937662377994536076814765442483925b-301 + x * (1384541879830207451864381985396784724052974165647827955280948849702069351845888573147632721b-301 + x * (-1269163346159839445350523220045430584331992463269364606309266712655742118702639730565130127b-314 + x * 230756973477414581247598169075781406036468241818904491493725969017677964460473556657443327b-301))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #26 ================"); I = [16387b-14;32775b-15] ; p = horner(remez(f, d, I)); p_old_32bit = 129781874583791038442386371655888238747214651568295499870462632615589784132048754166817559b-297 + x * (1845562821833811595888707917735803085968761361790239982389832893025681836759066641151458825b-301 + x * (1384584148813992118218502092824141150820996752581358234459863858555017483845838529217963523b-301 + x * (-1499966094994776220877820593486293830101759281321418876570529901431945302547470745474971957b-314 + x * 923056062915433300256084594722183984064011594047292071874020456477159231091344608769404751b-303))) ; p_old_64bit = 129781874583791038442386371655888238747214651568295499870462632615589784132048754166817559b-297 + x * (1845562821833811595888707917735803085968761361790239982389832893025681836759066641151458825b-301 + x * (1384584148813992118218502092824141150820996752581358234459863858555017483845838529217963523b-301 + x * (-1499966094994776220877820593486293830101759281321418876570529901431945302547470745474971957b-314 + x * 923056062915433300256084594722183984064011594047292071874020456477159231091344608769404751b-303))) ; p_svn = 519127498335158630438849944537739003235788144925780928440246986880208839775007090726675597b-299 + x * (1845562821833899951698211738738811196398297128357832936381554474912053986902403755733150637b-301 + x * (1384584148813859610721502078307685229594954837084035891935610394605149725267561036620748249b-301 + x * (-749983047135625881737490579257942200594490085861072813969764878125190845156216961172183267b-313 + x * 1846112125830689993741463623643395385818060771384246846684899278004784835999453500264629919b-304))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #27 ================"); I = [32775b-15;4097b-12] ; p = horner(remez(f, d, I)); p_old_32bit = 1038258520913329631182690364241114017060837400037458356533335658790054537690003841798971393b-300 + x * (1845534633911397139670115973835376772897004392321237091077394093224806285780259610993209833b-301 + x * (692313210833575385125038578893698920052248173732735304293505140886091558303904658423931033b-300 + x * (-1730782929220944054148482567938745159575983219937856205356812931349500903196307292525312495b-314 + x * 923084232780782923926735159276129795162580209945750248756228435482593334497531568751473455b-303))) ; p_old_64bit = 1038258520913329631182690364241114017060837400037458356533335658790054537690003841798971393b-300 + x * (1845534633911397139670115973835376772897004392321237091077394093224806285780259610993209833b-301 + x * (692313210833575385125038578893698920052248173732735304293505140886091558303904658423931033b-300 + x * (-1730782929220944054148482567938745159575983219937856205356812931349500903196307292525312495b-314 + x * 923084232780782923926735159276129795162580209945750248756228435482593334497531568751473455b-303))) ; p_svn = 1038258520913318582835871273068850476933856497077008462622245762799976468802191980219453751b-300 + x * (230691829238935688283021954504460225955832164377297712195680683883387600919481882172279827b-298 + x * (1384626421667018250622821490040263781999764206537059040333196049055481337520408035865245597b-301 + x * (-1730782928497375439674518395023876303183168123788598217714567069661455459900593836351181579b-314 + x * 461542116390347308923267897641860796326923886221496814784474481383857636583464998032289687b-302))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #28 ================"); I = [4097b-12;32777b-15] ; p = horner(remez(f, d, I)); p_old_32bit = 1038262045694030331360107288571033481310845936055396192569911648051621914710101903264082523b-300 + x * (1845506442548454768920116619308727687991614007806277523964786136086245050686512829575540843b-301 + x * (173083587298761427962455984082138996639756712278337144683760477571124473370811720671440019b-298 + x * (-1961613850206626209203908481303935475641262125973990140990420781913512806725438551266796249b-314 + x * 28847262609556929122639338428295863535850904646269632285682528473324343941472711236120323b-298))) ; p_old_64bit = 1038262045694030331360107288571033481310845936055396192569911648051621914710101903264082523b-300 + x * (1845506442548454768920116619308727687991614007806277523964786136086245050686512829575540843b-301 + x * (173083587298761427962455984082138996639756712278337144683760477571124473370811720671440019b-298 + x * (-1961613850206626209203908481303935475641262125973990140990420781913512806725438551266796249b-314 + x * 28847262609556929122639338428295863535850904646269632285682528473324343941472711236120323b-298))) ; p_svn = 1038262045694019281327644184498830223124624538903533316526000381856241934726227296243277141b-300 + x * (461376610637135786574950413989595397954553370890732717751691452128820892831594675084109125b-299 + x * (692334349194979445970636423727417256143496794350725629890609626014440059141562269050675299b-300 + x * (-980806924741506717818749967271003360851474142455928734971270525619689801236608458317349921b-313 + x * 461556201752866711574665321587582831953372202433881041376295584330220815148852534671601019b-302))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #29 ================"); I = [32777b-15;16389b-14] ; p = horner(remez(f, d, I)); p_old_32bit = 519132785506249659649202446742857299970401223489329249721092671862612630646516898175534471b-299 + x * (922739123872321640347645406112487210240542424232485865309181772337452142304813401978565157b-300 + x * (1384710978983089614554980944010000553236544926984416074420180493723390468154027020533019691b-301 + x * (-274057357324581485608201308026878795188066463784519077329794224330771414587511991256451199b-311 + x * 923140575090575960281429569584646159509857496569850532443973947641407848668443675573329097b-303))) ; p_old_64bit = 519132785506249659649202446742857299970401223489329249721092671862612630646516898175534471b-299 + x * (922739123872321640347645406112487210240542424232485865309181772337452142304813401978565157b-300 + x * (1384710978983089614554980944010000553236544926984416074420180493723390468154027020533019691b-301 + x * (-274057357324581485608201308026878795188066463784519077329794224330771414587511991256451199b-311 + x * 923140575090575960281429569584646159509857496569850532443973947641407848668443675573329097b-303))) ; p_svn = 1038265571012488267580081747701507502552864186319462514593895218257388262663254136335223063b-300 + x * (1845478247744731668861670841934712268962889917703749792296961594361126466257897183888722895b-301 + x * (1384710978982957070664622808178739493641569277585846232694551334615901588430012311059927601b-301 + x * (-548114714468248737546338914998330532715841724616354653209882304138110057649247627183294433b-312 + x * 1846281150180975297622580633121261037106757793781048506247239550278406622496601732122485233b-304))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #30 ================"); I = [16389b-14;32779b-15] ; p = horner(remez(f, d, I)); p_old_32bit = 519134548434402756767156555739491223749783992943450543735006853556479254975332814832586831b-299 + x * (1845450049499621444821257909088314960970174514175996642815635808483444745999950335490924487b-301 + x * (692376631723210447209723438129936623162107424838590538473236247198461508299268646645182651b-300 + x * (-1211658977517938259044519799457477565612229358925289453861820187775265473657297948543474075b-313 + x * 1846337495070143691660987442551713494094189875111533870425503384713134072129251923138744189b-304))) ; p_old_64bit = 519134548434402756767156555739491223749783992943450543735006853556479254975332814832586831b-299 + x * (1845450049499621444821257909088314960970174514175996642815635808483444745999950335490924487b-301 + x * (692376631723210447209723438129936623162107424838590538473236247198461508299268646645182651b-300 + x * (-1211658977517938259044519799457477565612229358925289453861820187775265473657297948543474075b-313 + x * 1846337495070143691660987442551713494094189875111533870425503384713134072129251923138744189b-304))) ; p_svn = 519134548434397230064956936127972782382520850925244827929853218836000799005904648968273143b-299 + x * (230681256187463730471925329479143461564111131822598486908688243409777897014209001777846291b-298 + x * (1384753263446288338396241827674000401222192703237048413873503052479299741967864085811668019b-301 + x * (-1211658977156087710136727201386554177595012980707457086826797163585841616876353357638132717b-313 + x * 1846337495069967063330522310584765768262905119753111305766662117014275030040591328883128009b-304))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #31 ================"); I = [32779b-15;8195b-13] ; p = horner(remez(f, d, I)); p_old_32bit = 129784077907877229989358408559022727015506092336158554639793545988337383876342394802174983b-297 + x * (1845421847813048003890891490305799586237781940993530060924167527705002243397401652292399469b-301 + x * (346198887945090207628197443350771030623367818935766056578607553395243263683162740596574271b-299 + x * (-1327095570084590892482248321617848024550507093692816293544367981215387497436366034675858795b-313 + x * 923196920839335626205194440883751587784554165940231967259873678081231946926685373213603605b-303))) ; p_old_64bit = 129784077907877229989358408559022727015506092336158554639793545988337383876342394802174983b-297 + x * (1845421847813048003890891490305799586237781940993530060924167527705002243397401652292399469b-301 + x * (346198887945090207628197443350771030623367818935766056578607553395243263683162740596574271b-299 + x * (-1327095570084590892482248321617848024550507093692816293544367981215387497436366034675858795b-313 + x * 923196920839335626205194440883751587784554165940231967259873678081231946926685373213603605b-303))) ; p_svn = 129784077907875848103021982645840680645591515169750492797657603107699291758590525037607837b-297 + x * (1845421847813136413633870703430607052046900605464424242657808159061539467274966216924228471b-301 + x * (346198887945057065588968490245692536303137108974197916838210212886896320833374986466764927b-299 + x * (-331773892430679565249001833341009611065841487884530153968475059201120001178518278702171029b-311 + x * 1846393841678494618689572625930147418834828664945174741628459702119652349640192118655305321b-304))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #32 ================"); I = [8195b-13;32781b-15] ; p = horner(remez(f, d, I)); p_old_32bit = 1038276150195205231598046738711326787177258175938486395650936392494584531982139206239184115b-300 + x * (1845393642684581673262535084218842151923675663720046624798283948403833291890563117846027567b-301 + x * (692418921992592502835948587721625658789940441742669912865045829664790944938388346827005581b-300 + x * (-90158700457546112553689981541875410522556478042701804576870900283483380686066639012347575b-309 + x * 1846450190006787079679592267911737638039999300863927226721933815878236131218424338147248637b-304))) ; p_old_64bit = 1038276150195205231598046738711326787177258175938486395650936392494584531982139206239184115b-300 + x * (1845393642684581673262535084218842151923675663720046624798283948403833291890563117846027567b-301 + x * (692418921992592502835948587721625658789940441742669912865045829664790944938388346827005581b-300 + x * (-90158700457546112553689981541875410522556478042701804576870900283483380686066639012347575b-309 + x * 1846450190006787079679592267911737638039999300863927226721933815878236131218424338147248637b-304))) ; p_svn = 259569037548798543705211766440273847552185791158218877274658712831809194210870713833745673b-298 + x * (1845393642684670093795418658443966483959499499111436368344376226006811395102256883883741195b-301 + x * (86552365249065776586275418697003276474007004222425941606188960245812786516813868977909749b-297 + x * (-721269603479421542891763001724490699127240426599723243259503557550901344348923138863739103b-312 + x * 230806273750826305071032548154040822033001931080469550661156849783960847391861039573187439b-301))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #33 ================"); I = [32781b-15;16391b-14] ; p = horner(remez(f, d, I)); p_old_32bit = 259569919416359157263353411595457107631487782846370515248264225272015360527824594363826399b-298 + x * (115335339632117571316138611855828589074790000759090941028960355593604439013749368475305519b-297 + x * (173110017507646127293946241187089077523281184437658863294068384210744593210320374774470417b-298 + x * (-389497472387211515714083349816328582000148764030707683808210862949049454218666003932452401b-311 + x * 923253270027271825969308891928787425004862776651570518692548000594247064900609481273701205b-303))) ; p_old_64bit = 259569919416359157263353411595457107631487782846370515248264225272015360527824594363826399b-298 + x * (115335339632117571316138611855828589074790000759090941028960355593604439013749368475305519b-297 + x * (173110017507646127293946241187089077523281184437658863294068384210744593210320374774470417b-298 + x * (-389497472387211515714083349816328582000148764030707683808210862949049454218666003932452401b-311 + x * 923253270027271825969308891928787425004862776651570518692548000594247064900609481273701205b-303))) ; p_svn = 519139838832712785294744793651849205116744861032104915377745580281528028175234451240326511b-299 + x * (922682717056984786191037842560048361064150737445945643745434647385992378443837872514948331b-300 + x * (346220035015259106481160210084789300105860147286960056577337502664764130028140026088559053b-299 + x * (-778994944593464631590340766081149572734753525688109985050433618675051212447864257923529627b-312 + x * 923253270027183503718302883172076158284093998622393550288930910988039761075871500306073869b-303))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #34 ================"); I = [16391b-14;32783b-15] ; p = horner(remez(f, d, I)); p_old_32bit = 32446350177305655626960987935742946812325170002522767312791157638567102933964497546634605b-295 + x * (1845337222100605068161869797262611840822189092245241589797562358357269406524276475910977639b-301 + x * (86557652500536780164080755973761565595940061827114833473856294034809846659646798323076743b-297 + x * (-836723808545697939112234873358000218526157193537343518615496583468179871302592432518607973b-312 + x * 923281445910996724629512929320034672478053969908467355594159490598884955120472381156840557b-303))) ; p_old_64bit = 32446350177305655626960987935742946812325170002522767312791157638567102933964497546634605b-295 + x * (1845337222100605068161869797262611840822189092245241589797562358357269406524276475910977639b-301 + x * (86557652500536780164080755973761565595940061827114833473856294034809846659646798323076743b-297 + x * (-836723808545697939112234873358000218526157193537343518615496583468179871302592432518607973b-312 + x * 923281445910996724629512929320034672478053969908467355594159490598884955120472381156840557b-303))) ; p_svn = 1038283205673769919911887025331851626448194016385847841894509031764122005422656005340735635b-300 + x * (1845337222100693510277772059379214171997026956522498276381252238605922803714852220093772511b-301 + x * (1384922440008455878062060395599360175063199452216836309401558676876383623276463266751524873b-301 + x * (-1673447616729456992937773129116785790977599349155587035126314461539364498038188339220166517b-313 + x * 923281445910908399683084596640108535366700793165165294325102396864118622171225970267733811b-303))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #35 ================"); I = [32783b-15;2049b-11] ; p = horner(remez(f, d, I)); p_old_32bit = 1038286734220307239720704557190733547822740233150419403919615053957098975441209633569686853b-300 + x * (461327251661103022054384452204918703840591591979662598242558653096653916764392844993155701b-299 + x * (173120592978464878523250110885262068594635284888249060190772989330683453346211323951145019b-298 + x * (-894456195135440284141609327212459558817515685541830444876237823904741453274093716964232117b-312 + x * 1846619245309188953313966043331537677921113939942277956355175799511092774945261000205458275b-304))) ; p_old_64bit = 1038286734220307239720704557190733547822740233150419403919615053957098975441209633569686853b-300 + x * (461327251661103022054384452204918703840591591979662598242558653096653916764392844993155701b-299 + x * (173120592978464878523250110885262068594635284888249060190772989330683453346211323951145019b-298 + x * (-894456195135440284141609327212459558817515685541830444876237823904741453274093716964232117b-312 + x * 1846619245309188953313966043331537677921113939942277956355175799511092774945261000205458275b-304))) ; p_svn = 259571683555074044470670818178587812230825000699277365821145378951477594615160521312012945b-298 + x * (461327251661125135281638642126583135701747950391370487202780401118873146425858441195315429b-299 + x * (1384964743827586411485602529357234366644873145451430649939007038090334979300009801889793807b-301 + x * (-1788912389908919596374529568446813066503320970901186502380149207073680919363378497109230273b-313 + x * 461654811327253074507525053023055519156890774698540669390486172381238009591314241263639607b-302))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #36 ================"); I = [2049b-11;32785b-15] ; p = horner(remez(f, d, I)); p_old_32bit = 519145131652542185217707763517530853629482604390562710940905508700387992755729079147518445b-299 + x * (922640393872480403813800177925378752771650649922883158877492845194018341940238359134743875b-300 + x * (692503525759418150173428322959528988817757243557271875472398578625935986248675832975195243b-300 + x * (-1904384209409806576422326601306777292609996776581303101650200507548917112622001929760874319b-313 + x * 461668900129045661844556472102129996706923997672351301852902828249902414108550958025784073b-302))) ; p_old_64bit = 519145131652542185217707763517530853629482604390562710940905508700387992755729079147518445b-299 + x * (922640393872480403813800177925378752771650649922883158877492845194018341940238359134743875b-300 + x * (692503525759418150173428322959528988817757243557271875472398578625935986248675832975195243b-300 + x * (-1904384209409806576422326601306777292609996776581303101650200507548917112622001929760874319b-313 + x * 461668900129045661844556472102129996706923997672351301852902828249902414108550958025784073b-302))) ; p_svn = 1038290263305073306910021357436777192703295793131639015679471380799055303888403647377259899b-300 + x * (1845280787745049271330801829385601924012697162885023235578234014713148345855702891268450563b-301 + x * (692503525759351835754213767281560999066059958340277525211195856674418520000763995276439531b-300 + x * (-1904384209047823516880656194229500482163654355185846454456001023003869726586038172925283849b-313 + x * 1846675600516005986703186368235938935641456969689551398906012084701101900989550520438953497b-304))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #37 ================"); I = [32785b-15;16393b-14] ; p = horner(remez(f, d, I)); p_old_32bit = 519146896464090670964582799011339625361876312484969902057815620146269565557712154432556743b-299 + x * (922626282700954902775491508103862824059066665916649646534456723782791265130430024881922389b-300 + x * (1385049363082215960042012852378943648217286866499398277925205949319793323173306680123576807b-301 + x * (-2019863074830693468602081973853455808051455628892417786481781217095389893397674055267503279b-313 + x * 1846731957443027016328279822610383179119522193788621019425224466359106076002887389125705337b-304))) ; p_old_64bit = 519146896464090670964582799011339625361876312484969902057815620146269565557712154432556743b-299 + x * (922626282700954902775491508103862824059066665916649646534456723782791265130430024881922389b-300 + x * (1385049363082215960042012852378943648217286866499398277925205949319793323173306680123576807b-301 + x * (-2019863074830693468602081973853455808051455628892417786481781217095389893397674055267503279b-313 + x * 1846731957443027016328279822610383179119522193788621019425224466359106076002887389125705337b-304))) ; p_svn = 129786724116021284589522791389533938685366914467921888591421991207973332630177941352280335b-297 + x * (922626282700999140024719752636160971604564766039702962600835043546126010405661939156175315b-300 + x * (1385049363082083319064688842536214923187066318823787115934850164088246633478542653277439281b-301 + x * (-2019863074468688320416400256549979086423852482583986753156892163967545423708598910926249469b-313 + x * 923365978721425175130951042714906397326260406560816810752882959071052073486538252895994867b-303))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #38 ================"); I = [16393b-14;32787b-15] ; p = horner(remez(f, d, I)); p_old_32bit = 1038297323089667131239012803580298341305713834793419452962509467851074752565013307757925211b-300 + x * (461306084903729408475343382353118217458409264416593990336519465374065385491184797547928089b-299 + x * (692545839259066841913693084826024353050072653235181386446947448934842309391203558978010225b-300 + x * (-133459311678504620865868670843504381990951036478161257103477502586783643932650946540974923b-309 + x * 923394158044887273321169016644805632854020760156510314516944026455765523834141879892028803b-303))) ; p_old_64bit = 1038297323089667131239012803580298341305713834793419452962509467851074752565013307757925211b-300 + x * (461306084903729408475343382353118217458409264416593990336519465374065385491184797547928089b-299 + x * (692545839259066841913693084826024353050072653235181386446947448934842309391203558978010225b-300 + x * (-133459311678504620865868670843504381990951036478161257103477502586783643932650946540974923b-309 + x * 923394158044887273321169016644805632854020760156510314516944026455765523834141879892028803b-303))) ; p_svn = 519148661544828032169112102124382491302320248973389841878107879960509083336343313940712093b-299 + x * (922612169807503059598077710548707697089552788794835145315237686434928383156922308443824261b-300 + x * (1385091678518001030710303067495711898717493641565016862821034871695097707892835720800233351b-301 + x * (-1067674493247023348006567289431697340072623351320326378673614505309301324650879612282858339b-312 + x * 923394158044798937592228773002626337647906422756899856455862690345226526602596370564158317b-303))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #39 ================"); I = [32787b-15;8197b-13] ; p = horner(remez(f, d, I)); p_old_32bit = 1038300853789610722717431117998072253672745354894008819884081084657820842766590196380279323b-300 + x * (922598055191821408672718405244320303689195084515518394521613676725148488667342591269985053b-300 + x * (692566998913432581940713261525895859800522806638943732672249466782620232752379964505934067b-300 + x * (-1125420972904246892390459207958219498521812206768675803782281061308773968546984562494103223b-312 + x * 1846844676456477726400395348253828365600567546020264505003689125703323360661624398778675999b-304))) ; p_old_64bit = 1038300853789610722717431117998072253672745354894008819884081084657820842766590196380279323b-300 + x * (922598055191821408672718405244320303689195084515518394521613676725148488667342591269985053b-300 + x * (692566998913432581940713261525895859800522806638943732672249466782620232752379964505934067b-300 + x * (-1125420972904246892390459207958219498521812206768675803782281061308773968546984562494103223b-312 + x * 1846844676456477726400395348253828365600567546020264505003689125703323360661624398778675999b-304))) ; p_svn = 1038300853789599654128620928191626403462648427765647651718303542069532121112884285723288433b-300 + x * (57662378449491603544925455540598389841828254930253970683478709975367784588910161998384317b-296 + x * (173141749728341562327965010722690133162605762229874074625618492074160663896377606365502051b-298 + x * (-1125420972723222228136979778653159546641743330995910397970803424610079692501283999601450839b-312 + x * 230855584557037631193855946593581809239481891779533705777169923044462180995976007328272449b-301))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #40 ================"); I = [8197b-13;32789b-15] ; p = horner(remez(f, d, I)); p_old_32bit = 1038304385028081108032949485150642166821786168174196617731484907518431023000345463323466159b-300 + x * (1845167877707743853301029862315370528448617293542570314524618753478073554077018916083953161b-301 + x * (1385176321008686108005887213926430898412220922469336951557518747806594802627115704254710467b-301 + x * (-295792744001313994757328807870081597724043138056186589579893810117232836871800794189163391b-310 + x * 57715657454474657665133753721862497061635908198782446418079866976955603901528724645894937b-299))) ; p_old_64bit = 1038304385028081108032949485150642166821786168174196617731484907518431023000345463323466159b-300 + x * (1845167877707743853301029862315370528448617293542570314524618753478073554077018916083953161b-301 + x * (1385176321008686108005887213926430898412220922469336951557518747806594802627115704254710467b-301 + x * (-295792744001313994757328807870081597724043138056186589579893810117232836871800794189163391b-310 + x * 57715657454474657665133753721862497061635908198782446418079866976955603901528724645894937b-299))) ; p_svn = 129788048128508754719487677985588652217030582751023707667272355799437698858583880493596255b-297 + x * (922583938853916180095837031088441763457759698847839528028476278601053096850981462009406181b-300 + x * (1385176321008553430606693149765976057091289953765215499825608320368344363306656509825322385b-301 + x * (-147896371978027533617145218288141306016409404459395846496000360299907460107780973037514293b-309 + x * 1846901038543012363042900512235202156962321012189403619311425629162308800009952703983856039b-304))) ; if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #41 ================"); restart; verbosity=0!; p = horner(remez(1-x/sin(x),[|3,5|],[-1/8;1/8],1/sin(x))); verbosity=1!; p_old_32bit = x^3 * (-31178697691997280151363863339059689087420918752665b-167 + x^2 * 24930042264710159851265878394398318040604898615191b-171); p_old_64bit = x^3 * (-31178697691997280151363863339059689087420918752665b-167 + x^2 * 24930042264710159851265878394398318040604898615191b-171); p_svn = x^3 * (-15589348845998640053441772179009544391934198160575b-166 + x^2 * 3116255283088763354828944887199725512210848109683b-168); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #42 ================"); restart; p = horner(remez(1,6,[-1b-5;1b-5],1/cos(x))); p_old_32bit = 5846006549323611671784298104022718622318882177971b-162 + x * (37857459261849734002934198358497784854969213609141b-241 + x * (-23384026197294176595383359674367214160107584181507b-165 + x * (-9650697869631352226371375426638274030332473125873b-226 + x * (31178701574267686389540459856148935530651557981629b-169 + x * (28234185975650294540907970780664381466140252467453b-217 + x * (-33256121763484710174675823588818018912416025532385b-174)))))); p_old_64bit = 5846006549323611671784298104022718622318882177971b-162 + x * (37857459261849734002934198358497784854969213609141b-241 + x * (-23384026197294176595383359674367214160107584181507b-165 + x * (-9650697869631352226371375426638274030332473125873b-226 + x * (31178701574267686389540459856148935530651557981629b-169 + x * (28234185975650294540907970780664381466140252467453b-217 + x * (-33256121763484710174675823588818018912416025532385b-174)))))); p_svn = 46768052394588893374274383349804429530193101540037b-165 + x * (37828133831966473044668513721851715408518819224469b-244 + x * (-46768052394588353190751917165222241452885446611429b-166 + x * (-25427705009315713179984612760631972436763477326811b-230 + x * (1948668848391730452279130065687865733407030940519b-165 + x * (19097661627829399791264180875000091942897986598809b-219 + x * (-33256121763550137230701412675274816909367928737119b-174)))))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #43 ================"); restart; p = horner(remez(sin(x),6,[-1b-5,1b-5])); p_old_32bit = 2148263723907549819858926287983956687732819b-218 + x * (46768052394587948180729798097226792243112547550905b-165 + x * (-25507165977932281269808564943557481990277558638851b-228 + x * (-31178701565420095891159605334409136402204722409641b-167 + x * (25169562694197869368373056758332575493933394803211b-217 + x * (24941946363609599630853575496590807881363811448161b-171 + x * (-13542288596511770213422971032075701040404674585399b-207)))))); p_old_64bit = 2148263723907549819858926287983956687732819b-218 + x * (46768052394587948180729798097226792243112547550905b-165 + x * (-25507165977932281269808564943557481990277558638851b-228 + x * (-31178701565420095891159605334409136402204722409641b-167 + x * (25169562694197869368373056758332575493933394803211b-217 + x * (24941946363609599630853575496590807881363811448161b-171 + x * (-13542288596511770213422971032075701040404674585399b-207)))))); p_svn = -31657351710771318264480101926512972684047b-216 + x * (11692013098646987045182253340122523086369332160129b-163 + x * (45142061063915304495253236000306896279355752461095b-232 + x * (-15589350782710047985431039322670567918156898471475b-166 + x * (-32638902245554706260123356836597206211247789846683b-220 + x * (12470973181805555448555253907066439009244525141935b-170 + x * 43769018414430920138875951265888862687962052230975b-211))))); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; print("=============== Check remez #44 ================"); restart; verbosity=0!; p = horner(remez(1-(1+x+x^2/2)/exp(x), [|3,4|],[-1b-8;12167298183958086083256693241475396846566462796809b-171], 1/exp(x))); verbosity=1!; p_old_32bit = x^3 * (7794680717168470900797342378780962700124730873177b-165 + x * 31179902867931546748200780881663744737011812548003b-169); p_old_64bit = x^3 * (7794680717168470900797342378780962700124730873177b-165 + x * 31179902867931546748200780881663744737011812548003b-169); p_svn = x^3 * (31178722868673883627864298068285024212112392034985b-167 + x * 7794975716982886342439431644725264558026848337299b-167); if ((p != p_svn) && (p != p_old_32bit) && (p != p_old_64bit)) then p else "Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK"; /* A bug has been fixed at rev 9f9d12d for the evaluation of functions with removable singularities. This fixes in the same time a problem in remez algorithm: in some cases, the retroaction loop concluded that the approximation was not good enough (due to an error of the estimation of the value of p/f-1 at 0, typically) and started over and over, for no reason. I am not sure whether we detected or not the problem with remez command at the time where the bug has been fixed, but no non-regression test has been added. One year and a half later, JM Muller submitted me a problem that he observed with his version of Sollya, which I first believed to be due to the absence of Haar condition (the typical situation of this problem is to approximate a function on [0,b] with a basis of the form X,X^2...: Haar condition is not fulfilled, and 0 being a bound it is automatically added to the list of points, hence introducing a row of zeros in the matrix, therefore the crash. The usual fix is to work on [eps, b] where eps>0 is small). But I was not able to reproduce it with the modern version of Sollya which contradicts the first hypothesis, since nothing has been done yet to handle this problem with Haar condition. A deeper inspection showed that it was indeed related to the above-mentioned problem of evaluation of functions with removable singularities. My feeling is that it is desirable to add a non-regression test for this bug, which I am doing with what follows. */ print("=============== Check remez #45 ================"); restart; verbosity=0!; p = remez(1,[|1,3,5|],[0;pi/8],1/sin(x)); if (p==p) then print("Removable singularity correctly detected") else print("Regression with respect to revision 9f9d12d");sollya-6.0+ds/tests-tool/check020.sollya.reference000066400000000000000000000210661300174114700220650ustar00rootroot00000000000000=============== Check remez #1 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #2 ================ The tool has been restarted. Warning in Remez: a slower algorithm is used for this step Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #3 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #4 ================ The tool has been restarted. Warning in Remez: a slower algorithm is used for this step Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #5 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #6 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #7 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #8 ================ The tool has been restarted. Warning in Remez: a slower algorithm is used for this step Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #9 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #10 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #11 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #12 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #13 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #14 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #15 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #16 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #17 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #18 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #19 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #20 ================ The tool has been restarted. The precision has been set to 300 bits. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #21 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #22 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #23 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #24 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #25 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #26 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #27 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #28 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #29 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #30 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #31 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #32 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #33 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #34 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #35 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #36 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #37 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #38 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #39 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #40 ================ Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #41 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #42 ================ The tool has been restarted. Warning in Remez: a slower algorithm is used for this step Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #43 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #44 ================ The tool has been restarted. Check that mpfr_urandom has the expected behavior (either one of the old 32-bit or 64-bit behavior), or the new one. OK =============== Check remez #45 ================ The tool has been restarted. Removable singularity correctly detected sollya-6.0+ds/tests-tool/check021.sollya000066400000000000000000000031111300174114700201200ustar00rootroot00000000000000restart; print("=============== Test ChebModels ================"); verbosity=0!; test2 = proc(f, n, I) { var x,TStruct, p, errs, Delta, t, i, xk, res; res = 1; TStruct = chebyshevform(f,n,I); p = TStruct[0]; errs = TStruct[1]; Delta= TStruct[2]; chebyCoeffs = TStruct[3]; for i from 0 to points do { roundingwarnings=off!; xk := inf(I) + sup([(i/points)*(sup(I)-inf(I))]); roundingwarnings=on!; if (xk >= sup(I)) then xk := sup(I); dd = [0]; for s from n to 0 by -1 do { dd = errs[s] + xk*dd; }; dd = dd + Delta; if (! (f(xk)-p(xk)) in dd) then { print("test2(",f,",",n,",",I,"): error at point x=",xk); res = 0; }; }; if (res==1) then {print("Testing chebyshevform(",f,",",n,",",I,"): OK"); print("Delta=",Delta);}; }; test2(sin(x), 7, [-1,1]); test2(sin(exp(x)) + 2 - x,7,[-1;1]); test2(sin(exp(x)) + 2 - x,7,[-1b-8;1b-7]); test2(sin(x)^4 + x^5 * exp(17 * x),7,[-1b-8;1b-7]); test2(2^x,7,[-1b-8;1b-7]); test2(x^17,7,[-1b-8;1b-7]); test2(x^5,7,[-1b-8;1b-7]); test2(1 + 2 * x + 3 * x^2 + 4 * x^3,7,[-1b-8;1b-7]); test2(2 * x + 3 * x^2 + 4 * x^3,7,[-1b-8;1b-7]); test2(exp(sin(x))^log2(1 + sin(x)^2) * erf(x),7,[-1b-8;1b-7]); test2(sin(x),10,[3,4]); test2(atan(x),15, [-0.25,0.25]); test2(atan(x),15, [-0.9,0.9]); test2(exp(1/cos(x)),14, [0,1]); test2(exp(x)/(log(2+x)*cos(x)),15, [0,1]); test2(sin(exp(x)),10, [-1,1]); test2(tanh(x+0.5)-tanh(x-0.5),10, [-1,1]); test2(sqrt(x+01.0001),10, [-1,0]); test2(sqrt(x+01.0001)*sin(x),10, [-1,0]); test2(1/(1+4*x^2),10, [-1,1]); test2(sin(x)^2+cos(x)^2,10, [-1,1]); sollya-6.0+ds/tests-tool/check021.sollya.reference000066400000000000000000000071731300174114700220710ustar00rootroot00000000000000The tool has been restarted. =============== Test ChebModels ================ Testing chebyshevform( sin(x) , 7 , [-1;1] ): OK Delta= [-2.0949157382649245727241856783473196206560848009071e-8;2.0949157382649245727241856783473196206560848009071e-8] Testing chebyshevform( sin(exp(x)) + 2 - x , 7 , [-1;1] ): OK Delta= [-1.18238734633728578082988892298704564314242319763076e-3;1.18238734633728578082988892298704564314242319763076e-3] Testing chebyshevform( sin(exp(x)) + 2 - x , 7 , [-3.90625e-3;7.8125e-3] ): OK Delta= [-7.7970437588408393806945333925286300924053682887281e-22;7.7970437588408393806945333925286300924053682887281e-22] Testing chebyshevform( sin(x)^4 + x^5 * exp(17 * x) , 7 , [-3.90625e-3;7.8125e-3] ): OK Delta= [-9.7077351133513950188855607630120654964826220951706e-18;9.7077351133513950188855607630120654964826220951706e-18] Testing chebyshevform( 2^x , 7 , [-3.90625e-3;7.8125e-3] ): OK Delta= [-1.4370360795578476186588086727640426138437049566734e-26;1.4370360795578476186588086727640426138437049566734e-26] Testing chebyshevform( x^17 , 7 , [-3.90625e-3;7.8125e-3] ): OK Delta= [-5.108713324764594911342782479414081845765878545756e-38;5.108713324764594911342782479414081845765878545756e-38] Testing chebyshevform( x^5 , 7 , [-3.90625e-3;7.8125e-3] ): OK Delta= [0;0] Testing chebyshevform( 1 + 2 * x + 3 * x^2 + 4 * x^3 , 7 , [-3.90625e-3;7.8125e-3] ): OK Delta= [0;0] Testing chebyshevform( 2 * x + 3 * x^2 + 4 * x^3 , 7 , [-3.90625e-3;7.8125e-3] ): OK Delta= [0;0] Testing chebyshevform( exp(sin(x))^log2(1 + sin(x)^2) * erf(x) , 7 , [-3.90625e-3;7.8125e-3] ): OK Delta= [-2.25639148834625344958080205961301237825032295085113e-20;2.25639148834625344958080205961301237825032295085113e-20] Testing chebyshevform( sin(x) , 10 , [3;4] ): OK Delta= [-1.19457761695107072711239377906044572711239377906055e-14;1.19457761695107072711239377906044572711239377906055e-14] Testing chebyshevform( atan(x) , 15 , [-0.25;0.25] ): OK Delta= [-7.8863835888947943491156938877750803840172011405348e-15;7.8863835888947943491156938877750803840172011405348e-15] Testing chebyshevform( atan(x) , 15 , [-0.9;0.9] ): OK Delta= [-5.0972725166489157583430205053110015869140625000533e-3;5.0972725166489157583430205053110015869140625000533e-3] Testing chebyshevform( exp(1 / cos(x)) , 14 , [0;1] ): OK Delta= [-5.2162157619872992347232961962015659874091869380588e-7;5.2162157619872992347232961962015659874091869380588e-7] Testing chebyshevform( exp(x) / (log(2 + x) * cos(x)) , 15 , [0;1] ): OK Delta= [-4.8636679820022049102877316653754006305117949125017e-9;4.8636679820022049102877316653754006305117949125017e-9] Testing chebyshevform( sin(exp(x)) , 10 , [-1;1] ): OK Delta= [-2.5526515509528982444611771290005152606157305347355e-5;2.5526515509528982444611771290005152606157305347355e-5] Testing chebyshevform( tanh(x + 0.5) - tanh(x - 0.5) , 10 , [-1;1] ): OK Delta= [-6.8676537333806244131033670978939266023350617297498e-3;6.8676537333806244131033670978939266023350617297498e-3] Testing chebyshevform( sqrt(x + 1.0001) , 10 , [-1;0] ): OK Delta= [-3.638269013199414804223559477624779316527652771061e-2;3.638269013199414804223559477624779316527652771061e-2] Testing chebyshevform( sqrt(x + 1.0001) * sin(x) , 10 , [-1;0] ): OK Delta= [-3.3261187696283411520611530960727589133153531137141e-2;3.3261187696283411520611530960727589133153531137141e-2] Testing chebyshevform( 1 / (1 + 4 * x^2) , 10 , [-1;1] ): OK Delta= [-1.1211271873342928566017725929853798954624872399305e-2;1.1211271873342928566017725929853798954624872399305e-2] Testing chebyshevform( sin(x)^2 + cos(x)^2 , 10 , [-1;1] ): OK Delta= [-3.9123632622656608633850998774290226898717139161473e-9;3.9123632622656608633850998774290226898717139161473e-9] sollya-6.0+ds/tests-tool/check022.sollya000066400000000000000000000146721300174114700201370ustar00rootroot00000000000000/* List operations in Sollya: - Literate lists: * [||] * [| 1, 2, exp(x), "Coucou" |] * ellipses in integer lists: [| 1, 7, ..., 27, 29 |] - Operations * Prepend .: * Append :. * Legacy prepend :: * Concatenation @ * tail * head * length * revert * sort * Random access in rvalues (taking elements out of lists) * Random access in lvalues (assignments) - Special operations in end-elliptic lists * length(l) = infty * tail never reaches the empty list * Random access works for any index >= 0 * append :. must fail with an error message * concatenation @ must fail with an error message iff an end-elliptic list is its left operand * matches match the implicit elements and decompose the lists correctly The following list operations are optimized for O(1) complexity, at least starting with the second optimized operation: * Prepend on the same variable: l = a .: l * tail on the same variable: l = tail(l) * head * length * Random access in rvalues The O(1) optimizations for prepend and tail are based on a in-place modification of the Sollya object representing the list that is stored in the table of (local) variables. Hence, if these operations are performed on list objects that share the same object representation with other lists, the optimizations cannot be performed for the first access. The optimizations for head are for free in an environment where Sollya objects can be reference-counted. The optimizations for length and random access in rvalues are based on a second internal representation of lists that allows for random accesses. That representation is built up at the first access to the list that touches all list elements (i.e. even a print or write). It is maintained for all other optimized list operations that eventually execute in O(1). This means it gets destroyed for random accesses to lists in lvalue and prepend and tail operations on Sollya list objects that are shared with other lists. In the sequel, we will test all list operations as well as there complexity for the important ones (prepend .:, tail, head, random access). We will not test the match operations as they have already been tested with the match construct tests. */ /* Test literate lists */ /* Empty lists */ a = [||]; a; b = a; b; a == b; a == [| |]; b == [| |]; length(a); length(b); /* Complete literate lists */ c = [| 1, 2, 3, 4, exp(x), "Coucou", 17, { .a = exp(x) } |]; d = c; c == d; c; d; length(c); length(d); c == [| 1, 2, 3, 4, exp(x), "Coucou", 17, { .a = exp(x) } |]; /* Literate lists in which ellipses need to be expanded */ e = [| 1, 2, 3, ..., floor(exp(2)), "Coucou" |]; f = [| 3, ..., 17, ..., 27, 29, ..., 67, ..., 99 |]; e; f; g = e; h = f; e == g; h == f; l = [| 1, 2, 17, ..., 23, "Coucou", 88... |]; l; for i from 0 to 17 do { write(l[i], " "); }; write("\n"); /* Ellipses and affectation */ l = [| 1, ..., 5, 17... |]; l[10] = "Coucou"; l; l[11]; l = [| 1, ..., 5, 1, exp(x)... |]; l[10] = "Coucou"; l; l[11]; l = [| 1, ..., 5, 17... |]; l[10] := "Coucou"; l; l[11]; l = [| 1, ..., 5, 1, exp(x)... |]; l[10] := "Coucou"; l; l[11]; /* Legacy O(n) operations * append :. * legacy prepend :: * concatenation @ * revert * sort */ /* Append :. */ [||] :. 5; ([||] :. 5) :. exp(x); l = [||]; for i from 0 to 10 do l = l :. i; l; /* Special way of performing append */ L = [||]; L[0] = 1; L; L[1] = "a"; L; L[2] = "Foo"; L; L[0] = "Bar is"; L; /* Prepend */ 5 .: [||]; exp(x) .: 5 .: [||]; 1 .: 2 .: 3 .: 4 .: [|"Hello", "guys"|]; [| 5 |] .: [||]; [| exp(x) |] .: [| 5 |] .: [||]; L = [| 1, ..., 5 |]; for i from 0 to 15 do { L = i .: L; }; for i from 0 to length(L)-1 do write(L[i], " "); write("\n"); L = [| 1, ..., 5 |]; L[0] = L[0]; for i from 0 to 15 do { L = i .: L; }; for i from 0 to length(L)-1 do write(L[i], " "); write("\n"); /* Concatenation */ [||] @ [||]; [| "eins", "zwei", "Polizei" |] @ [||]; [||] @ [| "eins", "zwei", "Polizei" |]; [| "eins", "zwei", "Polizei" |] @ [| "raz", "dva", "tri", "chetyre", "pyat", "poshol", "zaichik", "pogulat" |]; a = [| "eins", "zwei", "Polizei" |]; b = [| "raz", "dva", "tri", "chetyre", "pyat", "poshol", "zaichik", "pogulat" |]; c = a @ a; d = b @ b; e = d @ d; c; e; /* revert */ a = [||]; b = revert(a); c = revert(b); a; b; a == b; a == c; a = [|"hinein", "Welt", "weite", "die", "in", "allein", "ging", "klein", "Hänschen"|]; b = revert(a); c = revert(b); a; b; a == b; a == c; /* sort */ a = [||]; b = sort(a); a; b; a == b; okay = true; for i from 0 to length(b) - 2 do { okay = okay && (b[i] <= b[i + 1]); }; okay; a = [| 1 |]; b = sort(a); a; b; a == b; okay = true; for i from 0 to length(b) - 2 do { okay = okay && (b[i] <= b[i + 1]); }; okay; a = [| 1, ..., 17 |]; b = sort(a); a; b; a == b; okay = true; for i from 0 to length(b) - 2 do { okay = okay && (b[i] <= b[i + 1]); }; okay; a = [| 17, 2, 1, 16, 13, 9, 8, 6, 3, 14, 11 |]; b = sort(a); a; b; a == b; okay = true; for i from 0 to length(b) - 2 do { okay = okay && (b[i] <= b[i + 1]); }; okay; /* Special operations in end-elliptic lists * length(l) = infty * tail never reaches the empty list * Random access works for any index >= 0 * append :. must fail with an error message * concatenation @ must fail with an error message iff an end-elliptic list is its left operand */ length( [| 1, 3... |] ); length( [| 1, 3, "Coucou"... |] ); length( [| 0... |] ); l = [| "Käse", "fromage", "cheese", 0... |]; for i from 0 to 12 do { write(head(l), " "); l = tail(l); }; write("\n"); l; l = [| "Käse", "fromage", "cheese", exp(x)... |]; for i from 0 to 12 do { write(head(l), " "); l = tail(l); }; write("\n"); l; l = [| "Käse", "fromage", "cheese", 0... |]; l[0]; l[2]; l[17178]; l[9199010]; l = [| "Käse", "fromage", "cheese", "syr"... |]; l[0]; l[2]; l[17178]; l[9199010]; [| "Käse", "fromage", "cheese", 0... |] :. 5; [| "Käse", "fromage", "cheese", "syr"... |] :. 5; [| "Käse", "fromage", "cheese", 0... |] @ [| 5 |]; [| 5 |] @ [| "Käse", "fromage", "cheese", 0... |]; [| "Käse", "fromage", "cheese", 0... |] @ [| |]; [| |] @ [| "Käse", "fromage", "cheese", 0... |]; [| "Käse", "fromage", "cheese", "syr"... |] @ [| 5 |]; [| 5 |] @ [| "Käse", "fromage", "cheese", "syr"... |]; [| "Käse", "fromage", "cheese", "syr"... |] @ [| |]; [| |] @ [| "Käse", "fromage", "cheese", "syr"... |]; sollya-6.0+ds/tests-tool/check022.sollya.reference000066400000000000000000000070551300174114700220710ustar00rootroot00000000000000[| |] [| |] true true true 0 0 true [|1, 2, 3, 4, exp(x), "Coucou", 17, { .a = exp(x) }|] [|1, 2, 3, 4, exp(x), "Coucou", 17, { .a = exp(x) }|] 8 8 true [|1, 2, 3, 4, 5, 6, 7, "Coucou"|] [|3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99|] true true [|1, 2, 17, 18, 19, 20, 21, 22, 23, "Coucou", 88...|] 1 2 17 18 19 20 21 22 23 Coucou 88 89 90 91 92 93 94 95 [|1, 2, 3, 4, 5, 17, 18, 19, 20, 21, "Coucou", 23...|] 23 [|1, 2, 3, 4, 5, 1, exp(x), exp(x), exp(x), exp(x), "Coucou", exp(x)...|] exp(x) [|1, 2, 3, 4, 5, 17, 18, 19, 20, 21, "Coucou", 23...|] 23 [|1, 2, 3, 4, 5, 1, exp(x), exp(x), exp(x), exp(x), "Coucou", exp(x)...|] exp(x) [|5|] [|5, exp(x)|] [|0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10|] [|1|] [|1, "a"|] [|1, "a", "Foo"|] [|"Bar is", "a", "Foo"|] [|5|] [|exp(x), 5|] [|1, 2, 3, 4, "Hello", "guys"|] [|[|5|]|] [|[|exp(x)|], [|5|]|] 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 1 2 3 4 5 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 1 2 3 4 5 [| |] [|"eins", "zwei", "Polizei"|] [|"eins", "zwei", "Polizei"|] [|"eins", "zwei", "Polizei", "raz", "dva", "tri", "chetyre", "pyat", "poshol", "zaichik", "pogulat"|] [|"eins", "zwei", "Polizei", "eins", "zwei", "Polizei"|] [|"raz", "dva", "tri", "chetyre", "pyat", "poshol", "zaichik", "pogulat", "raz", "dva", "tri", "chetyre", "pyat", "poshol", "zaichik", "pogulat", "raz", "dva", "tri", "chetyre", "pyat", "poshol", "zaichik", "pogulat", "raz", "dva", "tri", "chetyre", "pyat", "poshol", "zaichik", "pogulat"|] [| |] [| |] true true [|"hinein", "Welt", "weite", "die", "in", "allein", "ging", "klein", "Hänschen"|] [|"Hänschen", "klein", "ging", "allein", "in", "die", "weite", "Welt", "hinein"|] false true [| |] [| |] true true [|1|] [|1|] true true [|1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17|] [|1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17|] true true [|17, 2, 1, 16, 13, 9, 8, 6, 3, 14, 11|] [|1, 2, 3, 6, 8, 9, 11, 13, 14, 16, 17|] false true infty infty infty Käse fromage cheese 0 1 2 3 4 5 6 7 8 9 [|10...|] Käse fromage cheese exp(x) exp(x) exp(x) exp(x) exp(x) exp(x) exp(x) exp(x) exp(x) exp(x) [|exp(x)...|] Käse cheese 17175 9199007 Käse cheese syr syr Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error [|5, "Käse", "fromage", "cheese", 0...|] Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error [|"Käse", "fromage", "cheese", 0...|] Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error [|5, "Käse", "fromage", "cheese", "syr"...|] Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error [|"Käse", "fromage", "cheese", "syr"...|] sollya-6.0+ds/tests-tool/check023.sollya000066400000000000000000000051361300174114700201330ustar00rootroot000000000000001 .: 2 .: 3 .: 4 .: [||]; /* expecting [|1, 2, 3, 4|] */ b = {.val = 2}; 1 .: b . val .: 3 .: 4 .: [||]; /* expecting [|1, 2, 3, 4|] */ 1 .: [||] != 1 .: [||]; /* expecting false */ 1 .: 2 .: [||] :. 3; /* expecting [|1, 2, 3|] */ 1 .: [||] .: [|2|]; /* expecting [|1, [| |], 2 |] */ [|1|] :. [|2|] .: [|3|]; /* expecting [|1, [|[|2|], 3|]|] */ [|1|] .: [|2|] :. [|3|]; /* expecting [|[|1|], 2, [|3|]|] */ [||] :. 1 :. 2 :. 3 :. 4; /* expecting [|1, 2, 3, 4|] */ 1 .: 2 .: [|3|] @ [|1|]; /* expecting [|1, 2, 3, 1|] */ [|2|] @ [|3|] .: [|1|]; /* expecting [|2, [|3|], 1|] */ [|1|] @ [|2|] :. 3 :. 4; /* expecting [|1, 2, 3, 4|] */ [|2|] :. [|3|] @ [|1|]; /* expecting [|2, [|3|], 1|] */ [|1 * 1 , 2|]; /* expecting [|1, 2|] */ [|0 + 1 , 2|]; /* expecting [|1, 2|] */ [|2 - 1 , 2|]; /* expecting [|1, 2|] */ [|2 / 2 , 2|]; /* expecting [|1, 2|] */ [|2 ^ 0 , 2|]; /* expecting [|1, 2|] */ [|true && false , 2|]; /* expecting [|false, 2|] */ [|false || false , 2|]; /* expecting [|false, 2|] */ [|1 == 2 , 2|]; /* expecting [|false, 2|] */ [|1 != 1 , 2|]; /* expecting [|false, 2|] */ b = {.val = 1}; [| b . val , 2|]; /* expecting [|1, 2|] */ [| 1 .: [||] , 2|]; /* expecting [|[|1|], 2|] */ [| [||] :. 1 , 2|]; /* expecting [|[|1|], 2|] */ [| [||] @ [|1|] , 2|]; /* expecting [|[|1|], 2|] */ a=false; a && false || true; /* expecting true */ b = {.val = true}; a && b . val; /* expecting false */ a && 1 < 2; /* expecting false */ a && 2 < 1; /* expecting false */ a && 1 == 1; /* expecting false */ a && 1 != 2; /* expecting false */ a=1; b = {.val = 1}; a != 0 + 1; /* expecting false */ a != 2 * (1/2); /* expecting false */ a != 3 - 2; /* expecting false */ a != b . val; /* expecting false */ a != 1 .: [||]; /* expecting true */ a != 2 / 2; /* expecting false */ a=[|1|]; a != [||] :. 1; /* expecting false */ a != [||] @ [|1|]; /* expecting false */ a = 2; a != 4 ^ (1/2); /* expecting false */ a != ~ 2; /* expecting false */ a=1; b = {.val = 1}; a == 0 + 1; /* expecting true */ a == 2 * (1/2); /* expecting true */ a == 3 - 2; /* expecting true */ a == b . val; /* expecting true */ a == 1 .: [||]; /* expecting false */ a == 2 / 2; /* expecting true */ a=[|1|]; a == [||] :. 1; /* expecting true */ a == [||] @ [|1|]; /* expecting true */ a = 2; a == 4 ^ (1/2); /* expecting true */ a == ~ 2; /* expecting true */ 1 < 1 + 1; /* expecting true */ 1 < 1 * 2; /* expecting true */ 1 < 1 - (-2); /* expecting true */ 1 < 1 / 0.5; /* expecting true */ 3 < 2 ^ 2; /* expecting true */sollya-6.0+ds/tests-tool/check023.sollya.reference000066400000000000000000000007601300174114700220660ustar00rootroot00000000000000[|1, 2, 3, 4|] [|1, 2, 3, 4|] false [|1, 2, 3|] [|1, [| |], 2|] [|1, [|[|2|], 3|]|] [|[|1|], 2, [|3|]|] [|1, 2, 3, 4|] [|1, 2, 3, 1|] [|2, [|3|], 1|] [|1, 2, 3, 4|] [|2, [|3|], 1|] [|1, 2|] [|1, 2|] [|1, 2|] [|1, 2|] [|1, 2|] [|false, 2|] [|false, 2|] [|false, 2|] [|false, 2|] [|1, 2|] [|[|1|], 2|] [|[|1|], 2|] [|[|1|], 2|] true false false false false false false false false false true false false false false false true true true true false true true true true true true true true true true sollya-6.0+ds/tests-tool/check024.sollya000066400000000000000000000034221300174114700201300ustar00rootroot00000000000000restart; print("=============== Test number 1 ================"); foo = library("./libraryexample.a"); verbosity=9; evaluate(diff(foo(x+1)), 0); /* Testing the __unique_id feature */ restart; print("=============== Test number 2 ================"); s = __unique_id; print(s) > "tmp_check024"; write("Checkingthat __unique_id is made of [0-9a-zA-Z_-]... "); bashexecute("sed -n 's/[0-9A-Za-z_-]//g;p' tmp_check024"); print("Done."); restart; s = __unique_id; print(s) > "tmp_check024b"; write("Checking that __unique_id is made of [0-9a-zA-Z_-]... "); bashexecute("sed -n 's/[0-9A-Za-z_-]//g;p' tmp_check024b"); print("Done."); print("Checking that __unique_id changes after restart... "); bashexecute("diff tmp_check024 tmp_check024b > /dev/null && echo \"__unique_id did not change after restart!\" && cat tmp_check024 && cat tmp_check024b"); print("Done."); bashexecute("rm -rf tmp_check024 tmp_check024b"); restart; print("=============== Test number 3 ================"); /* Non-regression test for bug [#20818] */ f = asin(x); dom = [1b-100; 0x3fefffffffffffff]; q = x * (6180970211295773 * 2^(-53) + x^2 * 7192083860379593*2^(-53)); r_exact = x*cos(q(x))-sin(q(x))*sqrt(1-x^2); monomials1 = [| q(x) * sqrt(1-x^2) / x|]; monomials2 = [|1, q(x)^2|]; display = dyadic!; fullparentheses = on!; autosimplify = off!; verbosity = 0!; rrstar = remez(r_exact/x, monomials1 @ monomials2, dom); verbosity = 1!; filename = "tempfile"@__unique_id; print("rrstar2 = ", rrstar, ";") > filename; execute(filename); bashexecute("rm -rf " @ filename); rrstar2 == rrstar; restart; print("=============== Test number 4 ================"); filename = "tempfile"@__unique_id; print("showmessagenumbers=on!; roundingwarnings=on!; verbosity=1!; a=0.1;") > filename; execute(filename); bashexecute("rm -rf " @ filename); sollya-6.0+ds/tests-tool/check024.sollya.reference000066400000000000000000000017331300174114700220700ustar00rootroot00000000000000The tool has been restarted. =============== Test number 1 ================ The verbosity level has been set to 9. Information: expression '(diff(foo))(x + 1) * 1' has been simplified to expression '(diff(foo))(x + 1)'. Warning: evaluateFaithful returned NaN. Information: expression '(diff(diff(foo)))(x + 1) * 1' has been simplified to expression '(diff(diff(foo)))(x + 1)'. [0;1] The tool has been restarted. =============== Test number 2 ================ Checkingthat __unique_id is made of [0-9a-zA-Z_-]... Done. The tool has been restarted. Checking that __unique_id is made of [0-9a-zA-Z_-]... Done. Checking that __unique_id changes after restart... Done. The tool has been restarted. =============== Test number 3 ================ true The tool has been restarted. =============== Test number 4 ================ Warning (174): Rounding occurred when converting the constant "0.1" to floating-point with 165 bits. If safe computation is needed, try to increase the precision. sollya-6.0+ds/tests-tool/check025.sollya000066400000000000000000000027651300174114700201420ustar00rootroot00000000000000restart; print("=============== Test number 1 ================"); (0*1)/@NaN@; evaluate((0*1)/@NaN@,13); restart; print("=============== Test number 2 ================"); /* This code used to produce a memory leak until revision 1871. See bug #8726 for details. */ prec = 53; nearest = floor(x + 1/2); procedure myround(k,X) { var ulp; ulp = 2^(floor(log2(abs(X)))-k+1); return ulp * nearest(X * 1/ulp); }; procedure worstCaseRange(f,mMin,mMax) { var m; var y, roundY; var delta; var minDelta, minDeltaM; minDelta = 1b1000000; minDeltaM = NaN; for m from mMin to mMax do { y = f(m); roundY = myround(25,y); delta = abs(roundY - y); if (delta < minDelta) then { minDelta = delta; minDeltaM = m; m,", ", ~delta; }; }; return [| minDelta, minDeltaM |]; }; f = 1/sqrt(x); a = worstCaseRange(f,1b23,1b23+10); restart; print("=============== Test number 3 ================"); f=x^2147483647; diff(f); restart; print("=============== Test number 4 ================"); p = (0 * x) / NaN + NaN; p; restart; print("=============== Test number 5 ================"); prec=12!; c=12345.25; a=floor(c); b=ceil(c); b==a+1; a<=c; c<=b; c=1234525; a=floor(c); b=ceil(c); b==a; a<=c; c<=b; print(floor(1233455646547894351534646584685465165146546135100546645604654654654654684864654165464654), " should be 1233455646547894351534646584685465165146546135100546645604654654654654684864654165464654"); print(ceil(4096.5), " should be 4097"); print(nearestint(4096.5), " should be 4096"); print(nearestint(4097), " should be 4097");sollya-6.0+ds/tests-tool/check025.sollya.reference000066400000000000000000000014541300174114700220710ustar00rootroot00000000000000The tool has been restarted. =============== Test number 1 ================ NaN [NaN;NaN] The tool has been restarted. =============== Test number 2 ================ The precision has been set to 53 bits. 8388608, 5.908992726796372e-12 8388609, 1.1860607934483566e-13 The tool has been restarted. =============== Test number 3 ================ x^2147483646 * 2147483647 The tool has been restarted. =============== Test number 4 ================ NaN The tool has been restarted. =============== Test number 5 ================ true true true true true true 1.233455646547894351534646584685465165146546135100546645604654654654654684864654165464654e87 should be 1233455646547894351534646584685465165146546135100546645604654654654654684864654165464654 4097 should be 4097 4096 should be 4096 4097 should be 4097 sollya-6.0+ds/tests-tool/check026.sollya000066400000000000000000000133601300174114700201340ustar00rootroot00000000000000a=1+1b-250; b = [a]; inf(b) == sup(b); b = [a*log2(10)*log10(2)]; inf(b) < sup(b); b = [a*log2(10)*log10(2), a*log2(10)*log10(2)]; inf(b) < sup(b); b = [1.000000000000000000000000000000000000000000000000000000000000000000000000000552714787526044]; inf(b) < sup(b); b = [1.000000000000000000000000000000000000000000000000000000000000000000000000000552714787526044, 1.000000000000000000000000000000000000000000000000000000000000000000000000000552714787526044]; inf(b) < sup(b); b=1.00000000000000000000000000000000000000000000000000000000000000000000000000055271478752604~3/5~; inf(b) < sup(b); prec=53!; b=[%165%1.000000000000000000000000000000000000000000000000000000000000000000000000000552714787526044]; inf(b) < sup(b); b=[%165%1.000000000000000000000000000000000000000000000000000000000000000000000000000552714787526044,%165%1.000000000000000000000000000000000000000000000000000000000000000000000000000552714787526044]; inf(b) < sup(b); prec=default!; a=1-1b-250; b = [a]; inf(b) == sup(b); b = [a*log2(10)*log10(2)]; inf(b) < sup(b); b = [a*log2(10)*log10(2), a*log2(10)*log10(2)]; inf(b) < sup(b); b = [0.9999999999999999999999999999999999999999999999999999999999999999999999999994472852124739555]; inf(b) < sup(b); b = [0.9999999999999999999999999999999999999999999999999999999999999999999999999994472852124739555,0.9999999999999999999999999999999999999999999999999999999999999999999999999994472852124739555]; inf(b) < sup(b); b=0.999999999999999999999999999999999999999999999999999999999999999999999999999447285212473955~4/6~; inf(b) < sup(b); prec=53!; b=[%165%0.9999999999999999999999999999999999999999999999999999999999999999999999999994472852124739555]; inf(b) < sup(b); b=[%165%0.9999999999999999999999999999999999999999999999999999999999999999999999999994472852124739555,%165%0.9999999999999999999999999999999999999999999999999999999999999999999999999994472852124739555]; inf(b) < sup(b); prec=default!; a=1+1b-165; b = [a]; inf(b) == sup(b); b = [a*log2(10)*log10(2)]; inf(b) < sup(b); b = [a*log2(10)*log10(2), a*log2(10)*log10(2)]; inf(b) < sup(b); b = [1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216]; inf(b) < sup(b); b = [1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216, 1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216]; inf(b) < sup(b); b=1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216~0/0~; inf(b) < sup(b); prec=53!; b=[%165%1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216]; inf(b) < sup(b); b=[%165%1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216,%165%1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216]; inf(b) < sup(b); prec=default!; a=-(1+1b-250); b = [a]; inf(b) == sup(b); b = [a*log2(10)*log10(2)]; inf(b) < sup(b); b = [a*log2(10)*log10(2), a*log2(10)*log10(2)]; inf(b) < sup(b); b = [-1.000000000000000000000000000000000000000000000000000000000000000000000000000552714787526044]; inf(b) < sup(b); b = [-1.000000000000000000000000000000000000000000000000000000000000000000000000000552714787526044, -1.000000000000000000000000000000000000000000000000000000000000000000000000000552714787526044]; inf(b) < sup(b); b=-1.00000000000000000000000000000000000000000000000000000000000000000000000000055271478752604~3/5~; inf(b) < sup(b); prec=53!; b=[-%165%1.000000000000000000000000000000000000000000000000000000000000000000000000000552714787526044]; inf(b) < sup(b); b=[-%165%1.000000000000000000000000000000000000000000000000000000000000000000000000000552714787526044, -%165%1.000000000000000000000000000000000000000000000000000000000000000000000000000552714787526044]; inf(b) < sup(b); prec=default!; a=-(1-1b-250); b = [a]; inf(b) == sup(b); b = [a*log2(10)*log10(2)]; inf(b) < sup(b); b = [a*log2(10)*log10(2), a*log2(10)*log10(2)]; inf(b) < sup(b); b = [-0.9999999999999999999999999999999999999999999999999999999999999999999999999994472852124739555]; inf(b) < sup(b); b = [-0.9999999999999999999999999999999999999999999999999999999999999999999999999994472852124739555, -0.9999999999999999999999999999999999999999999999999999999999999999999999999994472852124739555]; inf(b) < sup(b); b=-0.999999999999999999999999999999999999999999999999999999999999999999999999999447285212473955~4/6~; inf(b) < sup(b); prec=53!; b=[-%165%0.9999999999999999999999999999999999999999999999999999999999999999999999999994472852124739555]; inf(b) < sup(b); b=[-%165%0.9999999999999999999999999999999999999999999999999999999999999999999999999994472852124739555, -%165%0.9999999999999999999999999999999999999999999999999999999999999999999999999994472852124739555]; inf(b) < sup(b); prec=default!; a=-(1+1b-165); b = [a]; inf(b) == sup(b); b = [a*log2(10)*log10(2)]; inf(b) < sup(b); b = [a*log2(10)*log10(2), a*log2(10)*log10(2)]; inf(b) < sup(b); b = [-1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216]; inf(b) < sup(b); b = [-1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216, -1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216]; inf(b) < sup(b); b=-1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216~0/0~; inf(b) < sup(b); prec=53!; b=[-%165%1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216]; inf(b) < sup(b); b=[-%165%1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216, -%165%1.0000000000000000000000000000000000000000000000000213821176807375651691242917372118550305216]; inf(b) < sup(b); prec=default!; sollya-6.0+ds/tests-tool/check026.sollya.reference000066400000000000000000000003601300174114700220650ustar00rootroot00000000000000true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true true sollya-6.0+ds/tests-tool/check027.sollya000066400000000000000000000153441300174114700201410ustar00rootroot00000000000000/* Non-regression tests for #15256 */ restart; print("=============== Test number 1 ================"); a=17; b=0; c=abs(a)/abs(b); round(c,17,RD); a=17; b=0; c=abs(a)/abs(b); round(c,12,RN); /*********************************************************************************/ /* Non-regression tests for #10322*/ restart; print("=============== Test number 2 ================"); verbosity = 2; printsingle(round(2^2000,SG,RD)); printsingle(round(2^2000,SG,RN)); printsingle(round( (2^24-1)*2^104,SG,RN)); printsingle(round( (2^24-1)*2^104,SG,RD)); printsingle(round( (2^24-1)*2^104,SG,RU)); printsingle(round( (2^24-1/2)*2^104,SG,RD)); printsingle(round( (2^24-1/2)*2^104,SG,RN)); printsingle(round( (2^24-1/2)*2^104,SG,RU)); printsingle(round( (2^23)*2^(-149),SG,RD)); printsingle(round( (2^23)*2^(-149),SG,RN)); printsingle(round( (2^23)*2^(-149),SG,RU)); printsingle(round( (2^23-1)*2^(-149),SG,RD)); printsingle(round( (2^23-1)*2^(-149),SG,RN)); printsingle(round( (2^23-1)*2^(-149),SG,RU)); printsingle(round( (1)*2^(-149),SG,RD)); printsingle(round( (1)*2^(-149),SG,RN)); printsingle(round( (1)*2^(-149),SG,RU)); printsingle(round( (1/2)*2^(-149),SG,RD)); printsingle(round( (1/2)*2^(-149),SG,RN)); printsingle(round( (1/2)*2^(-149),SG,RU)); printsingle(round( -(2^24-1)*2^104,SG,RN)); printsingle(round( -(2^24-1)*2^104,SG,RD)); printsingle(round( -(2^24-1)*2^104,SG,RU)); printsingle(round( -(2^24-1/2)*2^104,SG,RD)); printsingle(round( -(2^24-1/2)*2^104,SG,RN)); printsingle(round( -(2^24-1/2)*2^104,SG,RU)); printsingle(round( -(2^23)*2^(-149),SG,RD)); printsingle(round( -(2^23)*2^(-149),SG,RN)); printsingle(round( -(2^23)*2^(-149),SG,RU)); printsingle(round( -(2^23-1)*2^(-149),SG,RD)); printsingle(round( -(2^23-1)*2^(-149),SG,RN)); printsingle(round( -(2^23-1)*2^(-149),SG,RU)); printsingle(round( -(1)*2^(-149),SG,RD)); printsingle(round( -(1)*2^(-149),SG,RN)); printsingle(round( -(1)*2^(-149),SG,RU)); printsingle(round( -(1/2)*2^(-149),SG,RD)); printsingle(round( -(1/2)*2^(-149),SG,RN)); printsingle(round( -(1/2)*2^(-149),SG,RU)); /*********************************************************************************/ /* Non-regression tests for #15239 Variable a is supposed to be evaluated the same way in both situations, i.e. with a faithful evaluation. */ restart; print("=============== Test number 3 ================"); verbosity = 2; a=1 + 2^20000 * sin((log(13)/log(17) - log2(13)/log2(17)) * 2^1000); a; a*x; /*********************************************************************************/ /* Non-regression tests for #10317 */ /* The warning displayed could mention that the inclusion property is satisfied and that a rounding has happened, but not that the safety is compromised. */ restart; print("=============== Test number 4 ================"); verbosity = 2; roundingwarnings=on; f=x; b=f([0.1]); /*********************************************************************************/ /* Non-regression tests for #16434 */ /* The simplification of expression is allowed only when the expression is well-defined everywhere (at least by continuity) */ restart; print("=============== Test number 5 ================"); evaluate(sin(5 * pi)/(sin(5 * pi)),17); /* expecting NaN */ evaluate(exp(log(sin(5 * pi)) - log(sin(5 * pi))),17); /* expecting NaN */ evaluate(log(sin(5 * pi)) - log(sin(5 * pi)),17); /* expecting NaN */ print(simplify( ((x/x)-1)/((x/x)-1) )); /* expecting 0/0 or NaN */ print(simplify( ((x/x)-1) )); /* expecting 0 */ print(simplify( x/x )); /* expecting 1 */ print(simplify( log2(x)-log(x)/log(2) )); /* expecting log2(x)-log(x)/log(2) */ print(simplify( (log2(x)-log(x)/log(2))/(log2(x)-log(x)/log(2)) )); /* expecting (log2(x)-log(x)/log(2))/(log2(x)-log(x)/log(2)) */ print(simplify( (cos(x)^2+sin(x)^2)+2 )); /* expecting (cos(x)^2+sin(x)^2)+2 */ print(simplify( ((cos(x)^2+sin(x)^2)+2)/((cos(x)^2+sin(x)^2)+2) )); /* expecting 1 */ print(simplify( (cos(x)+2)/(cos(x)+2) )); /* expecting 1 */ print(simplify( ((x+1)^2/(x^2+2*x+1)-1)/((x+1)^2/(x^2+2*x+1)-1) )); /* expecting ((x+1)^2/(x^2+2*x+1)-1)/((x+1)^2/(x^2+2*x+1)-1) */ print(simplify( (cos(x)+2)-(cos(x)+2) )); /* expecting 0 */ print(simplify( log((cos(x)^2+sin(x)^2)-1)-log((cos(x)^2+sin(x)^2)-1) )); /* expecting log((cos(x)^2+sin(x)^2)-1)-log((cos(x)^2+sin(x)^2)-1) */ print(simplify( cos(x)/cos(x) )); /* expecting cos(x)/cos(x) (1 would be better, but requires some effort to prove it) */ print(simplify( cos(2*x)/cos(2*x) )); /* expecting cos(2*x)/cos(2*x) (1 would be better, but requires some effort to prove it) */ print(simplify( cos(2+x)/cos(2+x) )); /* expecting cos(2+x)/cos(2+x) (1 would be better, but requires some effort to prove it) */ print(simplify( cos(pi/2+x)/cos(pi/2+x) )); /* expecting cos(pi/2+x)/cos(pi/2+x) (1 would be better, but requires some effort to prove it) */ print(simplify( cos(pi/2+cos(x)^2+sin(x)^2-1)/cos(pi/2+cos(x)^2+sin(x)^2-1) )); /* expecting cos(pi/2+cos(x)^2+sin(x)^2-1)/cos(pi/2+cos(x)^2+sin(x)^2-1) */ print(simplify( cos(pi*abs(x)/(2*x))/cos(pi*abs(x)/(2*x)) )); /* expecting cos(pi*abs(x)/(2*x))/cos(pi*abs(x)/(2*x)) */ print(simplify( log(x)-log(x) )); /* expecting log(x)-log(x) */ print(simplify( log(x)/log(x) )); /* expecting log(x)/log(x) */ print(simplify( cos(x)-cos(x) )); /* expecting 0 */ print(simplify( (x+1)^2/(x^2+2*x+1) - 1 )); /* expecting (x+1)^2/(x^2+2*x+1) - 1 */ print(simplify( (x^2+2*x+1)/(x^2+2*x+1) - 1 )); /* expecting 0 */ print(simplify( (-log(x))^(-1) / (-log(x))^(-1) )); /* expecting (-log(x))^(-1) / (-log(x))^(-1) */ print(simplify( 2/x - 2/x )); /* expecting 0 */ print(simplify( @Inf@/x - @Inf@/x )); /* expecting @Inf@/x - @Inf@/x */ u = 1/2 * (abs(x)/x + 1); print(simplify( u-u )); /* expecting 0 */ d = abs(x)/x; print(simplify( d/d )); /* expecting 1 */ f= abs(x)/x+1; print(simplify( f/f )); /* expecting (abs(x)/x+1)/(abs(x)/x+1) */ print(simplify( 0/f )); /* expecting 0/(abs(x)/x+1) */ print(simplify( log(3 + cos(x)) - log(3 + cos(x)) )); /* expecting 0 */ print(simplify( log(3 + cos(x)) / log(3 + cos(x)) )); /* expecting 1 */ /*********************************************************************************/ restart; print("=============== Test number 6 ================"); verbosity = 2; roundingwarnings=on; printsingle( 2^2000 ); printsingle( (2^24-1)*2^104 ); printsingle( (2^24-1/2)*2^104 ); printsingle( (2^23)*2^(-149) ); printsingle( (2^23-1)*2^(-149) ); printsingle( (1)*2^(-149) ); printsingle( (1/2)*2^(-149) ); printsingle( -(2^24-1)*2^104 ); printsingle( -(2^24-1/2)*2^104 ); printsingle( -(2^23)*2^(-149) ); printsingle( -(2^23-1)*2^(-149) ); printsingle( -(1)*2^(-149) ); printsingle( -(1/2)*2^(-149) ); printsingle( +0 ); printsingle( -0 ); /*********************************************************************************/ restart; print("=============== Test number 7 ================"); verbosity = 2; roundingwarnings=on; p = x+1; p(2);sollya-6.0+ds/tests-tool/check027.sollya.reference000066400000000000000000000103231300174114700220660ustar00rootroot00000000000000The tool has been restarted. =============== Test number 1 ================ NaN NaN The tool has been restarted. =============== Test number 2 ================ The verbosity level has been set to 2. Information: rounding down has happened. 0x7f7fffff Information: rounding up has happened. 0x7f800000 Information: no rounding has happened. 0x7f7fffff Information: no rounding has happened. 0x7f7fffff Information: no rounding has happened. 0x7f7fffff Information: rounding down has happened. 0x7f7fffff Information: rounding up has happened. 0x7f800000 Information: rounding up has happened. 0x7f800000 Information: no rounding has happened. 0x00800000 Information: no rounding has happened. 0x00800000 Information: no rounding has happened. 0x00800000 Information: no rounding has happened. 0x007fffff Information: no rounding has happened. 0x007fffff Information: no rounding has happened. 0x007fffff Information: no rounding has happened. 0x00000001 Information: no rounding has happened. 0x00000001 Information: no rounding has happened. 0x00000001 Information: rounding down has happened. 0x00000000 Information: rounding down has happened. 0x00000000 Information: rounding up has happened. 0x00000001 Information: no rounding has happened. 0xff7fffff Information: no rounding has happened. 0xff7fffff Information: no rounding has happened. 0xff7fffff Information: rounding down has happened. 0xff800000 Information: rounding down has happened. 0xff800000 Information: rounding up has happened. 0xff7fffff Information: no rounding has happened. 0x80800000 Information: no rounding has happened. 0x80800000 Information: no rounding has happened. 0x80800000 Information: no rounding has happened. 0x807fffff Information: no rounding has happened. 0x807fffff Information: no rounding has happened. 0x807fffff Information: no rounding has happened. 0x80000001 Information: no rounding has happened. 0x80000001 Information: no rounding has happened. 0x80000001 Information: rounding down has happened. 0x80000001 Information: rounding up has happened. 0x80000000 Information: rounding up has happened. 0x80000000 The tool has been restarted. =============== Test number 3 ================ The verbosity level has been set to 2. 1 x The tool has been restarted. =============== Test number 4 ================ The verbosity level has been set to 2. Rounding warning mode has been activated. Warning: Rounding occurred when converting the constant "0.1" to floating-point with 165 bits. The inclusion property is nevertheless satisfied. Warning: Rounding occurred when converting the constant "0.1" to floating-point with 165 bits. The inclusion property is nevertheless satisfied. The tool has been restarted. =============== Test number 5 ================ [-infty;infty] [NaN;NaN] [NaN;NaN] 0 / 0 0 1 log2(x) - log(x) / log(2) (log2(x) - log(x) / log(2)) / (log2(x) - log(x) / log(2)) cos(x)^2 + sin(x)^2 + 2 1 1 ((x + 1)^2 / (x^2 + 2 * x + 1) - 1) / ((x + 1)^2 / (x^2 + 2 * x + 1) - 1) 0 log(cos(x)^2 + sin(x)^2 - 1) - log(cos(x)^2 + sin(x)^2 - 1) cos(x) / cos(x) cos(2 * x) / cos(2 * x) cos(2 + x) / cos(2 + x) cos((pi) / 2 + x) / cos((pi) / 2 + x) cos((pi) / 2 + cos(x)^2 + sin(x)^2 - 1) / cos((pi) / 2 + cos(x)^2 + sin(x)^2 - 1) cos(((pi) * abs(x)) / (2 * x)) / cos(((pi) * abs(x)) / (2 * x)) log(x) - log(x) log(x) / log(x) 0 (x + 1)^2 / (x^2 + 2 * x + 1) - 1 0 (-log(x))^(-1) / (-log(x))^(-1) 0 infty / x - infty / x 0 1 (abs(x) / x + 1) / (abs(x) / x + 1) 0 / (abs(x) / x + 1) 0 1 The tool has been restarted. =============== Test number 6 ================ The verbosity level has been set to 2. Rounding warning mode has been activated. Warning: rounding up occurred before printing a value as a single. 0x7f800000 0x7f7fffff Warning: rounding up occurred before printing a value as a single. 0x7f800000 0x00800000 0x007fffff 0x00000001 Warning: rounding down occurred before printing a value as a single. 0x00000000 0xff7fffff Warning: rounding down occurred before printing a value as a single. 0xff800000 0x80800000 0x807fffff 0x80000001 Warning: rounding up occurred before printing a value as a single. 0x80000000 0x00000000 0x80000000 The tool has been restarted. =============== Test number 7 ================ The verbosity level has been set to 2. Rounding warning mode has been activated. 3 sollya-6.0+ds/tests-tool/check028.sollya000066400000000000000000007607431300174114700201540ustar00rootroot00000000000000restart; verbosity = 0!; @NaN@ + @NaN@ ; @NaN@ + -@Inf@ ; @NaN@ + @Inf@ ; @NaN@ + 5 ; @NaN@ + 1 ; @NaN@ + 0 ; @NaN@ + [@NaN@] ; @NaN@ + [-@Inf@] ; @NaN@ + [@Inf@] ; @NaN@ + [5] ; @NaN@ + [1] ; @NaN@ + [0] ; @NaN@ + [@NaN@;@NaN@] ; @NaN@ + [@NaN@;-@Inf@] ; @NaN@ + [@NaN@;@Inf@] ; @NaN@ + [@NaN@;5] ; @NaN@ + [@NaN@;1] ; @NaN@ + [@NaN@;0] ; @NaN@ + [-@Inf@;@NaN@] ; @NaN@ + [-@Inf@;-@Inf@] ; @NaN@ + [-@Inf@;@Inf@] ; @NaN@ + [-@Inf@;5] ; @NaN@ + [-@Inf@;1] ; @NaN@ + [-@Inf@;0] ; @NaN@ + [@Inf@;@NaN@] ; @NaN@ + [@Inf@;-@Inf@] ; @NaN@ + [@Inf@;@Inf@] ; @NaN@ + [@Inf@;5] ; @NaN@ + [@Inf@;1] ; @NaN@ + [@Inf@;0] ; @NaN@ + [5;@NaN@] ; @NaN@ + [5;-@Inf@] ; @NaN@ + [5;@Inf@] ; @NaN@ + [5;5] ; @NaN@ + [5;1] ; @NaN@ + [5;0] ; @NaN@ + [1;@NaN@] ; @NaN@ + [1;-@Inf@] ; @NaN@ + [1;@Inf@] ; @NaN@ + [1;5] ; @NaN@ + [1;1] ; @NaN@ + [1;0] ; @NaN@ + [0;@NaN@] ; @NaN@ + [0;-@Inf@] ; @NaN@ + [0;@Inf@] ; @NaN@ + [0;5] ; @NaN@ + [0;1] ; @NaN@ + [0;0] ; -@Inf@ + @NaN@ ; -@Inf@ + -@Inf@ ; -@Inf@ + @Inf@ ; -@Inf@ + 5 ; -@Inf@ + 1 ; -@Inf@ + 0 ; -@Inf@ + [@NaN@] ; -@Inf@ + [-@Inf@] ; -@Inf@ + [@Inf@] ; -@Inf@ + [5] ; -@Inf@ + [1] ; -@Inf@ + [0] ; -@Inf@ + [@NaN@;@NaN@] ; -@Inf@ + [@NaN@;-@Inf@] ; -@Inf@ + [@NaN@;@Inf@] ; -@Inf@ + [@NaN@;5] ; -@Inf@ + [@NaN@;1] ; -@Inf@ + [@NaN@;0] ; -@Inf@ + [-@Inf@;@NaN@] ; -@Inf@ + [-@Inf@;-@Inf@] ; -@Inf@ + [-@Inf@;@Inf@] ; -@Inf@ + [-@Inf@;5] ; -@Inf@ + [-@Inf@;1] ; -@Inf@ + [-@Inf@;0] ; -@Inf@ + [@Inf@;@NaN@] ; -@Inf@ + [@Inf@;-@Inf@] ; -@Inf@ + [@Inf@;@Inf@] ; -@Inf@ + [@Inf@;5] ; -@Inf@ + [@Inf@;1] ; -@Inf@ + [@Inf@;0] ; -@Inf@ + [5;@NaN@] ; -@Inf@ + [5;-@Inf@] ; -@Inf@ + [5;@Inf@] ; -@Inf@ + [5;5] ; -@Inf@ + [5;1] ; -@Inf@ + [5;0] ; -@Inf@ + [1;@NaN@] ; -@Inf@ + [1;-@Inf@] ; -@Inf@ + [1;@Inf@] ; -@Inf@ + [1;5] ; -@Inf@ + [1;1] ; -@Inf@ + [1;0] ; -@Inf@ + [0;@NaN@] ; -@Inf@ + [0;-@Inf@] ; -@Inf@ + [0;@Inf@] ; -@Inf@ + [0;5] ; -@Inf@ + [0;1] ; -@Inf@ + [0;0] ; @Inf@ + @NaN@ ; @Inf@ + -@Inf@ ; @Inf@ + @Inf@ ; @Inf@ + 5 ; @Inf@ + 1 ; @Inf@ + 0 ; @Inf@ + [@NaN@] ; @Inf@ + [-@Inf@] ; @Inf@ + [@Inf@] ; @Inf@ + [5] ; @Inf@ + [1] ; @Inf@ + [0] ; @Inf@ + [@NaN@;@NaN@] ; @Inf@ + [@NaN@;-@Inf@] ; @Inf@ + [@NaN@;@Inf@] ; @Inf@ + [@NaN@;5] ; @Inf@ + [@NaN@;1] ; @Inf@ + [@NaN@;0] ; @Inf@ + [-@Inf@;@NaN@] ; @Inf@ + [-@Inf@;-@Inf@] ; @Inf@ + [-@Inf@;@Inf@] ; @Inf@ + [-@Inf@;5] ; @Inf@ + [-@Inf@;1] ; @Inf@ + [-@Inf@;0] ; @Inf@ + [@Inf@;@NaN@] ; @Inf@ + [@Inf@;-@Inf@] ; @Inf@ + [@Inf@;@Inf@] ; @Inf@ + [@Inf@;5] ; @Inf@ + [@Inf@;1] ; @Inf@ + [@Inf@;0] ; @Inf@ + [5;@NaN@] ; @Inf@ + [5;-@Inf@] ; @Inf@ + [5;@Inf@] ; @Inf@ + [5;5] ; @Inf@ + [5;1] ; @Inf@ + [5;0] ; @Inf@ + [1;@NaN@] ; @Inf@ + [1;-@Inf@] ; @Inf@ + [1;@Inf@] ; @Inf@ + [1;5] ; @Inf@ + [1;1] ; @Inf@ + [1;0] ; @Inf@ + [0;@NaN@] ; @Inf@ + [0;-@Inf@] ; @Inf@ + [0;@Inf@] ; @Inf@ + [0;5] ; @Inf@ + [0;1] ; @Inf@ + [0;0] ; 5 + @NaN@ ; 5 + -@Inf@ ; 5 + @Inf@ ; 5 + 5 ; 5 + 1 ; 5 + 0 ; 5 + [@NaN@] ; 5 + [-@Inf@] ; 5 + [@Inf@] ; 5 + [5] ; 5 + [1] ; 5 + [0] ; 5 + [@NaN@;@NaN@] ; 5 + [@NaN@;-@Inf@] ; 5 + [@NaN@;@Inf@] ; 5 + [@NaN@;5] ; 5 + [@NaN@;1] ; 5 + [@NaN@;0] ; 5 + [-@Inf@;@NaN@] ; 5 + [-@Inf@;-@Inf@] ; 5 + [-@Inf@;@Inf@] ; 5 + [-@Inf@;5] ; 5 + [-@Inf@;1] ; 5 + [-@Inf@;0] ; 5 + [@Inf@;@NaN@] ; 5 + [@Inf@;-@Inf@] ; 5 + [@Inf@;@Inf@] ; 5 + [@Inf@;5] ; 5 + [@Inf@;1] ; 5 + [@Inf@;0] ; 5 + [5;@NaN@] ; 5 + [5;-@Inf@] ; 5 + [5;@Inf@] ; 5 + [5;5] ; 5 + [5;1] ; 5 + [5;0] ; 5 + [1;@NaN@] ; 5 + [1;-@Inf@] ; 5 + [1;@Inf@] ; 5 + [1;5] ; 5 + [1;1] ; 5 + [1;0] ; 5 + [0;@NaN@] ; 5 + [0;-@Inf@] ; 5 + [0;@Inf@] ; 5 + [0;5] ; 5 + [0;1] ; 5 + [0;0] ; 1 + @NaN@ ; 1 + -@Inf@ ; 1 + @Inf@ ; 1 + 5 ; 1 + 1 ; 1 + 0 ; 1 + [@NaN@] ; 1 + [-@Inf@] ; 1 + [@Inf@] ; 1 + [5] ; 1 + [1] ; 1 + [0] ; 1 + [@NaN@;@NaN@] ; 1 + [@NaN@;-@Inf@] ; 1 + [@NaN@;@Inf@] ; 1 + [@NaN@;5] ; 1 + [@NaN@;1] ; 1 + [@NaN@;0] ; 1 + [-@Inf@;@NaN@] ; 1 + [-@Inf@;-@Inf@] ; 1 + [-@Inf@;@Inf@] ; 1 + [-@Inf@;5] ; 1 + [-@Inf@;1] ; 1 + [-@Inf@;0] ; 1 + [@Inf@;@NaN@] ; 1 + [@Inf@;-@Inf@] ; 1 + [@Inf@;@Inf@] ; 1 + [@Inf@;5] ; 1 + [@Inf@;1] ; 1 + [@Inf@;0] ; 1 + [5;@NaN@] ; 1 + [5;-@Inf@] ; 1 + [5;@Inf@] ; 1 + [5;5] ; 1 + [5;1] ; 1 + [5;0] ; 1 + [1;@NaN@] ; 1 + [1;-@Inf@] ; 1 + [1;@Inf@] ; 1 + [1;5] ; 1 + [1;1] ; 1 + [1;0] ; 1 + [0;@NaN@] ; 1 + [0;-@Inf@] ; 1 + [0;@Inf@] ; 1 + [0;5] ; 1 + [0;1] ; 1 + [0;0] ; 0 + @NaN@ ; 0 + -@Inf@ ; 0 + @Inf@ ; 0 + 5 ; 0 + 1 ; 0 + 0 ; 0 + [@NaN@] ; 0 + [-@Inf@] ; 0 + [@Inf@] ; 0 + [5] ; 0 + [1] ; 0 + [0] ; 0 + [@NaN@;@NaN@] ; 0 + [@NaN@;-@Inf@] ; 0 + [@NaN@;@Inf@] ; 0 + [@NaN@;5] ; 0 + [@NaN@;1] ; 0 + [@NaN@;0] ; 0 + [-@Inf@;@NaN@] ; 0 + [-@Inf@;-@Inf@] ; 0 + [-@Inf@;@Inf@] ; 0 + [-@Inf@;5] ; 0 + [-@Inf@;1] ; 0 + [-@Inf@;0] ; 0 + [@Inf@;@NaN@] ; 0 + [@Inf@;-@Inf@] ; 0 + [@Inf@;@Inf@] ; 0 + [@Inf@;5] ; 0 + [@Inf@;1] ; 0 + [@Inf@;0] ; 0 + [5;@NaN@] ; 0 + [5;-@Inf@] ; 0 + [5;@Inf@] ; 0 + [5;5] ; 0 + [5;1] ; 0 + [5;0] ; 0 + [1;@NaN@] ; 0 + [1;-@Inf@] ; 0 + [1;@Inf@] ; 0 + [1;5] ; 0 + [1;1] ; 0 + [1;0] ; 0 + [0;@NaN@] ; 0 + [0;-@Inf@] ; 0 + [0;@Inf@] ; 0 + [0;5] ; 0 + [0;1] ; 0 + [0;0] ; [@NaN@] + @NaN@ ; [@NaN@] + -@Inf@ ; [@NaN@] + @Inf@ ; [@NaN@] + 5 ; [@NaN@] + 1 ; [@NaN@] + 0 ; [@NaN@] + [@NaN@] ; [@NaN@] + [-@Inf@] ; [@NaN@] + [@Inf@] ; [@NaN@] + [5] ; [@NaN@] + [1] ; [@NaN@] + [0] ; [@NaN@] + [@NaN@;@NaN@] ; [@NaN@] + [@NaN@;-@Inf@] ; [@NaN@] + [@NaN@;@Inf@] ; [@NaN@] + [@NaN@;5] ; [@NaN@] + [@NaN@;1] ; [@NaN@] + [@NaN@;0] ; [@NaN@] + [-@Inf@;@NaN@] ; [@NaN@] + [-@Inf@;-@Inf@] ; [@NaN@] + [-@Inf@;@Inf@] ; [@NaN@] + [-@Inf@;5] ; [@NaN@] + [-@Inf@;1] ; [@NaN@] + [-@Inf@;0] ; [@NaN@] + [@Inf@;@NaN@] ; [@NaN@] + [@Inf@;-@Inf@] ; [@NaN@] + [@Inf@;@Inf@] ; [@NaN@] + [@Inf@;5] ; [@NaN@] + [@Inf@;1] ; [@NaN@] + [@Inf@;0] ; [@NaN@] + [5;@NaN@] ; [@NaN@] + [5;-@Inf@] ; [@NaN@] + [5;@Inf@] ; [@NaN@] + [5;5] ; [@NaN@] + [5;1] ; [@NaN@] + [5;0] ; [@NaN@] + [1;@NaN@] ; [@NaN@] + [1;-@Inf@] ; [@NaN@] + [1;@Inf@] ; [@NaN@] + [1;5] ; [@NaN@] + [1;1] ; [@NaN@] + [1;0] ; [@NaN@] + [0;@NaN@] ; [@NaN@] + [0;-@Inf@] ; [@NaN@] + [0;@Inf@] ; [@NaN@] + [0;5] ; [@NaN@] + [0;1] ; [@NaN@] + [0;0] ; [-@Inf@] + @NaN@ ; [-@Inf@] + -@Inf@ ; [-@Inf@] + @Inf@ ; [-@Inf@] + 5 ; [-@Inf@] + 1 ; [-@Inf@] + 0 ; [-@Inf@] + [@NaN@] ; [-@Inf@] + [-@Inf@] ; [-@Inf@] + [@Inf@] ; [-@Inf@] + [5] ; [-@Inf@] + [1] ; [-@Inf@] + [0] ; [-@Inf@] + [@NaN@;@NaN@] ; [-@Inf@] + [@NaN@;-@Inf@] ; [-@Inf@] + [@NaN@;@Inf@] ; [-@Inf@] + [@NaN@;5] ; [-@Inf@] + [@NaN@;1] ; [-@Inf@] + [@NaN@;0] ; [-@Inf@] + [-@Inf@;@NaN@] ; [-@Inf@] + [-@Inf@;-@Inf@] ; [-@Inf@] + [-@Inf@;@Inf@] ; [-@Inf@] + [-@Inf@;5] ; [-@Inf@] + [-@Inf@;1] ; [-@Inf@] + [-@Inf@;0] ; [-@Inf@] + [@Inf@;@NaN@] ; [-@Inf@] + [@Inf@;-@Inf@] ; [-@Inf@] + [@Inf@;@Inf@] ; [-@Inf@] + [@Inf@;5] ; [-@Inf@] + [@Inf@;1] ; [-@Inf@] + [@Inf@;0] ; [-@Inf@] + [5;@NaN@] ; [-@Inf@] + [5;-@Inf@] ; [-@Inf@] + [5;@Inf@] ; [-@Inf@] + [5;5] ; [-@Inf@] + [5;1] ; [-@Inf@] + [5;0] ; [-@Inf@] + [1;@NaN@] ; [-@Inf@] + [1;-@Inf@] ; [-@Inf@] + [1;@Inf@] ; [-@Inf@] + [1;5] ; [-@Inf@] + [1;1] ; [-@Inf@] + [1;0] ; [-@Inf@] + [0;@NaN@] ; [-@Inf@] + [0;-@Inf@] ; [-@Inf@] + [0;@Inf@] ; [-@Inf@] + [0;5] ; [-@Inf@] + [0;1] ; [-@Inf@] + [0;0] ; [@Inf@] + @NaN@ ; [@Inf@] + -@Inf@ ; [@Inf@] + @Inf@ ; [@Inf@] + 5 ; [@Inf@] + 1 ; [@Inf@] + 0 ; [@Inf@] + [@NaN@] ; [@Inf@] + [-@Inf@] ; [@Inf@] + [@Inf@] ; [@Inf@] + [5] ; [@Inf@] + [1] ; [@Inf@] + [0] ; [@Inf@] + [@NaN@;@NaN@] ; [@Inf@] + [@NaN@;-@Inf@] ; [@Inf@] + [@NaN@;@Inf@] ; [@Inf@] + [@NaN@;5] ; [@Inf@] + [@NaN@;1] ; [@Inf@] + [@NaN@;0] ; [@Inf@] + [-@Inf@;@NaN@] ; [@Inf@] + [-@Inf@;-@Inf@] ; [@Inf@] + [-@Inf@;@Inf@] ; [@Inf@] + [-@Inf@;5] ; [@Inf@] + [-@Inf@;1] ; [@Inf@] + [-@Inf@;0] ; [@Inf@] + [@Inf@;@NaN@] ; [@Inf@] + [@Inf@;-@Inf@] ; [@Inf@] + [@Inf@;@Inf@] ; [@Inf@] + [@Inf@;5] ; [@Inf@] + [@Inf@;1] ; [@Inf@] + [@Inf@;0] ; [@Inf@] + [5;@NaN@] ; [@Inf@] + [5;-@Inf@] ; [@Inf@] + [5;@Inf@] ; [@Inf@] + [5;5] ; [@Inf@] + [5;1] ; [@Inf@] + [5;0] ; [@Inf@] + [1;@NaN@] ; [@Inf@] + [1;-@Inf@] ; [@Inf@] + [1;@Inf@] ; [@Inf@] + [1;5] ; [@Inf@] + [1;1] ; [@Inf@] + [1;0] ; [@Inf@] + [0;@NaN@] ; [@Inf@] + [0;-@Inf@] ; [@Inf@] + [0;@Inf@] ; [@Inf@] + [0;5] ; [@Inf@] + [0;1] ; [@Inf@] + [0;0] ; [5] + @NaN@ ; [5] + -@Inf@ ; [5] + @Inf@ ; [5] + 5 ; [5] + 1 ; [5] + 0 ; [5] + [@NaN@] ; [5] + [-@Inf@] ; [5] + [@Inf@] ; [5] + [5] ; [5] + [1] ; [5] + [0] ; [5] + [@NaN@;@NaN@] ; [5] + [@NaN@;-@Inf@] ; [5] + [@NaN@;@Inf@] ; [5] + [@NaN@;5] ; [5] + [@NaN@;1] ; [5] + [@NaN@;0] ; [5] + [-@Inf@;@NaN@] ; [5] + [-@Inf@;-@Inf@] ; [5] + [-@Inf@;@Inf@] ; [5] + [-@Inf@;5] ; [5] + [-@Inf@;1] ; [5] + [-@Inf@;0] ; [5] + [@Inf@;@NaN@] ; [5] + [@Inf@;-@Inf@] ; [5] + [@Inf@;@Inf@] ; [5] + [@Inf@;5] ; [5] + [@Inf@;1] ; [5] + [@Inf@;0] ; [5] + [5;@NaN@] ; [5] + [5;-@Inf@] ; [5] + [5;@Inf@] ; [5] + [5;5] ; [5] + [5;1] ; [5] + [5;0] ; [5] + [1;@NaN@] ; [5] + [1;-@Inf@] ; [5] + [1;@Inf@] ; [5] + [1;5] ; [5] + [1;1] ; [5] + [1;0] ; [5] + [0;@NaN@] ; [5] + [0;-@Inf@] ; [5] + [0;@Inf@] ; [5] + [0;5] ; [5] + [0;1] ; [5] + [0;0] ; [1] + @NaN@ ; [1] + -@Inf@ ; [1] + @Inf@ ; [1] + 5 ; [1] + 1 ; [1] + 0 ; [1] + [@NaN@] ; [1] + [-@Inf@] ; [1] + [@Inf@] ; [1] + [5] ; [1] + [1] ; [1] + [0] ; [1] + [@NaN@;@NaN@] ; [1] + [@NaN@;-@Inf@] ; [1] + [@NaN@;@Inf@] ; [1] + [@NaN@;5] ; [1] + [@NaN@;1] ; [1] + [@NaN@;0] ; [1] + [-@Inf@;@NaN@] ; [1] + [-@Inf@;-@Inf@] ; [1] + [-@Inf@;@Inf@] ; [1] + [-@Inf@;5] ; [1] + [-@Inf@;1] ; [1] + [-@Inf@;0] ; [1] + [@Inf@;@NaN@] ; [1] + [@Inf@;-@Inf@] ; [1] + [@Inf@;@Inf@] ; [1] + [@Inf@;5] ; [1] + [@Inf@;1] ; [1] + [@Inf@;0] ; [1] + [5;@NaN@] ; [1] + [5;-@Inf@] ; [1] + [5;@Inf@] ; [1] + [5;5] ; [1] + [5;1] ; [1] + [5;0] ; [1] + [1;@NaN@] ; [1] + [1;-@Inf@] ; [1] + [1;@Inf@] ; [1] + [1;5] ; [1] + [1;1] ; [1] + [1;0] ; [1] + [0;@NaN@] ; [1] + [0;-@Inf@] ; [1] + [0;@Inf@] ; [1] + [0;5] ; [1] + [0;1] ; [1] + [0;0] ; [0] + @NaN@ ; [0] + -@Inf@ ; [0] + @Inf@ ; [0] + 5 ; [0] + 1 ; [0] + 0 ; [0] + [@NaN@] ; [0] + [-@Inf@] ; [0] + [@Inf@] ; [0] + [5] ; [0] + [1] ; [0] + [0] ; [0] + [@NaN@;@NaN@] ; [0] + [@NaN@;-@Inf@] ; [0] + [@NaN@;@Inf@] ; [0] + [@NaN@;5] ; [0] + [@NaN@;1] ; [0] + [@NaN@;0] ; [0] + [-@Inf@;@NaN@] ; [0] + [-@Inf@;-@Inf@] ; [0] + [-@Inf@;@Inf@] ; [0] + [-@Inf@;5] ; [0] + [-@Inf@;1] ; [0] + [-@Inf@;0] ; [0] + [@Inf@;@NaN@] ; [0] + [@Inf@;-@Inf@] ; [0] + [@Inf@;@Inf@] ; [0] + [@Inf@;5] ; [0] + [@Inf@;1] ; [0] + [@Inf@;0] ; [0] + [5;@NaN@] ; [0] + [5;-@Inf@] ; [0] + [5;@Inf@] ; [0] + [5;5] ; [0] + [5;1] ; [0] + [5;0] ; [0] + [1;@NaN@] ; [0] + [1;-@Inf@] ; [0] + [1;@Inf@] ; [0] + [1;5] ; [0] + [1;1] ; [0] + [1;0] ; [0] + [0;@NaN@] ; [0] + [0;-@Inf@] ; [0] + [0;@Inf@] ; [0] + [0;5] ; [0] + [0;1] ; [0] + [0;0] ; [@NaN@;@NaN@] + @NaN@ ; [@NaN@;@NaN@] + -@Inf@ ; [@NaN@;@NaN@] + @Inf@ ; [@NaN@;@NaN@] + 5 ; [@NaN@;@NaN@] + 1 ; [@NaN@;@NaN@] + 0 ; [@NaN@;@NaN@] + [@NaN@] ; [@NaN@;@NaN@] + [-@Inf@] ; [@NaN@;@NaN@] + [@Inf@] ; [@NaN@;@NaN@] + [5] ; [@NaN@;@NaN@] + [1] ; [@NaN@;@NaN@] + [0] ; [@NaN@;@NaN@] + [@NaN@;@NaN@] ; [@NaN@;@NaN@] + [@NaN@;-@Inf@] ; [@NaN@;@NaN@] + [@NaN@;@Inf@] ; [@NaN@;@NaN@] + [@NaN@;5] ; [@NaN@;@NaN@] + [@NaN@;1] ; [@NaN@;@NaN@] + [@NaN@;0] ; [@NaN@;@NaN@] + [-@Inf@;@NaN@] ; [@NaN@;@NaN@] + [-@Inf@;-@Inf@] ; [@NaN@;@NaN@] + [-@Inf@;@Inf@] ; [@NaN@;@NaN@] + [-@Inf@;5] ; [@NaN@;@NaN@] + [-@Inf@;1] ; [@NaN@;@NaN@] + [-@Inf@;0] ; [@NaN@;@NaN@] + [@Inf@;@NaN@] ; [@NaN@;@NaN@] + [@Inf@;-@Inf@] ; [@NaN@;@NaN@] + [@Inf@;@Inf@] ; [@NaN@;@NaN@] + [@Inf@;5] ; [@NaN@;@NaN@] + [@Inf@;1] ; [@NaN@;@NaN@] + [@Inf@;0] ; [@NaN@;@NaN@] + [5;@NaN@] ; [@NaN@;@NaN@] + [5;-@Inf@] ; [@NaN@;@NaN@] + [5;@Inf@] ; [@NaN@;@NaN@] + [5;5] ; [@NaN@;@NaN@] + [5;1] ; [@NaN@;@NaN@] + [5;0] ; [@NaN@;@NaN@] + [1;@NaN@] ; [@NaN@;@NaN@] + [1;-@Inf@] ; [@NaN@;@NaN@] + [1;@Inf@] ; [@NaN@;@NaN@] + [1;5] ; [@NaN@;@NaN@] + [1;1] ; [@NaN@;@NaN@] + [1;0] ; [@NaN@;@NaN@] + [0;@NaN@] ; [@NaN@;@NaN@] + [0;-@Inf@] ; [@NaN@;@NaN@] + [0;@Inf@] ; [@NaN@;@NaN@] + [0;5] ; [@NaN@;@NaN@] + [0;1] ; [@NaN@;@NaN@] + [0;0] ; [@NaN@;-@Inf@] + @NaN@ ; [@NaN@;-@Inf@] + -@Inf@ ; [@NaN@;-@Inf@] + @Inf@ ; [@NaN@;-@Inf@] + 5 ; [@NaN@;-@Inf@] + 1 ; [@NaN@;-@Inf@] + 0 ; [@NaN@;-@Inf@] + [@NaN@] ; [@NaN@;-@Inf@] + [-@Inf@] ; [@NaN@;-@Inf@] + [@Inf@] ; [@NaN@;-@Inf@] + [5] ; [@NaN@;-@Inf@] + [1] ; [@NaN@;-@Inf@] + [0] ; [@NaN@;-@Inf@] + [@NaN@;@NaN@] ; [@NaN@;-@Inf@] + [@NaN@;-@Inf@] ; [@NaN@;-@Inf@] + [@NaN@;@Inf@] ; [@NaN@;-@Inf@] + [@NaN@;5] ; [@NaN@;-@Inf@] + [@NaN@;1] ; [@NaN@;-@Inf@] + [@NaN@;0] ; [@NaN@;-@Inf@] + [-@Inf@;@NaN@] ; [@NaN@;-@Inf@] + [-@Inf@;-@Inf@] ; [@NaN@;-@Inf@] + [-@Inf@;@Inf@] ; [@NaN@;-@Inf@] + [-@Inf@;5] ; [@NaN@;-@Inf@] + [-@Inf@;1] ; [@NaN@;-@Inf@] + [-@Inf@;0] ; [@NaN@;-@Inf@] + [@Inf@;@NaN@] ; [@NaN@;-@Inf@] + [@Inf@;-@Inf@] ; [@NaN@;-@Inf@] + [@Inf@;@Inf@] ; [@NaN@;-@Inf@] + [@Inf@;5] ; [@NaN@;-@Inf@] + [@Inf@;1] ; [@NaN@;-@Inf@] + [@Inf@;0] ; [@NaN@;-@Inf@] + [5;@NaN@] ; [@NaN@;-@Inf@] + [5;-@Inf@] ; [@NaN@;-@Inf@] + [5;@Inf@] ; [@NaN@;-@Inf@] + [5;5] ; [@NaN@;-@Inf@] + [5;1] ; [@NaN@;-@Inf@] + [5;0] ; [@NaN@;-@Inf@] + [1;@NaN@] ; [@NaN@;-@Inf@] + [1;-@Inf@] ; [@NaN@;-@Inf@] + [1;@Inf@] ; [@NaN@;-@Inf@] + [1;5] ; [@NaN@;-@Inf@] + [1;1] ; [@NaN@;-@Inf@] + [1;0] ; [@NaN@;-@Inf@] + [0;@NaN@] ; [@NaN@;-@Inf@] + [0;-@Inf@] ; [@NaN@;-@Inf@] + [0;@Inf@] ; [@NaN@;-@Inf@] + [0;5] ; [@NaN@;-@Inf@] + [0;1] ; [@NaN@;-@Inf@] + [0;0] ; [@NaN@;@Inf@] + @NaN@ ; [@NaN@;@Inf@] + -@Inf@ ; [@NaN@;@Inf@] + @Inf@ ; [@NaN@;@Inf@] + 5 ; [@NaN@;@Inf@] + 1 ; [@NaN@;@Inf@] + 0 ; [@NaN@;@Inf@] + [@NaN@] ; [@NaN@;@Inf@] + [-@Inf@] ; [@NaN@;@Inf@] + [@Inf@] ; [@NaN@;@Inf@] + [5] ; [@NaN@;@Inf@] + [1] ; [@NaN@;@Inf@] + [0] ; [@NaN@;@Inf@] + [@NaN@;@NaN@] ; [@NaN@;@Inf@] + [@NaN@;-@Inf@] ; [@NaN@;@Inf@] + [@NaN@;@Inf@] ; [@NaN@;@Inf@] + [@NaN@;5] ; [@NaN@;@Inf@] + [@NaN@;1] ; [@NaN@;@Inf@] + [@NaN@;0] ; [@NaN@;@Inf@] + [-@Inf@;@NaN@] ; [@NaN@;@Inf@] + [-@Inf@;-@Inf@] ; [@NaN@;@Inf@] + [-@Inf@;@Inf@] ; [@NaN@;@Inf@] + [-@Inf@;5] ; [@NaN@;@Inf@] + [-@Inf@;1] ; [@NaN@;@Inf@] + [-@Inf@;0] ; [@NaN@;@Inf@] + [@Inf@;@NaN@] ; [@NaN@;@Inf@] + [@Inf@;-@Inf@] ; [@NaN@;@Inf@] + [@Inf@;@Inf@] ; [@NaN@;@Inf@] + [@Inf@;5] ; [@NaN@;@Inf@] + [@Inf@;1] ; [@NaN@;@Inf@] + [@Inf@;0] ; [@NaN@;@Inf@] + [5;@NaN@] ; [@NaN@;@Inf@] + [5;-@Inf@] ; [@NaN@;@Inf@] + [5;@Inf@] ; [@NaN@;@Inf@] + [5;5] ; [@NaN@;@Inf@] + [5;1] ; [@NaN@;@Inf@] + [5;0] ; [@NaN@;@Inf@] + [1;@NaN@] ; [@NaN@;@Inf@] + [1;-@Inf@] ; [@NaN@;@Inf@] + [1;@Inf@] ; [@NaN@;@Inf@] + [1;5] ; [@NaN@;@Inf@] + [1;1] ; [@NaN@;@Inf@] + [1;0] ; [@NaN@;@Inf@] + [0;@NaN@] ; [@NaN@;@Inf@] + [0;-@Inf@] ; [@NaN@;@Inf@] + [0;@Inf@] ; [@NaN@;@Inf@] + [0;5] ; [@NaN@;@Inf@] + [0;1] ; [@NaN@;@Inf@] + [0;0] ; [@NaN@;5] + @NaN@ ; [@NaN@;5] + -@Inf@ ; [@NaN@;5] + @Inf@ ; [@NaN@;5] + 5 ; [@NaN@;5] + 1 ; [@NaN@;5] + 0 ; [@NaN@;5] + [@NaN@] ; [@NaN@;5] + [-@Inf@] ; [@NaN@;5] + [@Inf@] ; [@NaN@;5] + [5] ; [@NaN@;5] + [1] ; [@NaN@;5] + [0] ; [@NaN@;5] + [@NaN@;@NaN@] ; [@NaN@;5] + [@NaN@;-@Inf@] ; [@NaN@;5] + [@NaN@;@Inf@] ; [@NaN@;5] + [@NaN@;5] ; [@NaN@;5] + [@NaN@;1] ; [@NaN@;5] + [@NaN@;0] ; [@NaN@;5] + [-@Inf@;@NaN@] ; [@NaN@;5] + [-@Inf@;-@Inf@] ; [@NaN@;5] + [-@Inf@;@Inf@] ; [@NaN@;5] + [-@Inf@;5] ; [@NaN@;5] + [-@Inf@;1] ; [@NaN@;5] + [-@Inf@;0] ; [@NaN@;5] + [@Inf@;@NaN@] ; [@NaN@;5] + [@Inf@;-@Inf@] ; [@NaN@;5] + [@Inf@;@Inf@] ; [@NaN@;5] + [@Inf@;5] ; [@NaN@;5] + [@Inf@;1] ; [@NaN@;5] + [@Inf@;0] ; [@NaN@;5] + [5;@NaN@] ; [@NaN@;5] + [5;-@Inf@] ; [@NaN@;5] + [5;@Inf@] ; [@NaN@;5] + [5;5] ; [@NaN@;5] + [5;1] ; [@NaN@;5] + [5;0] ; [@NaN@;5] + [1;@NaN@] ; [@NaN@;5] + [1;-@Inf@] ; [@NaN@;5] + [1;@Inf@] ; [@NaN@;5] + [1;5] ; [@NaN@;5] + [1;1] ; [@NaN@;5] + [1;0] ; [@NaN@;5] + [0;@NaN@] ; [@NaN@;5] + [0;-@Inf@] ; [@NaN@;5] + [0;@Inf@] ; [@NaN@;5] + [0;5] ; [@NaN@;5] + [0;1] ; [@NaN@;5] + [0;0] ; [@NaN@;1] + @NaN@ ; [@NaN@;1] + -@Inf@ ; [@NaN@;1] + @Inf@ ; [@NaN@;1] + 5 ; [@NaN@;1] + 1 ; [@NaN@;1] + 0 ; [@NaN@;1] + [@NaN@] ; [@NaN@;1] + [-@Inf@] ; [@NaN@;1] + [@Inf@] ; [@NaN@;1] + [5] ; [@NaN@;1] + [1] ; [@NaN@;1] + [0] ; [@NaN@;1] + [@NaN@;@NaN@] ; [@NaN@;1] + [@NaN@;-@Inf@] ; [@NaN@;1] + [@NaN@;@Inf@] ; [@NaN@;1] + [@NaN@;5] ; [@NaN@;1] + [@NaN@;1] ; [@NaN@;1] + [@NaN@;0] ; [@NaN@;1] + [-@Inf@;@NaN@] ; [@NaN@;1] + [-@Inf@;-@Inf@] ; [@NaN@;1] + [-@Inf@;@Inf@] ; [@NaN@;1] + [-@Inf@;5] ; [@NaN@;1] + [-@Inf@;1] ; [@NaN@;1] + [-@Inf@;0] ; [@NaN@;1] + [@Inf@;@NaN@] ; [@NaN@;1] + [@Inf@;-@Inf@] ; [@NaN@;1] + [@Inf@;@Inf@] ; [@NaN@;1] + [@Inf@;5] ; [@NaN@;1] + [@Inf@;1] ; [@NaN@;1] + [@Inf@;0] ; [@NaN@;1] + [5;@NaN@] ; [@NaN@;1] + [5;-@Inf@] ; [@NaN@;1] + [5;@Inf@] ; [@NaN@;1] + [5;5] ; [@NaN@;1] + [5;1] ; [@NaN@;1] + [5;0] ; [@NaN@;1] + [1;@NaN@] ; [@NaN@;1] + [1;-@Inf@] ; [@NaN@;1] + [1;@Inf@] ; [@NaN@;1] + [1;5] ; [@NaN@;1] + [1;1] ; [@NaN@;1] + [1;0] ; [@NaN@;1] + [0;@NaN@] ; [@NaN@;1] + [0;-@Inf@] ; [@NaN@;1] + [0;@Inf@] ; [@NaN@;1] + [0;5] ; [@NaN@;1] + [0;1] ; [@NaN@;1] + [0;0] ; [@NaN@;0] + @NaN@ ; [@NaN@;0] + -@Inf@ ; [@NaN@;0] + @Inf@ ; [@NaN@;0] + 5 ; [@NaN@;0] + 1 ; [@NaN@;0] + 0 ; [@NaN@;0] + [@NaN@] ; [@NaN@;0] + [-@Inf@] ; [@NaN@;0] + [@Inf@] ; [@NaN@;0] + [5] ; [@NaN@;0] + [1] ; [@NaN@;0] + [0] ; [@NaN@;0] + [@NaN@;@NaN@] ; [@NaN@;0] + [@NaN@;-@Inf@] ; [@NaN@;0] + [@NaN@;@Inf@] ; [@NaN@;0] + [@NaN@;5] ; [@NaN@;0] + [@NaN@;1] ; [@NaN@;0] + [@NaN@;0] ; [@NaN@;0] + [-@Inf@;@NaN@] ; [@NaN@;0] + [-@Inf@;-@Inf@] ; [@NaN@;0] + [-@Inf@;@Inf@] ; [@NaN@;0] + [-@Inf@;5] ; [@NaN@;0] + [-@Inf@;1] ; [@NaN@;0] + [-@Inf@;0] ; [@NaN@;0] + [@Inf@;@NaN@] ; [@NaN@;0] + [@Inf@;-@Inf@] ; [@NaN@;0] + [@Inf@;@Inf@] ; [@NaN@;0] + [@Inf@;5] ; [@NaN@;0] + [@Inf@;1] ; [@NaN@;0] + [@Inf@;0] ; [@NaN@;0] + [5;@NaN@] ; [@NaN@;0] + [5;-@Inf@] ; [@NaN@;0] + [5;@Inf@] ; [@NaN@;0] + [5;5] ; [@NaN@;0] + [5;1] ; [@NaN@;0] + [5;0] ; [@NaN@;0] + [1;@NaN@] ; [@NaN@;0] + [1;-@Inf@] ; [@NaN@;0] + [1;@Inf@] ; [@NaN@;0] + [1;5] ; [@NaN@;0] + [1;1] ; [@NaN@;0] + [1;0] ; [@NaN@;0] + [0;@NaN@] ; [@NaN@;0] + [0;-@Inf@] ; [@NaN@;0] + [0;@Inf@] ; [@NaN@;0] + [0;5] ; [@NaN@;0] + [0;1] ; [@NaN@;0] + [0;0] ; [-@Inf@;@NaN@] + @NaN@ ; [-@Inf@;@NaN@] + -@Inf@ ; [-@Inf@;@NaN@] + @Inf@ ; [-@Inf@;@NaN@] + 5 ; [-@Inf@;@NaN@] + 1 ; [-@Inf@;@NaN@] + 0 ; [-@Inf@;@NaN@] + [@NaN@] ; [-@Inf@;@NaN@] + [-@Inf@] ; [-@Inf@;@NaN@] + [@Inf@] ; [-@Inf@;@NaN@] + [5] ; [-@Inf@;@NaN@] + [1] ; [-@Inf@;@NaN@] + [0] ; [-@Inf@;@NaN@] + [@NaN@;@NaN@] ; [-@Inf@;@NaN@] + [@NaN@;-@Inf@] ; [-@Inf@;@NaN@] + [@NaN@;@Inf@] ; [-@Inf@;@NaN@] + [@NaN@;5] ; [-@Inf@;@NaN@] + [@NaN@;1] ; [-@Inf@;@NaN@] + [@NaN@;0] ; [-@Inf@;@NaN@] + [-@Inf@;@NaN@] ; [-@Inf@;@NaN@] + [-@Inf@;-@Inf@] ; [-@Inf@;@NaN@] + [-@Inf@;@Inf@] ; [-@Inf@;@NaN@] + [-@Inf@;5] ; [-@Inf@;@NaN@] + [-@Inf@;1] ; [-@Inf@;@NaN@] + [-@Inf@;0] ; [-@Inf@;@NaN@] + [@Inf@;@NaN@] ; [-@Inf@;@NaN@] + [@Inf@;-@Inf@] ; [-@Inf@;@NaN@] + [@Inf@;@Inf@] ; [-@Inf@;@NaN@] + [@Inf@;5] ; [-@Inf@;@NaN@] + [@Inf@;1] ; [-@Inf@;@NaN@] + [@Inf@;0] ; [-@Inf@;@NaN@] + [5;@NaN@] ; [-@Inf@;@NaN@] + [5;-@Inf@] ; [-@Inf@;@NaN@] + [5;@Inf@] ; [-@Inf@;@NaN@] + [5;5] ; [-@Inf@;@NaN@] + [5;1] ; [-@Inf@;@NaN@] + [5;0] ; [-@Inf@;@NaN@] + [1;@NaN@] ; [-@Inf@;@NaN@] + [1;-@Inf@] ; [-@Inf@;@NaN@] + [1;@Inf@] ; [-@Inf@;@NaN@] + [1;5] ; [-@Inf@;@NaN@] + [1;1] ; [-@Inf@;@NaN@] + [1;0] ; [-@Inf@;@NaN@] + [0;@NaN@] ; [-@Inf@;@NaN@] + [0;-@Inf@] ; [-@Inf@;@NaN@] + [0;@Inf@] ; [-@Inf@;@NaN@] + [0;5] ; [-@Inf@;@NaN@] + [0;1] ; [-@Inf@;@NaN@] + [0;0] ; [-@Inf@;-@Inf@] + @NaN@ ; [-@Inf@;-@Inf@] + -@Inf@ ; [-@Inf@;-@Inf@] + @Inf@ ; [-@Inf@;-@Inf@] + 5 ; [-@Inf@;-@Inf@] + 1 ; [-@Inf@;-@Inf@] + 0 ; [-@Inf@;-@Inf@] + [@NaN@] ; [-@Inf@;-@Inf@] + [-@Inf@] ; [-@Inf@;-@Inf@] + [@Inf@] ; [-@Inf@;-@Inf@] + [5] ; [-@Inf@;-@Inf@] + [1] ; [-@Inf@;-@Inf@] + [0] ; [-@Inf@;-@Inf@] + [@NaN@;@NaN@] ; [-@Inf@;-@Inf@] + [@NaN@;-@Inf@] ; [-@Inf@;-@Inf@] + [@NaN@;@Inf@] ; [-@Inf@;-@Inf@] + [@NaN@;5] ; [-@Inf@;-@Inf@] + [@NaN@;1] ; [-@Inf@;-@Inf@] + [@NaN@;0] ; [-@Inf@;-@Inf@] + [-@Inf@;@NaN@] ; [-@Inf@;-@Inf@] + [-@Inf@;-@Inf@] ; [-@Inf@;-@Inf@] + [-@Inf@;@Inf@] ; [-@Inf@;-@Inf@] + [-@Inf@;5] ; [-@Inf@;-@Inf@] + [-@Inf@;1] ; [-@Inf@;-@Inf@] + [-@Inf@;0] ; [-@Inf@;-@Inf@] + [@Inf@;@NaN@] ; [-@Inf@;-@Inf@] + [@Inf@;-@Inf@] ; [-@Inf@;-@Inf@] + [@Inf@;@Inf@] ; [-@Inf@;-@Inf@] + [@Inf@;5] ; [-@Inf@;-@Inf@] + [@Inf@;1] ; [-@Inf@;-@Inf@] + [@Inf@;0] ; [-@Inf@;-@Inf@] + [5;@NaN@] ; [-@Inf@;-@Inf@] + [5;-@Inf@] ; [-@Inf@;-@Inf@] + [5;@Inf@] ; [-@Inf@;-@Inf@] + [5;5] ; [-@Inf@;-@Inf@] + [5;1] ; [-@Inf@;-@Inf@] + [5;0] ; [-@Inf@;-@Inf@] + [1;@NaN@] ; [-@Inf@;-@Inf@] + [1;-@Inf@] ; [-@Inf@;-@Inf@] + [1;@Inf@] ; [-@Inf@;-@Inf@] + [1;5] ; [-@Inf@;-@Inf@] + [1;1] ; [-@Inf@;-@Inf@] + [1;0] ; [-@Inf@;-@Inf@] + [0;@NaN@] ; [-@Inf@;-@Inf@] + [0;-@Inf@] ; [-@Inf@;-@Inf@] + [0;@Inf@] ; [-@Inf@;-@Inf@] + [0;5] ; [-@Inf@;-@Inf@] + [0;1] ; [-@Inf@;-@Inf@] + [0;0] ; [-@Inf@;@Inf@] + @NaN@ ; [-@Inf@;@Inf@] + -@Inf@ ; [-@Inf@;@Inf@] + @Inf@ ; [-@Inf@;@Inf@] + 5 ; [-@Inf@;@Inf@] + 1 ; [-@Inf@;@Inf@] + 0 ; [-@Inf@;@Inf@] + [@NaN@] ; [-@Inf@;@Inf@] + [-@Inf@] ; [-@Inf@;@Inf@] + [@Inf@] ; [-@Inf@;@Inf@] + [5] ; [-@Inf@;@Inf@] + [1] ; [-@Inf@;@Inf@] + [0] ; [-@Inf@;@Inf@] + [@NaN@;@NaN@] ; [-@Inf@;@Inf@] + [@NaN@;-@Inf@] ; [-@Inf@;@Inf@] + [@NaN@;@Inf@] ; [-@Inf@;@Inf@] + [@NaN@;5] ; [-@Inf@;@Inf@] + [@NaN@;1] ; [-@Inf@;@Inf@] + [@NaN@;0] ; [-@Inf@;@Inf@] + [-@Inf@;@NaN@] ; [-@Inf@;@Inf@] + [-@Inf@;-@Inf@] ; [-@Inf@;@Inf@] + [-@Inf@;@Inf@] ; [-@Inf@;@Inf@] + [-@Inf@;5] ; [-@Inf@;@Inf@] + [-@Inf@;1] ; [-@Inf@;@Inf@] + [-@Inf@;0] ; [-@Inf@;@Inf@] + [@Inf@;@NaN@] ; [-@Inf@;@Inf@] + [@Inf@;-@Inf@] ; [-@Inf@;@Inf@] + [@Inf@;@Inf@] ; [-@Inf@;@Inf@] + [@Inf@;5] ; [-@Inf@;@Inf@] + [@Inf@;1] ; [-@Inf@;@Inf@] + [@Inf@;0] ; [-@Inf@;@Inf@] + [5;@NaN@] ; [-@Inf@;@Inf@] + [5;-@Inf@] ; [-@Inf@;@Inf@] + [5;@Inf@] ; [-@Inf@;@Inf@] + [5;5] ; [-@Inf@;@Inf@] + [5;1] ; [-@Inf@;@Inf@] + [5;0] ; [-@Inf@;@Inf@] + [1;@NaN@] ; [-@Inf@;@Inf@] + [1;-@Inf@] ; [-@Inf@;@Inf@] + [1;@Inf@] ; [-@Inf@;@Inf@] + [1;5] ; [-@Inf@;@Inf@] + [1;1] ; [-@Inf@;@Inf@] + [1;0] ; [-@Inf@;@Inf@] + [0;@NaN@] ; [-@Inf@;@Inf@] + [0;-@Inf@] ; [-@Inf@;@Inf@] + [0;@Inf@] ; [-@Inf@;@Inf@] + [0;5] ; [-@Inf@;@Inf@] + [0;1] ; [-@Inf@;@Inf@] + [0;0] ; [-@Inf@;5] + @NaN@ ; [-@Inf@;5] + -@Inf@ ; [-@Inf@;5] + @Inf@ ; [-@Inf@;5] + 5 ; [-@Inf@;5] + 1 ; [-@Inf@;5] + 0 ; [-@Inf@;5] + [@NaN@] ; [-@Inf@;5] + [-@Inf@] ; [-@Inf@;5] + [@Inf@] ; [-@Inf@;5] + [5] ; [-@Inf@;5] + [1] ; [-@Inf@;5] + [0] ; [-@Inf@;5] + [@NaN@;@NaN@] ; [-@Inf@;5] + [@NaN@;-@Inf@] ; [-@Inf@;5] + [@NaN@;@Inf@] ; [-@Inf@;5] + [@NaN@;5] ; [-@Inf@;5] + [@NaN@;1] ; [-@Inf@;5] + [@NaN@;0] ; [-@Inf@;5] + [-@Inf@;@NaN@] ; [-@Inf@;5] + [-@Inf@;-@Inf@] ; [-@Inf@;5] + [-@Inf@;@Inf@] ; [-@Inf@;5] + [-@Inf@;5] ; [-@Inf@;5] + [-@Inf@;1] ; [-@Inf@;5] + [-@Inf@;0] ; [-@Inf@;5] + [@Inf@;@NaN@] ; [-@Inf@;5] + [@Inf@;-@Inf@] ; [-@Inf@;5] + [@Inf@;@Inf@] ; [-@Inf@;5] + [@Inf@;5] ; [-@Inf@;5] + [@Inf@;1] ; [-@Inf@;5] + [@Inf@;0] ; [-@Inf@;5] + [5;@NaN@] ; [-@Inf@;5] + [5;-@Inf@] ; [-@Inf@;5] + [5;@Inf@] ; [-@Inf@;5] + [5;5] ; [-@Inf@;5] + [5;1] ; [-@Inf@;5] + [5;0] ; [-@Inf@;5] + [1;@NaN@] ; [-@Inf@;5] + [1;-@Inf@] ; [-@Inf@;5] + [1;@Inf@] ; [-@Inf@;5] + [1;5] ; [-@Inf@;5] + [1;1] ; [-@Inf@;5] + [1;0] ; [-@Inf@;5] + [0;@NaN@] ; [-@Inf@;5] + [0;-@Inf@] ; [-@Inf@;5] + [0;@Inf@] ; [-@Inf@;5] + [0;5] ; [-@Inf@;5] + [0;1] ; [-@Inf@;5] + [0;0] ; [-@Inf@;1] + @NaN@ ; [-@Inf@;1] + -@Inf@ ; [-@Inf@;1] + @Inf@ ; [-@Inf@;1] + 5 ; [-@Inf@;1] + 1 ; [-@Inf@;1] + 0 ; [-@Inf@;1] + [@NaN@] ; [-@Inf@;1] + [-@Inf@] ; [-@Inf@;1] + [@Inf@] ; [-@Inf@;1] + [5] ; [-@Inf@;1] + [1] ; [-@Inf@;1] + [0] ; [-@Inf@;1] + [@NaN@;@NaN@] ; [-@Inf@;1] + [@NaN@;-@Inf@] ; [-@Inf@;1] + [@NaN@;@Inf@] ; [-@Inf@;1] + [@NaN@;5] ; [-@Inf@;1] + [@NaN@;1] ; [-@Inf@;1] + [@NaN@;0] ; [-@Inf@;1] + [-@Inf@;@NaN@] ; [-@Inf@;1] + [-@Inf@;-@Inf@] ; [-@Inf@;1] + [-@Inf@;@Inf@] ; [-@Inf@;1] + [-@Inf@;5] ; [-@Inf@;1] + [-@Inf@;1] ; [-@Inf@;1] + [-@Inf@;0] ; [-@Inf@;1] + [@Inf@;@NaN@] ; [-@Inf@;1] + [@Inf@;-@Inf@] ; [-@Inf@;1] + [@Inf@;@Inf@] ; [-@Inf@;1] + [@Inf@;5] ; [-@Inf@;1] + [@Inf@;1] ; [-@Inf@;1] + [@Inf@;0] ; [-@Inf@;1] + [5;@NaN@] ; [-@Inf@;1] + [5;-@Inf@] ; [-@Inf@;1] + [5;@Inf@] ; [-@Inf@;1] + [5;5] ; [-@Inf@;1] + [5;1] ; [-@Inf@;1] + [5;0] ; [-@Inf@;1] + [1;@NaN@] ; [-@Inf@;1] + [1;-@Inf@] ; [-@Inf@;1] + [1;@Inf@] ; [-@Inf@;1] + [1;5] ; [-@Inf@;1] + [1;1] ; [-@Inf@;1] + [1;0] ; [-@Inf@;1] + [0;@NaN@] ; [-@Inf@;1] + [0;-@Inf@] ; [-@Inf@;1] + [0;@Inf@] ; [-@Inf@;1] + [0;5] ; [-@Inf@;1] + [0;1] ; [-@Inf@;1] + [0;0] ; [-@Inf@;0] + @NaN@ ; [-@Inf@;0] + -@Inf@ ; [-@Inf@;0] + @Inf@ ; [-@Inf@;0] + 5 ; [-@Inf@;0] + 1 ; [-@Inf@;0] + 0 ; [-@Inf@;0] + [@NaN@] ; [-@Inf@;0] + [-@Inf@] ; [-@Inf@;0] + [@Inf@] ; [-@Inf@;0] + [5] ; [-@Inf@;0] + [1] ; [-@Inf@;0] + [0] ; [-@Inf@;0] + [@NaN@;@NaN@] ; [-@Inf@;0] + [@NaN@;-@Inf@] ; [-@Inf@;0] + [@NaN@;@Inf@] ; [-@Inf@;0] + [@NaN@;5] ; [-@Inf@;0] + [@NaN@;1] ; [-@Inf@;0] + [@NaN@;0] ; [-@Inf@;0] + [-@Inf@;@NaN@] ; [-@Inf@;0] + [-@Inf@;-@Inf@] ; [-@Inf@;0] + [-@Inf@;@Inf@] ; [-@Inf@;0] + [-@Inf@;5] ; [-@Inf@;0] + [-@Inf@;1] ; [-@Inf@;0] + [-@Inf@;0] ; [-@Inf@;0] + [@Inf@;@NaN@] ; [-@Inf@;0] + [@Inf@;-@Inf@] ; [-@Inf@;0] + [@Inf@;@Inf@] ; [-@Inf@;0] + [@Inf@;5] ; [-@Inf@;0] + [@Inf@;1] ; [-@Inf@;0] + [@Inf@;0] ; [-@Inf@;0] + [5;@NaN@] ; [-@Inf@;0] + [5;-@Inf@] ; [-@Inf@;0] + [5;@Inf@] ; [-@Inf@;0] + [5;5] ; [-@Inf@;0] + [5;1] ; [-@Inf@;0] + [5;0] ; [-@Inf@;0] + [1;@NaN@] ; [-@Inf@;0] + [1;-@Inf@] ; [-@Inf@;0] + [1;@Inf@] ; [-@Inf@;0] + [1;5] ; [-@Inf@;0] + [1;1] ; [-@Inf@;0] + [1;0] ; [-@Inf@;0] + [0;@NaN@] ; [-@Inf@;0] + [0;-@Inf@] ; [-@Inf@;0] + [0;@Inf@] ; [-@Inf@;0] + [0;5] ; [-@Inf@;0] + [0;1] ; [-@Inf@;0] + [0;0] ; [@Inf@;@NaN@] + @NaN@ ; [@Inf@;@NaN@] + -@Inf@ ; [@Inf@;@NaN@] + @Inf@ ; [@Inf@;@NaN@] + 5 ; [@Inf@;@NaN@] + 1 ; [@Inf@;@NaN@] + 0 ; [@Inf@;@NaN@] + [@NaN@] ; [@Inf@;@NaN@] + [-@Inf@] ; [@Inf@;@NaN@] + [@Inf@] ; [@Inf@;@NaN@] + [5] ; [@Inf@;@NaN@] + [1] ; [@Inf@;@NaN@] + [0] ; [@Inf@;@NaN@] + [@NaN@;@NaN@] ; [@Inf@;@NaN@] + [@NaN@;-@Inf@] ; [@Inf@;@NaN@] + [@NaN@;@Inf@] ; [@Inf@;@NaN@] + [@NaN@;5] ; [@Inf@;@NaN@] + [@NaN@;1] ; [@Inf@;@NaN@] + [@NaN@;0] ; [@Inf@;@NaN@] + [-@Inf@;@NaN@] ; [@Inf@;@NaN@] + [-@Inf@;-@Inf@] ; [@Inf@;@NaN@] + [-@Inf@;@Inf@] ; [@Inf@;@NaN@] + [-@Inf@;5] ; [@Inf@;@NaN@] + [-@Inf@;1] ; [@Inf@;@NaN@] + [-@Inf@;0] ; [@Inf@;@NaN@] + [@Inf@;@NaN@] ; [@Inf@;@NaN@] + [@Inf@;-@Inf@] ; [@Inf@;@NaN@] + [@Inf@;@Inf@] ; [@Inf@;@NaN@] + [@Inf@;5] ; [@Inf@;@NaN@] + [@Inf@;1] ; [@Inf@;@NaN@] + [@Inf@;0] ; [@Inf@;@NaN@] + [5;@NaN@] ; [@Inf@;@NaN@] + [5;-@Inf@] ; [@Inf@;@NaN@] + [5;@Inf@] ; [@Inf@;@NaN@] + [5;5] ; [@Inf@;@NaN@] + [5;1] ; [@Inf@;@NaN@] + [5;0] ; [@Inf@;@NaN@] + [1;@NaN@] ; [@Inf@;@NaN@] + [1;-@Inf@] ; [@Inf@;@NaN@] + [1;@Inf@] ; [@Inf@;@NaN@] + [1;5] ; [@Inf@;@NaN@] + [1;1] ; [@Inf@;@NaN@] + [1;0] ; [@Inf@;@NaN@] + [0;@NaN@] ; [@Inf@;@NaN@] + [0;-@Inf@] ; [@Inf@;@NaN@] + [0;@Inf@] ; [@Inf@;@NaN@] + [0;5] ; [@Inf@;@NaN@] + [0;1] ; [@Inf@;@NaN@] + [0;0] ; [@Inf@;-@Inf@] + @NaN@ ; [@Inf@;-@Inf@] + -@Inf@ ; [@Inf@;-@Inf@] + @Inf@ ; [@Inf@;-@Inf@] + 5 ; [@Inf@;-@Inf@] + 1 ; [@Inf@;-@Inf@] + 0 ; [@Inf@;-@Inf@] + [@NaN@] ; [@Inf@;-@Inf@] + [-@Inf@] ; [@Inf@;-@Inf@] + [@Inf@] ; [@Inf@;-@Inf@] + [5] ; [@Inf@;-@Inf@] + [1] ; [@Inf@;-@Inf@] + [0] ; [@Inf@;-@Inf@] + [@NaN@;@NaN@] ; [@Inf@;-@Inf@] + [@NaN@;-@Inf@] ; [@Inf@;-@Inf@] + [@NaN@;@Inf@] ; [@Inf@;-@Inf@] + [@NaN@;5] ; [@Inf@;-@Inf@] + [@NaN@;1] ; [@Inf@;-@Inf@] + [@NaN@;0] ; [@Inf@;-@Inf@] + [-@Inf@;@NaN@] ; [@Inf@;-@Inf@] + [-@Inf@;-@Inf@] ; [@Inf@;-@Inf@] + [-@Inf@;@Inf@] ; [@Inf@;-@Inf@] + [-@Inf@;5] ; [@Inf@;-@Inf@] + [-@Inf@;1] ; [@Inf@;-@Inf@] + [-@Inf@;0] ; [@Inf@;-@Inf@] + [@Inf@;@NaN@] ; [@Inf@;-@Inf@] + [@Inf@;-@Inf@] ; [@Inf@;-@Inf@] + [@Inf@;@Inf@] ; [@Inf@;-@Inf@] + [@Inf@;5] ; [@Inf@;-@Inf@] + [@Inf@;1] ; [@Inf@;-@Inf@] + [@Inf@;0] ; [@Inf@;-@Inf@] + [5;@NaN@] ; [@Inf@;-@Inf@] + [5;-@Inf@] ; [@Inf@;-@Inf@] + [5;@Inf@] ; [@Inf@;-@Inf@] + [5;5] ; [@Inf@;-@Inf@] + [5;1] ; [@Inf@;-@Inf@] + [5;0] ; [@Inf@;-@Inf@] + [1;@NaN@] ; [@Inf@;-@Inf@] + [1;-@Inf@] ; [@Inf@;-@Inf@] + [1;@Inf@] ; [@Inf@;-@Inf@] + [1;5] ; [@Inf@;-@Inf@] + [1;1] ; [@Inf@;-@Inf@] + [1;0] ; [@Inf@;-@Inf@] + [0;@NaN@] ; [@Inf@;-@Inf@] + [0;-@Inf@] ; [@Inf@;-@Inf@] + [0;@Inf@] ; [@Inf@;-@Inf@] + [0;5] ; [@Inf@;-@Inf@] + [0;1] ; [@Inf@;-@Inf@] + [0;0] ; [@Inf@;@Inf@] + @NaN@ ; [@Inf@;@Inf@] + -@Inf@ ; [@Inf@;@Inf@] + @Inf@ ; [@Inf@;@Inf@] + 5 ; [@Inf@;@Inf@] + 1 ; [@Inf@;@Inf@] + 0 ; [@Inf@;@Inf@] + [@NaN@] ; [@Inf@;@Inf@] + [-@Inf@] ; [@Inf@;@Inf@] + [@Inf@] ; [@Inf@;@Inf@] + [5] ; [@Inf@;@Inf@] + [1] ; [@Inf@;@Inf@] + [0] ; [@Inf@;@Inf@] + [@NaN@;@NaN@] ; [@Inf@;@Inf@] + [@NaN@;-@Inf@] ; [@Inf@;@Inf@] + [@NaN@;@Inf@] ; [@Inf@;@Inf@] + [@NaN@;5] ; [@Inf@;@Inf@] + [@NaN@;1] ; [@Inf@;@Inf@] + [@NaN@;0] ; [@Inf@;@Inf@] + [-@Inf@;@NaN@] ; [@Inf@;@Inf@] + [-@Inf@;-@Inf@] ; [@Inf@;@Inf@] + [-@Inf@;@Inf@] ; [@Inf@;@Inf@] + [-@Inf@;5] ; [@Inf@;@Inf@] + [-@Inf@;1] ; [@Inf@;@Inf@] + [-@Inf@;0] ; [@Inf@;@Inf@] + [@Inf@;@NaN@] ; [@Inf@;@Inf@] + [@Inf@;-@Inf@] ; [@Inf@;@Inf@] + [@Inf@;@Inf@] ; [@Inf@;@Inf@] + [@Inf@;5] ; [@Inf@;@Inf@] + [@Inf@;1] ; [@Inf@;@Inf@] + [@Inf@;0] ; [@Inf@;@Inf@] + [5;@NaN@] ; [@Inf@;@Inf@] + [5;-@Inf@] ; [@Inf@;@Inf@] + [5;@Inf@] ; [@Inf@;@Inf@] + [5;5] ; [@Inf@;@Inf@] + [5;1] ; [@Inf@;@Inf@] + [5;0] ; [@Inf@;@Inf@] + [1;@NaN@] ; [@Inf@;@Inf@] + [1;-@Inf@] ; [@Inf@;@Inf@] + [1;@Inf@] ; [@Inf@;@Inf@] + [1;5] ; [@Inf@;@Inf@] + [1;1] ; [@Inf@;@Inf@] + [1;0] ; [@Inf@;@Inf@] + [0;@NaN@] ; [@Inf@;@Inf@] + [0;-@Inf@] ; [@Inf@;@Inf@] + [0;@Inf@] ; [@Inf@;@Inf@] + [0;5] ; [@Inf@;@Inf@] + [0;1] ; [@Inf@;@Inf@] + [0;0] ; [@Inf@;5] + @NaN@ ; [@Inf@;5] + -@Inf@ ; [@Inf@;5] + @Inf@ ; [@Inf@;5] + 5 ; [@Inf@;5] + 1 ; [@Inf@;5] + 0 ; [@Inf@;5] + [@NaN@] ; [@Inf@;5] + [-@Inf@] ; [@Inf@;5] + [@Inf@] ; [@Inf@;5] + [5] ; [@Inf@;5] + [1] ; [@Inf@;5] + [0] ; [@Inf@;5] + [@NaN@;@NaN@] ; [@Inf@;5] + [@NaN@;-@Inf@] ; [@Inf@;5] + [@NaN@;@Inf@] ; [@Inf@;5] + [@NaN@;5] ; [@Inf@;5] + [@NaN@;1] ; [@Inf@;5] + [@NaN@;0] ; [@Inf@;5] + [-@Inf@;@NaN@] ; [@Inf@;5] + [-@Inf@;-@Inf@] ; [@Inf@;5] + [-@Inf@;@Inf@] ; [@Inf@;5] + [-@Inf@;5] ; [@Inf@;5] + [-@Inf@;1] ; [@Inf@;5] + [-@Inf@;0] ; [@Inf@;5] + [@Inf@;@NaN@] ; [@Inf@;5] + [@Inf@;-@Inf@] ; [@Inf@;5] + [@Inf@;@Inf@] ; [@Inf@;5] + [@Inf@;5] ; [@Inf@;5] + [@Inf@;1] ; [@Inf@;5] + [@Inf@;0] ; [@Inf@;5] + [5;@NaN@] ; [@Inf@;5] + [5;-@Inf@] ; [@Inf@;5] + [5;@Inf@] ; [@Inf@;5] + [5;5] ; [@Inf@;5] + [5;1] ; [@Inf@;5] + [5;0] ; [@Inf@;5] + [1;@NaN@] ; [@Inf@;5] + [1;-@Inf@] ; [@Inf@;5] + [1;@Inf@] ; [@Inf@;5] + [1;5] ; [@Inf@;5] + [1;1] ; [@Inf@;5] + [1;0] ; [@Inf@;5] + [0;@NaN@] ; [@Inf@;5] + [0;-@Inf@] ; [@Inf@;5] + [0;@Inf@] ; [@Inf@;5] + [0;5] ; [@Inf@;5] + [0;1] ; [@Inf@;5] + [0;0] ; [@Inf@;1] + @NaN@ ; [@Inf@;1] + -@Inf@ ; [@Inf@;1] + @Inf@ ; [@Inf@;1] + 5 ; [@Inf@;1] + 1 ; [@Inf@;1] + 0 ; [@Inf@;1] + [@NaN@] ; [@Inf@;1] + [-@Inf@] ; [@Inf@;1] + [@Inf@] ; [@Inf@;1] + [5] ; [@Inf@;1] + [1] ; [@Inf@;1] + [0] ; [@Inf@;1] + [@NaN@;@NaN@] ; [@Inf@;1] + [@NaN@;-@Inf@] ; [@Inf@;1] + [@NaN@;@Inf@] ; [@Inf@;1] + [@NaN@;5] ; [@Inf@;1] + [@NaN@;1] ; [@Inf@;1] + [@NaN@;0] ; [@Inf@;1] + [-@Inf@;@NaN@] ; [@Inf@;1] + [-@Inf@;-@Inf@] ; [@Inf@;1] + [-@Inf@;@Inf@] ; [@Inf@;1] + [-@Inf@;5] ; [@Inf@;1] + [-@Inf@;1] ; [@Inf@;1] + [-@Inf@;0] ; [@Inf@;1] + [@Inf@;@NaN@] ; [@Inf@;1] + [@Inf@;-@Inf@] ; [@Inf@;1] + [@Inf@;@Inf@] ; [@Inf@;1] + [@Inf@;5] ; [@Inf@;1] + [@Inf@;1] ; [@Inf@;1] + [@Inf@;0] ; [@Inf@;1] + [5;@NaN@] ; [@Inf@;1] + [5;-@Inf@] ; [@Inf@;1] + [5;@Inf@] ; [@Inf@;1] + [5;5] ; [@Inf@;1] + [5;1] ; [@Inf@;1] + [5;0] ; [@Inf@;1] + [1;@NaN@] ; [@Inf@;1] + [1;-@Inf@] ; [@Inf@;1] + [1;@Inf@] ; [@Inf@;1] + [1;5] ; [@Inf@;1] + [1;1] ; [@Inf@;1] + [1;0] ; [@Inf@;1] + [0;@NaN@] ; [@Inf@;1] + [0;-@Inf@] ; [@Inf@;1] + [0;@Inf@] ; [@Inf@;1] + [0;5] ; [@Inf@;1] + [0;1] ; [@Inf@;1] + [0;0] ; [@Inf@;0] + @NaN@ ; [@Inf@;0] + -@Inf@ ; [@Inf@;0] + @Inf@ ; [@Inf@;0] + 5 ; [@Inf@;0] + 1 ; [@Inf@;0] + 0 ; [@Inf@;0] + [@NaN@] ; [@Inf@;0] + [-@Inf@] ; [@Inf@;0] + [@Inf@] ; [@Inf@;0] + [5] ; [@Inf@;0] + [1] ; [@Inf@;0] + [0] ; [@Inf@;0] + [@NaN@;@NaN@] ; [@Inf@;0] + [@NaN@;-@Inf@] ; [@Inf@;0] + [@NaN@;@Inf@] ; [@Inf@;0] + [@NaN@;5] ; [@Inf@;0] + [@NaN@;1] ; [@Inf@;0] + [@NaN@;0] ; [@Inf@;0] + [-@Inf@;@NaN@] ; [@Inf@;0] + [-@Inf@;-@Inf@] ; [@Inf@;0] + [-@Inf@;@Inf@] ; [@Inf@;0] + [-@Inf@;5] ; [@Inf@;0] + [-@Inf@;1] ; [@Inf@;0] + [-@Inf@;0] ; [@Inf@;0] + [@Inf@;@NaN@] ; [@Inf@;0] + [@Inf@;-@Inf@] ; [@Inf@;0] + [@Inf@;@Inf@] ; [@Inf@;0] + [@Inf@;5] ; [@Inf@;0] + [@Inf@;1] ; [@Inf@;0] + [@Inf@;0] ; [@Inf@;0] + [5;@NaN@] ; [@Inf@;0] + [5;-@Inf@] ; [@Inf@;0] + [5;@Inf@] ; [@Inf@;0] + [5;5] ; [@Inf@;0] + [5;1] ; [@Inf@;0] + [5;0] ; [@Inf@;0] + [1;@NaN@] ; [@Inf@;0] + [1;-@Inf@] ; [@Inf@;0] + [1;@Inf@] ; [@Inf@;0] + [1;5] ; [@Inf@;0] + [1;1] ; [@Inf@;0] + [1;0] ; [@Inf@;0] + [0;@NaN@] ; [@Inf@;0] + [0;-@Inf@] ; [@Inf@;0] + [0;@Inf@] ; [@Inf@;0] + [0;5] ; [@Inf@;0] + [0;1] ; [@Inf@;0] + [0;0] ; [5;@NaN@] + @NaN@ ; [5;@NaN@] + -@Inf@ ; [5;@NaN@] + @Inf@ ; [5;@NaN@] + 5 ; [5;@NaN@] + 1 ; [5;@NaN@] + 0 ; [5;@NaN@] + [@NaN@] ; [5;@NaN@] + [-@Inf@] ; [5;@NaN@] + [@Inf@] ; [5;@NaN@] + [5] ; [5;@NaN@] + [1] ; [5;@NaN@] + [0] ; [5;@NaN@] + [@NaN@;@NaN@] ; [5;@NaN@] + [@NaN@;-@Inf@] ; [5;@NaN@] + [@NaN@;@Inf@] ; [5;@NaN@] + [@NaN@;5] ; [5;@NaN@] + [@NaN@;1] ; [5;@NaN@] + [@NaN@;0] ; [5;@NaN@] + [-@Inf@;@NaN@] ; [5;@NaN@] + [-@Inf@;-@Inf@] ; [5;@NaN@] + [-@Inf@;@Inf@] ; [5;@NaN@] + [-@Inf@;5] ; [5;@NaN@] + [-@Inf@;1] ; [5;@NaN@] + [-@Inf@;0] ; [5;@NaN@] + [@Inf@;@NaN@] ; [5;@NaN@] + [@Inf@;-@Inf@] ; [5;@NaN@] + [@Inf@;@Inf@] ; [5;@NaN@] + [@Inf@;5] ; [5;@NaN@] + [@Inf@;1] ; [5;@NaN@] + [@Inf@;0] ; [5;@NaN@] + [5;@NaN@] ; [5;@NaN@] + [5;-@Inf@] ; [5;@NaN@] + [5;@Inf@] ; [5;@NaN@] + [5;5] ; [5;@NaN@] + [5;1] ; [5;@NaN@] + [5;0] ; [5;@NaN@] + [1;@NaN@] ; [5;@NaN@] + [1;-@Inf@] ; [5;@NaN@] + [1;@Inf@] ; [5;@NaN@] + [1;5] ; [5;@NaN@] + [1;1] ; [5;@NaN@] + [1;0] ; [5;@NaN@] + [0;@NaN@] ; [5;@NaN@] + [0;-@Inf@] ; [5;@NaN@] + [0;@Inf@] ; [5;@NaN@] + [0;5] ; [5;@NaN@] + [0;1] ; [5;@NaN@] + [0;0] ; [5;-@Inf@] + @NaN@ ; [5;-@Inf@] + -@Inf@ ; [5;-@Inf@] + @Inf@ ; [5;-@Inf@] + 5 ; [5;-@Inf@] + 1 ; [5;-@Inf@] + 0 ; [5;-@Inf@] + [@NaN@] ; [5;-@Inf@] + [-@Inf@] ; [5;-@Inf@] + [@Inf@] ; [5;-@Inf@] + [5] ; [5;-@Inf@] + [1] ; [5;-@Inf@] + [0] ; [5;-@Inf@] + [@NaN@;@NaN@] ; [5;-@Inf@] + [@NaN@;-@Inf@] ; [5;-@Inf@] + [@NaN@;@Inf@] ; [5;-@Inf@] + [@NaN@;5] ; [5;-@Inf@] + [@NaN@;1] ; [5;-@Inf@] + [@NaN@;0] ; [5;-@Inf@] + [-@Inf@;@NaN@] ; [5;-@Inf@] + [-@Inf@;-@Inf@] ; [5;-@Inf@] + [-@Inf@;@Inf@] ; [5;-@Inf@] + [-@Inf@;5] ; [5;-@Inf@] + [-@Inf@;1] ; [5;-@Inf@] + [-@Inf@;0] ; [5;-@Inf@] + [@Inf@;@NaN@] ; [5;-@Inf@] + [@Inf@;-@Inf@] ; [5;-@Inf@] + [@Inf@;@Inf@] ; [5;-@Inf@] + [@Inf@;5] ; [5;-@Inf@] + [@Inf@;1] ; [5;-@Inf@] + [@Inf@;0] ; [5;-@Inf@] + [5;@NaN@] ; [5;-@Inf@] + [5;-@Inf@] ; [5;-@Inf@] + [5;@Inf@] ; [5;-@Inf@] + [5;5] ; [5;-@Inf@] + [5;1] ; [5;-@Inf@] + [5;0] ; [5;-@Inf@] + [1;@NaN@] ; [5;-@Inf@] + [1;-@Inf@] ; [5;-@Inf@] + [1;@Inf@] ; [5;-@Inf@] + [1;5] ; [5;-@Inf@] + [1;1] ; [5;-@Inf@] + [1;0] ; [5;-@Inf@] + [0;@NaN@] ; [5;-@Inf@] + [0;-@Inf@] ; [5;-@Inf@] + [0;@Inf@] ; [5;-@Inf@] + [0;5] ; [5;-@Inf@] + [0;1] ; [5;-@Inf@] + [0;0] ; [5;@Inf@] + @NaN@ ; [5;@Inf@] + -@Inf@ ; [5;@Inf@] + @Inf@ ; [5;@Inf@] + 5 ; [5;@Inf@] + 1 ; [5;@Inf@] + 0 ; [5;@Inf@] + [@NaN@] ; [5;@Inf@] + [-@Inf@] ; [5;@Inf@] + [@Inf@] ; [5;@Inf@] + [5] ; [5;@Inf@] + [1] ; [5;@Inf@] + [0] ; [5;@Inf@] + [@NaN@;@NaN@] ; [5;@Inf@] + [@NaN@;-@Inf@] ; [5;@Inf@] + [@NaN@;@Inf@] ; [5;@Inf@] + [@NaN@;5] ; [5;@Inf@] + [@NaN@;1] ; [5;@Inf@] + [@NaN@;0] ; [5;@Inf@] + [-@Inf@;@NaN@] ; [5;@Inf@] + [-@Inf@;-@Inf@] ; [5;@Inf@] + [-@Inf@;@Inf@] ; [5;@Inf@] + [-@Inf@;5] ; [5;@Inf@] + [-@Inf@;1] ; [5;@Inf@] + [-@Inf@;0] ; [5;@Inf@] + [@Inf@;@NaN@] ; [5;@Inf@] + [@Inf@;-@Inf@] ; [5;@Inf@] + [@Inf@;@Inf@] ; [5;@Inf@] + [@Inf@;5] ; [5;@Inf@] + [@Inf@;1] ; [5;@Inf@] + [@Inf@;0] ; [5;@Inf@] + [5;@NaN@] ; [5;@Inf@] + [5;-@Inf@] ; [5;@Inf@] + [5;@Inf@] ; [5;@Inf@] + [5;5] ; [5;@Inf@] + [5;1] ; [5;@Inf@] + [5;0] ; [5;@Inf@] + [1;@NaN@] ; [5;@Inf@] + [1;-@Inf@] ; [5;@Inf@] + [1;@Inf@] ; [5;@Inf@] + [1;5] ; [5;@Inf@] + [1;1] ; [5;@Inf@] + [1;0] ; [5;@Inf@] + [0;@NaN@] ; [5;@Inf@] + [0;-@Inf@] ; [5;@Inf@] + [0;@Inf@] ; [5;@Inf@] + [0;5] ; [5;@Inf@] + [0;1] ; [5;@Inf@] + [0;0] ; [5;5] + @NaN@ ; [5;5] + -@Inf@ ; [5;5] + @Inf@ ; [5;5] + 5 ; [5;5] + 1 ; [5;5] + 0 ; [5;5] + [@NaN@] ; [5;5] + [-@Inf@] ; [5;5] + [@Inf@] ; [5;5] + [5] ; [5;5] + [1] ; [5;5] + [0] ; [5;5] + [@NaN@;@NaN@] ; [5;5] + [@NaN@;-@Inf@] ; [5;5] + [@NaN@;@Inf@] ; [5;5] + [@NaN@;5] ; [5;5] + [@NaN@;1] ; [5;5] + [@NaN@;0] ; [5;5] + [-@Inf@;@NaN@] ; [5;5] + [-@Inf@;-@Inf@] ; [5;5] + [-@Inf@;@Inf@] ; [5;5] + [-@Inf@;5] ; [5;5] + [-@Inf@;1] ; [5;5] + [-@Inf@;0] ; [5;5] + [@Inf@;@NaN@] ; [5;5] + [@Inf@;-@Inf@] ; [5;5] + [@Inf@;@Inf@] ; [5;5] + [@Inf@;5] ; [5;5] + [@Inf@;1] ; [5;5] + [@Inf@;0] ; [5;5] + [5;@NaN@] ; [5;5] + [5;-@Inf@] ; [5;5] + [5;@Inf@] ; [5;5] + [5;5] ; [5;5] + [5;1] ; [5;5] + [5;0] ; [5;5] + [1;@NaN@] ; [5;5] + [1;-@Inf@] ; [5;5] + [1;@Inf@] ; [5;5] + [1;5] ; [5;5] + [1;1] ; [5;5] + [1;0] ; [5;5] + [0;@NaN@] ; [5;5] + [0;-@Inf@] ; [5;5] + [0;@Inf@] ; [5;5] + [0;5] ; [5;5] + [0;1] ; [5;5] + [0;0] ; [5;1] + @NaN@ ; [5;1] + -@Inf@ ; [5;1] + @Inf@ ; [5;1] + 5 ; [5;1] + 1 ; [5;1] + 0 ; [5;1] + [@NaN@] ; [5;1] + [-@Inf@] ; [5;1] + [@Inf@] ; [5;1] + [5] ; [5;1] + [1] ; [5;1] + [0] ; [5;1] + [@NaN@;@NaN@] ; [5;1] + [@NaN@;-@Inf@] ; [5;1] + [@NaN@;@Inf@] ; [5;1] + [@NaN@;5] ; [5;1] + [@NaN@;1] ; [5;1] + [@NaN@;0] ; [5;1] + [-@Inf@;@NaN@] ; [5;1] + [-@Inf@;-@Inf@] ; [5;1] + [-@Inf@;@Inf@] ; [5;1] + [-@Inf@;5] ; [5;1] + [-@Inf@;1] ; [5;1] + [-@Inf@;0] ; [5;1] + [@Inf@;@NaN@] ; [5;1] + [@Inf@;-@Inf@] ; [5;1] + [@Inf@;@Inf@] ; [5;1] + [@Inf@;5] ; [5;1] + [@Inf@;1] ; [5;1] + [@Inf@;0] ; [5;1] + [5;@NaN@] ; [5;1] + [5;-@Inf@] ; [5;1] + [5;@Inf@] ; [5;1] + [5;5] ; [5;1] + [5;1] ; [5;1] + [5;0] ; [5;1] + [1;@NaN@] ; [5;1] + [1;-@Inf@] ; [5;1] + [1;@Inf@] ; [5;1] + [1;5] ; [5;1] + [1;1] ; [5;1] + [1;0] ; [5;1] + [0;@NaN@] ; [5;1] + [0;-@Inf@] ; [5;1] + [0;@Inf@] ; [5;1] + [0;5] ; [5;1] + [0;1] ; [5;1] + [0;0] ; [5;0] + @NaN@ ; [5;0] + -@Inf@ ; [5;0] + @Inf@ ; [5;0] + 5 ; [5;0] + 1 ; [5;0] + 0 ; [5;0] + [@NaN@] ; [5;0] + [-@Inf@] ; [5;0] + [@Inf@] ; [5;0] + [5] ; [5;0] + [1] ; [5;0] + [0] ; [5;0] + [@NaN@;@NaN@] ; [5;0] + [@NaN@;-@Inf@] ; [5;0] + [@NaN@;@Inf@] ; [5;0] + [@NaN@;5] ; [5;0] + [@NaN@;1] ; [5;0] + [@NaN@;0] ; [5;0] + [-@Inf@;@NaN@] ; [5;0] + [-@Inf@;-@Inf@] ; [5;0] + [-@Inf@;@Inf@] ; [5;0] + [-@Inf@;5] ; [5;0] + [-@Inf@;1] ; [5;0] + [-@Inf@;0] ; [5;0] + [@Inf@;@NaN@] ; [5;0] + [@Inf@;-@Inf@] ; [5;0] + [@Inf@;@Inf@] ; [5;0] + [@Inf@;5] ; [5;0] + [@Inf@;1] ; [5;0] + [@Inf@;0] ; [5;0] + [5;@NaN@] ; [5;0] + [5;-@Inf@] ; [5;0] + [5;@Inf@] ; [5;0] + [5;5] ; [5;0] + [5;1] ; [5;0] + [5;0] ; [5;0] + [1;@NaN@] ; [5;0] + [1;-@Inf@] ; [5;0] + [1;@Inf@] ; [5;0] + [1;5] ; [5;0] + [1;1] ; [5;0] + [1;0] ; [5;0] + [0;@NaN@] ; [5;0] + [0;-@Inf@] ; [5;0] + [0;@Inf@] ; [5;0] + [0;5] ; [5;0] + [0;1] ; [5;0] + [0;0] ; [1;@NaN@] + @NaN@ ; [1;@NaN@] + -@Inf@ ; [1;@NaN@] + @Inf@ ; [1;@NaN@] + 5 ; [1;@NaN@] + 1 ; [1;@NaN@] + 0 ; [1;@NaN@] + [@NaN@] ; [1;@NaN@] + [-@Inf@] ; [1;@NaN@] + [@Inf@] ; [1;@NaN@] + [5] ; [1;@NaN@] + [1] ; [1;@NaN@] + [0] ; [1;@NaN@] + [@NaN@;@NaN@] ; [1;@NaN@] + [@NaN@;-@Inf@] ; [1;@NaN@] + [@NaN@;@Inf@] ; [1;@NaN@] + [@NaN@;5] ; [1;@NaN@] + [@NaN@;1] ; [1;@NaN@] + [@NaN@;0] ; [1;@NaN@] + [-@Inf@;@NaN@] ; [1;@NaN@] + [-@Inf@;-@Inf@] ; [1;@NaN@] + [-@Inf@;@Inf@] ; [1;@NaN@] + [-@Inf@;5] ; [1;@NaN@] + [-@Inf@;1] ; [1;@NaN@] + [-@Inf@;0] ; [1;@NaN@] + [@Inf@;@NaN@] ; [1;@NaN@] + [@Inf@;-@Inf@] ; [1;@NaN@] + [@Inf@;@Inf@] ; [1;@NaN@] + [@Inf@;5] ; [1;@NaN@] + [@Inf@;1] ; [1;@NaN@] + [@Inf@;0] ; [1;@NaN@] + [5;@NaN@] ; [1;@NaN@] + [5;-@Inf@] ; [1;@NaN@] + [5;@Inf@] ; [1;@NaN@] + [5;5] ; [1;@NaN@] + [5;1] ; [1;@NaN@] + [5;0] ; [1;@NaN@] + [1;@NaN@] ; [1;@NaN@] + [1;-@Inf@] ; [1;@NaN@] + [1;@Inf@] ; [1;@NaN@] + [1;5] ; [1;@NaN@] + [1;1] ; [1;@NaN@] + [1;0] ; [1;@NaN@] + [0;@NaN@] ; [1;@NaN@] + [0;-@Inf@] ; [1;@NaN@] + [0;@Inf@] ; [1;@NaN@] + [0;5] ; [1;@NaN@] + [0;1] ; [1;@NaN@] + [0;0] ; [1;-@Inf@] + @NaN@ ; [1;-@Inf@] + -@Inf@ ; [1;-@Inf@] + @Inf@ ; [1;-@Inf@] + 5 ; [1;-@Inf@] + 1 ; [1;-@Inf@] + 0 ; [1;-@Inf@] + [@NaN@] ; [1;-@Inf@] + [-@Inf@] ; [1;-@Inf@] + [@Inf@] ; [1;-@Inf@] + [5] ; [1;-@Inf@] + [1] ; [1;-@Inf@] + [0] ; [1;-@Inf@] + [@NaN@;@NaN@] ; [1;-@Inf@] + [@NaN@;-@Inf@] ; [1;-@Inf@] + [@NaN@;@Inf@] ; [1;-@Inf@] + [@NaN@;5] ; [1;-@Inf@] + [@NaN@;1] ; [1;-@Inf@] + [@NaN@;0] ; [1;-@Inf@] + [-@Inf@;@NaN@] ; [1;-@Inf@] + [-@Inf@;-@Inf@] ; [1;-@Inf@] + [-@Inf@;@Inf@] ; [1;-@Inf@] + [-@Inf@;5] ; [1;-@Inf@] + [-@Inf@;1] ; [1;-@Inf@] + [-@Inf@;0] ; [1;-@Inf@] + [@Inf@;@NaN@] ; [1;-@Inf@] + [@Inf@;-@Inf@] ; [1;-@Inf@] + [@Inf@;@Inf@] ; [1;-@Inf@] + [@Inf@;5] ; [1;-@Inf@] + [@Inf@;1] ; [1;-@Inf@] + [@Inf@;0] ; [1;-@Inf@] + [5;@NaN@] ; [1;-@Inf@] + [5;-@Inf@] ; [1;-@Inf@] + [5;@Inf@] ; [1;-@Inf@] + [5;5] ; [1;-@Inf@] + [5;1] ; [1;-@Inf@] + [5;0] ; [1;-@Inf@] + [1;@NaN@] ; [1;-@Inf@] + [1;-@Inf@] ; [1;-@Inf@] + [1;@Inf@] ; [1;-@Inf@] + [1;5] ; [1;-@Inf@] + [1;1] ; [1;-@Inf@] + [1;0] ; [1;-@Inf@] + [0;@NaN@] ; [1;-@Inf@] + [0;-@Inf@] ; [1;-@Inf@] + [0;@Inf@] ; [1;-@Inf@] + [0;5] ; [1;-@Inf@] + [0;1] ; [1;-@Inf@] + [0;0] ; [1;@Inf@] + @NaN@ ; [1;@Inf@] + -@Inf@ ; [1;@Inf@] + @Inf@ ; [1;@Inf@] + 5 ; [1;@Inf@] + 1 ; [1;@Inf@] + 0 ; [1;@Inf@] + [@NaN@] ; [1;@Inf@] + [-@Inf@] ; [1;@Inf@] + [@Inf@] ; [1;@Inf@] + [5] ; [1;@Inf@] + [1] ; [1;@Inf@] + [0] ; [1;@Inf@] + [@NaN@;@NaN@] ; [1;@Inf@] + [@NaN@;-@Inf@] ; [1;@Inf@] + [@NaN@;@Inf@] ; [1;@Inf@] + [@NaN@;5] ; [1;@Inf@] + [@NaN@;1] ; [1;@Inf@] + [@NaN@;0] ; [1;@Inf@] + [-@Inf@;@NaN@] ; [1;@Inf@] + [-@Inf@;-@Inf@] ; [1;@Inf@] + [-@Inf@;@Inf@] ; [1;@Inf@] + [-@Inf@;5] ; [1;@Inf@] + [-@Inf@;1] ; [1;@Inf@] + [-@Inf@;0] ; [1;@Inf@] + [@Inf@;@NaN@] ; [1;@Inf@] + [@Inf@;-@Inf@] ; [1;@Inf@] + [@Inf@;@Inf@] ; [1;@Inf@] + [@Inf@;5] ; [1;@Inf@] + [@Inf@;1] ; [1;@Inf@] + [@Inf@;0] ; [1;@Inf@] + [5;@NaN@] ; [1;@Inf@] + [5;-@Inf@] ; [1;@Inf@] + [5;@Inf@] ; [1;@Inf@] + [5;5] ; [1;@Inf@] + [5;1] ; [1;@Inf@] + [5;0] ; [1;@Inf@] + [1;@NaN@] ; [1;@Inf@] + [1;-@Inf@] ; [1;@Inf@] + [1;@Inf@] ; [1;@Inf@] + [1;5] ; [1;@Inf@] + [1;1] ; [1;@Inf@] + [1;0] ; [1;@Inf@] + [0;@NaN@] ; [1;@Inf@] + [0;-@Inf@] ; [1;@Inf@] + [0;@Inf@] ; [1;@Inf@] + [0;5] ; [1;@Inf@] + [0;1] ; [1;@Inf@] + [0;0] ; [1;5] + @NaN@ ; [1;5] + -@Inf@ ; [1;5] + @Inf@ ; [1;5] + 5 ; [1;5] + 1 ; [1;5] + 0 ; [1;5] + [@NaN@] ; [1;5] + [-@Inf@] ; [1;5] + [@Inf@] ; [1;5] + [5] ; [1;5] + [1] ; [1;5] + [0] ; [1;5] + [@NaN@;@NaN@] ; [1;5] + [@NaN@;-@Inf@] ; [1;5] + [@NaN@;@Inf@] ; [1;5] + [@NaN@;5] ; [1;5] + [@NaN@;1] ; [1;5] + [@NaN@;0] ; [1;5] + [-@Inf@;@NaN@] ; [1;5] + [-@Inf@;-@Inf@] ; [1;5] + [-@Inf@;@Inf@] ; [1;5] + [-@Inf@;5] ; [1;5] + [-@Inf@;1] ; [1;5] + [-@Inf@;0] ; [1;5] + [@Inf@;@NaN@] ; [1;5] + [@Inf@;-@Inf@] ; [1;5] + [@Inf@;@Inf@] ; [1;5] + [@Inf@;5] ; [1;5] + [@Inf@;1] ; [1;5] + [@Inf@;0] ; [1;5] + [5;@NaN@] ; [1;5] + [5;-@Inf@] ; [1;5] + [5;@Inf@] ; [1;5] + [5;5] ; [1;5] + [5;1] ; [1;5] + [5;0] ; [1;5] + [1;@NaN@] ; [1;5] + [1;-@Inf@] ; [1;5] + [1;@Inf@] ; [1;5] + [1;5] ; [1;5] + [1;1] ; [1;5] + [1;0] ; [1;5] + [0;@NaN@] ; [1;5] + [0;-@Inf@] ; [1;5] + [0;@Inf@] ; [1;5] + [0;5] ; [1;5] + [0;1] ; [1;5] + [0;0] ; [1;1] + @NaN@ ; [1;1] + -@Inf@ ; [1;1] + @Inf@ ; [1;1] + 5 ; [1;1] + 1 ; [1;1] + 0 ; [1;1] + [@NaN@] ; [1;1] + [-@Inf@] ; [1;1] + [@Inf@] ; [1;1] + [5] ; [1;1] + [1] ; [1;1] + [0] ; [1;1] + [@NaN@;@NaN@] ; [1;1] + [@NaN@;-@Inf@] ; [1;1] + [@NaN@;@Inf@] ; [1;1] + [@NaN@;5] ; [1;1] + [@NaN@;1] ; [1;1] + [@NaN@;0] ; [1;1] + [-@Inf@;@NaN@] ; [1;1] + [-@Inf@;-@Inf@] ; [1;1] + [-@Inf@;@Inf@] ; [1;1] + [-@Inf@;5] ; [1;1] + [-@Inf@;1] ; [1;1] + [-@Inf@;0] ; [1;1] + [@Inf@;@NaN@] ; [1;1] + [@Inf@;-@Inf@] ; [1;1] + [@Inf@;@Inf@] ; [1;1] + [@Inf@;5] ; [1;1] + [@Inf@;1] ; [1;1] + [@Inf@;0] ; [1;1] + [5;@NaN@] ; [1;1] + [5;-@Inf@] ; [1;1] + [5;@Inf@] ; [1;1] + [5;5] ; [1;1] + [5;1] ; [1;1] + [5;0] ; [1;1] + [1;@NaN@] ; [1;1] + [1;-@Inf@] ; [1;1] + [1;@Inf@] ; [1;1] + [1;5] ; [1;1] + [1;1] ; [1;1] + [1;0] ; [1;1] + [0;@NaN@] ; [1;1] + [0;-@Inf@] ; [1;1] + [0;@Inf@] ; [1;1] + [0;5] ; [1;1] + [0;1] ; [1;1] + [0;0] ; [1;0] + @NaN@ ; [1;0] + -@Inf@ ; [1;0] + @Inf@ ; [1;0] + 5 ; [1;0] + 1 ; [1;0] + 0 ; [1;0] + [@NaN@] ; [1;0] + [-@Inf@] ; [1;0] + [@Inf@] ; [1;0] + [5] ; [1;0] + [1] ; [1;0] + [0] ; [1;0] + [@NaN@;@NaN@] ; [1;0] + [@NaN@;-@Inf@] ; [1;0] + [@NaN@;@Inf@] ; [1;0] + [@NaN@;5] ; [1;0] + [@NaN@;1] ; [1;0] + [@NaN@;0] ; [1;0] + [-@Inf@;@NaN@] ; [1;0] + [-@Inf@;-@Inf@] ; [1;0] + [-@Inf@;@Inf@] ; [1;0] + [-@Inf@;5] ; [1;0] + [-@Inf@;1] ; [1;0] + [-@Inf@;0] ; [1;0] + [@Inf@;@NaN@] ; [1;0] + [@Inf@;-@Inf@] ; [1;0] + [@Inf@;@Inf@] ; [1;0] + [@Inf@;5] ; [1;0] + [@Inf@;1] ; [1;0] + [@Inf@;0] ; [1;0] + [5;@NaN@] ; [1;0] + [5;-@Inf@] ; [1;0] + [5;@Inf@] ; [1;0] + [5;5] ; [1;0] + [5;1] ; [1;0] + [5;0] ; [1;0] + [1;@NaN@] ; [1;0] + [1;-@Inf@] ; [1;0] + [1;@Inf@] ; [1;0] + [1;5] ; [1;0] + [1;1] ; [1;0] + [1;0] ; [1;0] + [0;@NaN@] ; [1;0] + [0;-@Inf@] ; [1;0] + [0;@Inf@] ; [1;0] + [0;5] ; [1;0] + [0;1] ; [1;0] + [0;0] ; [0;@NaN@] + @NaN@ ; [0;@NaN@] + -@Inf@ ; [0;@NaN@] + @Inf@ ; [0;@NaN@] + 5 ; [0;@NaN@] + 1 ; [0;@NaN@] + 0 ; [0;@NaN@] + [@NaN@] ; [0;@NaN@] + [-@Inf@] ; [0;@NaN@] + [@Inf@] ; [0;@NaN@] + [5] ; [0;@NaN@] + [1] ; [0;@NaN@] + [0] ; [0;@NaN@] + [@NaN@;@NaN@] ; [0;@NaN@] + [@NaN@;-@Inf@] ; [0;@NaN@] + [@NaN@;@Inf@] ; [0;@NaN@] + [@NaN@;5] ; [0;@NaN@] + [@NaN@;1] ; [0;@NaN@] + [@NaN@;0] ; [0;@NaN@] + [-@Inf@;@NaN@] ; [0;@NaN@] + [-@Inf@;-@Inf@] ; [0;@NaN@] + [-@Inf@;@Inf@] ; [0;@NaN@] + [-@Inf@;5] ; [0;@NaN@] + [-@Inf@;1] ; [0;@NaN@] + [-@Inf@;0] ; [0;@NaN@] + [@Inf@;@NaN@] ; [0;@NaN@] + [@Inf@;-@Inf@] ; [0;@NaN@] + [@Inf@;@Inf@] ; [0;@NaN@] + [@Inf@;5] ; [0;@NaN@] + [@Inf@;1] ; [0;@NaN@] + [@Inf@;0] ; [0;@NaN@] + [5;@NaN@] ; [0;@NaN@] + [5;-@Inf@] ; [0;@NaN@] + [5;@Inf@] ; [0;@NaN@] + [5;5] ; [0;@NaN@] + [5;1] ; [0;@NaN@] + [5;0] ; [0;@NaN@] + [1;@NaN@] ; [0;@NaN@] + [1;-@Inf@] ; [0;@NaN@] + [1;@Inf@] ; [0;@NaN@] + [1;5] ; [0;@NaN@] + [1;1] ; [0;@NaN@] + [1;0] ; [0;@NaN@] + [0;@NaN@] ; [0;@NaN@] + [0;-@Inf@] ; [0;@NaN@] + [0;@Inf@] ; [0;@NaN@] + [0;5] ; [0;@NaN@] + [0;1] ; [0;@NaN@] + [0;0] ; [0;-@Inf@] + @NaN@ ; [0;-@Inf@] + -@Inf@ ; [0;-@Inf@] + @Inf@ ; [0;-@Inf@] + 5 ; [0;-@Inf@] + 1 ; [0;-@Inf@] + 0 ; [0;-@Inf@] + [@NaN@] ; [0;-@Inf@] + [-@Inf@] ; [0;-@Inf@] + [@Inf@] ; [0;-@Inf@] + [5] ; [0;-@Inf@] + [1] ; [0;-@Inf@] + [0] ; [0;-@Inf@] + [@NaN@;@NaN@] ; [0;-@Inf@] + [@NaN@;-@Inf@] ; [0;-@Inf@] + [@NaN@;@Inf@] ; [0;-@Inf@] + [@NaN@;5] ; [0;-@Inf@] + [@NaN@;1] ; [0;-@Inf@] + [@NaN@;0] ; [0;-@Inf@] + [-@Inf@;@NaN@] ; [0;-@Inf@] + [-@Inf@;-@Inf@] ; [0;-@Inf@] + [-@Inf@;@Inf@] ; [0;-@Inf@] + [-@Inf@;5] ; [0;-@Inf@] + [-@Inf@;1] ; [0;-@Inf@] + [-@Inf@;0] ; [0;-@Inf@] + [@Inf@;@NaN@] ; [0;-@Inf@] + [@Inf@;-@Inf@] ; [0;-@Inf@] + [@Inf@;@Inf@] ; [0;-@Inf@] + [@Inf@;5] ; [0;-@Inf@] + [@Inf@;1] ; [0;-@Inf@] + [@Inf@;0] ; [0;-@Inf@] + [5;@NaN@] ; [0;-@Inf@] + [5;-@Inf@] ; [0;-@Inf@] + [5;@Inf@] ; [0;-@Inf@] + [5;5] ; [0;-@Inf@] + [5;1] ; [0;-@Inf@] + [5;0] ; [0;-@Inf@] + [1;@NaN@] ; [0;-@Inf@] + [1;-@Inf@] ; [0;-@Inf@] + [1;@Inf@] ; [0;-@Inf@] + [1;5] ; [0;-@Inf@] + [1;1] ; [0;-@Inf@] + [1;0] ; [0;-@Inf@] + [0;@NaN@] ; [0;-@Inf@] + [0;-@Inf@] ; [0;-@Inf@] + [0;@Inf@] ; [0;-@Inf@] + [0;5] ; [0;-@Inf@] + [0;1] ; [0;-@Inf@] + [0;0] ; [0;@Inf@] + @NaN@ ; [0;@Inf@] + -@Inf@ ; [0;@Inf@] + @Inf@ ; [0;@Inf@] + 5 ; [0;@Inf@] + 1 ; [0;@Inf@] + 0 ; [0;@Inf@] + [@NaN@] ; [0;@Inf@] + [-@Inf@] ; [0;@Inf@] + [@Inf@] ; [0;@Inf@] + [5] ; [0;@Inf@] + [1] ; [0;@Inf@] + [0] ; [0;@Inf@] + [@NaN@;@NaN@] ; [0;@Inf@] + [@NaN@;-@Inf@] ; [0;@Inf@] + [@NaN@;@Inf@] ; [0;@Inf@] + [@NaN@;5] ; [0;@Inf@] + [@NaN@;1] ; [0;@Inf@] + [@NaN@;0] ; [0;@Inf@] + [-@Inf@;@NaN@] ; [0;@Inf@] + [-@Inf@;-@Inf@] ; [0;@Inf@] + [-@Inf@;@Inf@] ; [0;@Inf@] + [-@Inf@;5] ; [0;@Inf@] + [-@Inf@;1] ; [0;@Inf@] + [-@Inf@;0] ; [0;@Inf@] + [@Inf@;@NaN@] ; [0;@Inf@] + [@Inf@;-@Inf@] ; [0;@Inf@] + [@Inf@;@Inf@] ; [0;@Inf@] + [@Inf@;5] ; [0;@Inf@] + [@Inf@;1] ; [0;@Inf@] + [@Inf@;0] ; [0;@Inf@] + [5;@NaN@] ; [0;@Inf@] + [5;-@Inf@] ; [0;@Inf@] + [5;@Inf@] ; [0;@Inf@] + [5;5] ; [0;@Inf@] + [5;1] ; [0;@Inf@] + [5;0] ; [0;@Inf@] + [1;@NaN@] ; [0;@Inf@] + [1;-@Inf@] ; [0;@Inf@] + [1;@Inf@] ; [0;@Inf@] + [1;5] ; [0;@Inf@] + [1;1] ; [0;@Inf@] + [1;0] ; [0;@Inf@] + [0;@NaN@] ; [0;@Inf@] + [0;-@Inf@] ; [0;@Inf@] + [0;@Inf@] ; [0;@Inf@] + [0;5] ; [0;@Inf@] + [0;1] ; [0;@Inf@] + [0;0] ; [0;5] + @NaN@ ; [0;5] + -@Inf@ ; [0;5] + @Inf@ ; [0;5] + 5 ; [0;5] + 1 ; [0;5] + 0 ; [0;5] + [@NaN@] ; [0;5] + [-@Inf@] ; [0;5] + [@Inf@] ; [0;5] + [5] ; [0;5] + [1] ; [0;5] + [0] ; [0;5] + [@NaN@;@NaN@] ; [0;5] + [@NaN@;-@Inf@] ; [0;5] + [@NaN@;@Inf@] ; [0;5] + [@NaN@;5] ; [0;5] + [@NaN@;1] ; [0;5] + [@NaN@;0] ; [0;5] + [-@Inf@;@NaN@] ; [0;5] + [-@Inf@;-@Inf@] ; [0;5] + [-@Inf@;@Inf@] ; [0;5] + [-@Inf@;5] ; [0;5] + [-@Inf@;1] ; [0;5] + [-@Inf@;0] ; [0;5] + [@Inf@;@NaN@] ; [0;5] + [@Inf@;-@Inf@] ; [0;5] + [@Inf@;@Inf@] ; [0;5] + [@Inf@;5] ; [0;5] + [@Inf@;1] ; [0;5] + [@Inf@;0] ; [0;5] + [5;@NaN@] ; [0;5] + [5;-@Inf@] ; [0;5] + [5;@Inf@] ; [0;5] + [5;5] ; [0;5] + [5;1] ; [0;5] + [5;0] ; [0;5] + [1;@NaN@] ; [0;5] + [1;-@Inf@] ; [0;5] + [1;@Inf@] ; [0;5] + [1;5] ; [0;5] + [1;1] ; [0;5] + [1;0] ; [0;5] + [0;@NaN@] ; [0;5] + [0;-@Inf@] ; [0;5] + [0;@Inf@] ; [0;5] + [0;5] ; [0;5] + [0;1] ; [0;5] + [0;0] ; [0;1] + @NaN@ ; [0;1] + -@Inf@ ; [0;1] + @Inf@ ; [0;1] + 5 ; [0;1] + 1 ; [0;1] + 0 ; [0;1] + [@NaN@] ; [0;1] + [-@Inf@] ; [0;1] + [@Inf@] ; [0;1] + [5] ; [0;1] + [1] ; [0;1] + [0] ; [0;1] + [@NaN@;@NaN@] ; [0;1] + [@NaN@;-@Inf@] ; [0;1] + [@NaN@;@Inf@] ; [0;1] + [@NaN@;5] ; [0;1] + [@NaN@;1] ; [0;1] + [@NaN@;0] ; [0;1] + [-@Inf@;@NaN@] ; [0;1] + [-@Inf@;-@Inf@] ; [0;1] + [-@Inf@;@Inf@] ; [0;1] + [-@Inf@;5] ; [0;1] + [-@Inf@;1] ; [0;1] + [-@Inf@;0] ; [0;1] + [@Inf@;@NaN@] ; [0;1] + [@Inf@;-@Inf@] ; [0;1] + [@Inf@;@Inf@] ; [0;1] + [@Inf@;5] ; [0;1] + [@Inf@;1] ; [0;1] + [@Inf@;0] ; [0;1] + [5;@NaN@] ; [0;1] + [5;-@Inf@] ; [0;1] + [5;@Inf@] ; [0;1] + [5;5] ; [0;1] + [5;1] ; [0;1] + [5;0] ; [0;1] + [1;@NaN@] ; [0;1] + [1;-@Inf@] ; [0;1] + [1;@Inf@] ; [0;1] + [1;5] ; [0;1] + [1;1] ; [0;1] + [1;0] ; [0;1] + [0;@NaN@] ; [0;1] + [0;-@Inf@] ; [0;1] + [0;@Inf@] ; [0;1] + [0;5] ; [0;1] + [0;1] ; [0;1] + [0;0] ; [0;0] + @NaN@ ; [0;0] + -@Inf@ ; [0;0] + @Inf@ ; [0;0] + 5 ; [0;0] + 1 ; [0;0] + 0 ; [0;0] + [@NaN@] ; [0;0] + [-@Inf@] ; [0;0] + [@Inf@] ; [0;0] + [5] ; [0;0] + [1] ; [0;0] + [0] ; [0;0] + [@NaN@;@NaN@] ; [0;0] + [@NaN@;-@Inf@] ; [0;0] + [@NaN@;@Inf@] ; [0;0] + [@NaN@;5] ; [0;0] + [@NaN@;1] ; [0;0] + [@NaN@;0] ; [0;0] + [-@Inf@;@NaN@] ; [0;0] + [-@Inf@;-@Inf@] ; [0;0] + [-@Inf@;@Inf@] ; [0;0] + [-@Inf@;5] ; [0;0] + [-@Inf@;1] ; [0;0] + [-@Inf@;0] ; [0;0] + [@Inf@;@NaN@] ; [0;0] + [@Inf@;-@Inf@] ; [0;0] + [@Inf@;@Inf@] ; [0;0] + [@Inf@;5] ; [0;0] + [@Inf@;1] ; [0;0] + [@Inf@;0] ; [0;0] + [5;@NaN@] ; [0;0] + [5;-@Inf@] ; [0;0] + [5;@Inf@] ; [0;0] + [5;5] ; [0;0] + [5;1] ; [0;0] + [5;0] ; [0;0] + [1;@NaN@] ; [0;0] + [1;-@Inf@] ; [0;0] + [1;@Inf@] ; [0;0] + [1;5] ; [0;0] + [1;1] ; [0;0] + [1;0] ; [0;0] + [0;@NaN@] ; [0;0] + [0;-@Inf@] ; [0;0] + [0;@Inf@] ; [0;0] + [0;5] ; [0;0] + [0;1] ; [0;0] + [0;0] ; @NaN@ - @NaN@ ; @NaN@ - -@Inf@ ; @NaN@ - @Inf@ ; @NaN@ - 5 ; @NaN@ - 1 ; @NaN@ - 0 ; @NaN@ - [@NaN@] ; @NaN@ - [-@Inf@] ; @NaN@ - [@Inf@] ; @NaN@ - [5] ; @NaN@ - [1] ; @NaN@ - [0] ; @NaN@ - [@NaN@;@NaN@] ; @NaN@ - [@NaN@;-@Inf@] ; @NaN@ - [@NaN@;@Inf@] ; @NaN@ - [@NaN@;5] ; @NaN@ - [@NaN@;1] ; @NaN@ - [@NaN@;0] ; @NaN@ - [-@Inf@;@NaN@] ; @NaN@ - [-@Inf@;-@Inf@] ; @NaN@ - [-@Inf@;@Inf@] ; @NaN@ - [-@Inf@;5] ; @NaN@ - [-@Inf@;1] ; @NaN@ - [-@Inf@;0] ; @NaN@ - [@Inf@;@NaN@] ; @NaN@ - [@Inf@;-@Inf@] ; @NaN@ - [@Inf@;@Inf@] ; @NaN@ - [@Inf@;5] ; @NaN@ - [@Inf@;1] ; @NaN@ - [@Inf@;0] ; @NaN@ - [5;@NaN@] ; @NaN@ - [5;-@Inf@] ; @NaN@ - [5;@Inf@] ; @NaN@ - [5;5] ; @NaN@ - [5;1] ; @NaN@ - [5;0] ; @NaN@ - [1;@NaN@] ; @NaN@ - [1;-@Inf@] ; @NaN@ - [1;@Inf@] ; @NaN@ - [1;5] ; @NaN@ - [1;1] ; @NaN@ - [1;0] ; @NaN@ - [0;@NaN@] ; @NaN@ - [0;-@Inf@] ; @NaN@ - [0;@Inf@] ; @NaN@ - [0;5] ; @NaN@ - [0;1] ; @NaN@ - [0;0] ; -@Inf@ - @NaN@ ; -@Inf@ - -@Inf@ ; -@Inf@ - @Inf@ ; -@Inf@ - 5 ; -@Inf@ - 1 ; -@Inf@ - 0 ; -@Inf@ - [@NaN@] ; -@Inf@ - [-@Inf@] ; -@Inf@ - [@Inf@] ; -@Inf@ - [5] ; -@Inf@ - [1] ; -@Inf@ - [0] ; -@Inf@ - [@NaN@;@NaN@] ; -@Inf@ - [@NaN@;-@Inf@] ; -@Inf@ - [@NaN@;@Inf@] ; -@Inf@ - [@NaN@;5] ; -@Inf@ - [@NaN@;1] ; -@Inf@ - [@NaN@;0] ; -@Inf@ - [-@Inf@;@NaN@] ; -@Inf@ - [-@Inf@;-@Inf@] ; -@Inf@ - [-@Inf@;@Inf@] ; -@Inf@ - [-@Inf@;5] ; -@Inf@ - [-@Inf@;1] ; -@Inf@ - [-@Inf@;0] ; -@Inf@ - [@Inf@;@NaN@] ; -@Inf@ - [@Inf@;-@Inf@] ; -@Inf@ - [@Inf@;@Inf@] ; -@Inf@ - [@Inf@;5] ; -@Inf@ - [@Inf@;1] ; -@Inf@ - [@Inf@;0] ; -@Inf@ - [5;@NaN@] ; -@Inf@ - [5;-@Inf@] ; -@Inf@ - [5;@Inf@] ; -@Inf@ - [5;5] ; -@Inf@ - [5;1] ; -@Inf@ - [5;0] ; -@Inf@ - [1;@NaN@] ; -@Inf@ - [1;-@Inf@] ; -@Inf@ - [1;@Inf@] ; -@Inf@ - [1;5] ; -@Inf@ - [1;1] ; -@Inf@ - [1;0] ; -@Inf@ - [0;@NaN@] ; -@Inf@ - [0;-@Inf@] ; -@Inf@ - [0;@Inf@] ; -@Inf@ - [0;5] ; -@Inf@ - [0;1] ; -@Inf@ - [0;0] ; @Inf@ - @NaN@ ; @Inf@ - -@Inf@ ; @Inf@ - @Inf@ ; @Inf@ - 5 ; @Inf@ - 1 ; @Inf@ - 0 ; @Inf@ - [@NaN@] ; @Inf@ - [-@Inf@] ; @Inf@ - [@Inf@] ; @Inf@ - [5] ; @Inf@ - [1] ; @Inf@ - [0] ; @Inf@ - [@NaN@;@NaN@] ; @Inf@ - [@NaN@;-@Inf@] ; @Inf@ - [@NaN@;@Inf@] ; @Inf@ - [@NaN@;5] ; @Inf@ - [@NaN@;1] ; @Inf@ - [@NaN@;0] ; @Inf@ - [-@Inf@;@NaN@] ; @Inf@ - [-@Inf@;-@Inf@] ; @Inf@ - [-@Inf@;@Inf@] ; @Inf@ - [-@Inf@;5] ; @Inf@ - [-@Inf@;1] ; @Inf@ - [-@Inf@;0] ; @Inf@ - [@Inf@;@NaN@] ; @Inf@ - [@Inf@;-@Inf@] ; @Inf@ - [@Inf@;@Inf@] ; @Inf@ - [@Inf@;5] ; @Inf@ - [@Inf@;1] ; @Inf@ - [@Inf@;0] ; @Inf@ - [5;@NaN@] ; @Inf@ - [5;-@Inf@] ; @Inf@ - [5;@Inf@] ; @Inf@ - [5;5] ; @Inf@ - [5;1] ; @Inf@ - [5;0] ; @Inf@ - [1;@NaN@] ; @Inf@ - [1;-@Inf@] ; @Inf@ - [1;@Inf@] ; @Inf@ - [1;5] ; @Inf@ - [1;1] ; @Inf@ - [1;0] ; @Inf@ - [0;@NaN@] ; @Inf@ - [0;-@Inf@] ; @Inf@ - [0;@Inf@] ; @Inf@ - [0;5] ; @Inf@ - [0;1] ; @Inf@ - [0;0] ; 5 - @NaN@ ; 5 - -@Inf@ ; 5 - @Inf@ ; 5 - 5 ; 5 - 1 ; 5 - 0 ; 5 - [@NaN@] ; 5 - [-@Inf@] ; 5 - [@Inf@] ; 5 - [5] ; 5 - [1] ; 5 - [0] ; 5 - [@NaN@;@NaN@] ; 5 - [@NaN@;-@Inf@] ; 5 - [@NaN@;@Inf@] ; 5 - [@NaN@;5] ; 5 - [@NaN@;1] ; 5 - [@NaN@;0] ; 5 - [-@Inf@;@NaN@] ; 5 - [-@Inf@;-@Inf@] ; 5 - [-@Inf@;@Inf@] ; 5 - [-@Inf@;5] ; 5 - [-@Inf@;1] ; 5 - [-@Inf@;0] ; 5 - [@Inf@;@NaN@] ; 5 - [@Inf@;-@Inf@] ; 5 - [@Inf@;@Inf@] ; 5 - [@Inf@;5] ; 5 - [@Inf@;1] ; 5 - [@Inf@;0] ; 5 - [5;@NaN@] ; 5 - [5;-@Inf@] ; 5 - [5;@Inf@] ; 5 - [5;5] ; 5 - [5;1] ; 5 - [5;0] ; 5 - [1;@NaN@] ; 5 - [1;-@Inf@] ; 5 - [1;@Inf@] ; 5 - [1;5] ; 5 - [1;1] ; 5 - [1;0] ; 5 - [0;@NaN@] ; 5 - [0;-@Inf@] ; 5 - [0;@Inf@] ; 5 - [0;5] ; 5 - [0;1] ; 5 - [0;0] ; 1 - @NaN@ ; 1 - -@Inf@ ; 1 - @Inf@ ; 1 - 5 ; 1 - 1 ; 1 - 0 ; 1 - [@NaN@] ; 1 - [-@Inf@] ; 1 - [@Inf@] ; 1 - [5] ; 1 - [1] ; 1 - [0] ; 1 - [@NaN@;@NaN@] ; 1 - [@NaN@;-@Inf@] ; 1 - [@NaN@;@Inf@] ; 1 - [@NaN@;5] ; 1 - [@NaN@;1] ; 1 - [@NaN@;0] ; 1 - [-@Inf@;@NaN@] ; 1 - [-@Inf@;-@Inf@] ; 1 - [-@Inf@;@Inf@] ; 1 - [-@Inf@;5] ; 1 - [-@Inf@;1] ; 1 - [-@Inf@;0] ; 1 - [@Inf@;@NaN@] ; 1 - [@Inf@;-@Inf@] ; 1 - [@Inf@;@Inf@] ; 1 - [@Inf@;5] ; 1 - [@Inf@;1] ; 1 - [@Inf@;0] ; 1 - [5;@NaN@] ; 1 - [5;-@Inf@] ; 1 - [5;@Inf@] ; 1 - [5;5] ; 1 - [5;1] ; 1 - [5;0] ; 1 - [1;@NaN@] ; 1 - [1;-@Inf@] ; 1 - [1;@Inf@] ; 1 - [1;5] ; 1 - [1;1] ; 1 - [1;0] ; 1 - [0;@NaN@] ; 1 - [0;-@Inf@] ; 1 - [0;@Inf@] ; 1 - [0;5] ; 1 - [0;1] ; 1 - [0;0] ; 0 - @NaN@ ; 0 - -@Inf@ ; 0 - @Inf@ ; 0 - 5 ; 0 - 1 ; 0 - 0 ; 0 - [@NaN@] ; 0 - [-@Inf@] ; 0 - [@Inf@] ; 0 - [5] ; 0 - [1] ; 0 - [0] ; 0 - [@NaN@;@NaN@] ; 0 - [@NaN@;-@Inf@] ; 0 - [@NaN@;@Inf@] ; 0 - [@NaN@;5] ; 0 - [@NaN@;1] ; 0 - [@NaN@;0] ; 0 - [-@Inf@;@NaN@] ; 0 - [-@Inf@;-@Inf@] ; 0 - [-@Inf@;@Inf@] ; 0 - [-@Inf@;5] ; 0 - [-@Inf@;1] ; 0 - [-@Inf@;0] ; 0 - [@Inf@;@NaN@] ; 0 - [@Inf@;-@Inf@] ; 0 - [@Inf@;@Inf@] ; 0 - [@Inf@;5] ; 0 - [@Inf@;1] ; 0 - [@Inf@;0] ; 0 - [5;@NaN@] ; 0 - [5;-@Inf@] ; 0 - [5;@Inf@] ; 0 - [5;5] ; 0 - [5;1] ; 0 - [5;0] ; 0 - [1;@NaN@] ; 0 - [1;-@Inf@] ; 0 - [1;@Inf@] ; 0 - [1;5] ; 0 - [1;1] ; 0 - [1;0] ; 0 - [0;@NaN@] ; 0 - [0;-@Inf@] ; 0 - [0;@Inf@] ; 0 - [0;5] ; 0 - [0;1] ; 0 - [0;0] ; [@NaN@] - @NaN@ ; [@NaN@] - -@Inf@ ; [@NaN@] - @Inf@ ; [@NaN@] - 5 ; [@NaN@] - 1 ; [@NaN@] - 0 ; [@NaN@] - [@NaN@] ; [@NaN@] - [-@Inf@] ; [@NaN@] - [@Inf@] ; [@NaN@] - [5] ; [@NaN@] - [1] ; [@NaN@] - [0] ; [@NaN@] - [@NaN@;@NaN@] ; [@NaN@] - [@NaN@;-@Inf@] ; [@NaN@] - [@NaN@;@Inf@] ; [@NaN@] - [@NaN@;5] ; [@NaN@] - [@NaN@;1] ; [@NaN@] - [@NaN@;0] ; [@NaN@] - [-@Inf@;@NaN@] ; [@NaN@] - [-@Inf@;-@Inf@] ; [@NaN@] - [-@Inf@;@Inf@] ; [@NaN@] - [-@Inf@;5] ; [@NaN@] - [-@Inf@;1] ; [@NaN@] - [-@Inf@;0] ; [@NaN@] - [@Inf@;@NaN@] ; [@NaN@] - [@Inf@;-@Inf@] ; [@NaN@] - [@Inf@;@Inf@] ; [@NaN@] - [@Inf@;5] ; [@NaN@] - [@Inf@;1] ; [@NaN@] - [@Inf@;0] ; [@NaN@] - [5;@NaN@] ; [@NaN@] - [5;-@Inf@] ; [@NaN@] - [5;@Inf@] ; [@NaN@] - [5;5] ; [@NaN@] - [5;1] ; [@NaN@] - [5;0] ; [@NaN@] - [1;@NaN@] ; [@NaN@] - [1;-@Inf@] ; [@NaN@] - [1;@Inf@] ; [@NaN@] - [1;5] ; [@NaN@] - [1;1] ; [@NaN@] - [1;0] ; [@NaN@] - [0;@NaN@] ; [@NaN@] - [0;-@Inf@] ; [@NaN@] - [0;@Inf@] ; [@NaN@] - [0;5] ; [@NaN@] - [0;1] ; [@NaN@] - [0;0] ; [-@Inf@] - @NaN@ ; [-@Inf@] - -@Inf@ ; [-@Inf@] - @Inf@ ; [-@Inf@] - 5 ; [-@Inf@] - 1 ; [-@Inf@] - 0 ; [-@Inf@] - [@NaN@] ; [-@Inf@] - [-@Inf@] ; [-@Inf@] - [@Inf@] ; [-@Inf@] - [5] ; [-@Inf@] - [1] ; [-@Inf@] - [0] ; [-@Inf@] - [@NaN@;@NaN@] ; [-@Inf@] - [@NaN@;-@Inf@] ; [-@Inf@] - [@NaN@;@Inf@] ; [-@Inf@] - [@NaN@;5] ; [-@Inf@] - [@NaN@;1] ; [-@Inf@] - [@NaN@;0] ; [-@Inf@] - [-@Inf@;@NaN@] ; [-@Inf@] - [-@Inf@;-@Inf@] ; [-@Inf@] - [-@Inf@;@Inf@] ; [-@Inf@] - [-@Inf@;5] ; [-@Inf@] - [-@Inf@;1] ; [-@Inf@] - [-@Inf@;0] ; [-@Inf@] - [@Inf@;@NaN@] ; [-@Inf@] - [@Inf@;-@Inf@] ; [-@Inf@] - [@Inf@;@Inf@] ; [-@Inf@] - [@Inf@;5] ; [-@Inf@] - [@Inf@;1] ; [-@Inf@] - [@Inf@;0] ; [-@Inf@] - [5;@NaN@] ; [-@Inf@] - [5;-@Inf@] ; [-@Inf@] - [5;@Inf@] ; [-@Inf@] - [5;5] ; [-@Inf@] - [5;1] ; [-@Inf@] - [5;0] ; [-@Inf@] - [1;@NaN@] ; [-@Inf@] - [1;-@Inf@] ; [-@Inf@] - [1;@Inf@] ; [-@Inf@] - [1;5] ; [-@Inf@] - [1;1] ; [-@Inf@] - [1;0] ; [-@Inf@] - [0;@NaN@] ; [-@Inf@] - [0;-@Inf@] ; [-@Inf@] - [0;@Inf@] ; [-@Inf@] - [0;5] ; [-@Inf@] - [0;1] ; [-@Inf@] - [0;0] ; [@Inf@] - @NaN@ ; [@Inf@] - -@Inf@ ; [@Inf@] - @Inf@ ; [@Inf@] - 5 ; [@Inf@] - 1 ; [@Inf@] - 0 ; [@Inf@] - [@NaN@] ; [@Inf@] - [-@Inf@] ; [@Inf@] - [@Inf@] ; [@Inf@] - [5] ; [@Inf@] - [1] ; [@Inf@] - [0] ; [@Inf@] - [@NaN@;@NaN@] ; [@Inf@] - [@NaN@;-@Inf@] ; [@Inf@] - [@NaN@;@Inf@] ; [@Inf@] - [@NaN@;5] ; [@Inf@] - [@NaN@;1] ; [@Inf@] - [@NaN@;0] ; [@Inf@] - [-@Inf@;@NaN@] ; [@Inf@] - [-@Inf@;-@Inf@] ; [@Inf@] - [-@Inf@;@Inf@] ; [@Inf@] - [-@Inf@;5] ; [@Inf@] - [-@Inf@;1] ; [@Inf@] - [-@Inf@;0] ; [@Inf@] - [@Inf@;@NaN@] ; [@Inf@] - [@Inf@;-@Inf@] ; [@Inf@] - [@Inf@;@Inf@] ; [@Inf@] - [@Inf@;5] ; [@Inf@] - [@Inf@;1] ; [@Inf@] - [@Inf@;0] ; [@Inf@] - [5;@NaN@] ; [@Inf@] - [5;-@Inf@] ; [@Inf@] - [5;@Inf@] ; [@Inf@] - [5;5] ; [@Inf@] - [5;1] ; [@Inf@] - [5;0] ; [@Inf@] - [1;@NaN@] ; [@Inf@] - [1;-@Inf@] ; [@Inf@] - [1;@Inf@] ; [@Inf@] - [1;5] ; [@Inf@] - [1;1] ; [@Inf@] - [1;0] ; [@Inf@] - [0;@NaN@] ; [@Inf@] - [0;-@Inf@] ; [@Inf@] - [0;@Inf@] ; [@Inf@] - [0;5] ; [@Inf@] - [0;1] ; [@Inf@] - [0;0] ; [5] - @NaN@ ; [5] - -@Inf@ ; [5] - @Inf@ ; [5] - 5 ; [5] - 1 ; [5] - 0 ; [5] - [@NaN@] ; [5] - [-@Inf@] ; [5] - [@Inf@] ; [5] - [5] ; [5] - [1] ; [5] - [0] ; [5] - [@NaN@;@NaN@] ; [5] - [@NaN@;-@Inf@] ; [5] - [@NaN@;@Inf@] ; [5] - [@NaN@;5] ; [5] - [@NaN@;1] ; [5] - [@NaN@;0] ; [5] - [-@Inf@;@NaN@] ; [5] - [-@Inf@;-@Inf@] ; [5] - [-@Inf@;@Inf@] ; [5] - [-@Inf@;5] ; [5] - [-@Inf@;1] ; [5] - [-@Inf@;0] ; [5] - [@Inf@;@NaN@] ; [5] - [@Inf@;-@Inf@] ; [5] - [@Inf@;@Inf@] ; [5] - [@Inf@;5] ; [5] - [@Inf@;1] ; [5] - [@Inf@;0] ; [5] - [5;@NaN@] ; [5] - [5;-@Inf@] ; [5] - [5;@Inf@] ; [5] - [5;5] ; [5] - [5;1] ; [5] - [5;0] ; [5] - [1;@NaN@] ; [5] - [1;-@Inf@] ; [5] - [1;@Inf@] ; [5] - [1;5] ; [5] - [1;1] ; [5] - [1;0] ; [5] - [0;@NaN@] ; [5] - [0;-@Inf@] ; [5] - [0;@Inf@] ; [5] - [0;5] ; [5] - [0;1] ; [5] - [0;0] ; [1] - @NaN@ ; [1] - -@Inf@ ; [1] - @Inf@ ; [1] - 5 ; [1] - 1 ; [1] - 0 ; [1] - [@NaN@] ; [1] - [-@Inf@] ; [1] - [@Inf@] ; [1] - [5] ; [1] - [1] ; [1] - [0] ; [1] - [@NaN@;@NaN@] ; [1] - [@NaN@;-@Inf@] ; [1] - [@NaN@;@Inf@] ; [1] - [@NaN@;5] ; [1] - [@NaN@;1] ; [1] - [@NaN@;0] ; [1] - [-@Inf@;@NaN@] ; [1] - [-@Inf@;-@Inf@] ; [1] - [-@Inf@;@Inf@] ; [1] - [-@Inf@;5] ; [1] - [-@Inf@;1] ; [1] - [-@Inf@;0] ; [1] - [@Inf@;@NaN@] ; [1] - [@Inf@;-@Inf@] ; [1] - [@Inf@;@Inf@] ; [1] - [@Inf@;5] ; [1] - [@Inf@;1] ; [1] - [@Inf@;0] ; [1] - [5;@NaN@] ; [1] - [5;-@Inf@] ; [1] - [5;@Inf@] ; [1] - [5;5] ; [1] - [5;1] ; [1] - [5;0] ; [1] - [1;@NaN@] ; [1] - [1;-@Inf@] ; [1] - [1;@Inf@] ; [1] - [1;5] ; [1] - [1;1] ; [1] - [1;0] ; [1] - [0;@NaN@] ; [1] - [0;-@Inf@] ; [1] - [0;@Inf@] ; [1] - [0;5] ; [1] - [0;1] ; [1] - [0;0] ; [0] - @NaN@ ; [0] - -@Inf@ ; [0] - @Inf@ ; [0] - 5 ; [0] - 1 ; [0] - 0 ; [0] - [@NaN@] ; [0] - [-@Inf@] ; [0] - [@Inf@] ; [0] - [5] ; [0] - [1] ; [0] - [0] ; [0] - [@NaN@;@NaN@] ; [0] - [@NaN@;-@Inf@] ; [0] - [@NaN@;@Inf@] ; [0] - [@NaN@;5] ; [0] - [@NaN@;1] ; [0] - [@NaN@;0] ; [0] - [-@Inf@;@NaN@] ; [0] - [-@Inf@;-@Inf@] ; [0] - [-@Inf@;@Inf@] ; [0] - [-@Inf@;5] ; [0] - [-@Inf@;1] ; [0] - [-@Inf@;0] ; [0] - [@Inf@;@NaN@] ; [0] - [@Inf@;-@Inf@] ; [0] - [@Inf@;@Inf@] ; [0] - [@Inf@;5] ; [0] - [@Inf@;1] ; [0] - [@Inf@;0] ; [0] - [5;@NaN@] ; [0] - [5;-@Inf@] ; [0] - [5;@Inf@] ; [0] - [5;5] ; [0] - [5;1] ; [0] - [5;0] ; [0] - [1;@NaN@] ; [0] - [1;-@Inf@] ; [0] - [1;@Inf@] ; [0] - [1;5] ; [0] - [1;1] ; [0] - [1;0] ; [0] - [0;@NaN@] ; [0] - [0;-@Inf@] ; [0] - [0;@Inf@] ; [0] - [0;5] ; [0] - [0;1] ; [0] - [0;0] ; [@NaN@;@NaN@] - @NaN@ ; [@NaN@;@NaN@] - -@Inf@ ; [@NaN@;@NaN@] - @Inf@ ; [@NaN@;@NaN@] - 5 ; [@NaN@;@NaN@] - 1 ; [@NaN@;@NaN@] - 0 ; [@NaN@;@NaN@] - [@NaN@] ; [@NaN@;@NaN@] - [-@Inf@] ; [@NaN@;@NaN@] - [@Inf@] ; [@NaN@;@NaN@] - [5] ; [@NaN@;@NaN@] - [1] ; [@NaN@;@NaN@] - [0] ; [@NaN@;@NaN@] - [@NaN@;@NaN@] ; [@NaN@;@NaN@] - [@NaN@;-@Inf@] ; [@NaN@;@NaN@] - [@NaN@;@Inf@] ; [@NaN@;@NaN@] - [@NaN@;5] ; [@NaN@;@NaN@] - [@NaN@;1] ; [@NaN@;@NaN@] - [@NaN@;0] ; [@NaN@;@NaN@] - [-@Inf@;@NaN@] ; [@NaN@;@NaN@] - [-@Inf@;-@Inf@] ; [@NaN@;@NaN@] - [-@Inf@;@Inf@] ; [@NaN@;@NaN@] - [-@Inf@;5] ; [@NaN@;@NaN@] - [-@Inf@;1] ; [@NaN@;@NaN@] - [-@Inf@;0] ; [@NaN@;@NaN@] - [@Inf@;@NaN@] ; [@NaN@;@NaN@] - [@Inf@;-@Inf@] ; [@NaN@;@NaN@] - [@Inf@;@Inf@] ; [@NaN@;@NaN@] - [@Inf@;5] ; [@NaN@;@NaN@] - [@Inf@;1] ; [@NaN@;@NaN@] - [@Inf@;0] ; [@NaN@;@NaN@] - [5;@NaN@] ; [@NaN@;@NaN@] - [5;-@Inf@] ; [@NaN@;@NaN@] - [5;@Inf@] ; [@NaN@;@NaN@] - [5;5] ; [@NaN@;@NaN@] - [5;1] ; [@NaN@;@NaN@] - [5;0] ; [@NaN@;@NaN@] - [1;@NaN@] ; [@NaN@;@NaN@] - [1;-@Inf@] ; [@NaN@;@NaN@] - [1;@Inf@] ; [@NaN@;@NaN@] - [1;5] ; [@NaN@;@NaN@] - [1;1] ; [@NaN@;@NaN@] - [1;0] ; [@NaN@;@NaN@] - [0;@NaN@] ; [@NaN@;@NaN@] - [0;-@Inf@] ; [@NaN@;@NaN@] - [0;@Inf@] ; [@NaN@;@NaN@] - [0;5] ; [@NaN@;@NaN@] - [0;1] ; [@NaN@;@NaN@] - [0;0] ; [@NaN@;-@Inf@] - @NaN@ ; [@NaN@;-@Inf@] - -@Inf@ ; [@NaN@;-@Inf@] - @Inf@ ; [@NaN@;-@Inf@] - 5 ; [@NaN@;-@Inf@] - 1 ; [@NaN@;-@Inf@] - 0 ; [@NaN@;-@Inf@] - [@NaN@] ; [@NaN@;-@Inf@] - [-@Inf@] ; [@NaN@;-@Inf@] - [@Inf@] ; [@NaN@;-@Inf@] - [5] ; [@NaN@;-@Inf@] - [1] ; [@NaN@;-@Inf@] - [0] ; [@NaN@;-@Inf@] - [@NaN@;@NaN@] ; [@NaN@;-@Inf@] - [@NaN@;-@Inf@] ; [@NaN@;-@Inf@] - [@NaN@;@Inf@] ; [@NaN@;-@Inf@] - [@NaN@;5] ; [@NaN@;-@Inf@] - [@NaN@;1] ; [@NaN@;-@Inf@] - [@NaN@;0] ; [@NaN@;-@Inf@] - [-@Inf@;@NaN@] ; [@NaN@;-@Inf@] - [-@Inf@;-@Inf@] ; [@NaN@;-@Inf@] - [-@Inf@;@Inf@] ; [@NaN@;-@Inf@] - [-@Inf@;5] ; [@NaN@;-@Inf@] - [-@Inf@;1] ; [@NaN@;-@Inf@] - [-@Inf@;0] ; [@NaN@;-@Inf@] - [@Inf@;@NaN@] ; [@NaN@;-@Inf@] - [@Inf@;-@Inf@] ; [@NaN@;-@Inf@] - [@Inf@;@Inf@] ; [@NaN@;-@Inf@] - [@Inf@;5] ; [@NaN@;-@Inf@] - [@Inf@;1] ; [@NaN@;-@Inf@] - [@Inf@;0] ; [@NaN@;-@Inf@] - [5;@NaN@] ; [@NaN@;-@Inf@] - [5;-@Inf@] ; [@NaN@;-@Inf@] - [5;@Inf@] ; [@NaN@;-@Inf@] - [5;5] ; [@NaN@;-@Inf@] - [5;1] ; [@NaN@;-@Inf@] - [5;0] ; [@NaN@;-@Inf@] - [1;@NaN@] ; [@NaN@;-@Inf@] - [1;-@Inf@] ; [@NaN@;-@Inf@] - [1;@Inf@] ; [@NaN@;-@Inf@] - [1;5] ; [@NaN@;-@Inf@] - [1;1] ; [@NaN@;-@Inf@] - [1;0] ; [@NaN@;-@Inf@] - [0;@NaN@] ; [@NaN@;-@Inf@] - [0;-@Inf@] ; [@NaN@;-@Inf@] - [0;@Inf@] ; [@NaN@;-@Inf@] - [0;5] ; [@NaN@;-@Inf@] - [0;1] ; [@NaN@;-@Inf@] - [0;0] ; [@NaN@;@Inf@] - @NaN@ ; [@NaN@;@Inf@] - -@Inf@ ; [@NaN@;@Inf@] - @Inf@ ; [@NaN@;@Inf@] - 5 ; [@NaN@;@Inf@] - 1 ; [@NaN@;@Inf@] - 0 ; [@NaN@;@Inf@] - [@NaN@] ; [@NaN@;@Inf@] - [-@Inf@] ; [@NaN@;@Inf@] - [@Inf@] ; [@NaN@;@Inf@] - [5] ; [@NaN@;@Inf@] - [1] ; [@NaN@;@Inf@] - [0] ; [@NaN@;@Inf@] - [@NaN@;@NaN@] ; [@NaN@;@Inf@] - [@NaN@;-@Inf@] ; [@NaN@;@Inf@] - [@NaN@;@Inf@] ; [@NaN@;@Inf@] - [@NaN@;5] ; [@NaN@;@Inf@] - [@NaN@;1] ; [@NaN@;@Inf@] - [@NaN@;0] ; [@NaN@;@Inf@] - [-@Inf@;@NaN@] ; [@NaN@;@Inf@] - [-@Inf@;-@Inf@] ; [@NaN@;@Inf@] - [-@Inf@;@Inf@] ; [@NaN@;@Inf@] - [-@Inf@;5] ; [@NaN@;@Inf@] - [-@Inf@;1] ; [@NaN@;@Inf@] - [-@Inf@;0] ; [@NaN@;@Inf@] - [@Inf@;@NaN@] ; [@NaN@;@Inf@] - [@Inf@;-@Inf@] ; [@NaN@;@Inf@] - [@Inf@;@Inf@] ; [@NaN@;@Inf@] - [@Inf@;5] ; [@NaN@;@Inf@] - [@Inf@;1] ; [@NaN@;@Inf@] - [@Inf@;0] ; [@NaN@;@Inf@] - [5;@NaN@] ; [@NaN@;@Inf@] - [5;-@Inf@] ; [@NaN@;@Inf@] - [5;@Inf@] ; [@NaN@;@Inf@] - [5;5] ; [@NaN@;@Inf@] - [5;1] ; [@NaN@;@Inf@] - [5;0] ; [@NaN@;@Inf@] - [1;@NaN@] ; [@NaN@;@Inf@] - [1;-@Inf@] ; [@NaN@;@Inf@] - [1;@Inf@] ; [@NaN@;@Inf@] - [1;5] ; [@NaN@;@Inf@] - [1;1] ; [@NaN@;@Inf@] - [1;0] ; [@NaN@;@Inf@] - [0;@NaN@] ; [@NaN@;@Inf@] - [0;-@Inf@] ; [@NaN@;@Inf@] - [0;@Inf@] ; [@NaN@;@Inf@] - [0;5] ; [@NaN@;@Inf@] - [0;1] ; [@NaN@;@Inf@] - [0;0] ; [@NaN@;5] - @NaN@ ; [@NaN@;5] - -@Inf@ ; [@NaN@;5] - @Inf@ ; [@NaN@;5] - 5 ; [@NaN@;5] - 1 ; [@NaN@;5] - 0 ; [@NaN@;5] - [@NaN@] ; [@NaN@;5] - [-@Inf@] ; [@NaN@;5] - [@Inf@] ; [@NaN@;5] - [5] ; [@NaN@;5] - [1] ; [@NaN@;5] - [0] ; [@NaN@;5] - [@NaN@;@NaN@] ; [@NaN@;5] - [@NaN@;-@Inf@] ; [@NaN@;5] - [@NaN@;@Inf@] ; [@NaN@;5] - [@NaN@;5] ; [@NaN@;5] - [@NaN@;1] ; [@NaN@;5] - [@NaN@;0] ; [@NaN@;5] - [-@Inf@;@NaN@] ; [@NaN@;5] - [-@Inf@;-@Inf@] ; [@NaN@;5] - [-@Inf@;@Inf@] ; [@NaN@;5] - [-@Inf@;5] ; [@NaN@;5] - [-@Inf@;1] ; [@NaN@;5] - [-@Inf@;0] ; [@NaN@;5] - [@Inf@;@NaN@] ; [@NaN@;5] - [@Inf@;-@Inf@] ; [@NaN@;5] - [@Inf@;@Inf@] ; [@NaN@;5] - [@Inf@;5] ; [@NaN@;5] - [@Inf@;1] ; [@NaN@;5] - [@Inf@;0] ; [@NaN@;5] - [5;@NaN@] ; [@NaN@;5] - [5;-@Inf@] ; [@NaN@;5] - [5;@Inf@] ; [@NaN@;5] - [5;5] ; [@NaN@;5] - [5;1] ; [@NaN@;5] - [5;0] ; [@NaN@;5] - [1;@NaN@] ; [@NaN@;5] - [1;-@Inf@] ; [@NaN@;5] - [1;@Inf@] ; [@NaN@;5] - [1;5] ; [@NaN@;5] - [1;1] ; [@NaN@;5] - [1;0] ; [@NaN@;5] - [0;@NaN@] ; [@NaN@;5] - [0;-@Inf@] ; [@NaN@;5] - [0;@Inf@] ; [@NaN@;5] - [0;5] ; [@NaN@;5] - [0;1] ; [@NaN@;5] - [0;0] ; [@NaN@;1] - @NaN@ ; [@NaN@;1] - -@Inf@ ; [@NaN@;1] - @Inf@ ; [@NaN@;1] - 5 ; [@NaN@;1] - 1 ; [@NaN@;1] - 0 ; [@NaN@;1] - [@NaN@] ; [@NaN@;1] - [-@Inf@] ; [@NaN@;1] - [@Inf@] ; [@NaN@;1] - [5] ; [@NaN@;1] - [1] ; [@NaN@;1] - [0] ; [@NaN@;1] - [@NaN@;@NaN@] ; [@NaN@;1] - [@NaN@;-@Inf@] ; [@NaN@;1] - [@NaN@;@Inf@] ; [@NaN@;1] - [@NaN@;5] ; [@NaN@;1] - [@NaN@;1] ; [@NaN@;1] - [@NaN@;0] ; [@NaN@;1] - [-@Inf@;@NaN@] ; [@NaN@;1] - [-@Inf@;-@Inf@] ; [@NaN@;1] - [-@Inf@;@Inf@] ; [@NaN@;1] - [-@Inf@;5] ; [@NaN@;1] - [-@Inf@;1] ; [@NaN@;1] - [-@Inf@;0] ; [@NaN@;1] - [@Inf@;@NaN@] ; [@NaN@;1] - [@Inf@;-@Inf@] ; [@NaN@;1] - [@Inf@;@Inf@] ; [@NaN@;1] - [@Inf@;5] ; [@NaN@;1] - [@Inf@;1] ; [@NaN@;1] - [@Inf@;0] ; [@NaN@;1] - [5;@NaN@] ; [@NaN@;1] - [5;-@Inf@] ; [@NaN@;1] - [5;@Inf@] ; [@NaN@;1] - [5;5] ; [@NaN@;1] - [5;1] ; [@NaN@;1] - [5;0] ; [@NaN@;1] - [1;@NaN@] ; [@NaN@;1] - [1;-@Inf@] ; [@NaN@;1] - [1;@Inf@] ; [@NaN@;1] - [1;5] ; [@NaN@;1] - [1;1] ; [@NaN@;1] - [1;0] ; [@NaN@;1] - [0;@NaN@] ; [@NaN@;1] - [0;-@Inf@] ; [@NaN@;1] - [0;@Inf@] ; [@NaN@;1] - [0;5] ; [@NaN@;1] - [0;1] ; [@NaN@;1] - [0;0] ; [@NaN@;0] - @NaN@ ; [@NaN@;0] - -@Inf@ ; [@NaN@;0] - @Inf@ ; [@NaN@;0] - 5 ; [@NaN@;0] - 1 ; [@NaN@;0] - 0 ; [@NaN@;0] - [@NaN@] ; [@NaN@;0] - [-@Inf@] ; [@NaN@;0] - [@Inf@] ; [@NaN@;0] - [5] ; [@NaN@;0] - [1] ; [@NaN@;0] - [0] ; [@NaN@;0] - [@NaN@;@NaN@] ; [@NaN@;0] - [@NaN@;-@Inf@] ; [@NaN@;0] - [@NaN@;@Inf@] ; [@NaN@;0] - [@NaN@;5] ; [@NaN@;0] - [@NaN@;1] ; [@NaN@;0] - [@NaN@;0] ; [@NaN@;0] - [-@Inf@;@NaN@] ; [@NaN@;0] - [-@Inf@;-@Inf@] ; [@NaN@;0] - [-@Inf@;@Inf@] ; [@NaN@;0] - [-@Inf@;5] ; [@NaN@;0] - [-@Inf@;1] ; [@NaN@;0] - [-@Inf@;0] ; [@NaN@;0] - [@Inf@;@NaN@] ; [@NaN@;0] - [@Inf@;-@Inf@] ; [@NaN@;0] - [@Inf@;@Inf@] ; [@NaN@;0] - [@Inf@;5] ; [@NaN@;0] - [@Inf@;1] ; [@NaN@;0] - [@Inf@;0] ; [@NaN@;0] - [5;@NaN@] ; [@NaN@;0] - [5;-@Inf@] ; [@NaN@;0] - [5;@Inf@] ; [@NaN@;0] - [5;5] ; [@NaN@;0] - [5;1] ; [@NaN@;0] - [5;0] ; [@NaN@;0] - [1;@NaN@] ; [@NaN@;0] - [1;-@Inf@] ; [@NaN@;0] - [1;@Inf@] ; [@NaN@;0] - [1;5] ; [@NaN@;0] - [1;1] ; [@NaN@;0] - [1;0] ; [@NaN@;0] - [0;@NaN@] ; [@NaN@;0] - [0;-@Inf@] ; [@NaN@;0] - [0;@Inf@] ; [@NaN@;0] - [0;5] ; [@NaN@;0] - [0;1] ; [@NaN@;0] - [0;0] ; [-@Inf@;@NaN@] - @NaN@ ; [-@Inf@;@NaN@] - -@Inf@ ; [-@Inf@;@NaN@] - @Inf@ ; [-@Inf@;@NaN@] - 5 ; [-@Inf@;@NaN@] - 1 ; [-@Inf@;@NaN@] - 0 ; [-@Inf@;@NaN@] - [@NaN@] ; [-@Inf@;@NaN@] - [-@Inf@] ; [-@Inf@;@NaN@] - [@Inf@] ; [-@Inf@;@NaN@] - [5] ; [-@Inf@;@NaN@] - [1] ; [-@Inf@;@NaN@] - [0] ; [-@Inf@;@NaN@] - [@NaN@;@NaN@] ; [-@Inf@;@NaN@] - [@NaN@;-@Inf@] ; [-@Inf@;@NaN@] - [@NaN@;@Inf@] ; [-@Inf@;@NaN@] - [@NaN@;5] ; [-@Inf@;@NaN@] - [@NaN@;1] ; [-@Inf@;@NaN@] - [@NaN@;0] ; [-@Inf@;@NaN@] - [-@Inf@;@NaN@] ; [-@Inf@;@NaN@] - [-@Inf@;-@Inf@] ; [-@Inf@;@NaN@] - [-@Inf@;@Inf@] ; [-@Inf@;@NaN@] - [-@Inf@;5] ; [-@Inf@;@NaN@] - [-@Inf@;1] ; [-@Inf@;@NaN@] - [-@Inf@;0] ; [-@Inf@;@NaN@] - [@Inf@;@NaN@] ; [-@Inf@;@NaN@] - [@Inf@;-@Inf@] ; [-@Inf@;@NaN@] - [@Inf@;@Inf@] ; [-@Inf@;@NaN@] - [@Inf@;5] ; [-@Inf@;@NaN@] - [@Inf@;1] ; [-@Inf@;@NaN@] - [@Inf@;0] ; [-@Inf@;@NaN@] - [5;@NaN@] ; [-@Inf@;@NaN@] - [5;-@Inf@] ; [-@Inf@;@NaN@] - [5;@Inf@] ; [-@Inf@;@NaN@] - [5;5] ; [-@Inf@;@NaN@] - [5;1] ; [-@Inf@;@NaN@] - [5;0] ; [-@Inf@;@NaN@] - [1;@NaN@] ; [-@Inf@;@NaN@] - [1;-@Inf@] ; [-@Inf@;@NaN@] - [1;@Inf@] ; [-@Inf@;@NaN@] - [1;5] ; [-@Inf@;@NaN@] - [1;1] ; [-@Inf@;@NaN@] - [1;0] ; [-@Inf@;@NaN@] - [0;@NaN@] ; [-@Inf@;@NaN@] - [0;-@Inf@] ; [-@Inf@;@NaN@] - [0;@Inf@] ; [-@Inf@;@NaN@] - [0;5] ; [-@Inf@;@NaN@] - [0;1] ; [-@Inf@;@NaN@] - [0;0] ; [-@Inf@;-@Inf@] - @NaN@ ; [-@Inf@;-@Inf@] - -@Inf@ ; [-@Inf@;-@Inf@] - @Inf@ ; [-@Inf@;-@Inf@] - 5 ; [-@Inf@;-@Inf@] - 1 ; [-@Inf@;-@Inf@] - 0 ; [-@Inf@;-@Inf@] - [@NaN@] ; [-@Inf@;-@Inf@] - [-@Inf@] ; [-@Inf@;-@Inf@] - [@Inf@] ; [-@Inf@;-@Inf@] - [5] ; [-@Inf@;-@Inf@] - [1] ; [-@Inf@;-@Inf@] - [0] ; [-@Inf@;-@Inf@] - [@NaN@;@NaN@] ; [-@Inf@;-@Inf@] - [@NaN@;-@Inf@] ; [-@Inf@;-@Inf@] - [@NaN@;@Inf@] ; [-@Inf@;-@Inf@] - [@NaN@;5] ; [-@Inf@;-@Inf@] - [@NaN@;1] ; [-@Inf@;-@Inf@] - [@NaN@;0] ; [-@Inf@;-@Inf@] - [-@Inf@;@NaN@] ; [-@Inf@;-@Inf@] - [-@Inf@;-@Inf@] ; [-@Inf@;-@Inf@] - [-@Inf@;@Inf@] ; [-@Inf@;-@Inf@] - [-@Inf@;5] ; [-@Inf@;-@Inf@] - [-@Inf@;1] ; [-@Inf@;-@Inf@] - [-@Inf@;0] ; [-@Inf@;-@Inf@] - [@Inf@;@NaN@] ; [-@Inf@;-@Inf@] - [@Inf@;-@Inf@] ; [-@Inf@;-@Inf@] - [@Inf@;@Inf@] ; [-@Inf@;-@Inf@] - [@Inf@;5] ; [-@Inf@;-@Inf@] - [@Inf@;1] ; [-@Inf@;-@Inf@] - [@Inf@;0] ; [-@Inf@;-@Inf@] - [5;@NaN@] ; [-@Inf@;-@Inf@] - [5;-@Inf@] ; [-@Inf@;-@Inf@] - [5;@Inf@] ; [-@Inf@;-@Inf@] - [5;5] ; [-@Inf@;-@Inf@] - [5;1] ; [-@Inf@;-@Inf@] - [5;0] ; [-@Inf@;-@Inf@] - [1;@NaN@] ; [-@Inf@;-@Inf@] - [1;-@Inf@] ; [-@Inf@;-@Inf@] - [1;@Inf@] ; [-@Inf@;-@Inf@] - [1;5] ; [-@Inf@;-@Inf@] - [1;1] ; [-@Inf@;-@Inf@] - [1;0] ; [-@Inf@;-@Inf@] - [0;@NaN@] ; [-@Inf@;-@Inf@] - [0;-@Inf@] ; [-@Inf@;-@Inf@] - [0;@Inf@] ; [-@Inf@;-@Inf@] - [0;5] ; [-@Inf@;-@Inf@] - [0;1] ; [-@Inf@;-@Inf@] - [0;0] ; [-@Inf@;@Inf@] - @NaN@ ; [-@Inf@;@Inf@] - -@Inf@ ; [-@Inf@;@Inf@] - @Inf@ ; [-@Inf@;@Inf@] - 5 ; [-@Inf@;@Inf@] - 1 ; [-@Inf@;@Inf@] - 0 ; [-@Inf@;@Inf@] - [@NaN@] ; [-@Inf@;@Inf@] - [-@Inf@] ; [-@Inf@;@Inf@] - [@Inf@] ; [-@Inf@;@Inf@] - [5] ; [-@Inf@;@Inf@] - [1] ; [-@Inf@;@Inf@] - [0] ; [-@Inf@;@Inf@] - [@NaN@;@NaN@] ; [-@Inf@;@Inf@] - [@NaN@;-@Inf@] ; [-@Inf@;@Inf@] - [@NaN@;@Inf@] ; [-@Inf@;@Inf@] - [@NaN@;5] ; [-@Inf@;@Inf@] - [@NaN@;1] ; [-@Inf@;@Inf@] - [@NaN@;0] ; [-@Inf@;@Inf@] - [-@Inf@;@NaN@] ; [-@Inf@;@Inf@] - [-@Inf@;-@Inf@] ; [-@Inf@;@Inf@] - [-@Inf@;@Inf@] ; [-@Inf@;@Inf@] - [-@Inf@;5] ; [-@Inf@;@Inf@] - [-@Inf@;1] ; [-@Inf@;@Inf@] - [-@Inf@;0] ; [-@Inf@;@Inf@] - [@Inf@;@NaN@] ; [-@Inf@;@Inf@] - [@Inf@;-@Inf@] ; [-@Inf@;@Inf@] - [@Inf@;@Inf@] ; [-@Inf@;@Inf@] - [@Inf@;5] ; [-@Inf@;@Inf@] - [@Inf@;1] ; [-@Inf@;@Inf@] - [@Inf@;0] ; [-@Inf@;@Inf@] - [5;@NaN@] ; [-@Inf@;@Inf@] - [5;-@Inf@] ; [-@Inf@;@Inf@] - [5;@Inf@] ; [-@Inf@;@Inf@] - [5;5] ; [-@Inf@;@Inf@] - [5;1] ; [-@Inf@;@Inf@] - [5;0] ; [-@Inf@;@Inf@] - [1;@NaN@] ; [-@Inf@;@Inf@] - [1;-@Inf@] ; [-@Inf@;@Inf@] - [1;@Inf@] ; [-@Inf@;@Inf@] - [1;5] ; [-@Inf@;@Inf@] - [1;1] ; [-@Inf@;@Inf@] - [1;0] ; [-@Inf@;@Inf@] - [0;@NaN@] ; [-@Inf@;@Inf@] - [0;-@Inf@] ; [-@Inf@;@Inf@] - [0;@Inf@] ; [-@Inf@;@Inf@] - [0;5] ; [-@Inf@;@Inf@] - [0;1] ; [-@Inf@;@Inf@] - [0;0] ; [-@Inf@;5] - @NaN@ ; [-@Inf@;5] - -@Inf@ ; [-@Inf@;5] - @Inf@ ; [-@Inf@;5] - 5 ; [-@Inf@;5] - 1 ; [-@Inf@;5] - 0 ; [-@Inf@;5] - [@NaN@] ; [-@Inf@;5] - [-@Inf@] ; [-@Inf@;5] - [@Inf@] ; [-@Inf@;5] - [5] ; [-@Inf@;5] - [1] ; [-@Inf@;5] - [0] ; [-@Inf@;5] - [@NaN@;@NaN@] ; [-@Inf@;5] - [@NaN@;-@Inf@] ; [-@Inf@;5] - [@NaN@;@Inf@] ; [-@Inf@;5] - [@NaN@;5] ; [-@Inf@;5] - [@NaN@;1] ; [-@Inf@;5] - [@NaN@;0] ; [-@Inf@;5] - [-@Inf@;@NaN@] ; [-@Inf@;5] - [-@Inf@;-@Inf@] ; [-@Inf@;5] - [-@Inf@;@Inf@] ; [-@Inf@;5] - [-@Inf@;5] ; [-@Inf@;5] - [-@Inf@;1] ; [-@Inf@;5] - [-@Inf@;0] ; [-@Inf@;5] - [@Inf@;@NaN@] ; [-@Inf@;5] - [@Inf@;-@Inf@] ; [-@Inf@;5] - [@Inf@;@Inf@] ; [-@Inf@;5] - [@Inf@;5] ; [-@Inf@;5] - [@Inf@;1] ; [-@Inf@;5] - [@Inf@;0] ; [-@Inf@;5] - [5;@NaN@] ; [-@Inf@;5] - [5;-@Inf@] ; [-@Inf@;5] - [5;@Inf@] ; [-@Inf@;5] - [5;5] ; [-@Inf@;5] - [5;1] ; [-@Inf@;5] - [5;0] ; [-@Inf@;5] - [1;@NaN@] ; [-@Inf@;5] - [1;-@Inf@] ; [-@Inf@;5] - [1;@Inf@] ; [-@Inf@;5] - [1;5] ; [-@Inf@;5] - [1;1] ; [-@Inf@;5] - [1;0] ; [-@Inf@;5] - [0;@NaN@] ; [-@Inf@;5] - [0;-@Inf@] ; [-@Inf@;5] - [0;@Inf@] ; [-@Inf@;5] - [0;5] ; [-@Inf@;5] - [0;1] ; [-@Inf@;5] - [0;0] ; [-@Inf@;1] - @NaN@ ; [-@Inf@;1] - -@Inf@ ; [-@Inf@;1] - @Inf@ ; [-@Inf@;1] - 5 ; [-@Inf@;1] - 1 ; [-@Inf@;1] - 0 ; [-@Inf@;1] - [@NaN@] ; [-@Inf@;1] - [-@Inf@] ; [-@Inf@;1] - [@Inf@] ; [-@Inf@;1] - [5] ; [-@Inf@;1] - [1] ; [-@Inf@;1] - [0] ; [-@Inf@;1] - [@NaN@;@NaN@] ; [-@Inf@;1] - [@NaN@;-@Inf@] ; [-@Inf@;1] - [@NaN@;@Inf@] ; [-@Inf@;1] - [@NaN@;5] ; [-@Inf@;1] - [@NaN@;1] ; [-@Inf@;1] - [@NaN@;0] ; [-@Inf@;1] - [-@Inf@;@NaN@] ; [-@Inf@;1] - [-@Inf@;-@Inf@] ; [-@Inf@;1] - [-@Inf@;@Inf@] ; [-@Inf@;1] - [-@Inf@;5] ; [-@Inf@;1] - [-@Inf@;1] ; [-@Inf@;1] - [-@Inf@;0] ; [-@Inf@;1] - [@Inf@;@NaN@] ; [-@Inf@;1] - [@Inf@;-@Inf@] ; [-@Inf@;1] - [@Inf@;@Inf@] ; [-@Inf@;1] - [@Inf@;5] ; [-@Inf@;1] - [@Inf@;1] ; [-@Inf@;1] - [@Inf@;0] ; [-@Inf@;1] - [5;@NaN@] ; [-@Inf@;1] - [5;-@Inf@] ; [-@Inf@;1] - [5;@Inf@] ; [-@Inf@;1] - [5;5] ; [-@Inf@;1] - [5;1] ; [-@Inf@;1] - [5;0] ; [-@Inf@;1] - [1;@NaN@] ; [-@Inf@;1] - [1;-@Inf@] ; [-@Inf@;1] - [1;@Inf@] ; [-@Inf@;1] - [1;5] ; [-@Inf@;1] - [1;1] ; [-@Inf@;1] - [1;0] ; [-@Inf@;1] - [0;@NaN@] ; [-@Inf@;1] - [0;-@Inf@] ; [-@Inf@;1] - [0;@Inf@] ; [-@Inf@;1] - [0;5] ; [-@Inf@;1] - [0;1] ; [-@Inf@;1] - [0;0] ; [-@Inf@;0] - @NaN@ ; [-@Inf@;0] - -@Inf@ ; [-@Inf@;0] - @Inf@ ; [-@Inf@;0] - 5 ; [-@Inf@;0] - 1 ; [-@Inf@;0] - 0 ; [-@Inf@;0] - [@NaN@] ; [-@Inf@;0] - [-@Inf@] ; [-@Inf@;0] - [@Inf@] ; [-@Inf@;0] - [5] ; [-@Inf@;0] - [1] ; [-@Inf@;0] - [0] ; [-@Inf@;0] - [@NaN@;@NaN@] ; [-@Inf@;0] - [@NaN@;-@Inf@] ; [-@Inf@;0] - [@NaN@;@Inf@] ; [-@Inf@;0] - [@NaN@;5] ; [-@Inf@;0] - [@NaN@;1] ; [-@Inf@;0] - [@NaN@;0] ; [-@Inf@;0] - [-@Inf@;@NaN@] ; [-@Inf@;0] - [-@Inf@;-@Inf@] ; [-@Inf@;0] - [-@Inf@;@Inf@] ; [-@Inf@;0] - [-@Inf@;5] ; [-@Inf@;0] - [-@Inf@;1] ; [-@Inf@;0] - [-@Inf@;0] ; [-@Inf@;0] - [@Inf@;@NaN@] ; [-@Inf@;0] - [@Inf@;-@Inf@] ; [-@Inf@;0] - [@Inf@;@Inf@] ; [-@Inf@;0] - [@Inf@;5] ; [-@Inf@;0] - [@Inf@;1] ; [-@Inf@;0] - [@Inf@;0] ; [-@Inf@;0] - [5;@NaN@] ; [-@Inf@;0] - [5;-@Inf@] ; [-@Inf@;0] - [5;@Inf@] ; [-@Inf@;0] - [5;5] ; [-@Inf@;0] - [5;1] ; [-@Inf@;0] - [5;0] ; [-@Inf@;0] - [1;@NaN@] ; [-@Inf@;0] - [1;-@Inf@] ; [-@Inf@;0] - [1;@Inf@] ; [-@Inf@;0] - [1;5] ; [-@Inf@;0] - [1;1] ; [-@Inf@;0] - [1;0] ; [-@Inf@;0] - [0;@NaN@] ; [-@Inf@;0] - [0;-@Inf@] ; [-@Inf@;0] - [0;@Inf@] ; [-@Inf@;0] - [0;5] ; [-@Inf@;0] - [0;1] ; [-@Inf@;0] - [0;0] ; [@Inf@;@NaN@] - @NaN@ ; [@Inf@;@NaN@] - -@Inf@ ; [@Inf@;@NaN@] - @Inf@ ; [@Inf@;@NaN@] - 5 ; [@Inf@;@NaN@] - 1 ; [@Inf@;@NaN@] - 0 ; [@Inf@;@NaN@] - [@NaN@] ; [@Inf@;@NaN@] - [-@Inf@] ; [@Inf@;@NaN@] - [@Inf@] ; [@Inf@;@NaN@] - [5] ; [@Inf@;@NaN@] - [1] ; [@Inf@;@NaN@] - [0] ; [@Inf@;@NaN@] - [@NaN@;@NaN@] ; [@Inf@;@NaN@] - [@NaN@;-@Inf@] ; [@Inf@;@NaN@] - [@NaN@;@Inf@] ; [@Inf@;@NaN@] - [@NaN@;5] ; [@Inf@;@NaN@] - [@NaN@;1] ; [@Inf@;@NaN@] - [@NaN@;0] ; [@Inf@;@NaN@] - [-@Inf@;@NaN@] ; [@Inf@;@NaN@] - [-@Inf@;-@Inf@] ; [@Inf@;@NaN@] - [-@Inf@;@Inf@] ; [@Inf@;@NaN@] - [-@Inf@;5] ; [@Inf@;@NaN@] - [-@Inf@;1] ; [@Inf@;@NaN@] - [-@Inf@;0] ; [@Inf@;@NaN@] - [@Inf@;@NaN@] ; [@Inf@;@NaN@] - [@Inf@;-@Inf@] ; [@Inf@;@NaN@] - [@Inf@;@Inf@] ; [@Inf@;@NaN@] - [@Inf@;5] ; [@Inf@;@NaN@] - [@Inf@;1] ; [@Inf@;@NaN@] - [@Inf@;0] ; [@Inf@;@NaN@] - [5;@NaN@] ; [@Inf@;@NaN@] - [5;-@Inf@] ; [@Inf@;@NaN@] - [5;@Inf@] ; [@Inf@;@NaN@] - [5;5] ; [@Inf@;@NaN@] - [5;1] ; [@Inf@;@NaN@] - [5;0] ; [@Inf@;@NaN@] - [1;@NaN@] ; [@Inf@;@NaN@] - [1;-@Inf@] ; [@Inf@;@NaN@] - [1;@Inf@] ; [@Inf@;@NaN@] - [1;5] ; [@Inf@;@NaN@] - [1;1] ; [@Inf@;@NaN@] - [1;0] ; [@Inf@;@NaN@] - [0;@NaN@] ; [@Inf@;@NaN@] - [0;-@Inf@] ; [@Inf@;@NaN@] - [0;@Inf@] ; [@Inf@;@NaN@] - [0;5] ; [@Inf@;@NaN@] - [0;1] ; [@Inf@;@NaN@] - [0;0] ; [@Inf@;-@Inf@] - @NaN@ ; [@Inf@;-@Inf@] - -@Inf@ ; [@Inf@;-@Inf@] - @Inf@ ; [@Inf@;-@Inf@] - 5 ; [@Inf@;-@Inf@] - 1 ; [@Inf@;-@Inf@] - 0 ; [@Inf@;-@Inf@] - [@NaN@] ; [@Inf@;-@Inf@] - [-@Inf@] ; [@Inf@;-@Inf@] - [@Inf@] ; [@Inf@;-@Inf@] - [5] ; [@Inf@;-@Inf@] - [1] ; [@Inf@;-@Inf@] - [0] ; [@Inf@;-@Inf@] - [@NaN@;@NaN@] ; [@Inf@;-@Inf@] - [@NaN@;-@Inf@] ; [@Inf@;-@Inf@] - [@NaN@;@Inf@] ; [@Inf@;-@Inf@] - [@NaN@;5] ; [@Inf@;-@Inf@] - [@NaN@;1] ; [@Inf@;-@Inf@] - [@NaN@;0] ; [@Inf@;-@Inf@] - [-@Inf@;@NaN@] ; [@Inf@;-@Inf@] - [-@Inf@;-@Inf@] ; [@Inf@;-@Inf@] - [-@Inf@;@Inf@] ; [@Inf@;-@Inf@] - [-@Inf@;5] ; [@Inf@;-@Inf@] - [-@Inf@;1] ; [@Inf@;-@Inf@] - [-@Inf@;0] ; [@Inf@;-@Inf@] - [@Inf@;@NaN@] ; [@Inf@;-@Inf@] - [@Inf@;-@Inf@] ; [@Inf@;-@Inf@] - [@Inf@;@Inf@] ; [@Inf@;-@Inf@] - [@Inf@;5] ; [@Inf@;-@Inf@] - [@Inf@;1] ; [@Inf@;-@Inf@] - [@Inf@;0] ; [@Inf@;-@Inf@] - [5;@NaN@] ; [@Inf@;-@Inf@] - [5;-@Inf@] ; [@Inf@;-@Inf@] - [5;@Inf@] ; [@Inf@;-@Inf@] - [5;5] ; [@Inf@;-@Inf@] - [5;1] ; [@Inf@;-@Inf@] - [5;0] ; [@Inf@;-@Inf@] - [1;@NaN@] ; [@Inf@;-@Inf@] - [1;-@Inf@] ; [@Inf@;-@Inf@] - [1;@Inf@] ; [@Inf@;-@Inf@] - [1;5] ; [@Inf@;-@Inf@] - [1;1] ; [@Inf@;-@Inf@] - [1;0] ; [@Inf@;-@Inf@] - [0;@NaN@] ; [@Inf@;-@Inf@] - [0;-@Inf@] ; [@Inf@;-@Inf@] - [0;@Inf@] ; [@Inf@;-@Inf@] - [0;5] ; [@Inf@;-@Inf@] - [0;1] ; [@Inf@;-@Inf@] - [0;0] ; [@Inf@;@Inf@] - @NaN@ ; [@Inf@;@Inf@] - -@Inf@ ; [@Inf@;@Inf@] - @Inf@ ; [@Inf@;@Inf@] - 5 ; [@Inf@;@Inf@] - 1 ; [@Inf@;@Inf@] - 0 ; [@Inf@;@Inf@] - [@NaN@] ; [@Inf@;@Inf@] - [-@Inf@] ; [@Inf@;@Inf@] - [@Inf@] ; [@Inf@;@Inf@] - [5] ; [@Inf@;@Inf@] - [1] ; [@Inf@;@Inf@] - [0] ; [@Inf@;@Inf@] - [@NaN@;@NaN@] ; [@Inf@;@Inf@] - [@NaN@;-@Inf@] ; [@Inf@;@Inf@] - [@NaN@;@Inf@] ; [@Inf@;@Inf@] - [@NaN@;5] ; [@Inf@;@Inf@] - [@NaN@;1] ; [@Inf@;@Inf@] - [@NaN@;0] ; [@Inf@;@Inf@] - [-@Inf@;@NaN@] ; [@Inf@;@Inf@] - [-@Inf@;-@Inf@] ; [@Inf@;@Inf@] - [-@Inf@;@Inf@] ; [@Inf@;@Inf@] - [-@Inf@;5] ; [@Inf@;@Inf@] - [-@Inf@;1] ; [@Inf@;@Inf@] - [-@Inf@;0] ; [@Inf@;@Inf@] - [@Inf@;@NaN@] ; [@Inf@;@Inf@] - [@Inf@;-@Inf@] ; [@Inf@;@Inf@] - [@Inf@;@Inf@] ; [@Inf@;@Inf@] - [@Inf@;5] ; [@Inf@;@Inf@] - [@Inf@;1] ; [@Inf@;@Inf@] - [@Inf@;0] ; [@Inf@;@Inf@] - [5;@NaN@] ; [@Inf@;@Inf@] - [5;-@Inf@] ; [@Inf@;@Inf@] - [5;@Inf@] ; [@Inf@;@Inf@] - [5;5] ; [@Inf@;@Inf@] - [5;1] ; [@Inf@;@Inf@] - [5;0] ; [@Inf@;@Inf@] - [1;@NaN@] ; [@Inf@;@Inf@] - [1;-@Inf@] ; [@Inf@;@Inf@] - [1;@Inf@] ; [@Inf@;@Inf@] - [1;5] ; [@Inf@;@Inf@] - [1;1] ; [@Inf@;@Inf@] - [1;0] ; [@Inf@;@Inf@] - [0;@NaN@] ; [@Inf@;@Inf@] - [0;-@Inf@] ; [@Inf@;@Inf@] - [0;@Inf@] ; [@Inf@;@Inf@] - [0;5] ; [@Inf@;@Inf@] - [0;1] ; [@Inf@;@Inf@] - [0;0] ; [@Inf@;5] - @NaN@ ; [@Inf@;5] - -@Inf@ ; [@Inf@;5] - @Inf@ ; [@Inf@;5] - 5 ; [@Inf@;5] - 1 ; [@Inf@;5] - 0 ; [@Inf@;5] - [@NaN@] ; [@Inf@;5] - [-@Inf@] ; [@Inf@;5] - [@Inf@] ; [@Inf@;5] - [5] ; [@Inf@;5] - [1] ; [@Inf@;5] - [0] ; [@Inf@;5] - [@NaN@;@NaN@] ; [@Inf@;5] - [@NaN@;-@Inf@] ; [@Inf@;5] - [@NaN@;@Inf@] ; [@Inf@;5] - [@NaN@;5] ; [@Inf@;5] - [@NaN@;1] ; [@Inf@;5] - [@NaN@;0] ; [@Inf@;5] - [-@Inf@;@NaN@] ; [@Inf@;5] - [-@Inf@;-@Inf@] ; [@Inf@;5] - [-@Inf@;@Inf@] ; [@Inf@;5] - [-@Inf@;5] ; [@Inf@;5] - [-@Inf@;1] ; [@Inf@;5] - [-@Inf@;0] ; [@Inf@;5] - [@Inf@;@NaN@] ; [@Inf@;5] - [@Inf@;-@Inf@] ; [@Inf@;5] - [@Inf@;@Inf@] ; [@Inf@;5] - [@Inf@;5] ; [@Inf@;5] - [@Inf@;1] ; [@Inf@;5] - [@Inf@;0] ; [@Inf@;5] - [5;@NaN@] ; [@Inf@;5] - [5;-@Inf@] ; [@Inf@;5] - [5;@Inf@] ; [@Inf@;5] - [5;5] ; [@Inf@;5] - [5;1] ; [@Inf@;5] - [5;0] ; [@Inf@;5] - [1;@NaN@] ; [@Inf@;5] - [1;-@Inf@] ; [@Inf@;5] - [1;@Inf@] ; [@Inf@;5] - [1;5] ; [@Inf@;5] - [1;1] ; [@Inf@;5] - [1;0] ; [@Inf@;5] - [0;@NaN@] ; [@Inf@;5] - [0;-@Inf@] ; [@Inf@;5] - [0;@Inf@] ; [@Inf@;5] - [0;5] ; [@Inf@;5] - [0;1] ; [@Inf@;5] - [0;0] ; [@Inf@;1] - @NaN@ ; [@Inf@;1] - -@Inf@ ; [@Inf@;1] - @Inf@ ; [@Inf@;1] - 5 ; [@Inf@;1] - 1 ; [@Inf@;1] - 0 ; [@Inf@;1] - [@NaN@] ; [@Inf@;1] - [-@Inf@] ; [@Inf@;1] - [@Inf@] ; [@Inf@;1] - [5] ; [@Inf@;1] - [1] ; [@Inf@;1] - [0] ; [@Inf@;1] - [@NaN@;@NaN@] ; [@Inf@;1] - [@NaN@;-@Inf@] ; [@Inf@;1] - [@NaN@;@Inf@] ; [@Inf@;1] - [@NaN@;5] ; [@Inf@;1] - [@NaN@;1] ; [@Inf@;1] - [@NaN@;0] ; [@Inf@;1] - [-@Inf@;@NaN@] ; [@Inf@;1] - [-@Inf@;-@Inf@] ; [@Inf@;1] - [-@Inf@;@Inf@] ; [@Inf@;1] - [-@Inf@;5] ; [@Inf@;1] - [-@Inf@;1] ; [@Inf@;1] - [-@Inf@;0] ; [@Inf@;1] - [@Inf@;@NaN@] ; [@Inf@;1] - [@Inf@;-@Inf@] ; [@Inf@;1] - [@Inf@;@Inf@] ; [@Inf@;1] - [@Inf@;5] ; [@Inf@;1] - [@Inf@;1] ; [@Inf@;1] - [@Inf@;0] ; [@Inf@;1] - [5;@NaN@] ; [@Inf@;1] - [5;-@Inf@] ; [@Inf@;1] - [5;@Inf@] ; [@Inf@;1] - [5;5] ; [@Inf@;1] - [5;1] ; [@Inf@;1] - [5;0] ; [@Inf@;1] - [1;@NaN@] ; [@Inf@;1] - [1;-@Inf@] ; [@Inf@;1] - [1;@Inf@] ; [@Inf@;1] - [1;5] ; [@Inf@;1] - [1;1] ; [@Inf@;1] - [1;0] ; [@Inf@;1] - [0;@NaN@] ; [@Inf@;1] - [0;-@Inf@] ; [@Inf@;1] - [0;@Inf@] ; [@Inf@;1] - [0;5] ; [@Inf@;1] - [0;1] ; [@Inf@;1] - [0;0] ; [@Inf@;0] - @NaN@ ; [@Inf@;0] - -@Inf@ ; [@Inf@;0] - @Inf@ ; [@Inf@;0] - 5 ; [@Inf@;0] - 1 ; [@Inf@;0] - 0 ; [@Inf@;0] - [@NaN@] ; [@Inf@;0] - [-@Inf@] ; [@Inf@;0] - [@Inf@] ; [@Inf@;0] - [5] ; [@Inf@;0] - [1] ; [@Inf@;0] - [0] ; [@Inf@;0] - [@NaN@;@NaN@] ; [@Inf@;0] - [@NaN@;-@Inf@] ; [@Inf@;0] - [@NaN@;@Inf@] ; [@Inf@;0] - [@NaN@;5] ; [@Inf@;0] - [@NaN@;1] ; [@Inf@;0] - [@NaN@;0] ; [@Inf@;0] - [-@Inf@;@NaN@] ; [@Inf@;0] - [-@Inf@;-@Inf@] ; [@Inf@;0] - [-@Inf@;@Inf@] ; [@Inf@;0] - [-@Inf@;5] ; [@Inf@;0] - [-@Inf@;1] ; [@Inf@;0] - [-@Inf@;0] ; [@Inf@;0] - [@Inf@;@NaN@] ; [@Inf@;0] - [@Inf@;-@Inf@] ; [@Inf@;0] - [@Inf@;@Inf@] ; [@Inf@;0] - [@Inf@;5] ; [@Inf@;0] - [@Inf@;1] ; [@Inf@;0] - [@Inf@;0] ; [@Inf@;0] - [5;@NaN@] ; [@Inf@;0] - [5;-@Inf@] ; [@Inf@;0] - [5;@Inf@] ; [@Inf@;0] - [5;5] ; [@Inf@;0] - [5;1] ; [@Inf@;0] - [5;0] ; [@Inf@;0] - [1;@NaN@] ; [@Inf@;0] - [1;-@Inf@] ; [@Inf@;0] - [1;@Inf@] ; [@Inf@;0] - [1;5] ; [@Inf@;0] - [1;1] ; [@Inf@;0] - [1;0] ; [@Inf@;0] - [0;@NaN@] ; [@Inf@;0] - [0;-@Inf@] ; [@Inf@;0] - [0;@Inf@] ; [@Inf@;0] - [0;5] ; [@Inf@;0] - [0;1] ; [@Inf@;0] - [0;0] ; [5;@NaN@] - @NaN@ ; [5;@NaN@] - -@Inf@ ; [5;@NaN@] - @Inf@ ; [5;@NaN@] - 5 ; [5;@NaN@] - 1 ; [5;@NaN@] - 0 ; [5;@NaN@] - [@NaN@] ; [5;@NaN@] - [-@Inf@] ; [5;@NaN@] - [@Inf@] ; [5;@NaN@] - [5] ; [5;@NaN@] - [1] ; [5;@NaN@] - [0] ; [5;@NaN@] - [@NaN@;@NaN@] ; [5;@NaN@] - [@NaN@;-@Inf@] ; [5;@NaN@] - [@NaN@;@Inf@] ; [5;@NaN@] - [@NaN@;5] ; [5;@NaN@] - [@NaN@;1] ; [5;@NaN@] - [@NaN@;0] ; [5;@NaN@] - [-@Inf@;@NaN@] ; [5;@NaN@] - [-@Inf@;-@Inf@] ; [5;@NaN@] - [-@Inf@;@Inf@] ; [5;@NaN@] - [-@Inf@;5] ; [5;@NaN@] - [-@Inf@;1] ; [5;@NaN@] - [-@Inf@;0] ; [5;@NaN@] - [@Inf@;@NaN@] ; [5;@NaN@] - [@Inf@;-@Inf@] ; [5;@NaN@] - [@Inf@;@Inf@] ; [5;@NaN@] - [@Inf@;5] ; [5;@NaN@] - [@Inf@;1] ; [5;@NaN@] - [@Inf@;0] ; [5;@NaN@] - [5;@NaN@] ; [5;@NaN@] - [5;-@Inf@] ; [5;@NaN@] - [5;@Inf@] ; [5;@NaN@] - [5;5] ; [5;@NaN@] - [5;1] ; [5;@NaN@] - [5;0] ; [5;@NaN@] - [1;@NaN@] ; [5;@NaN@] - [1;-@Inf@] ; [5;@NaN@] - [1;@Inf@] ; [5;@NaN@] - [1;5] ; [5;@NaN@] - [1;1] ; [5;@NaN@] - [1;0] ; [5;@NaN@] - [0;@NaN@] ; [5;@NaN@] - [0;-@Inf@] ; [5;@NaN@] - [0;@Inf@] ; [5;@NaN@] - [0;5] ; [5;@NaN@] - [0;1] ; [5;@NaN@] - [0;0] ; [5;-@Inf@] - @NaN@ ; [5;-@Inf@] - -@Inf@ ; [5;-@Inf@] - @Inf@ ; [5;-@Inf@] - 5 ; [5;-@Inf@] - 1 ; [5;-@Inf@] - 0 ; [5;-@Inf@] - [@NaN@] ; [5;-@Inf@] - [-@Inf@] ; [5;-@Inf@] - [@Inf@] ; [5;-@Inf@] - [5] ; [5;-@Inf@] - [1] ; [5;-@Inf@] - [0] ; [5;-@Inf@] - [@NaN@;@NaN@] ; [5;-@Inf@] - [@NaN@;-@Inf@] ; [5;-@Inf@] - [@NaN@;@Inf@] ; [5;-@Inf@] - [@NaN@;5] ; [5;-@Inf@] - [@NaN@;1] ; [5;-@Inf@] - [@NaN@;0] ; [5;-@Inf@] - [-@Inf@;@NaN@] ; [5;-@Inf@] - [-@Inf@;-@Inf@] ; [5;-@Inf@] - [-@Inf@;@Inf@] ; [5;-@Inf@] - [-@Inf@;5] ; [5;-@Inf@] - [-@Inf@;1] ; [5;-@Inf@] - [-@Inf@;0] ; [5;-@Inf@] - [@Inf@;@NaN@] ; [5;-@Inf@] - [@Inf@;-@Inf@] ; [5;-@Inf@] - [@Inf@;@Inf@] ; [5;-@Inf@] - [@Inf@;5] ; [5;-@Inf@] - [@Inf@;1] ; [5;-@Inf@] - [@Inf@;0] ; [5;-@Inf@] - [5;@NaN@] ; [5;-@Inf@] - [5;-@Inf@] ; [5;-@Inf@] - [5;@Inf@] ; [5;-@Inf@] - [5;5] ; [5;-@Inf@] - [5;1] ; [5;-@Inf@] - [5;0] ; [5;-@Inf@] - [1;@NaN@] ; [5;-@Inf@] - [1;-@Inf@] ; [5;-@Inf@] - [1;@Inf@] ; [5;-@Inf@] - [1;5] ; [5;-@Inf@] - [1;1] ; [5;-@Inf@] - [1;0] ; [5;-@Inf@] - [0;@NaN@] ; [5;-@Inf@] - [0;-@Inf@] ; [5;-@Inf@] - [0;@Inf@] ; [5;-@Inf@] - [0;5] ; [5;-@Inf@] - [0;1] ; [5;-@Inf@] - [0;0] ; [5;@Inf@] - @NaN@ ; [5;@Inf@] - -@Inf@ ; [5;@Inf@] - @Inf@ ; [5;@Inf@] - 5 ; [5;@Inf@] - 1 ; [5;@Inf@] - 0 ; [5;@Inf@] - [@NaN@] ; [5;@Inf@] - [-@Inf@] ; [5;@Inf@] - [@Inf@] ; [5;@Inf@] - [5] ; [5;@Inf@] - [1] ; [5;@Inf@] - [0] ; [5;@Inf@] - [@NaN@;@NaN@] ; [5;@Inf@] - [@NaN@;-@Inf@] ; [5;@Inf@] - [@NaN@;@Inf@] ; [5;@Inf@] - [@NaN@;5] ; [5;@Inf@] - [@NaN@;1] ; [5;@Inf@] - [@NaN@;0] ; [5;@Inf@] - [-@Inf@;@NaN@] ; [5;@Inf@] - [-@Inf@;-@Inf@] ; [5;@Inf@] - [-@Inf@;@Inf@] ; [5;@Inf@] - [-@Inf@;5] ; [5;@Inf@] - [-@Inf@;1] ; [5;@Inf@] - [-@Inf@;0] ; [5;@Inf@] - [@Inf@;@NaN@] ; [5;@Inf@] - [@Inf@;-@Inf@] ; [5;@Inf@] - [@Inf@;@Inf@] ; [5;@Inf@] - [@Inf@;5] ; [5;@Inf@] - [@Inf@;1] ; [5;@Inf@] - [@Inf@;0] ; [5;@Inf@] - [5;@NaN@] ; [5;@Inf@] - [5;-@Inf@] ; [5;@Inf@] - [5;@Inf@] ; [5;@Inf@] - [5;5] ; [5;@Inf@] - [5;1] ; [5;@Inf@] - [5;0] ; [5;@Inf@] - [1;@NaN@] ; [5;@Inf@] - [1;-@Inf@] ; [5;@Inf@] - [1;@Inf@] ; [5;@Inf@] - [1;5] ; [5;@Inf@] - [1;1] ; [5;@Inf@] - [1;0] ; [5;@Inf@] - [0;@NaN@] ; [5;@Inf@] - [0;-@Inf@] ; [5;@Inf@] - [0;@Inf@] ; [5;@Inf@] - [0;5] ; [5;@Inf@] - [0;1] ; [5;@Inf@] - [0;0] ; [5;5] - @NaN@ ; [5;5] - -@Inf@ ; [5;5] - @Inf@ ; [5;5] - 5 ; [5;5] - 1 ; [5;5] - 0 ; [5;5] - [@NaN@] ; [5;5] - [-@Inf@] ; [5;5] - [@Inf@] ; [5;5] - [5] ; [5;5] - [1] ; [5;5] - [0] ; [5;5] - [@NaN@;@NaN@] ; [5;5] - [@NaN@;-@Inf@] ; [5;5] - [@NaN@;@Inf@] ; [5;5] - [@NaN@;5] ; [5;5] - [@NaN@;1] ; [5;5] - [@NaN@;0] ; [5;5] - [-@Inf@;@NaN@] ; [5;5] - [-@Inf@;-@Inf@] ; [5;5] - [-@Inf@;@Inf@] ; [5;5] - [-@Inf@;5] ; [5;5] - [-@Inf@;1] ; [5;5] - [-@Inf@;0] ; [5;5] - [@Inf@;@NaN@] ; [5;5] - [@Inf@;-@Inf@] ; [5;5] - [@Inf@;@Inf@] ; [5;5] - [@Inf@;5] ; [5;5] - [@Inf@;1] ; [5;5] - [@Inf@;0] ; [5;5] - [5;@NaN@] ; [5;5] - [5;-@Inf@] ; [5;5] - [5;@Inf@] ; [5;5] - [5;5] ; [5;5] - [5;1] ; [5;5] - [5;0] ; [5;5] - [1;@NaN@] ; [5;5] - [1;-@Inf@] ; [5;5] - [1;@Inf@] ; [5;5] - [1;5] ; [5;5] - [1;1] ; [5;5] - [1;0] ; [5;5] - [0;@NaN@] ; [5;5] - [0;-@Inf@] ; [5;5] - [0;@Inf@] ; [5;5] - [0;5] ; [5;5] - [0;1] ; [5;5] - [0;0] ; [5;1] - @NaN@ ; [5;1] - -@Inf@ ; [5;1] - @Inf@ ; [5;1] - 5 ; [5;1] - 1 ; [5;1] - 0 ; [5;1] - [@NaN@] ; [5;1] - [-@Inf@] ; [5;1] - [@Inf@] ; [5;1] - [5] ; [5;1] - [1] ; [5;1] - [0] ; [5;1] - [@NaN@;@NaN@] ; [5;1] - [@NaN@;-@Inf@] ; [5;1] - [@NaN@;@Inf@] ; [5;1] - [@NaN@;5] ; [5;1] - [@NaN@;1] ; [5;1] - [@NaN@;0] ; [5;1] - [-@Inf@;@NaN@] ; [5;1] - [-@Inf@;-@Inf@] ; [5;1] - [-@Inf@;@Inf@] ; [5;1] - [-@Inf@;5] ; [5;1] - [-@Inf@;1] ; [5;1] - [-@Inf@;0] ; [5;1] - [@Inf@;@NaN@] ; [5;1] - [@Inf@;-@Inf@] ; [5;1] - [@Inf@;@Inf@] ; [5;1] - [@Inf@;5] ; [5;1] - [@Inf@;1] ; [5;1] - [@Inf@;0] ; [5;1] - [5;@NaN@] ; [5;1] - [5;-@Inf@] ; [5;1] - [5;@Inf@] ; [5;1] - [5;5] ; [5;1] - [5;1] ; [5;1] - [5;0] ; [5;1] - [1;@NaN@] ; [5;1] - [1;-@Inf@] ; [5;1] - [1;@Inf@] ; [5;1] - [1;5] ; [5;1] - [1;1] ; [5;1] - [1;0] ; [5;1] - [0;@NaN@] ; [5;1] - [0;-@Inf@] ; [5;1] - [0;@Inf@] ; [5;1] - [0;5] ; [5;1] - [0;1] ; [5;1] - [0;0] ; [5;0] - @NaN@ ; [5;0] - -@Inf@ ; [5;0] - @Inf@ ; [5;0] - 5 ; [5;0] - 1 ; [5;0] - 0 ; [5;0] - [@NaN@] ; [5;0] - [-@Inf@] ; [5;0] - [@Inf@] ; [5;0] - [5] ; [5;0] - [1] ; [5;0] - [0] ; [5;0] - [@NaN@;@NaN@] ; [5;0] - [@NaN@;-@Inf@] ; [5;0] - [@NaN@;@Inf@] ; [5;0] - [@NaN@;5] ; [5;0] - [@NaN@;1] ; [5;0] - [@NaN@;0] ; [5;0] - [-@Inf@;@NaN@] ; [5;0] - [-@Inf@;-@Inf@] ; [5;0] - [-@Inf@;@Inf@] ; [5;0] - [-@Inf@;5] ; [5;0] - [-@Inf@;1] ; [5;0] - [-@Inf@;0] ; [5;0] - [@Inf@;@NaN@] ; [5;0] - [@Inf@;-@Inf@] ; [5;0] - [@Inf@;@Inf@] ; [5;0] - [@Inf@;5] ; [5;0] - [@Inf@;1] ; [5;0] - [@Inf@;0] ; [5;0] - [5;@NaN@] ; [5;0] - [5;-@Inf@] ; [5;0] - [5;@Inf@] ; [5;0] - [5;5] ; [5;0] - [5;1] ; [5;0] - [5;0] ; [5;0] - [1;@NaN@] ; [5;0] - [1;-@Inf@] ; [5;0] - [1;@Inf@] ; [5;0] - [1;5] ; [5;0] - [1;1] ; [5;0] - [1;0] ; [5;0] - [0;@NaN@] ; [5;0] - [0;-@Inf@] ; [5;0] - [0;@Inf@] ; [5;0] - [0;5] ; [5;0] - [0;1] ; [5;0] - [0;0] ; [1;@NaN@] - @NaN@ ; [1;@NaN@] - -@Inf@ ; [1;@NaN@] - @Inf@ ; [1;@NaN@] - 5 ; [1;@NaN@] - 1 ; [1;@NaN@] - 0 ; [1;@NaN@] - [@NaN@] ; [1;@NaN@] - [-@Inf@] ; [1;@NaN@] - [@Inf@] ; [1;@NaN@] - [5] ; [1;@NaN@] - [1] ; [1;@NaN@] - [0] ; [1;@NaN@] - [@NaN@;@NaN@] ; [1;@NaN@] - [@NaN@;-@Inf@] ; [1;@NaN@] - [@NaN@;@Inf@] ; [1;@NaN@] - [@NaN@;5] ; [1;@NaN@] - [@NaN@;1] ; [1;@NaN@] - [@NaN@;0] ; [1;@NaN@] - [-@Inf@;@NaN@] ; [1;@NaN@] - [-@Inf@;-@Inf@] ; [1;@NaN@] - [-@Inf@;@Inf@] ; [1;@NaN@] - [-@Inf@;5] ; [1;@NaN@] - [-@Inf@;1] ; [1;@NaN@] - [-@Inf@;0] ; [1;@NaN@] - [@Inf@;@NaN@] ; [1;@NaN@] - [@Inf@;-@Inf@] ; [1;@NaN@] - [@Inf@;@Inf@] ; [1;@NaN@] - [@Inf@;5] ; [1;@NaN@] - [@Inf@;1] ; [1;@NaN@] - [@Inf@;0] ; [1;@NaN@] - [5;@NaN@] ; [1;@NaN@] - [5;-@Inf@] ; [1;@NaN@] - [5;@Inf@] ; [1;@NaN@] - [5;5] ; [1;@NaN@] - [5;1] ; [1;@NaN@] - [5;0] ; [1;@NaN@] - [1;@NaN@] ; [1;@NaN@] - [1;-@Inf@] ; [1;@NaN@] - [1;@Inf@] ; [1;@NaN@] - [1;5] ; [1;@NaN@] - [1;1] ; [1;@NaN@] - [1;0] ; [1;@NaN@] - [0;@NaN@] ; [1;@NaN@] - [0;-@Inf@] ; [1;@NaN@] - [0;@Inf@] ; [1;@NaN@] - [0;5] ; [1;@NaN@] - [0;1] ; [1;@NaN@] - [0;0] ; [1;-@Inf@] - @NaN@ ; [1;-@Inf@] - -@Inf@ ; [1;-@Inf@] - @Inf@ ; [1;-@Inf@] - 5 ; [1;-@Inf@] - 1 ; [1;-@Inf@] - 0 ; [1;-@Inf@] - [@NaN@] ; [1;-@Inf@] - [-@Inf@] ; [1;-@Inf@] - [@Inf@] ; [1;-@Inf@] - [5] ; [1;-@Inf@] - [1] ; [1;-@Inf@] - [0] ; [1;-@Inf@] - [@NaN@;@NaN@] ; [1;-@Inf@] - [@NaN@;-@Inf@] ; [1;-@Inf@] - [@NaN@;@Inf@] ; [1;-@Inf@] - [@NaN@;5] ; [1;-@Inf@] - [@NaN@;1] ; [1;-@Inf@] - [@NaN@;0] ; [1;-@Inf@] - [-@Inf@;@NaN@] ; [1;-@Inf@] - [-@Inf@;-@Inf@] ; [1;-@Inf@] - [-@Inf@;@Inf@] ; [1;-@Inf@] - [-@Inf@;5] ; [1;-@Inf@] - [-@Inf@;1] ; [1;-@Inf@] - [-@Inf@;0] ; [1;-@Inf@] - [@Inf@;@NaN@] ; [1;-@Inf@] - [@Inf@;-@Inf@] ; [1;-@Inf@] - [@Inf@;@Inf@] ; [1;-@Inf@] - [@Inf@;5] ; [1;-@Inf@] - [@Inf@;1] ; [1;-@Inf@] - [@Inf@;0] ; [1;-@Inf@] - [5;@NaN@] ; [1;-@Inf@] - [5;-@Inf@] ; [1;-@Inf@] - [5;@Inf@] ; [1;-@Inf@] - [5;5] ; [1;-@Inf@] - [5;1] ; [1;-@Inf@] - [5;0] ; [1;-@Inf@] - [1;@NaN@] ; [1;-@Inf@] - [1;-@Inf@] ; [1;-@Inf@] - [1;@Inf@] ; [1;-@Inf@] - [1;5] ; [1;-@Inf@] - [1;1] ; [1;-@Inf@] - [1;0] ; [1;-@Inf@] - [0;@NaN@] ; [1;-@Inf@] - [0;-@Inf@] ; [1;-@Inf@] - [0;@Inf@] ; [1;-@Inf@] - [0;5] ; [1;-@Inf@] - [0;1] ; [1;-@Inf@] - [0;0] ; [1;@Inf@] - @NaN@ ; [1;@Inf@] - -@Inf@ ; [1;@Inf@] - @Inf@ ; [1;@Inf@] - 5 ; [1;@Inf@] - 1 ; [1;@Inf@] - 0 ; [1;@Inf@] - [@NaN@] ; [1;@Inf@] - [-@Inf@] ; [1;@Inf@] - [@Inf@] ; [1;@Inf@] - [5] ; [1;@Inf@] - [1] ; [1;@Inf@] - [0] ; [1;@Inf@] - [@NaN@;@NaN@] ; [1;@Inf@] - [@NaN@;-@Inf@] ; [1;@Inf@] - [@NaN@;@Inf@] ; [1;@Inf@] - [@NaN@;5] ; [1;@Inf@] - [@NaN@;1] ; [1;@Inf@] - [@NaN@;0] ; [1;@Inf@] - [-@Inf@;@NaN@] ; [1;@Inf@] - [-@Inf@;-@Inf@] ; [1;@Inf@] - [-@Inf@;@Inf@] ; [1;@Inf@] - [-@Inf@;5] ; [1;@Inf@] - [-@Inf@;1] ; [1;@Inf@] - [-@Inf@;0] ; [1;@Inf@] - [@Inf@;@NaN@] ; [1;@Inf@] - [@Inf@;-@Inf@] ; [1;@Inf@] - [@Inf@;@Inf@] ; [1;@Inf@] - [@Inf@;5] ; [1;@Inf@] - [@Inf@;1] ; [1;@Inf@] - [@Inf@;0] ; [1;@Inf@] - [5;@NaN@] ; [1;@Inf@] - [5;-@Inf@] ; [1;@Inf@] - [5;@Inf@] ; [1;@Inf@] - [5;5] ; [1;@Inf@] - [5;1] ; [1;@Inf@] - [5;0] ; [1;@Inf@] - [1;@NaN@] ; [1;@Inf@] - [1;-@Inf@] ; [1;@Inf@] - [1;@Inf@] ; [1;@Inf@] - [1;5] ; [1;@Inf@] - [1;1] ; [1;@Inf@] - [1;0] ; [1;@Inf@] - [0;@NaN@] ; [1;@Inf@] - [0;-@Inf@] ; [1;@Inf@] - [0;@Inf@] ; [1;@Inf@] - [0;5] ; [1;@Inf@] - [0;1] ; [1;@Inf@] - [0;0] ; [1;5] - @NaN@ ; [1;5] - -@Inf@ ; [1;5] - @Inf@ ; [1;5] - 5 ; [1;5] - 1 ; [1;5] - 0 ; [1;5] - [@NaN@] ; [1;5] - [-@Inf@] ; [1;5] - [@Inf@] ; [1;5] - [5] ; [1;5] - [1] ; [1;5] - [0] ; [1;5] - [@NaN@;@NaN@] ; [1;5] - [@NaN@;-@Inf@] ; [1;5] - [@NaN@;@Inf@] ; [1;5] - [@NaN@;5] ; [1;5] - [@NaN@;1] ; [1;5] - [@NaN@;0] ; [1;5] - [-@Inf@;@NaN@] ; [1;5] - [-@Inf@;-@Inf@] ; [1;5] - [-@Inf@;@Inf@] ; [1;5] - [-@Inf@;5] ; [1;5] - [-@Inf@;1] ; [1;5] - [-@Inf@;0] ; [1;5] - [@Inf@;@NaN@] ; [1;5] - [@Inf@;-@Inf@] ; [1;5] - [@Inf@;@Inf@] ; [1;5] - [@Inf@;5] ; [1;5] - [@Inf@;1] ; [1;5] - [@Inf@;0] ; [1;5] - [5;@NaN@] ; [1;5] - [5;-@Inf@] ; [1;5] - [5;@Inf@] ; [1;5] - [5;5] ; [1;5] - [5;1] ; [1;5] - [5;0] ; [1;5] - [1;@NaN@] ; [1;5] - [1;-@Inf@] ; [1;5] - [1;@Inf@] ; [1;5] - [1;5] ; [1;5] - [1;1] ; [1;5] - [1;0] ; [1;5] - [0;@NaN@] ; [1;5] - [0;-@Inf@] ; [1;5] - [0;@Inf@] ; [1;5] - [0;5] ; [1;5] - [0;1] ; [1;5] - [0;0] ; [1;1] - @NaN@ ; [1;1] - -@Inf@ ; [1;1] - @Inf@ ; [1;1] - 5 ; [1;1] - 1 ; [1;1] - 0 ; [1;1] - [@NaN@] ; [1;1] - [-@Inf@] ; [1;1] - [@Inf@] ; [1;1] - [5] ; [1;1] - [1] ; [1;1] - [0] ; [1;1] - [@NaN@;@NaN@] ; [1;1] - [@NaN@;-@Inf@] ; [1;1] - [@NaN@;@Inf@] ; [1;1] - [@NaN@;5] ; [1;1] - [@NaN@;1] ; [1;1] - [@NaN@;0] ; [1;1] - [-@Inf@;@NaN@] ; [1;1] - [-@Inf@;-@Inf@] ; [1;1] - [-@Inf@;@Inf@] ; [1;1] - [-@Inf@;5] ; [1;1] - [-@Inf@;1] ; [1;1] - [-@Inf@;0] ; [1;1] - [@Inf@;@NaN@] ; [1;1] - [@Inf@;-@Inf@] ; [1;1] - [@Inf@;@Inf@] ; [1;1] - [@Inf@;5] ; [1;1] - [@Inf@;1] ; [1;1] - [@Inf@;0] ; [1;1] - [5;@NaN@] ; [1;1] - [5;-@Inf@] ; [1;1] - [5;@Inf@] ; [1;1] - [5;5] ; [1;1] - [5;1] ; [1;1] - [5;0] ; [1;1] - [1;@NaN@] ; [1;1] - [1;-@Inf@] ; [1;1] - [1;@Inf@] ; [1;1] - [1;5] ; [1;1] - [1;1] ; [1;1] - [1;0] ; [1;1] - [0;@NaN@] ; [1;1] - [0;-@Inf@] ; [1;1] - [0;@Inf@] ; [1;1] - [0;5] ; [1;1] - [0;1] ; [1;1] - [0;0] ; [1;0] - @NaN@ ; [1;0] - -@Inf@ ; [1;0] - @Inf@ ; [1;0] - 5 ; [1;0] - 1 ; [1;0] - 0 ; [1;0] - [@NaN@] ; [1;0] - [-@Inf@] ; [1;0] - [@Inf@] ; [1;0] - [5] ; [1;0] - [1] ; [1;0] - [0] ; [1;0] - [@NaN@;@NaN@] ; [1;0] - [@NaN@;-@Inf@] ; [1;0] - [@NaN@;@Inf@] ; [1;0] - [@NaN@;5] ; [1;0] - [@NaN@;1] ; [1;0] - [@NaN@;0] ; [1;0] - [-@Inf@;@NaN@] ; [1;0] - [-@Inf@;-@Inf@] ; [1;0] - [-@Inf@;@Inf@] ; [1;0] - [-@Inf@;5] ; [1;0] - [-@Inf@;1] ; [1;0] - [-@Inf@;0] ; [1;0] - [@Inf@;@NaN@] ; [1;0] - [@Inf@;-@Inf@] ; [1;0] - [@Inf@;@Inf@] ; [1;0] - [@Inf@;5] ; [1;0] - [@Inf@;1] ; [1;0] - [@Inf@;0] ; [1;0] - [5;@NaN@] ; [1;0] - [5;-@Inf@] ; [1;0] - [5;@Inf@] ; [1;0] - [5;5] ; [1;0] - [5;1] ; [1;0] - [5;0] ; [1;0] - [1;@NaN@] ; [1;0] - [1;-@Inf@] ; [1;0] - [1;@Inf@] ; [1;0] - [1;5] ; [1;0] - [1;1] ; [1;0] - [1;0] ; [1;0] - [0;@NaN@] ; [1;0] - [0;-@Inf@] ; [1;0] - [0;@Inf@] ; [1;0] - [0;5] ; [1;0] - [0;1] ; [1;0] - [0;0] ; [0;@NaN@] - @NaN@ ; [0;@NaN@] - -@Inf@ ; [0;@NaN@] - @Inf@ ; [0;@NaN@] - 5 ; [0;@NaN@] - 1 ; [0;@NaN@] - 0 ; [0;@NaN@] - [@NaN@] ; [0;@NaN@] - [-@Inf@] ; [0;@NaN@] - [@Inf@] ; [0;@NaN@] - [5] ; [0;@NaN@] - [1] ; [0;@NaN@] - [0] ; [0;@NaN@] - [@NaN@;@NaN@] ; [0;@NaN@] - [@NaN@;-@Inf@] ; [0;@NaN@] - [@NaN@;@Inf@] ; [0;@NaN@] - [@NaN@;5] ; [0;@NaN@] - [@NaN@;1] ; [0;@NaN@] - [@NaN@;0] ; [0;@NaN@] - [-@Inf@;@NaN@] ; [0;@NaN@] - [-@Inf@;-@Inf@] ; [0;@NaN@] - [-@Inf@;@Inf@] ; [0;@NaN@] - [-@Inf@;5] ; [0;@NaN@] - [-@Inf@;1] ; [0;@NaN@] - [-@Inf@;0] ; [0;@NaN@] - [@Inf@;@NaN@] ; [0;@NaN@] - [@Inf@;-@Inf@] ; [0;@NaN@] - [@Inf@;@Inf@] ; [0;@NaN@] - [@Inf@;5] ; [0;@NaN@] - [@Inf@;1] ; [0;@NaN@] - [@Inf@;0] ; [0;@NaN@] - [5;@NaN@] ; [0;@NaN@] - [5;-@Inf@] ; [0;@NaN@] - [5;@Inf@] ; [0;@NaN@] - [5;5] ; [0;@NaN@] - [5;1] ; [0;@NaN@] - [5;0] ; [0;@NaN@] - [1;@NaN@] ; [0;@NaN@] - [1;-@Inf@] ; [0;@NaN@] - [1;@Inf@] ; [0;@NaN@] - [1;5] ; [0;@NaN@] - [1;1] ; [0;@NaN@] - [1;0] ; [0;@NaN@] - [0;@NaN@] ; [0;@NaN@] - [0;-@Inf@] ; [0;@NaN@] - [0;@Inf@] ; [0;@NaN@] - [0;5] ; [0;@NaN@] - [0;1] ; [0;@NaN@] - [0;0] ; [0;-@Inf@] - @NaN@ ; [0;-@Inf@] - -@Inf@ ; [0;-@Inf@] - @Inf@ ; [0;-@Inf@] - 5 ; [0;-@Inf@] - 1 ; [0;-@Inf@] - 0 ; [0;-@Inf@] - [@NaN@] ; [0;-@Inf@] - [-@Inf@] ; [0;-@Inf@] - [@Inf@] ; [0;-@Inf@] - [5] ; [0;-@Inf@] - [1] ; [0;-@Inf@] - [0] ; [0;-@Inf@] - [@NaN@;@NaN@] ; [0;-@Inf@] - [@NaN@;-@Inf@] ; [0;-@Inf@] - [@NaN@;@Inf@] ; [0;-@Inf@] - [@NaN@;5] ; [0;-@Inf@] - [@NaN@;1] ; [0;-@Inf@] - [@NaN@;0] ; [0;-@Inf@] - [-@Inf@;@NaN@] ; [0;-@Inf@] - [-@Inf@;-@Inf@] ; [0;-@Inf@] - [-@Inf@;@Inf@] ; [0;-@Inf@] - [-@Inf@;5] ; [0;-@Inf@] - [-@Inf@;1] ; [0;-@Inf@] - [-@Inf@;0] ; [0;-@Inf@] - [@Inf@;@NaN@] ; [0;-@Inf@] - [@Inf@;-@Inf@] ; [0;-@Inf@] - [@Inf@;@Inf@] ; [0;-@Inf@] - [@Inf@;5] ; [0;-@Inf@] - [@Inf@;1] ; [0;-@Inf@] - [@Inf@;0] ; [0;-@Inf@] - [5;@NaN@] ; [0;-@Inf@] - [5;-@Inf@] ; [0;-@Inf@] - [5;@Inf@] ; [0;-@Inf@] - [5;5] ; [0;-@Inf@] - [5;1] ; [0;-@Inf@] - [5;0] ; [0;-@Inf@] - [1;@NaN@] ; [0;-@Inf@] - [1;-@Inf@] ; [0;-@Inf@] - [1;@Inf@] ; [0;-@Inf@] - [1;5] ; [0;-@Inf@] - [1;1] ; [0;-@Inf@] - [1;0] ; [0;-@Inf@] - [0;@NaN@] ; [0;-@Inf@] - [0;-@Inf@] ; [0;-@Inf@] - [0;@Inf@] ; [0;-@Inf@] - [0;5] ; [0;-@Inf@] - [0;1] ; [0;-@Inf@] - [0;0] ; [0;@Inf@] - @NaN@ ; [0;@Inf@] - -@Inf@ ; [0;@Inf@] - @Inf@ ; [0;@Inf@] - 5 ; [0;@Inf@] - 1 ; [0;@Inf@] - 0 ; [0;@Inf@] - [@NaN@] ; [0;@Inf@] - [-@Inf@] ; [0;@Inf@] - [@Inf@] ; [0;@Inf@] - [5] ; [0;@Inf@] - [1] ; [0;@Inf@] - [0] ; [0;@Inf@] - [@NaN@;@NaN@] ; [0;@Inf@] - [@NaN@;-@Inf@] ; [0;@Inf@] - [@NaN@;@Inf@] ; [0;@Inf@] - [@NaN@;5] ; [0;@Inf@] - [@NaN@;1] ; [0;@Inf@] - [@NaN@;0] ; [0;@Inf@] - [-@Inf@;@NaN@] ; [0;@Inf@] - [-@Inf@;-@Inf@] ; [0;@Inf@] - [-@Inf@;@Inf@] ; [0;@Inf@] - [-@Inf@;5] ; [0;@Inf@] - [-@Inf@;1] ; [0;@Inf@] - [-@Inf@;0] ; [0;@Inf@] - [@Inf@;@NaN@] ; [0;@Inf@] - [@Inf@;-@Inf@] ; [0;@Inf@] - [@Inf@;@Inf@] ; [0;@Inf@] - [@Inf@;5] ; [0;@Inf@] - [@Inf@;1] ; [0;@Inf@] - [@Inf@;0] ; [0;@Inf@] - [5;@NaN@] ; [0;@Inf@] - [5;-@Inf@] ; [0;@Inf@] - [5;@Inf@] ; [0;@Inf@] - [5;5] ; [0;@Inf@] - [5;1] ; [0;@Inf@] - [5;0] ; [0;@Inf@] - [1;@NaN@] ; [0;@Inf@] - [1;-@Inf@] ; [0;@Inf@] - [1;@Inf@] ; [0;@Inf@] - [1;5] ; [0;@Inf@] - [1;1] ; [0;@Inf@] - [1;0] ; [0;@Inf@] - [0;@NaN@] ; [0;@Inf@] - [0;-@Inf@] ; [0;@Inf@] - [0;@Inf@] ; [0;@Inf@] - [0;5] ; [0;@Inf@] - [0;1] ; [0;@Inf@] - [0;0] ; [0;5] - @NaN@ ; [0;5] - -@Inf@ ; [0;5] - @Inf@ ; [0;5] - 5 ; [0;5] - 1 ; [0;5] - 0 ; [0;5] - [@NaN@] ; [0;5] - [-@Inf@] ; [0;5] - [@Inf@] ; [0;5] - [5] ; [0;5] - [1] ; [0;5] - [0] ; [0;5] - [@NaN@;@NaN@] ; [0;5] - [@NaN@;-@Inf@] ; [0;5] - [@NaN@;@Inf@] ; [0;5] - [@NaN@;5] ; [0;5] - [@NaN@;1] ; [0;5] - [@NaN@;0] ; [0;5] - [-@Inf@;@NaN@] ; [0;5] - [-@Inf@;-@Inf@] ; [0;5] - [-@Inf@;@Inf@] ; [0;5] - [-@Inf@;5] ; [0;5] - [-@Inf@;1] ; [0;5] - [-@Inf@;0] ; [0;5] - [@Inf@;@NaN@] ; [0;5] - [@Inf@;-@Inf@] ; [0;5] - [@Inf@;@Inf@] ; [0;5] - [@Inf@;5] ; [0;5] - [@Inf@;1] ; [0;5] - [@Inf@;0] ; [0;5] - [5;@NaN@] ; [0;5] - [5;-@Inf@] ; [0;5] - [5;@Inf@] ; [0;5] - [5;5] ; [0;5] - [5;1] ; [0;5] - [5;0] ; [0;5] - [1;@NaN@] ; [0;5] - [1;-@Inf@] ; [0;5] - [1;@Inf@] ; [0;5] - [1;5] ; [0;5] - [1;1] ; [0;5] - [1;0] ; [0;5] - [0;@NaN@] ; [0;5] - [0;-@Inf@] ; [0;5] - [0;@Inf@] ; [0;5] - [0;5] ; [0;5] - [0;1] ; [0;5] - [0;0] ; [0;1] - @NaN@ ; [0;1] - -@Inf@ ; [0;1] - @Inf@ ; [0;1] - 5 ; [0;1] - 1 ; [0;1] - 0 ; [0;1] - [@NaN@] ; [0;1] - [-@Inf@] ; [0;1] - [@Inf@] ; [0;1] - [5] ; [0;1] - [1] ; [0;1] - [0] ; [0;1] - [@NaN@;@NaN@] ; [0;1] - [@NaN@;-@Inf@] ; [0;1] - [@NaN@;@Inf@] ; [0;1] - [@NaN@;5] ; [0;1] - [@NaN@;1] ; [0;1] - [@NaN@;0] ; [0;1] - [-@Inf@;@NaN@] ; [0;1] - [-@Inf@;-@Inf@] ; [0;1] - [-@Inf@;@Inf@] ; [0;1] - [-@Inf@;5] ; [0;1] - [-@Inf@;1] ; [0;1] - [-@Inf@;0] ; [0;1] - [@Inf@;@NaN@] ; [0;1] - [@Inf@;-@Inf@] ; [0;1] - [@Inf@;@Inf@] ; [0;1] - [@Inf@;5] ; [0;1] - [@Inf@;1] ; [0;1] - [@Inf@;0] ; [0;1] - [5;@NaN@] ; [0;1] - [5;-@Inf@] ; [0;1] - [5;@Inf@] ; [0;1] - [5;5] ; [0;1] - [5;1] ; [0;1] - [5;0] ; [0;1] - [1;@NaN@] ; [0;1] - [1;-@Inf@] ; [0;1] - [1;@Inf@] ; [0;1] - [1;5] ; [0;1] - [1;1] ; [0;1] - [1;0] ; [0;1] - [0;@NaN@] ; [0;1] - [0;-@Inf@] ; [0;1] - [0;@Inf@] ; [0;1] - [0;5] ; [0;1] - [0;1] ; [0;1] - [0;0] ; [0;0] - @NaN@ ; [0;0] - -@Inf@ ; [0;0] - @Inf@ ; [0;0] - 5 ; [0;0] - 1 ; [0;0] - 0 ; [0;0] - [@NaN@] ; [0;0] - [-@Inf@] ; [0;0] - [@Inf@] ; [0;0] - [5] ; [0;0] - [1] ; [0;0] - [0] ; [0;0] - [@NaN@;@NaN@] ; [0;0] - [@NaN@;-@Inf@] ; [0;0] - [@NaN@;@Inf@] ; [0;0] - [@NaN@;5] ; [0;0] - [@NaN@;1] ; [0;0] - [@NaN@;0] ; [0;0] - [-@Inf@;@NaN@] ; [0;0] - [-@Inf@;-@Inf@] ; [0;0] - [-@Inf@;@Inf@] ; [0;0] - [-@Inf@;5] ; [0;0] - [-@Inf@;1] ; [0;0] - [-@Inf@;0] ; [0;0] - [@Inf@;@NaN@] ; [0;0] - [@Inf@;-@Inf@] ; [0;0] - [@Inf@;@Inf@] ; [0;0] - [@Inf@;5] ; [0;0] - [@Inf@;1] ; [0;0] - [@Inf@;0] ; [0;0] - [5;@NaN@] ; [0;0] - [5;-@Inf@] ; [0;0] - [5;@Inf@] ; [0;0] - [5;5] ; [0;0] - [5;1] ; [0;0] - [5;0] ; [0;0] - [1;@NaN@] ; [0;0] - [1;-@Inf@] ; [0;0] - [1;@Inf@] ; [0;0] - [1;5] ; [0;0] - [1;1] ; [0;0] - [1;0] ; [0;0] - [0;@NaN@] ; [0;0] - [0;-@Inf@] ; [0;0] - [0;@Inf@] ; [0;0] - [0;5] ; [0;0] - [0;1] ; [0;0] - [0;0] ; @NaN@ * @NaN@ ; @NaN@ * -@Inf@ ; @NaN@ * @Inf@ ; @NaN@ * 5 ; @NaN@ * 1 ; @NaN@ * 0 ; @NaN@ * [@NaN@] ; @NaN@ * [-@Inf@] ; @NaN@ * [@Inf@] ; @NaN@ * [5] ; @NaN@ * [1] ; @NaN@ * [0] ; @NaN@ * [@NaN@;@NaN@] ; @NaN@ * [@NaN@;-@Inf@] ; @NaN@ * [@NaN@;@Inf@] ; @NaN@ * [@NaN@;5] ; @NaN@ * [@NaN@;1] ; @NaN@ * [@NaN@;0] ; @NaN@ * [-@Inf@;@NaN@] ; @NaN@ * [-@Inf@;-@Inf@] ; @NaN@ * [-@Inf@;@Inf@] ; @NaN@ * [-@Inf@;5] ; @NaN@ * [-@Inf@;1] ; @NaN@ * [-@Inf@;0] ; @NaN@ * [@Inf@;@NaN@] ; @NaN@ * [@Inf@;-@Inf@] ; @NaN@ * [@Inf@;@Inf@] ; @NaN@ * [@Inf@;5] ; @NaN@ * [@Inf@;1] ; @NaN@ * [@Inf@;0] ; @NaN@ * [5;@NaN@] ; @NaN@ * [5;-@Inf@] ; @NaN@ * [5;@Inf@] ; @NaN@ * [5;5] ; @NaN@ * [5;1] ; @NaN@ * [5;0] ; @NaN@ * [1;@NaN@] ; @NaN@ * [1;-@Inf@] ; @NaN@ * [1;@Inf@] ; @NaN@ * [1;5] ; @NaN@ * [1;1] ; @NaN@ * [1;0] ; @NaN@ * [0;@NaN@] ; @NaN@ * [0;-@Inf@] ; @NaN@ * [0;@Inf@] ; @NaN@ * [0;5] ; @NaN@ * [0;1] ; @NaN@ * [0;0] ; -@Inf@ * @NaN@ ; -@Inf@ * -@Inf@ ; -@Inf@ * @Inf@ ; -@Inf@ * 5 ; -@Inf@ * 1 ; -@Inf@ * 0 ; -@Inf@ * [@NaN@] ; -@Inf@ * [-@Inf@] ; -@Inf@ * [@Inf@] ; -@Inf@ * [5] ; -@Inf@ * [1] ; -@Inf@ * [0] ; -@Inf@ * [@NaN@;@NaN@] ; -@Inf@ * [@NaN@;-@Inf@] ; -@Inf@ * [@NaN@;@Inf@] ; -@Inf@ * [@NaN@;5] ; -@Inf@ * [@NaN@;1] ; -@Inf@ * [@NaN@;0] ; -@Inf@ * [-@Inf@;@NaN@] ; -@Inf@ * [-@Inf@;-@Inf@] ; -@Inf@ * [-@Inf@;@Inf@] ; -@Inf@ * [-@Inf@;5] ; -@Inf@ * [-@Inf@;1] ; -@Inf@ * [-@Inf@;0] ; -@Inf@ * [@Inf@;@NaN@] ; -@Inf@ * [@Inf@;-@Inf@] ; -@Inf@ * [@Inf@;@Inf@] ; -@Inf@ * [@Inf@;5] ; -@Inf@ * [@Inf@;1] ; -@Inf@ * [@Inf@;0] ; -@Inf@ * [5;@NaN@] ; -@Inf@ * [5;-@Inf@] ; -@Inf@ * [5;@Inf@] ; -@Inf@ * [5;5] ; -@Inf@ * [5;1] ; -@Inf@ * [5;0] ; -@Inf@ * [1;@NaN@] ; -@Inf@ * [1;-@Inf@] ; -@Inf@ * [1;@Inf@] ; -@Inf@ * [1;5] ; -@Inf@ * [1;1] ; -@Inf@ * [1;0] ; -@Inf@ * [0;@NaN@] ; -@Inf@ * [0;-@Inf@] ; -@Inf@ * [0;@Inf@] ; -@Inf@ * [0;5] ; -@Inf@ * [0;1] ; -@Inf@ * [0;0] ; @Inf@ * @NaN@ ; @Inf@ * -@Inf@ ; @Inf@ * @Inf@ ; @Inf@ * 5 ; @Inf@ * 1 ; @Inf@ * 0 ; @Inf@ * [@NaN@] ; @Inf@ * [-@Inf@] ; @Inf@ * [@Inf@] ; @Inf@ * [5] ; @Inf@ * [1] ; @Inf@ * [0] ; @Inf@ * [@NaN@;@NaN@] ; @Inf@ * [@NaN@;-@Inf@] ; @Inf@ * [@NaN@;@Inf@] ; @Inf@ * [@NaN@;5] ; @Inf@ * [@NaN@;1] ; @Inf@ * [@NaN@;0] ; @Inf@ * [-@Inf@;@NaN@] ; @Inf@ * [-@Inf@;-@Inf@] ; @Inf@ * [-@Inf@;@Inf@] ; @Inf@ * [-@Inf@;5] ; @Inf@ * [-@Inf@;1] ; @Inf@ * [-@Inf@;0] ; @Inf@ * [@Inf@;@NaN@] ; @Inf@ * [@Inf@;-@Inf@] ; @Inf@ * [@Inf@;@Inf@] ; @Inf@ * [@Inf@;5] ; @Inf@ * [@Inf@;1] ; @Inf@ * [@Inf@;0] ; @Inf@ * [5;@NaN@] ; @Inf@ * [5;-@Inf@] ; @Inf@ * [5;@Inf@] ; @Inf@ * [5;5] ; @Inf@ * [5;1] ; @Inf@ * [5;0] ; @Inf@ * [1;@NaN@] ; @Inf@ * [1;-@Inf@] ; @Inf@ * [1;@Inf@] ; @Inf@ * [1;5] ; @Inf@ * [1;1] ; @Inf@ * [1;0] ; @Inf@ * [0;@NaN@] ; @Inf@ * [0;-@Inf@] ; @Inf@ * [0;@Inf@] ; @Inf@ * [0;5] ; @Inf@ * [0;1] ; @Inf@ * [0;0] ; 5 * @NaN@ ; 5 * -@Inf@ ; 5 * @Inf@ ; 5 * 5 ; 5 * 1 ; 5 * 0 ; 5 * [@NaN@] ; 5 * [-@Inf@] ; 5 * [@Inf@] ; 5 * [5] ; 5 * [1] ; 5 * [0] ; 5 * [@NaN@;@NaN@] ; 5 * [@NaN@;-@Inf@] ; 5 * [@NaN@;@Inf@] ; 5 * [@NaN@;5] ; 5 * [@NaN@;1] ; 5 * [@NaN@;0] ; 5 * [-@Inf@;@NaN@] ; 5 * [-@Inf@;-@Inf@] ; 5 * [-@Inf@;@Inf@] ; 5 * [-@Inf@;5] ; 5 * [-@Inf@;1] ; 5 * [-@Inf@;0] ; 5 * [@Inf@;@NaN@] ; 5 * [@Inf@;-@Inf@] ; 5 * [@Inf@;@Inf@] ; 5 * [@Inf@;5] ; 5 * [@Inf@;1] ; 5 * [@Inf@;0] ; 5 * [5;@NaN@] ; 5 * [5;-@Inf@] ; 5 * [5;@Inf@] ; 5 * [5;5] ; 5 * [5;1] ; 5 * [5;0] ; 5 * [1;@NaN@] ; 5 * [1;-@Inf@] ; 5 * [1;@Inf@] ; 5 * [1;5] ; 5 * [1;1] ; 5 * [1;0] ; 5 * [0;@NaN@] ; 5 * [0;-@Inf@] ; 5 * [0;@Inf@] ; 5 * [0;5] ; 5 * [0;1] ; 5 * [0;0] ; 1 * @NaN@ ; 1 * -@Inf@ ; 1 * @Inf@ ; 1 * 5 ; 1 * 1 ; 1 * 0 ; 1 * [@NaN@] ; 1 * [-@Inf@] ; 1 * [@Inf@] ; 1 * [5] ; 1 * [1] ; 1 * [0] ; 1 * [@NaN@;@NaN@] ; 1 * [@NaN@;-@Inf@] ; 1 * [@NaN@;@Inf@] ; 1 * [@NaN@;5] ; 1 * [@NaN@;1] ; 1 * [@NaN@;0] ; 1 * [-@Inf@;@NaN@] ; 1 * [-@Inf@;-@Inf@] ; 1 * [-@Inf@;@Inf@] ; 1 * [-@Inf@;5] ; 1 * [-@Inf@;1] ; 1 * [-@Inf@;0] ; 1 * [@Inf@;@NaN@] ; 1 * [@Inf@;-@Inf@] ; 1 * [@Inf@;@Inf@] ; 1 * [@Inf@;5] ; 1 * [@Inf@;1] ; 1 * [@Inf@;0] ; 1 * [5;@NaN@] ; 1 * [5;-@Inf@] ; 1 * [5;@Inf@] ; 1 * [5;5] ; 1 * [5;1] ; 1 * [5;0] ; 1 * [1;@NaN@] ; 1 * [1;-@Inf@] ; 1 * [1;@Inf@] ; 1 * [1;5] ; 1 * [1;1] ; 1 * [1;0] ; 1 * [0;@NaN@] ; 1 * [0;-@Inf@] ; 1 * [0;@Inf@] ; 1 * [0;5] ; 1 * [0;1] ; 1 * [0;0] ; 0 * @NaN@ ; 0 * -@Inf@ ; 0 * @Inf@ ; 0 * 5 ; 0 * 1 ; 0 * 0 ; 0 * [@NaN@] ; 0 * [-@Inf@] ; 0 * [@Inf@] ; 0 * [5] ; 0 * [1] ; 0 * [0] ; 0 * [@NaN@;@NaN@] ; 0 * [@NaN@;-@Inf@] ; 0 * [@NaN@;@Inf@] ; 0 * [@NaN@;5] ; 0 * [@NaN@;1] ; 0 * [@NaN@;0] ; 0 * [-@Inf@;@NaN@] ; 0 * [-@Inf@;-@Inf@] ; 0 * [-@Inf@;@Inf@] ; 0 * [-@Inf@;5] ; 0 * [-@Inf@;1] ; 0 * [-@Inf@;0] ; 0 * [@Inf@;@NaN@] ; 0 * [@Inf@;-@Inf@] ; 0 * [@Inf@;@Inf@] ; 0 * [@Inf@;5] ; 0 * [@Inf@;1] ; 0 * [@Inf@;0] ; 0 * [5;@NaN@] ; 0 * [5;-@Inf@] ; 0 * [5;@Inf@] ; 0 * [5;5] ; 0 * [5;1] ; 0 * [5;0] ; 0 * [1;@NaN@] ; 0 * [1;-@Inf@] ; 0 * [1;@Inf@] ; 0 * [1;5] ; 0 * [1;1] ; 0 * [1;0] ; 0 * [0;@NaN@] ; 0 * [0;-@Inf@] ; 0 * [0;@Inf@] ; 0 * [0;5] ; 0 * [0;1] ; 0 * [0;0] ; [@NaN@] * @NaN@ ; [@NaN@] * -@Inf@ ; [@NaN@] * @Inf@ ; [@NaN@] * 5 ; [@NaN@] * 1 ; [@NaN@] * 0 ; [@NaN@] * [@NaN@] ; [@NaN@] * [-@Inf@] ; [@NaN@] * [@Inf@] ; [@NaN@] * [5] ; [@NaN@] * [1] ; [@NaN@] * [0] ; [@NaN@] * [@NaN@;@NaN@] ; [@NaN@] * [@NaN@;-@Inf@] ; [@NaN@] * [@NaN@;@Inf@] ; [@NaN@] * [@NaN@;5] ; [@NaN@] * [@NaN@;1] ; [@NaN@] * [@NaN@;0] ; [@NaN@] * [-@Inf@;@NaN@] ; [@NaN@] * [-@Inf@;-@Inf@] ; [@NaN@] * [-@Inf@;@Inf@] ; [@NaN@] * [-@Inf@;5] ; [@NaN@] * [-@Inf@;1] ; [@NaN@] * [-@Inf@;0] ; [@NaN@] * [@Inf@;@NaN@] ; [@NaN@] * [@Inf@;-@Inf@] ; [@NaN@] * [@Inf@;@Inf@] ; [@NaN@] * [@Inf@;5] ; [@NaN@] * [@Inf@;1] ; [@NaN@] * [@Inf@;0] ; [@NaN@] * [5;@NaN@] ; [@NaN@] * [5;-@Inf@] ; [@NaN@] * [5;@Inf@] ; [@NaN@] * [5;5] ; [@NaN@] * [5;1] ; [@NaN@] * [5;0] ; [@NaN@] * [1;@NaN@] ; [@NaN@] * [1;-@Inf@] ; [@NaN@] * [1;@Inf@] ; [@NaN@] * [1;5] ; [@NaN@] * [1;1] ; [@NaN@] * [1;0] ; [@NaN@] * [0;@NaN@] ; [@NaN@] * [0;-@Inf@] ; [@NaN@] * [0;@Inf@] ; [@NaN@] * [0;5] ; [@NaN@] * [0;1] ; [@NaN@] * [0;0] ; [-@Inf@] * @NaN@ ; [-@Inf@] * -@Inf@ ; [-@Inf@] * @Inf@ ; [-@Inf@] * 5 ; [-@Inf@] * 1 ; [-@Inf@] * 0 ; [-@Inf@] * [@NaN@] ; [-@Inf@] * [-@Inf@] ; [-@Inf@] * [@Inf@] ; [-@Inf@] * [5] ; [-@Inf@] * [1] ; [-@Inf@] * [0] ; [-@Inf@] * [@NaN@;@NaN@] ; [-@Inf@] * [@NaN@;-@Inf@] ; [-@Inf@] * [@NaN@;@Inf@] ; [-@Inf@] * [@NaN@;5] ; [-@Inf@] * [@NaN@;1] ; [-@Inf@] * [@NaN@;0] ; [-@Inf@] * [-@Inf@;@NaN@] ; [-@Inf@] * [-@Inf@;-@Inf@] ; [-@Inf@] * [-@Inf@;@Inf@] ; [-@Inf@] * [-@Inf@;5] ; [-@Inf@] * [-@Inf@;1] ; [-@Inf@] * [-@Inf@;0] ; [-@Inf@] * [@Inf@;@NaN@] ; [-@Inf@] * [@Inf@;-@Inf@] ; [-@Inf@] * [@Inf@;@Inf@] ; [-@Inf@] * [@Inf@;5] ; [-@Inf@] * [@Inf@;1] ; [-@Inf@] * [@Inf@;0] ; [-@Inf@] * [5;@NaN@] ; [-@Inf@] * [5;-@Inf@] ; [-@Inf@] * [5;@Inf@] ; [-@Inf@] * [5;5] ; [-@Inf@] * [5;1] ; [-@Inf@] * [5;0] ; [-@Inf@] * [1;@NaN@] ; [-@Inf@] * [1;-@Inf@] ; [-@Inf@] * [1;@Inf@] ; [-@Inf@] * [1;5] ; [-@Inf@] * [1;1] ; [-@Inf@] * [1;0] ; [-@Inf@] * [0;@NaN@] ; [-@Inf@] * [0;-@Inf@] ; [-@Inf@] * [0;@Inf@] ; [-@Inf@] * [0;5] ; [-@Inf@] * [0;1] ; [-@Inf@] * [0;0] ; [@Inf@] * @NaN@ ; [@Inf@] * -@Inf@ ; [@Inf@] * @Inf@ ; [@Inf@] * 5 ; [@Inf@] * 1 ; [@Inf@] * 0 ; [@Inf@] * [@NaN@] ; [@Inf@] * [-@Inf@] ; [@Inf@] * [@Inf@] ; [@Inf@] * [5] ; [@Inf@] * [1] ; [@Inf@] * [0] ; [@Inf@] * [@NaN@;@NaN@] ; [@Inf@] * [@NaN@;-@Inf@] ; [@Inf@] * [@NaN@;@Inf@] ; [@Inf@] * [@NaN@;5] ; [@Inf@] * [@NaN@;1] ; [@Inf@] * [@NaN@;0] ; [@Inf@] * [-@Inf@;@NaN@] ; [@Inf@] * [-@Inf@;-@Inf@] ; [@Inf@] * [-@Inf@;@Inf@] ; [@Inf@] * [-@Inf@;5] ; [@Inf@] * [-@Inf@;1] ; [@Inf@] * [-@Inf@;0] ; [@Inf@] * [@Inf@;@NaN@] ; [@Inf@] * [@Inf@;-@Inf@] ; [@Inf@] * [@Inf@;@Inf@] ; [@Inf@] * [@Inf@;5] ; [@Inf@] * [@Inf@;1] ; [@Inf@] * [@Inf@;0] ; [@Inf@] * [5;@NaN@] ; [@Inf@] * [5;-@Inf@] ; [@Inf@] * [5;@Inf@] ; [@Inf@] * [5;5] ; [@Inf@] * [5;1] ; [@Inf@] * [5;0] ; [@Inf@] * [1;@NaN@] ; [@Inf@] * [1;-@Inf@] ; [@Inf@] * [1;@Inf@] ; [@Inf@] * [1;5] ; [@Inf@] * [1;1] ; [@Inf@] * [1;0] ; [@Inf@] * [0;@NaN@] ; [@Inf@] * [0;-@Inf@] ; [@Inf@] * [0;@Inf@] ; [@Inf@] * [0;5] ; [@Inf@] * [0;1] ; [@Inf@] * [0;0] ; [5] * @NaN@ ; [5] * -@Inf@ ; [5] * @Inf@ ; [5] * 5 ; [5] * 1 ; [5] * 0 ; [5] * [@NaN@] ; [5] * [-@Inf@] ; [5] * [@Inf@] ; [5] * [5] ; [5] * [1] ; [5] * [0] ; [5] * [@NaN@;@NaN@] ; [5] * [@NaN@;-@Inf@] ; [5] * [@NaN@;@Inf@] ; [5] * [@NaN@;5] ; [5] * [@NaN@;1] ; [5] * [@NaN@;0] ; [5] * [-@Inf@;@NaN@] ; [5] * [-@Inf@;-@Inf@] ; [5] * [-@Inf@;@Inf@] ; [5] * [-@Inf@;5] ; [5] * [-@Inf@;1] ; [5] * [-@Inf@;0] ; [5] * [@Inf@;@NaN@] ; [5] * [@Inf@;-@Inf@] ; [5] * [@Inf@;@Inf@] ; [5] * [@Inf@;5] ; [5] * [@Inf@;1] ; [5] * [@Inf@;0] ; [5] * [5;@NaN@] ; [5] * [5;-@Inf@] ; [5] * [5;@Inf@] ; [5] * [5;5] ; [5] * [5;1] ; [5] * [5;0] ; [5] * [1;@NaN@] ; [5] * [1;-@Inf@] ; [5] * [1;@Inf@] ; [5] * [1;5] ; [5] * [1;1] ; [5] * [1;0] ; [5] * [0;@NaN@] ; [5] * [0;-@Inf@] ; [5] * [0;@Inf@] ; [5] * [0;5] ; [5] * [0;1] ; [5] * [0;0] ; [1] * @NaN@ ; [1] * -@Inf@ ; [1] * @Inf@ ; [1] * 5 ; [1] * 1 ; [1] * 0 ; [1] * [@NaN@] ; [1] * [-@Inf@] ; [1] * [@Inf@] ; [1] * [5] ; [1] * [1] ; [1] * [0] ; [1] * [@NaN@;@NaN@] ; [1] * [@NaN@;-@Inf@] ; [1] * [@NaN@;@Inf@] ; [1] * [@NaN@;5] ; [1] * [@NaN@;1] ; [1] * [@NaN@;0] ; [1] * [-@Inf@;@NaN@] ; [1] * [-@Inf@;-@Inf@] ; [1] * [-@Inf@;@Inf@] ; [1] * [-@Inf@;5] ; [1] * [-@Inf@;1] ; [1] * [-@Inf@;0] ; [1] * [@Inf@;@NaN@] ; [1] * [@Inf@;-@Inf@] ; [1] * [@Inf@;@Inf@] ; [1] * [@Inf@;5] ; [1] * [@Inf@;1] ; [1] * [@Inf@;0] ; [1] * [5;@NaN@] ; [1] * [5;-@Inf@] ; [1] * [5;@Inf@] ; [1] * [5;5] ; [1] * [5;1] ; [1] * [5;0] ; [1] * [1;@NaN@] ; [1] * [1;-@Inf@] ; [1] * [1;@Inf@] ; [1] * [1;5] ; [1] * [1;1] ; [1] * [1;0] ; [1] * [0;@NaN@] ; [1] * [0;-@Inf@] ; [1] * [0;@Inf@] ; [1] * [0;5] ; [1] * [0;1] ; [1] * [0;0] ; [0] * @NaN@ ; [0] * -@Inf@ ; [0] * @Inf@ ; [0] * 5 ; [0] * 1 ; [0] * 0 ; [0] * [@NaN@] ; [0] * [-@Inf@] ; [0] * [@Inf@] ; [0] * [5] ; [0] * [1] ; [0] * [0] ; [0] * [@NaN@;@NaN@] ; [0] * [@NaN@;-@Inf@] ; [0] * [@NaN@;@Inf@] ; [0] * [@NaN@;5] ; [0] * [@NaN@;1] ; [0] * [@NaN@;0] ; [0] * [-@Inf@;@NaN@] ; [0] * [-@Inf@;-@Inf@] ; [0] * [-@Inf@;@Inf@] ; [0] * [-@Inf@;5] ; [0] * [-@Inf@;1] ; [0] * [-@Inf@;0] ; [0] * [@Inf@;@NaN@] ; [0] * [@Inf@;-@Inf@] ; [0] * [@Inf@;@Inf@] ; [0] * [@Inf@;5] ; [0] * [@Inf@;1] ; [0] * [@Inf@;0] ; [0] * [5;@NaN@] ; [0] * [5;-@Inf@] ; [0] * [5;@Inf@] ; [0] * [5;5] ; [0] * [5;1] ; [0] * [5;0] ; [0] * [1;@NaN@] ; [0] * [1;-@Inf@] ; [0] * [1;@Inf@] ; [0] * [1;5] ; [0] * [1;1] ; [0] * [1;0] ; [0] * [0;@NaN@] ; [0] * [0;-@Inf@] ; [0] * [0;@Inf@] ; [0] * [0;5] ; [0] * [0;1] ; [0] * [0;0] ; [@NaN@;@NaN@] * @NaN@ ; [@NaN@;@NaN@] * -@Inf@ ; [@NaN@;@NaN@] * @Inf@ ; [@NaN@;@NaN@] * 5 ; [@NaN@;@NaN@] * 1 ; [@NaN@;@NaN@] * 0 ; [@NaN@;@NaN@] * [@NaN@] ; [@NaN@;@NaN@] * [-@Inf@] ; [@NaN@;@NaN@] * [@Inf@] ; [@NaN@;@NaN@] * [5] ; [@NaN@;@NaN@] * [1] ; [@NaN@;@NaN@] * [0] ; [@NaN@;@NaN@] * [@NaN@;@NaN@] ; [@NaN@;@NaN@] * [@NaN@;-@Inf@] ; [@NaN@;@NaN@] * [@NaN@;@Inf@] ; [@NaN@;@NaN@] * [@NaN@;5] ; [@NaN@;@NaN@] * [@NaN@;1] ; [@NaN@;@NaN@] * [@NaN@;0] ; [@NaN@;@NaN@] * [-@Inf@;@NaN@] ; [@NaN@;@NaN@] * [-@Inf@;-@Inf@] ; [@NaN@;@NaN@] * [-@Inf@;@Inf@] ; [@NaN@;@NaN@] * [-@Inf@;5] ; [@NaN@;@NaN@] * [-@Inf@;1] ; [@NaN@;@NaN@] * [-@Inf@;0] ; [@NaN@;@NaN@] * [@Inf@;@NaN@] ; [@NaN@;@NaN@] * [@Inf@;-@Inf@] ; [@NaN@;@NaN@] * [@Inf@;@Inf@] ; [@NaN@;@NaN@] * [@Inf@;5] ; [@NaN@;@NaN@] * [@Inf@;1] ; [@NaN@;@NaN@] * [@Inf@;0] ; [@NaN@;@NaN@] * [5;@NaN@] ; [@NaN@;@NaN@] * [5;-@Inf@] ; [@NaN@;@NaN@] * [5;@Inf@] ; [@NaN@;@NaN@] * [5;5] ; [@NaN@;@NaN@] * [5;1] ; [@NaN@;@NaN@] * [5;0] ; [@NaN@;@NaN@] * [1;@NaN@] ; [@NaN@;@NaN@] * [1;-@Inf@] ; [@NaN@;@NaN@] * [1;@Inf@] ; [@NaN@;@NaN@] * [1;5] ; [@NaN@;@NaN@] * [1;1] ; [@NaN@;@NaN@] * [1;0] ; [@NaN@;@NaN@] * [0;@NaN@] ; [@NaN@;@NaN@] * [0;-@Inf@] ; [@NaN@;@NaN@] * [0;@Inf@] ; [@NaN@;@NaN@] * [0;5] ; [@NaN@;@NaN@] * [0;1] ; [@NaN@;@NaN@] * [0;0] ; [@NaN@;-@Inf@] * @NaN@ ; [@NaN@;-@Inf@] * -@Inf@ ; [@NaN@;-@Inf@] * @Inf@ ; [@NaN@;-@Inf@] * 5 ; [@NaN@;-@Inf@] * 1 ; [@NaN@;-@Inf@] * 0 ; [@NaN@;-@Inf@] * [@NaN@] ; [@NaN@;-@Inf@] * [-@Inf@] ; [@NaN@;-@Inf@] * [@Inf@] ; [@NaN@;-@Inf@] * [5] ; [@NaN@;-@Inf@] * [1] ; [@NaN@;-@Inf@] * [0] ; [@NaN@;-@Inf@] * [@NaN@;@NaN@] ; [@NaN@;-@Inf@] * [@NaN@;-@Inf@] ; [@NaN@;-@Inf@] * [@NaN@;@Inf@] ; [@NaN@;-@Inf@] * [@NaN@;5] ; [@NaN@;-@Inf@] * [@NaN@;1] ; [@NaN@;-@Inf@] * [@NaN@;0] ; [@NaN@;-@Inf@] * [-@Inf@;@NaN@] ; [@NaN@;-@Inf@] * [-@Inf@;-@Inf@] ; [@NaN@;-@Inf@] * [-@Inf@;@Inf@] ; [@NaN@;-@Inf@] * [-@Inf@;5] ; [@NaN@;-@Inf@] * [-@Inf@;1] ; [@NaN@;-@Inf@] * [-@Inf@;0] ; [@NaN@;-@Inf@] * [@Inf@;@NaN@] ; [@NaN@;-@Inf@] * [@Inf@;-@Inf@] ; [@NaN@;-@Inf@] * [@Inf@;@Inf@] ; [@NaN@;-@Inf@] * [@Inf@;5] ; [@NaN@;-@Inf@] * [@Inf@;1] ; [@NaN@;-@Inf@] * [@Inf@;0] ; [@NaN@;-@Inf@] * [5;@NaN@] ; [@NaN@;-@Inf@] * [5;-@Inf@] ; [@NaN@;-@Inf@] * [5;@Inf@] ; [@NaN@;-@Inf@] * [5;5] ; [@NaN@;-@Inf@] * [5;1] ; [@NaN@;-@Inf@] * [5;0] ; [@NaN@;-@Inf@] * [1;@NaN@] ; [@NaN@;-@Inf@] * [1;-@Inf@] ; [@NaN@;-@Inf@] * [1;@Inf@] ; [@NaN@;-@Inf@] * [1;5] ; [@NaN@;-@Inf@] * [1;1] ; [@NaN@;-@Inf@] * [1;0] ; [@NaN@;-@Inf@] * [0;@NaN@] ; [@NaN@;-@Inf@] * [0;-@Inf@] ; [@NaN@;-@Inf@] * [0;@Inf@] ; [@NaN@;-@Inf@] * [0;5] ; [@NaN@;-@Inf@] * [0;1] ; [@NaN@;-@Inf@] * [0;0] ; [@NaN@;@Inf@] * @NaN@ ; [@NaN@;@Inf@] * -@Inf@ ; [@NaN@;@Inf@] * @Inf@ ; [@NaN@;@Inf@] * 5 ; [@NaN@;@Inf@] * 1 ; [@NaN@;@Inf@] * 0 ; [@NaN@;@Inf@] * [@NaN@] ; [@NaN@;@Inf@] * [-@Inf@] ; [@NaN@;@Inf@] * [@Inf@] ; [@NaN@;@Inf@] * [5] ; [@NaN@;@Inf@] * [1] ; [@NaN@;@Inf@] * [0] ; [@NaN@;@Inf@] * [@NaN@;@NaN@] ; [@NaN@;@Inf@] * [@NaN@;-@Inf@] ; [@NaN@;@Inf@] * [@NaN@;@Inf@] ; [@NaN@;@Inf@] * [@NaN@;5] ; [@NaN@;@Inf@] * [@NaN@;1] ; [@NaN@;@Inf@] * [@NaN@;0] ; [@NaN@;@Inf@] * [-@Inf@;@NaN@] ; [@NaN@;@Inf@] * [-@Inf@;-@Inf@] ; [@NaN@;@Inf@] * [-@Inf@;@Inf@] ; [@NaN@;@Inf@] * [-@Inf@;5] ; [@NaN@;@Inf@] * [-@Inf@;1] ; [@NaN@;@Inf@] * [-@Inf@;0] ; [@NaN@;@Inf@] * [@Inf@;@NaN@] ; [@NaN@;@Inf@] * [@Inf@;-@Inf@] ; [@NaN@;@Inf@] * [@Inf@;@Inf@] ; [@NaN@;@Inf@] * [@Inf@;5] ; [@NaN@;@Inf@] * [@Inf@;1] ; [@NaN@;@Inf@] * [@Inf@;0] ; [@NaN@;@Inf@] * [5;@NaN@] ; [@NaN@;@Inf@] * [5;-@Inf@] ; [@NaN@;@Inf@] * [5;@Inf@] ; [@NaN@;@Inf@] * [5;5] ; [@NaN@;@Inf@] * [5;1] ; [@NaN@;@Inf@] * [5;0] ; [@NaN@;@Inf@] * [1;@NaN@] ; [@NaN@;@Inf@] * [1;-@Inf@] ; [@NaN@;@Inf@] * [1;@Inf@] ; [@NaN@;@Inf@] * [1;5] ; [@NaN@;@Inf@] * [1;1] ; [@NaN@;@Inf@] * [1;0] ; [@NaN@;@Inf@] * [0;@NaN@] ; [@NaN@;@Inf@] * [0;-@Inf@] ; [@NaN@;@Inf@] * [0;@Inf@] ; [@NaN@;@Inf@] * [0;5] ; [@NaN@;@Inf@] * [0;1] ; [@NaN@;@Inf@] * [0;0] ; [@NaN@;5] * @NaN@ ; [@NaN@;5] * -@Inf@ ; [@NaN@;5] * @Inf@ ; [@NaN@;5] * 5 ; [@NaN@;5] * 1 ; [@NaN@;5] * 0 ; [@NaN@;5] * [@NaN@] ; [@NaN@;5] * [-@Inf@] ; [@NaN@;5] * [@Inf@] ; [@NaN@;5] * [5] ; [@NaN@;5] * [1] ; [@NaN@;5] * [0] ; [@NaN@;5] * [@NaN@;@NaN@] ; [@NaN@;5] * [@NaN@;-@Inf@] ; [@NaN@;5] * [@NaN@;@Inf@] ; [@NaN@;5] * [@NaN@;5] ; [@NaN@;5] * [@NaN@;1] ; [@NaN@;5] * [@NaN@;0] ; [@NaN@;5] * [-@Inf@;@NaN@] ; [@NaN@;5] * [-@Inf@;-@Inf@] ; [@NaN@;5] * [-@Inf@;@Inf@] ; [@NaN@;5] * [-@Inf@;5] ; [@NaN@;5] * [-@Inf@;1] ; [@NaN@;5] * [-@Inf@;0] ; [@NaN@;5] * [@Inf@;@NaN@] ; [@NaN@;5] * [@Inf@;-@Inf@] ; [@NaN@;5] * [@Inf@;@Inf@] ; [@NaN@;5] * [@Inf@;5] ; [@NaN@;5] * [@Inf@;1] ; [@NaN@;5] * [@Inf@;0] ; [@NaN@;5] * [5;@NaN@] ; [@NaN@;5] * [5;-@Inf@] ; [@NaN@;5] * [5;@Inf@] ; [@NaN@;5] * [5;5] ; [@NaN@;5] * [5;1] ; [@NaN@;5] * [5;0] ; [@NaN@;5] * [1;@NaN@] ; [@NaN@;5] * [1;-@Inf@] ; [@NaN@;5] * [1;@Inf@] ; [@NaN@;5] * [1;5] ; [@NaN@;5] * [1;1] ; [@NaN@;5] * [1;0] ; [@NaN@;5] * [0;@NaN@] ; [@NaN@;5] * [0;-@Inf@] ; [@NaN@;5] * [0;@Inf@] ; [@NaN@;5] * [0;5] ; [@NaN@;5] * [0;1] ; [@NaN@;5] * [0;0] ; [@NaN@;1] * @NaN@ ; [@NaN@;1] * -@Inf@ ; [@NaN@;1] * @Inf@ ; [@NaN@;1] * 5 ; [@NaN@;1] * 1 ; [@NaN@;1] * 0 ; [@NaN@;1] * [@NaN@] ; [@NaN@;1] * [-@Inf@] ; [@NaN@;1] * [@Inf@] ; [@NaN@;1] * [5] ; [@NaN@;1] * [1] ; [@NaN@;1] * [0] ; [@NaN@;1] * [@NaN@;@NaN@] ; [@NaN@;1] * [@NaN@;-@Inf@] ; [@NaN@;1] * [@NaN@;@Inf@] ; [@NaN@;1] * [@NaN@;5] ; [@NaN@;1] * [@NaN@;1] ; [@NaN@;1] * [@NaN@;0] ; [@NaN@;1] * [-@Inf@;@NaN@] ; [@NaN@;1] * [-@Inf@;-@Inf@] ; [@NaN@;1] * [-@Inf@;@Inf@] ; [@NaN@;1] * [-@Inf@;5] ; [@NaN@;1] * [-@Inf@;1] ; [@NaN@;1] * [-@Inf@;0] ; [@NaN@;1] * [@Inf@;@NaN@] ; [@NaN@;1] * [@Inf@;-@Inf@] ; [@NaN@;1] * [@Inf@;@Inf@] ; [@NaN@;1] * [@Inf@;5] ; [@NaN@;1] * [@Inf@;1] ; [@NaN@;1] * [@Inf@;0] ; [@NaN@;1] * [5;@NaN@] ; [@NaN@;1] * [5;-@Inf@] ; [@NaN@;1] * [5;@Inf@] ; [@NaN@;1] * [5;5] ; [@NaN@;1] * [5;1] ; [@NaN@;1] * [5;0] ; [@NaN@;1] * [1;@NaN@] ; [@NaN@;1] * [1;-@Inf@] ; [@NaN@;1] * [1;@Inf@] ; [@NaN@;1] * [1;5] ; [@NaN@;1] * [1;1] ; [@NaN@;1] * [1;0] ; [@NaN@;1] * [0;@NaN@] ; [@NaN@;1] * [0;-@Inf@] ; [@NaN@;1] * [0;@Inf@] ; [@NaN@;1] * [0;5] ; [@NaN@;1] * [0;1] ; [@NaN@;1] * [0;0] ; [@NaN@;0] * @NaN@ ; [@NaN@;0] * -@Inf@ ; [@NaN@;0] * @Inf@ ; [@NaN@;0] * 5 ; [@NaN@;0] * 1 ; [@NaN@;0] * 0 ; [@NaN@;0] * [@NaN@] ; [@NaN@;0] * [-@Inf@] ; [@NaN@;0] * [@Inf@] ; [@NaN@;0] * [5] ; [@NaN@;0] * [1] ; [@NaN@;0] * [0] ; [@NaN@;0] * [@NaN@;@NaN@] ; [@NaN@;0] * [@NaN@;-@Inf@] ; [@NaN@;0] * [@NaN@;@Inf@] ; [@NaN@;0] * [@NaN@;5] ; [@NaN@;0] * [@NaN@;1] ; [@NaN@;0] * [@NaN@;0] ; [@NaN@;0] * [-@Inf@;@NaN@] ; [@NaN@;0] * [-@Inf@;-@Inf@] ; [@NaN@;0] * [-@Inf@;@Inf@] ; [@NaN@;0] * [-@Inf@;5] ; [@NaN@;0] * [-@Inf@;1] ; [@NaN@;0] * [-@Inf@;0] ; [@NaN@;0] * [@Inf@;@NaN@] ; [@NaN@;0] * [@Inf@;-@Inf@] ; [@NaN@;0] * [@Inf@;@Inf@] ; [@NaN@;0] * [@Inf@;5] ; [@NaN@;0] * [@Inf@;1] ; [@NaN@;0] * [@Inf@;0] ; [@NaN@;0] * [5;@NaN@] ; [@NaN@;0] * [5;-@Inf@] ; [@NaN@;0] * [5;@Inf@] ; [@NaN@;0] * [5;5] ; [@NaN@;0] * [5;1] ; [@NaN@;0] * [5;0] ; [@NaN@;0] * [1;@NaN@] ; [@NaN@;0] * [1;-@Inf@] ; [@NaN@;0] * [1;@Inf@] ; [@NaN@;0] * [1;5] ; [@NaN@;0] * [1;1] ; [@NaN@;0] * [1;0] ; [@NaN@;0] * [0;@NaN@] ; [@NaN@;0] * [0;-@Inf@] ; [@NaN@;0] * [0;@Inf@] ; [@NaN@;0] * [0;5] ; [@NaN@;0] * [0;1] ; [@NaN@;0] * [0;0] ; [-@Inf@;@NaN@] * @NaN@ ; [-@Inf@;@NaN@] * -@Inf@ ; [-@Inf@;@NaN@] * @Inf@ ; [-@Inf@;@NaN@] * 5 ; [-@Inf@;@NaN@] * 1 ; [-@Inf@;@NaN@] * 0 ; [-@Inf@;@NaN@] * [@NaN@] ; [-@Inf@;@NaN@] * [-@Inf@] ; [-@Inf@;@NaN@] * [@Inf@] ; [-@Inf@;@NaN@] * [5] ; [-@Inf@;@NaN@] * [1] ; [-@Inf@;@NaN@] * [0] ; [-@Inf@;@NaN@] * [@NaN@;@NaN@] ; [-@Inf@;@NaN@] * [@NaN@;-@Inf@] ; [-@Inf@;@NaN@] * [@NaN@;@Inf@] ; [-@Inf@;@NaN@] * [@NaN@;5] ; [-@Inf@;@NaN@] * [@NaN@;1] ; [-@Inf@;@NaN@] * [@NaN@;0] ; [-@Inf@;@NaN@] * [-@Inf@;@NaN@] ; [-@Inf@;@NaN@] * [-@Inf@;-@Inf@] ; [-@Inf@;@NaN@] * [-@Inf@;@Inf@] ; [-@Inf@;@NaN@] * [-@Inf@;5] ; [-@Inf@;@NaN@] * [-@Inf@;1] ; [-@Inf@;@NaN@] * [-@Inf@;0] ; [-@Inf@;@NaN@] * [@Inf@;@NaN@] ; [-@Inf@;@NaN@] * [@Inf@;-@Inf@] ; [-@Inf@;@NaN@] * [@Inf@;@Inf@] ; [-@Inf@;@NaN@] * [@Inf@;5] ; [-@Inf@;@NaN@] * [@Inf@;1] ; [-@Inf@;@NaN@] * [@Inf@;0] ; [-@Inf@;@NaN@] * [5;@NaN@] ; [-@Inf@;@NaN@] * [5;-@Inf@] ; [-@Inf@;@NaN@] * [5;@Inf@] ; [-@Inf@;@NaN@] * [5;5] ; [-@Inf@;@NaN@] * [5;1] ; [-@Inf@;@NaN@] * [5;0] ; [-@Inf@;@NaN@] * [1;@NaN@] ; [-@Inf@;@NaN@] * [1;-@Inf@] ; [-@Inf@;@NaN@] * [1;@Inf@] ; [-@Inf@;@NaN@] * [1;5] ; [-@Inf@;@NaN@] * [1;1] ; [-@Inf@;@NaN@] * [1;0] ; [-@Inf@;@NaN@] * [0;@NaN@] ; [-@Inf@;@NaN@] * [0;-@Inf@] ; [-@Inf@;@NaN@] * [0;@Inf@] ; [-@Inf@;@NaN@] * [0;5] ; [-@Inf@;@NaN@] * [0;1] ; [-@Inf@;@NaN@] * [0;0] ; [-@Inf@;-@Inf@] * @NaN@ ; [-@Inf@;-@Inf@] * -@Inf@ ; [-@Inf@;-@Inf@] * @Inf@ ; [-@Inf@;-@Inf@] * 5 ; [-@Inf@;-@Inf@] * 1 ; [-@Inf@;-@Inf@] * 0 ; [-@Inf@;-@Inf@] * [@NaN@] ; [-@Inf@;-@Inf@] * [-@Inf@] ; [-@Inf@;-@Inf@] * [@Inf@] ; [-@Inf@;-@Inf@] * [5] ; [-@Inf@;-@Inf@] * [1] ; [-@Inf@;-@Inf@] * [0] ; [-@Inf@;-@Inf@] * [@NaN@;@NaN@] ; [-@Inf@;-@Inf@] * [@NaN@;-@Inf@] ; [-@Inf@;-@Inf@] * [@NaN@;@Inf@] ; [-@Inf@;-@Inf@] * [@NaN@;5] ; [-@Inf@;-@Inf@] * [@NaN@;1] ; [-@Inf@;-@Inf@] * [@NaN@;0] ; [-@Inf@;-@Inf@] * [-@Inf@;@NaN@] ; [-@Inf@;-@Inf@] * [-@Inf@;-@Inf@] ; [-@Inf@;-@Inf@] * [-@Inf@;@Inf@] ; [-@Inf@;-@Inf@] * [-@Inf@;5] ; [-@Inf@;-@Inf@] * [-@Inf@;1] ; [-@Inf@;-@Inf@] * [-@Inf@;0] ; [-@Inf@;-@Inf@] * [@Inf@;@NaN@] ; [-@Inf@;-@Inf@] * [@Inf@;-@Inf@] ; [-@Inf@;-@Inf@] * [@Inf@;@Inf@] ; [-@Inf@;-@Inf@] * [@Inf@;5] ; [-@Inf@;-@Inf@] * [@Inf@;1] ; [-@Inf@;-@Inf@] * [@Inf@;0] ; [-@Inf@;-@Inf@] * [5;@NaN@] ; [-@Inf@;-@Inf@] * [5;-@Inf@] ; [-@Inf@;-@Inf@] * [5;@Inf@] ; [-@Inf@;-@Inf@] * [5;5] ; [-@Inf@;-@Inf@] * [5;1] ; [-@Inf@;-@Inf@] * [5;0] ; [-@Inf@;-@Inf@] * [1;@NaN@] ; [-@Inf@;-@Inf@] * [1;-@Inf@] ; [-@Inf@;-@Inf@] * [1;@Inf@] ; [-@Inf@;-@Inf@] * [1;5] ; [-@Inf@;-@Inf@] * [1;1] ; [-@Inf@;-@Inf@] * [1;0] ; [-@Inf@;-@Inf@] * [0;@NaN@] ; [-@Inf@;-@Inf@] * [0;-@Inf@] ; [-@Inf@;-@Inf@] * [0;@Inf@] ; [-@Inf@;-@Inf@] * [0;5] ; [-@Inf@;-@Inf@] * [0;1] ; [-@Inf@;-@Inf@] * [0;0] ; [-@Inf@;@Inf@] * @NaN@ ; [-@Inf@;@Inf@] * -@Inf@ ; [-@Inf@;@Inf@] * @Inf@ ; [-@Inf@;@Inf@] * 5 ; [-@Inf@;@Inf@] * 1 ; [-@Inf@;@Inf@] * 0 ; [-@Inf@;@Inf@] * [@NaN@] ; [-@Inf@;@Inf@] * [-@Inf@] ; [-@Inf@;@Inf@] * [@Inf@] ; [-@Inf@;@Inf@] * [5] ; [-@Inf@;@Inf@] * [1] ; [-@Inf@;@Inf@] * [0] ; [-@Inf@;@Inf@] * [@NaN@;@NaN@] ; [-@Inf@;@Inf@] * [@NaN@;-@Inf@] ; [-@Inf@;@Inf@] * [@NaN@;@Inf@] ; [-@Inf@;@Inf@] * [@NaN@;5] ; [-@Inf@;@Inf@] * [@NaN@;1] ; [-@Inf@;@Inf@] * [@NaN@;0] ; [-@Inf@;@Inf@] * [-@Inf@;@NaN@] ; [-@Inf@;@Inf@] * [-@Inf@;-@Inf@] ; [-@Inf@;@Inf@] * [-@Inf@;@Inf@] ; [-@Inf@;@Inf@] * [-@Inf@;5] ; [-@Inf@;@Inf@] * [-@Inf@;1] ; [-@Inf@;@Inf@] * [-@Inf@;0] ; [-@Inf@;@Inf@] * [@Inf@;@NaN@] ; [-@Inf@;@Inf@] * [@Inf@;-@Inf@] ; [-@Inf@;@Inf@] * [@Inf@;@Inf@] ; [-@Inf@;@Inf@] * [@Inf@;5] ; [-@Inf@;@Inf@] * [@Inf@;1] ; [-@Inf@;@Inf@] * [@Inf@;0] ; [-@Inf@;@Inf@] * [5;@NaN@] ; [-@Inf@;@Inf@] * [5;-@Inf@] ; [-@Inf@;@Inf@] * [5;@Inf@] ; [-@Inf@;@Inf@] * [5;5] ; [-@Inf@;@Inf@] * [5;1] ; [-@Inf@;@Inf@] * [5;0] ; [-@Inf@;@Inf@] * [1;@NaN@] ; [-@Inf@;@Inf@] * [1;-@Inf@] ; [-@Inf@;@Inf@] * [1;@Inf@] ; [-@Inf@;@Inf@] * [1;5] ; [-@Inf@;@Inf@] * [1;1] ; [-@Inf@;@Inf@] * [1;0] ; [-@Inf@;@Inf@] * [0;@NaN@] ; [-@Inf@;@Inf@] * [0;-@Inf@] ; [-@Inf@;@Inf@] * [0;@Inf@] ; [-@Inf@;@Inf@] * [0;5] ; [-@Inf@;@Inf@] * [0;1] ; [-@Inf@;@Inf@] * [0;0] ; [-@Inf@;5] * @NaN@ ; [-@Inf@;5] * -@Inf@ ; [-@Inf@;5] * @Inf@ ; [-@Inf@;5] * 5 ; [-@Inf@;5] * 1 ; [-@Inf@;5] * 0 ; [-@Inf@;5] * [@NaN@] ; [-@Inf@;5] * [-@Inf@] ; [-@Inf@;5] * [@Inf@] ; [-@Inf@;5] * [5] ; [-@Inf@;5] * [1] ; [-@Inf@;5] * [0] ; [-@Inf@;5] * [@NaN@;@NaN@] ; [-@Inf@;5] * [@NaN@;-@Inf@] ; [-@Inf@;5] * [@NaN@;@Inf@] ; [-@Inf@;5] * [@NaN@;5] ; [-@Inf@;5] * [@NaN@;1] ; [-@Inf@;5] * [@NaN@;0] ; [-@Inf@;5] * [-@Inf@;@NaN@] ; [-@Inf@;5] * [-@Inf@;-@Inf@] ; [-@Inf@;5] * [-@Inf@;@Inf@] ; [-@Inf@;5] * [-@Inf@;5] ; [-@Inf@;5] * [-@Inf@;1] ; [-@Inf@;5] * [-@Inf@;0] ; [-@Inf@;5] * [@Inf@;@NaN@] ; [-@Inf@;5] * [@Inf@;-@Inf@] ; [-@Inf@;5] * [@Inf@;@Inf@] ; [-@Inf@;5] * [@Inf@;5] ; [-@Inf@;5] * [@Inf@;1] ; [-@Inf@;5] * [@Inf@;0] ; [-@Inf@;5] * [5;@NaN@] ; [-@Inf@;5] * [5;-@Inf@] ; [-@Inf@;5] * [5;@Inf@] ; [-@Inf@;5] * [5;5] ; [-@Inf@;5] * [5;1] ; [-@Inf@;5] * [5;0] ; [-@Inf@;5] * [1;@NaN@] ; [-@Inf@;5] * [1;-@Inf@] ; [-@Inf@;5] * [1;@Inf@] ; [-@Inf@;5] * [1;5] ; [-@Inf@;5] * [1;1] ; [-@Inf@;5] * [1;0] ; [-@Inf@;5] * [0;@NaN@] ; [-@Inf@;5] * [0;-@Inf@] ; [-@Inf@;5] * [0;@Inf@] ; [-@Inf@;5] * [0;5] ; [-@Inf@;5] * [0;1] ; [-@Inf@;5] * [0;0] ; [-@Inf@;1] * @NaN@ ; [-@Inf@;1] * -@Inf@ ; [-@Inf@;1] * @Inf@ ; [-@Inf@;1] * 5 ; [-@Inf@;1] * 1 ; [-@Inf@;1] * 0 ; [-@Inf@;1] * [@NaN@] ; [-@Inf@;1] * [-@Inf@] ; [-@Inf@;1] * [@Inf@] ; [-@Inf@;1] * [5] ; [-@Inf@;1] * [1] ; [-@Inf@;1] * [0] ; [-@Inf@;1] * [@NaN@;@NaN@] ; [-@Inf@;1] * [@NaN@;-@Inf@] ; [-@Inf@;1] * [@NaN@;@Inf@] ; [-@Inf@;1] * [@NaN@;5] ; [-@Inf@;1] * [@NaN@;1] ; [-@Inf@;1] * [@NaN@;0] ; [-@Inf@;1] * [-@Inf@;@NaN@] ; [-@Inf@;1] * [-@Inf@;-@Inf@] ; [-@Inf@;1] * [-@Inf@;@Inf@] ; [-@Inf@;1] * [-@Inf@;5] ; [-@Inf@;1] * [-@Inf@;1] ; [-@Inf@;1] * [-@Inf@;0] ; [-@Inf@;1] * [@Inf@;@NaN@] ; [-@Inf@;1] * [@Inf@;-@Inf@] ; [-@Inf@;1] * [@Inf@;@Inf@] ; [-@Inf@;1] * [@Inf@;5] ; [-@Inf@;1] * [@Inf@;1] ; [-@Inf@;1] * [@Inf@;0] ; [-@Inf@;1] * [5;@NaN@] ; [-@Inf@;1] * [5;-@Inf@] ; [-@Inf@;1] * [5;@Inf@] ; [-@Inf@;1] * [5;5] ; [-@Inf@;1] * [5;1] ; [-@Inf@;1] * [5;0] ; [-@Inf@;1] * [1;@NaN@] ; [-@Inf@;1] * [1;-@Inf@] ; [-@Inf@;1] * [1;@Inf@] ; [-@Inf@;1] * [1;5] ; [-@Inf@;1] * [1;1] ; [-@Inf@;1] * [1;0] ; [-@Inf@;1] * [0;@NaN@] ; [-@Inf@;1] * [0;-@Inf@] ; [-@Inf@;1] * [0;@Inf@] ; [-@Inf@;1] * [0;5] ; [-@Inf@;1] * [0;1] ; [-@Inf@;1] * [0;0] ; [-@Inf@;0] * @NaN@ ; [-@Inf@;0] * -@Inf@ ; [-@Inf@;0] * @Inf@ ; [-@Inf@;0] * 5 ; [-@Inf@;0] * 1 ; [-@Inf@;0] * 0 ; [-@Inf@;0] * [@NaN@] ; [-@Inf@;0] * [-@Inf@] ; [-@Inf@;0] * [@Inf@] ; [-@Inf@;0] * [5] ; [-@Inf@;0] * [1] ; [-@Inf@;0] * [0] ; [-@Inf@;0] * [@NaN@;@NaN@] ; [-@Inf@;0] * [@NaN@;-@Inf@] ; [-@Inf@;0] * [@NaN@;@Inf@] ; [-@Inf@;0] * [@NaN@;5] ; [-@Inf@;0] * [@NaN@;1] ; [-@Inf@;0] * [@NaN@;0] ; [-@Inf@;0] * [-@Inf@;@NaN@] ; [-@Inf@;0] * [-@Inf@;-@Inf@] ; [-@Inf@;0] * [-@Inf@;@Inf@] ; [-@Inf@;0] * [-@Inf@;5] ; [-@Inf@;0] * [-@Inf@;1] ; [-@Inf@;0] * [-@Inf@;0] ; [-@Inf@;0] * [@Inf@;@NaN@] ; [-@Inf@;0] * [@Inf@;-@Inf@] ; [-@Inf@;0] * [@Inf@;@Inf@] ; [-@Inf@;0] * [@Inf@;5] ; [-@Inf@;0] * [@Inf@;1] ; [-@Inf@;0] * [@Inf@;0] ; [-@Inf@;0] * [5;@NaN@] ; [-@Inf@;0] * [5;-@Inf@] ; [-@Inf@;0] * [5;@Inf@] ; [-@Inf@;0] * [5;5] ; [-@Inf@;0] * [5;1] ; [-@Inf@;0] * [5;0] ; [-@Inf@;0] * [1;@NaN@] ; [-@Inf@;0] * [1;-@Inf@] ; [-@Inf@;0] * [1;@Inf@] ; [-@Inf@;0] * [1;5] ; [-@Inf@;0] * [1;1] ; [-@Inf@;0] * [1;0] ; [-@Inf@;0] * [0;@NaN@] ; [-@Inf@;0] * [0;-@Inf@] ; [-@Inf@;0] * [0;@Inf@] ; [-@Inf@;0] * [0;5] ; [-@Inf@;0] * [0;1] ; [-@Inf@;0] * [0;0] ; [@Inf@;@NaN@] * @NaN@ ; [@Inf@;@NaN@] * -@Inf@ ; [@Inf@;@NaN@] * @Inf@ ; [@Inf@;@NaN@] * 5 ; [@Inf@;@NaN@] * 1 ; [@Inf@;@NaN@] * 0 ; [@Inf@;@NaN@] * [@NaN@] ; [@Inf@;@NaN@] * [-@Inf@] ; [@Inf@;@NaN@] * [@Inf@] ; [@Inf@;@NaN@] * [5] ; [@Inf@;@NaN@] * [1] ; [@Inf@;@NaN@] * [0] ; [@Inf@;@NaN@] * [@NaN@;@NaN@] ; [@Inf@;@NaN@] * [@NaN@;-@Inf@] ; [@Inf@;@NaN@] * [@NaN@;@Inf@] ; [@Inf@;@NaN@] * [@NaN@;5] ; [@Inf@;@NaN@] * [@NaN@;1] ; [@Inf@;@NaN@] * [@NaN@;0] ; [@Inf@;@NaN@] * [-@Inf@;@NaN@] ; [@Inf@;@NaN@] * [-@Inf@;-@Inf@] ; [@Inf@;@NaN@] * [-@Inf@;@Inf@] ; [@Inf@;@NaN@] * [-@Inf@;5] ; [@Inf@;@NaN@] * [-@Inf@;1] ; [@Inf@;@NaN@] * [-@Inf@;0] ; [@Inf@;@NaN@] * [@Inf@;@NaN@] ; [@Inf@;@NaN@] * [@Inf@;-@Inf@] ; [@Inf@;@NaN@] * [@Inf@;@Inf@] ; [@Inf@;@NaN@] * [@Inf@;5] ; [@Inf@;@NaN@] * [@Inf@;1] ; [@Inf@;@NaN@] * [@Inf@;0] ; [@Inf@;@NaN@] * [5;@NaN@] ; [@Inf@;@NaN@] * [5;-@Inf@] ; [@Inf@;@NaN@] * [5;@Inf@] ; [@Inf@;@NaN@] * [5;5] ; [@Inf@;@NaN@] * [5;1] ; [@Inf@;@NaN@] * [5;0] ; [@Inf@;@NaN@] * [1;@NaN@] ; [@Inf@;@NaN@] * [1;-@Inf@] ; [@Inf@;@NaN@] * [1;@Inf@] ; [@Inf@;@NaN@] * [1;5] ; [@Inf@;@NaN@] * [1;1] ; [@Inf@;@NaN@] * [1;0] ; [@Inf@;@NaN@] * [0;@NaN@] ; [@Inf@;@NaN@] * [0;-@Inf@] ; [@Inf@;@NaN@] * [0;@Inf@] ; [@Inf@;@NaN@] * [0;5] ; [@Inf@;@NaN@] * [0;1] ; [@Inf@;@NaN@] * [0;0] ; [@Inf@;-@Inf@] * @NaN@ ; [@Inf@;-@Inf@] * -@Inf@ ; [@Inf@;-@Inf@] * @Inf@ ; [@Inf@;-@Inf@] * 5 ; [@Inf@;-@Inf@] * 1 ; [@Inf@;-@Inf@] * 0 ; [@Inf@;-@Inf@] * [@NaN@] ; [@Inf@;-@Inf@] * [-@Inf@] ; [@Inf@;-@Inf@] * [@Inf@] ; [@Inf@;-@Inf@] * [5] ; [@Inf@;-@Inf@] * [1] ; [@Inf@;-@Inf@] * [0] ; [@Inf@;-@Inf@] * [@NaN@;@NaN@] ; [@Inf@;-@Inf@] * [@NaN@;-@Inf@] ; [@Inf@;-@Inf@] * [@NaN@;@Inf@] ; [@Inf@;-@Inf@] * [@NaN@;5] ; [@Inf@;-@Inf@] * [@NaN@;1] ; [@Inf@;-@Inf@] * [@NaN@;0] ; [@Inf@;-@Inf@] * [-@Inf@;@NaN@] ; [@Inf@;-@Inf@] * [-@Inf@;-@Inf@] ; [@Inf@;-@Inf@] * [-@Inf@;@Inf@] ; [@Inf@;-@Inf@] * [-@Inf@;5] ; [@Inf@;-@Inf@] * [-@Inf@;1] ; [@Inf@;-@Inf@] * [-@Inf@;0] ; [@Inf@;-@Inf@] * [@Inf@;@NaN@] ; [@Inf@;-@Inf@] * [@Inf@;-@Inf@] ; [@Inf@;-@Inf@] * [@Inf@;@Inf@] ; [@Inf@;-@Inf@] * [@Inf@;5] ; [@Inf@;-@Inf@] * [@Inf@;1] ; [@Inf@;-@Inf@] * [@Inf@;0] ; [@Inf@;-@Inf@] * [5;@NaN@] ; [@Inf@;-@Inf@] * [5;-@Inf@] ; [@Inf@;-@Inf@] * [5;@Inf@] ; [@Inf@;-@Inf@] * [5;5] ; [@Inf@;-@Inf@] * [5;1] ; [@Inf@;-@Inf@] * [5;0] ; [@Inf@;-@Inf@] * [1;@NaN@] ; [@Inf@;-@Inf@] * [1;-@Inf@] ; [@Inf@;-@Inf@] * [1;@Inf@] ; [@Inf@;-@Inf@] * [1;5] ; [@Inf@;-@Inf@] * [1;1] ; [@Inf@;-@Inf@] * [1;0] ; [@Inf@;-@Inf@] * [0;@NaN@] ; [@Inf@;-@Inf@] * [0;-@Inf@] ; [@Inf@;-@Inf@] * [0;@Inf@] ; [@Inf@;-@Inf@] * [0;5] ; [@Inf@;-@Inf@] * [0;1] ; [@Inf@;-@Inf@] * [0;0] ; [@Inf@;@Inf@] * @NaN@ ; [@Inf@;@Inf@] * -@Inf@ ; [@Inf@;@Inf@] * @Inf@ ; [@Inf@;@Inf@] * 5 ; [@Inf@;@Inf@] * 1 ; [@Inf@;@Inf@] * 0 ; [@Inf@;@Inf@] * [@NaN@] ; [@Inf@;@Inf@] * [-@Inf@] ; [@Inf@;@Inf@] * [@Inf@] ; [@Inf@;@Inf@] * [5] ; [@Inf@;@Inf@] * [1] ; [@Inf@;@Inf@] * [0] ; [@Inf@;@Inf@] * [@NaN@;@NaN@] ; [@Inf@;@Inf@] * [@NaN@;-@Inf@] ; [@Inf@;@Inf@] * [@NaN@;@Inf@] ; [@Inf@;@Inf@] * [@NaN@;5] ; [@Inf@;@Inf@] * [@NaN@;1] ; [@Inf@;@Inf@] * [@NaN@;0] ; [@Inf@;@Inf@] * [-@Inf@;@NaN@] ; [@Inf@;@Inf@] * [-@Inf@;-@Inf@] ; [@Inf@;@Inf@] * [-@Inf@;@Inf@] ; [@Inf@;@Inf@] * [-@Inf@;5] ; [@Inf@;@Inf@] * [-@Inf@;1] ; [@Inf@;@Inf@] * [-@Inf@;0] ; [@Inf@;@Inf@] * [@Inf@;@NaN@] ; [@Inf@;@Inf@] * [@Inf@;-@Inf@] ; [@Inf@;@Inf@] * [@Inf@;@Inf@] ; [@Inf@;@Inf@] * [@Inf@;5] ; [@Inf@;@Inf@] * [@Inf@;1] ; [@Inf@;@Inf@] * [@Inf@;0] ; [@Inf@;@Inf@] * [5;@NaN@] ; [@Inf@;@Inf@] * [5;-@Inf@] ; [@Inf@;@Inf@] * [5;@Inf@] ; [@Inf@;@Inf@] * [5;5] ; [@Inf@;@Inf@] * [5;1] ; [@Inf@;@Inf@] * [5;0] ; [@Inf@;@Inf@] * [1;@NaN@] ; [@Inf@;@Inf@] * [1;-@Inf@] ; [@Inf@;@Inf@] * [1;@Inf@] ; [@Inf@;@Inf@] * [1;5] ; [@Inf@;@Inf@] * [1;1] ; [@Inf@;@Inf@] * [1;0] ; [@Inf@;@Inf@] * [0;@NaN@] ; [@Inf@;@Inf@] * [0;-@Inf@] ; [@Inf@;@Inf@] * [0;@Inf@] ; [@Inf@;@Inf@] * [0;5] ; [@Inf@;@Inf@] * [0;1] ; [@Inf@;@Inf@] * [0;0] ; [@Inf@;5] * @NaN@ ; [@Inf@;5] * -@Inf@ ; [@Inf@;5] * @Inf@ ; [@Inf@;5] * 5 ; [@Inf@;5] * 1 ; [@Inf@;5] * 0 ; [@Inf@;5] * [@NaN@] ; [@Inf@;5] * [-@Inf@] ; [@Inf@;5] * [@Inf@] ; [@Inf@;5] * [5] ; [@Inf@;5] * [1] ; [@Inf@;5] * [0] ; [@Inf@;5] * [@NaN@;@NaN@] ; [@Inf@;5] * [@NaN@;-@Inf@] ; [@Inf@;5] * [@NaN@;@Inf@] ; [@Inf@;5] * [@NaN@;5] ; [@Inf@;5] * [@NaN@;1] ; [@Inf@;5] * [@NaN@;0] ; [@Inf@;5] * [-@Inf@;@NaN@] ; [@Inf@;5] * [-@Inf@;-@Inf@] ; [@Inf@;5] * [-@Inf@;@Inf@] ; [@Inf@;5] * [-@Inf@;5] ; [@Inf@;5] * [-@Inf@;1] ; [@Inf@;5] * [-@Inf@;0] ; [@Inf@;5] * [@Inf@;@NaN@] ; [@Inf@;5] * [@Inf@;-@Inf@] ; [@Inf@;5] * [@Inf@;@Inf@] ; [@Inf@;5] * [@Inf@;5] ; [@Inf@;5] * [@Inf@;1] ; [@Inf@;5] * [@Inf@;0] ; [@Inf@;5] * [5;@NaN@] ; [@Inf@;5] * [5;-@Inf@] ; [@Inf@;5] * [5;@Inf@] ; [@Inf@;5] * [5;5] ; [@Inf@;5] * [5;1] ; [@Inf@;5] * [5;0] ; [@Inf@;5] * [1;@NaN@] ; [@Inf@;5] * [1;-@Inf@] ; [@Inf@;5] * [1;@Inf@] ; [@Inf@;5] * [1;5] ; [@Inf@;5] * [1;1] ; [@Inf@;5] * [1;0] ; [@Inf@;5] * [0;@NaN@] ; [@Inf@;5] * [0;-@Inf@] ; [@Inf@;5] * [0;@Inf@] ; [@Inf@;5] * [0;5] ; [@Inf@;5] * [0;1] ; [@Inf@;5] * [0;0] ; [@Inf@;1] * @NaN@ ; [@Inf@;1] * -@Inf@ ; [@Inf@;1] * @Inf@ ; [@Inf@;1] * 5 ; [@Inf@;1] * 1 ; [@Inf@;1] * 0 ; [@Inf@;1] * [@NaN@] ; [@Inf@;1] * [-@Inf@] ; [@Inf@;1] * [@Inf@] ; [@Inf@;1] * [5] ; [@Inf@;1] * [1] ; [@Inf@;1] * [0] ; [@Inf@;1] * [@NaN@;@NaN@] ; [@Inf@;1] * [@NaN@;-@Inf@] ; [@Inf@;1] * [@NaN@;@Inf@] ; [@Inf@;1] * [@NaN@;5] ; [@Inf@;1] * [@NaN@;1] ; [@Inf@;1] * [@NaN@;0] ; [@Inf@;1] * [-@Inf@;@NaN@] ; [@Inf@;1] * [-@Inf@;-@Inf@] ; [@Inf@;1] * [-@Inf@;@Inf@] ; [@Inf@;1] * [-@Inf@;5] ; [@Inf@;1] * [-@Inf@;1] ; [@Inf@;1] * [-@Inf@;0] ; [@Inf@;1] * [@Inf@;@NaN@] ; [@Inf@;1] * [@Inf@;-@Inf@] ; [@Inf@;1] * [@Inf@;@Inf@] ; [@Inf@;1] * [@Inf@;5] ; [@Inf@;1] * [@Inf@;1] ; [@Inf@;1] * [@Inf@;0] ; [@Inf@;1] * [5;@NaN@] ; [@Inf@;1] * [5;-@Inf@] ; [@Inf@;1] * [5;@Inf@] ; [@Inf@;1] * [5;5] ; [@Inf@;1] * [5;1] ; [@Inf@;1] * [5;0] ; [@Inf@;1] * [1;@NaN@] ; [@Inf@;1] * [1;-@Inf@] ; [@Inf@;1] * [1;@Inf@] ; [@Inf@;1] * [1;5] ; [@Inf@;1] * [1;1] ; [@Inf@;1] * [1;0] ; [@Inf@;1] * [0;@NaN@] ; [@Inf@;1] * [0;-@Inf@] ; [@Inf@;1] * [0;@Inf@] ; [@Inf@;1] * [0;5] ; [@Inf@;1] * [0;1] ; [@Inf@;1] * [0;0] ; [@Inf@;0] * @NaN@ ; [@Inf@;0] * -@Inf@ ; [@Inf@;0] * @Inf@ ; [@Inf@;0] * 5 ; [@Inf@;0] * 1 ; [@Inf@;0] * 0 ; [@Inf@;0] * [@NaN@] ; [@Inf@;0] * [-@Inf@] ; [@Inf@;0] * [@Inf@] ; [@Inf@;0] * [5] ; [@Inf@;0] * [1] ; [@Inf@;0] * [0] ; [@Inf@;0] * [@NaN@;@NaN@] ; [@Inf@;0] * [@NaN@;-@Inf@] ; [@Inf@;0] * [@NaN@;@Inf@] ; [@Inf@;0] * [@NaN@;5] ; [@Inf@;0] * [@NaN@;1] ; [@Inf@;0] * [@NaN@;0] ; [@Inf@;0] * [-@Inf@;@NaN@] ; [@Inf@;0] * [-@Inf@;-@Inf@] ; [@Inf@;0] * [-@Inf@;@Inf@] ; [@Inf@;0] * [-@Inf@;5] ; [@Inf@;0] * [-@Inf@;1] ; [@Inf@;0] * [-@Inf@;0] ; [@Inf@;0] * [@Inf@;@NaN@] ; [@Inf@;0] * [@Inf@;-@Inf@] ; [@Inf@;0] * [@Inf@;@Inf@] ; [@Inf@;0] * [@Inf@;5] ; [@Inf@;0] * [@Inf@;1] ; [@Inf@;0] * [@Inf@;0] ; [@Inf@;0] * [5;@NaN@] ; [@Inf@;0] * [5;-@Inf@] ; [@Inf@;0] * [5;@Inf@] ; [@Inf@;0] * [5;5] ; [@Inf@;0] * [5;1] ; [@Inf@;0] * [5;0] ; [@Inf@;0] * [1;@NaN@] ; [@Inf@;0] * [1;-@Inf@] ; [@Inf@;0] * [1;@Inf@] ; [@Inf@;0] * [1;5] ; [@Inf@;0] * [1;1] ; [@Inf@;0] * [1;0] ; [@Inf@;0] * [0;@NaN@] ; [@Inf@;0] * [0;-@Inf@] ; [@Inf@;0] * [0;@Inf@] ; [@Inf@;0] * [0;5] ; [@Inf@;0] * [0;1] ; [@Inf@;0] * [0;0] ; [5;@NaN@] * @NaN@ ; [5;@NaN@] * -@Inf@ ; [5;@NaN@] * @Inf@ ; [5;@NaN@] * 5 ; [5;@NaN@] * 1 ; [5;@NaN@] * 0 ; [5;@NaN@] * [@NaN@] ; [5;@NaN@] * [-@Inf@] ; [5;@NaN@] * [@Inf@] ; [5;@NaN@] * [5] ; [5;@NaN@] * [1] ; [5;@NaN@] * [0] ; [5;@NaN@] * [@NaN@;@NaN@] ; [5;@NaN@] * [@NaN@;-@Inf@] ; [5;@NaN@] * [@NaN@;@Inf@] ; [5;@NaN@] * [@NaN@;5] ; [5;@NaN@] * [@NaN@;1] ; [5;@NaN@] * [@NaN@;0] ; [5;@NaN@] * [-@Inf@;@NaN@] ; [5;@NaN@] * [-@Inf@;-@Inf@] ; [5;@NaN@] * [-@Inf@;@Inf@] ; [5;@NaN@] * [-@Inf@;5] ; [5;@NaN@] * [-@Inf@;1] ; [5;@NaN@] * [-@Inf@;0] ; [5;@NaN@] * [@Inf@;@NaN@] ; [5;@NaN@] * [@Inf@;-@Inf@] ; [5;@NaN@] * [@Inf@;@Inf@] ; [5;@NaN@] * [@Inf@;5] ; [5;@NaN@] * [@Inf@;1] ; [5;@NaN@] * [@Inf@;0] ; [5;@NaN@] * [5;@NaN@] ; [5;@NaN@] * [5;-@Inf@] ; [5;@NaN@] * [5;@Inf@] ; [5;@NaN@] * [5;5] ; [5;@NaN@] * [5;1] ; [5;@NaN@] * [5;0] ; [5;@NaN@] * [1;@NaN@] ; [5;@NaN@] * [1;-@Inf@] ; [5;@NaN@] * [1;@Inf@] ; [5;@NaN@] * [1;5] ; [5;@NaN@] * [1;1] ; [5;@NaN@] * [1;0] ; [5;@NaN@] * [0;@NaN@] ; [5;@NaN@] * [0;-@Inf@] ; [5;@NaN@] * [0;@Inf@] ; [5;@NaN@] * [0;5] ; [5;@NaN@] * [0;1] ; [5;@NaN@] * [0;0] ; [5;-@Inf@] * @NaN@ ; [5;-@Inf@] * -@Inf@ ; [5;-@Inf@] * @Inf@ ; [5;-@Inf@] * 5 ; [5;-@Inf@] * 1 ; [5;-@Inf@] * 0 ; [5;-@Inf@] * [@NaN@] ; [5;-@Inf@] * [-@Inf@] ; [5;-@Inf@] * [@Inf@] ; [5;-@Inf@] * [5] ; [5;-@Inf@] * [1] ; [5;-@Inf@] * [0] ; [5;-@Inf@] * [@NaN@;@NaN@] ; [5;-@Inf@] * [@NaN@;-@Inf@] ; [5;-@Inf@] * [@NaN@;@Inf@] ; [5;-@Inf@] * [@NaN@;5] ; [5;-@Inf@] * [@NaN@;1] ; [5;-@Inf@] * [@NaN@;0] ; [5;-@Inf@] * [-@Inf@;@NaN@] ; [5;-@Inf@] * [-@Inf@;-@Inf@] ; [5;-@Inf@] * [-@Inf@;@Inf@] ; [5;-@Inf@] * [-@Inf@;5] ; [5;-@Inf@] * [-@Inf@;1] ; [5;-@Inf@] * [-@Inf@;0] ; [5;-@Inf@] * [@Inf@;@NaN@] ; [5;-@Inf@] * [@Inf@;-@Inf@] ; [5;-@Inf@] * [@Inf@;@Inf@] ; [5;-@Inf@] * [@Inf@;5] ; [5;-@Inf@] * [@Inf@;1] ; [5;-@Inf@] * [@Inf@;0] ; [5;-@Inf@] * [5;@NaN@] ; [5;-@Inf@] * [5;-@Inf@] ; [5;-@Inf@] * [5;@Inf@] ; [5;-@Inf@] * [5;5] ; [5;-@Inf@] * [5;1] ; [5;-@Inf@] * [5;0] ; [5;-@Inf@] * [1;@NaN@] ; [5;-@Inf@] * [1;-@Inf@] ; [5;-@Inf@] * [1;@Inf@] ; [5;-@Inf@] * [1;5] ; [5;-@Inf@] * [1;1] ; [5;-@Inf@] * [1;0] ; [5;-@Inf@] * [0;@NaN@] ; [5;-@Inf@] * [0;-@Inf@] ; [5;-@Inf@] * [0;@Inf@] ; [5;-@Inf@] * [0;5] ; [5;-@Inf@] * [0;1] ; [5;-@Inf@] * [0;0] ; [5;@Inf@] * @NaN@ ; [5;@Inf@] * -@Inf@ ; [5;@Inf@] * @Inf@ ; [5;@Inf@] * 5 ; [5;@Inf@] * 1 ; [5;@Inf@] * 0 ; [5;@Inf@] * [@NaN@] ; [5;@Inf@] * [-@Inf@] ; [5;@Inf@] * [@Inf@] ; [5;@Inf@] * [5] ; [5;@Inf@] * [1] ; [5;@Inf@] * [0] ; [5;@Inf@] * [@NaN@;@NaN@] ; [5;@Inf@] * [@NaN@;-@Inf@] ; [5;@Inf@] * [@NaN@;@Inf@] ; [5;@Inf@] * [@NaN@;5] ; [5;@Inf@] * [@NaN@;1] ; [5;@Inf@] * [@NaN@;0] ; [5;@Inf@] * [-@Inf@;@NaN@] ; [5;@Inf@] * [-@Inf@;-@Inf@] ; [5;@Inf@] * [-@Inf@;@Inf@] ; [5;@Inf@] * [-@Inf@;5] ; [5;@Inf@] * [-@Inf@;1] ; [5;@Inf@] * [-@Inf@;0] ; [5;@Inf@] * [@Inf@;@NaN@] ; [5;@Inf@] * [@Inf@;-@Inf@] ; [5;@Inf@] * [@Inf@;@Inf@] ; [5;@Inf@] * [@Inf@;5] ; [5;@Inf@] * [@Inf@;1] ; [5;@Inf@] * [@Inf@;0] ; [5;@Inf@] * [5;@NaN@] ; [5;@Inf@] * [5;-@Inf@] ; [5;@Inf@] * [5;@Inf@] ; [5;@Inf@] * [5;5] ; [5;@Inf@] * [5;1] ; [5;@Inf@] * [5;0] ; [5;@Inf@] * [1;@NaN@] ; [5;@Inf@] * [1;-@Inf@] ; [5;@Inf@] * [1;@Inf@] ; [5;@Inf@] * [1;5] ; [5;@Inf@] * [1;1] ; [5;@Inf@] * [1;0] ; [5;@Inf@] * [0;@NaN@] ; [5;@Inf@] * [0;-@Inf@] ; [5;@Inf@] * [0;@Inf@] ; [5;@Inf@] * [0;5] ; [5;@Inf@] * [0;1] ; [5;@Inf@] * [0;0] ; [5;5] * @NaN@ ; [5;5] * -@Inf@ ; [5;5] * @Inf@ ; [5;5] * 5 ; [5;5] * 1 ; [5;5] * 0 ; [5;5] * [@NaN@] ; [5;5] * [-@Inf@] ; [5;5] * [@Inf@] ; [5;5] * [5] ; [5;5] * [1] ; [5;5] * [0] ; [5;5] * [@NaN@;@NaN@] ; [5;5] * [@NaN@;-@Inf@] ; [5;5] * [@NaN@;@Inf@] ; [5;5] * [@NaN@;5] ; [5;5] * [@NaN@;1] ; [5;5] * [@NaN@;0] ; [5;5] * [-@Inf@;@NaN@] ; [5;5] * [-@Inf@;-@Inf@] ; [5;5] * [-@Inf@;@Inf@] ; [5;5] * [-@Inf@;5] ; [5;5] * [-@Inf@;1] ; [5;5] * [-@Inf@;0] ; [5;5] * [@Inf@;@NaN@] ; [5;5] * [@Inf@;-@Inf@] ; [5;5] * [@Inf@;@Inf@] ; [5;5] * [@Inf@;5] ; [5;5] * [@Inf@;1] ; [5;5] * [@Inf@;0] ; [5;5] * [5;@NaN@] ; [5;5] * [5;-@Inf@] ; [5;5] * [5;@Inf@] ; [5;5] * [5;5] ; [5;5] * [5;1] ; [5;5] * [5;0] ; [5;5] * [1;@NaN@] ; [5;5] * [1;-@Inf@] ; [5;5] * [1;@Inf@] ; [5;5] * [1;5] ; [5;5] * [1;1] ; [5;5] * [1;0] ; [5;5] * [0;@NaN@] ; [5;5] * [0;-@Inf@] ; [5;5] * [0;@Inf@] ; [5;5] * [0;5] ; [5;5] * [0;1] ; [5;5] * [0;0] ; [5;1] * @NaN@ ; [5;1] * -@Inf@ ; [5;1] * @Inf@ ; [5;1] * 5 ; [5;1] * 1 ; [5;1] * 0 ; [5;1] * [@NaN@] ; [5;1] * [-@Inf@] ; [5;1] * [@Inf@] ; [5;1] * [5] ; [5;1] * [1] ; [5;1] * [0] ; [5;1] * [@NaN@;@NaN@] ; [5;1] * [@NaN@;-@Inf@] ; [5;1] * [@NaN@;@Inf@] ; [5;1] * [@NaN@;5] ; [5;1] * [@NaN@;1] ; [5;1] * [@NaN@;0] ; [5;1] * [-@Inf@;@NaN@] ; [5;1] * [-@Inf@;-@Inf@] ; [5;1] * [-@Inf@;@Inf@] ; [5;1] * [-@Inf@;5] ; [5;1] * [-@Inf@;1] ; [5;1] * [-@Inf@;0] ; [5;1] * [@Inf@;@NaN@] ; [5;1] * [@Inf@;-@Inf@] ; [5;1] * [@Inf@;@Inf@] ; [5;1] * [@Inf@;5] ; [5;1] * [@Inf@;1] ; [5;1] * [@Inf@;0] ; [5;1] * [5;@NaN@] ; [5;1] * [5;-@Inf@] ; [5;1] * [5;@Inf@] ; [5;1] * [5;5] ; [5;1] * [5;1] ; [5;1] * [5;0] ; [5;1] * [1;@NaN@] ; [5;1] * [1;-@Inf@] ; [5;1] * [1;@Inf@] ; [5;1] * [1;5] ; [5;1] * [1;1] ; [5;1] * [1;0] ; [5;1] * [0;@NaN@] ; [5;1] * [0;-@Inf@] ; [5;1] * [0;@Inf@] ; [5;1] * [0;5] ; [5;1] * [0;1] ; [5;1] * [0;0] ; [5;0] * @NaN@ ; [5;0] * -@Inf@ ; [5;0] * @Inf@ ; [5;0] * 5 ; [5;0] * 1 ; [5;0] * 0 ; [5;0] * [@NaN@] ; [5;0] * [-@Inf@] ; [5;0] * [@Inf@] ; [5;0] * [5] ; [5;0] * [1] ; [5;0] * [0] ; [5;0] * [@NaN@;@NaN@] ; [5;0] * [@NaN@;-@Inf@] ; [5;0] * [@NaN@;@Inf@] ; [5;0] * [@NaN@;5] ; [5;0] * [@NaN@;1] ; [5;0] * [@NaN@;0] ; [5;0] * [-@Inf@;@NaN@] ; [5;0] * [-@Inf@;-@Inf@] ; [5;0] * [-@Inf@;@Inf@] ; [5;0] * [-@Inf@;5] ; [5;0] * [-@Inf@;1] ; [5;0] * [-@Inf@;0] ; [5;0] * [@Inf@;@NaN@] ; [5;0] * [@Inf@;-@Inf@] ; [5;0] * [@Inf@;@Inf@] ; [5;0] * [@Inf@;5] ; [5;0] * [@Inf@;1] ; [5;0] * [@Inf@;0] ; [5;0] * [5;@NaN@] ; [5;0] * [5;-@Inf@] ; [5;0] * [5;@Inf@] ; [5;0] * [5;5] ; [5;0] * [5;1] ; [5;0] * [5;0] ; [5;0] * [1;@NaN@] ; [5;0] * [1;-@Inf@] ; [5;0] * [1;@Inf@] ; [5;0] * [1;5] ; [5;0] * [1;1] ; [5;0] * [1;0] ; [5;0] * [0;@NaN@] ; [5;0] * [0;-@Inf@] ; [5;0] * [0;@Inf@] ; [5;0] * [0;5] ; [5;0] * [0;1] ; [5;0] * [0;0] ; [1;@NaN@] * @NaN@ ; [1;@NaN@] * -@Inf@ ; [1;@NaN@] * @Inf@ ; [1;@NaN@] * 5 ; [1;@NaN@] * 1 ; [1;@NaN@] * 0 ; [1;@NaN@] * [@NaN@] ; [1;@NaN@] * [-@Inf@] ; [1;@NaN@] * [@Inf@] ; [1;@NaN@] * [5] ; [1;@NaN@] * [1] ; [1;@NaN@] * [0] ; [1;@NaN@] * [@NaN@;@NaN@] ; [1;@NaN@] * [@NaN@;-@Inf@] ; [1;@NaN@] * [@NaN@;@Inf@] ; [1;@NaN@] * [@NaN@;5] ; [1;@NaN@] * [@NaN@;1] ; [1;@NaN@] * [@NaN@;0] ; [1;@NaN@] * [-@Inf@;@NaN@] ; [1;@NaN@] * [-@Inf@;-@Inf@] ; [1;@NaN@] * [-@Inf@;@Inf@] ; [1;@NaN@] * [-@Inf@;5] ; [1;@NaN@] * [-@Inf@;1] ; [1;@NaN@] * [-@Inf@;0] ; [1;@NaN@] * [@Inf@;@NaN@] ; [1;@NaN@] * [@Inf@;-@Inf@] ; [1;@NaN@] * [@Inf@;@Inf@] ; [1;@NaN@] * [@Inf@;5] ; [1;@NaN@] * [@Inf@;1] ; [1;@NaN@] * [@Inf@;0] ; [1;@NaN@] * [5;@NaN@] ; [1;@NaN@] * [5;-@Inf@] ; [1;@NaN@] * [5;@Inf@] ; [1;@NaN@] * [5;5] ; [1;@NaN@] * [5;1] ; [1;@NaN@] * [5;0] ; [1;@NaN@] * [1;@NaN@] ; [1;@NaN@] * [1;-@Inf@] ; [1;@NaN@] * [1;@Inf@] ; [1;@NaN@] * [1;5] ; [1;@NaN@] * [1;1] ; [1;@NaN@] * [1;0] ; [1;@NaN@] * [0;@NaN@] ; [1;@NaN@] * [0;-@Inf@] ; [1;@NaN@] * [0;@Inf@] ; [1;@NaN@] * [0;5] ; [1;@NaN@] * [0;1] ; [1;@NaN@] * [0;0] ; [1;-@Inf@] * @NaN@ ; [1;-@Inf@] * -@Inf@ ; [1;-@Inf@] * @Inf@ ; [1;-@Inf@] * 5 ; [1;-@Inf@] * 1 ; [1;-@Inf@] * 0 ; [1;-@Inf@] * [@NaN@] ; [1;-@Inf@] * [-@Inf@] ; [1;-@Inf@] * [@Inf@] ; [1;-@Inf@] * [5] ; [1;-@Inf@] * [1] ; [1;-@Inf@] * [0] ; [1;-@Inf@] * [@NaN@;@NaN@] ; [1;-@Inf@] * [@NaN@;-@Inf@] ; [1;-@Inf@] * [@NaN@;@Inf@] ; [1;-@Inf@] * [@NaN@;5] ; [1;-@Inf@] * [@NaN@;1] ; [1;-@Inf@] * [@NaN@;0] ; [1;-@Inf@] * [-@Inf@;@NaN@] ; [1;-@Inf@] * [-@Inf@;-@Inf@] ; [1;-@Inf@] * [-@Inf@;@Inf@] ; [1;-@Inf@] * [-@Inf@;5] ; [1;-@Inf@] * [-@Inf@;1] ; [1;-@Inf@] * [-@Inf@;0] ; [1;-@Inf@] * [@Inf@;@NaN@] ; [1;-@Inf@] * [@Inf@;-@Inf@] ; [1;-@Inf@] * [@Inf@;@Inf@] ; [1;-@Inf@] * [@Inf@;5] ; [1;-@Inf@] * [@Inf@;1] ; [1;-@Inf@] * [@Inf@;0] ; [1;-@Inf@] * [5;@NaN@] ; [1;-@Inf@] * [5;-@Inf@] ; [1;-@Inf@] * [5;@Inf@] ; [1;-@Inf@] * [5;5] ; [1;-@Inf@] * [5;1] ; [1;-@Inf@] * [5;0] ; [1;-@Inf@] * [1;@NaN@] ; [1;-@Inf@] * [1;-@Inf@] ; [1;-@Inf@] * [1;@Inf@] ; [1;-@Inf@] * [1;5] ; [1;-@Inf@] * [1;1] ; [1;-@Inf@] * [1;0] ; [1;-@Inf@] * [0;@NaN@] ; [1;-@Inf@] * [0;-@Inf@] ; [1;-@Inf@] * [0;@Inf@] ; [1;-@Inf@] * [0;5] ; [1;-@Inf@] * [0;1] ; [1;-@Inf@] * [0;0] ; [1;@Inf@] * @NaN@ ; [1;@Inf@] * -@Inf@ ; [1;@Inf@] * @Inf@ ; [1;@Inf@] * 5 ; [1;@Inf@] * 1 ; [1;@Inf@] * 0 ; [1;@Inf@] * [@NaN@] ; [1;@Inf@] * [-@Inf@] ; [1;@Inf@] * [@Inf@] ; [1;@Inf@] * [5] ; [1;@Inf@] * [1] ; [1;@Inf@] * [0] ; [1;@Inf@] * [@NaN@;@NaN@] ; [1;@Inf@] * [@NaN@;-@Inf@] ; [1;@Inf@] * [@NaN@;@Inf@] ; [1;@Inf@] * [@NaN@;5] ; [1;@Inf@] * [@NaN@;1] ; [1;@Inf@] * [@NaN@;0] ; [1;@Inf@] * [-@Inf@;@NaN@] ; [1;@Inf@] * [-@Inf@;-@Inf@] ; [1;@Inf@] * [-@Inf@;@Inf@] ; [1;@Inf@] * [-@Inf@;5] ; [1;@Inf@] * [-@Inf@;1] ; [1;@Inf@] * [-@Inf@;0] ; [1;@Inf@] * [@Inf@;@NaN@] ; [1;@Inf@] * [@Inf@;-@Inf@] ; [1;@Inf@] * [@Inf@;@Inf@] ; [1;@Inf@] * [@Inf@;5] ; [1;@Inf@] * [@Inf@;1] ; [1;@Inf@] * [@Inf@;0] ; [1;@Inf@] * [5;@NaN@] ; [1;@Inf@] * [5;-@Inf@] ; [1;@Inf@] * [5;@Inf@] ; [1;@Inf@] * [5;5] ; [1;@Inf@] * [5;1] ; [1;@Inf@] * [5;0] ; [1;@Inf@] * [1;@NaN@] ; [1;@Inf@] * [1;-@Inf@] ; [1;@Inf@] * [1;@Inf@] ; [1;@Inf@] * [1;5] ; [1;@Inf@] * [1;1] ; [1;@Inf@] * [1;0] ; [1;@Inf@] * [0;@NaN@] ; [1;@Inf@] * [0;-@Inf@] ; [1;@Inf@] * [0;@Inf@] ; [1;@Inf@] * [0;5] ; [1;@Inf@] * [0;1] ; [1;@Inf@] * [0;0] ; [1;5] * @NaN@ ; [1;5] * -@Inf@ ; [1;5] * @Inf@ ; [1;5] * 5 ; [1;5] * 1 ; [1;5] * 0 ; [1;5] * [@NaN@] ; [1;5] * [-@Inf@] ; [1;5] * [@Inf@] ; [1;5] * [5] ; [1;5] * [1] ; [1;5] * [0] ; [1;5] * [@NaN@;@NaN@] ; [1;5] * [@NaN@;-@Inf@] ; [1;5] * [@NaN@;@Inf@] ; [1;5] * [@NaN@;5] ; [1;5] * [@NaN@;1] ; [1;5] * [@NaN@;0] ; [1;5] * [-@Inf@;@NaN@] ; [1;5] * [-@Inf@;-@Inf@] ; [1;5] * [-@Inf@;@Inf@] ; [1;5] * [-@Inf@;5] ; [1;5] * [-@Inf@;1] ; [1;5] * [-@Inf@;0] ; [1;5] * [@Inf@;@NaN@] ; [1;5] * [@Inf@;-@Inf@] ; [1;5] * [@Inf@;@Inf@] ; [1;5] * [@Inf@;5] ; [1;5] * [@Inf@;1] ; [1;5] * [@Inf@;0] ; [1;5] * [5;@NaN@] ; [1;5] * [5;-@Inf@] ; [1;5] * [5;@Inf@] ; [1;5] * [5;5] ; [1;5] * [5;1] ; [1;5] * [5;0] ; [1;5] * [1;@NaN@] ; [1;5] * [1;-@Inf@] ; [1;5] * [1;@Inf@] ; [1;5] * [1;5] ; [1;5] * [1;1] ; [1;5] * [1;0] ; [1;5] * [0;@NaN@] ; [1;5] * [0;-@Inf@] ; [1;5] * [0;@Inf@] ; [1;5] * [0;5] ; [1;5] * [0;1] ; [1;5] * [0;0] ; [1;1] * @NaN@ ; [1;1] * -@Inf@ ; [1;1] * @Inf@ ; [1;1] * 5 ; [1;1] * 1 ; [1;1] * 0 ; [1;1] * [@NaN@] ; [1;1] * [-@Inf@] ; [1;1] * [@Inf@] ; [1;1] * [5] ; [1;1] * [1] ; [1;1] * [0] ; [1;1] * [@NaN@;@NaN@] ; [1;1] * [@NaN@;-@Inf@] ; [1;1] * [@NaN@;@Inf@] ; [1;1] * [@NaN@;5] ; [1;1] * [@NaN@;1] ; [1;1] * [@NaN@;0] ; [1;1] * [-@Inf@;@NaN@] ; [1;1] * [-@Inf@;-@Inf@] ; [1;1] * [-@Inf@;@Inf@] ; [1;1] * [-@Inf@;5] ; [1;1] * [-@Inf@;1] ; [1;1] * [-@Inf@;0] ; [1;1] * [@Inf@;@NaN@] ; [1;1] * [@Inf@;-@Inf@] ; [1;1] * [@Inf@;@Inf@] ; [1;1] * [@Inf@;5] ; [1;1] * [@Inf@;1] ; [1;1] * [@Inf@;0] ; [1;1] * [5;@NaN@] ; [1;1] * [5;-@Inf@] ; [1;1] * [5;@Inf@] ; [1;1] * [5;5] ; [1;1] * [5;1] ; [1;1] * [5;0] ; [1;1] * [1;@NaN@] ; [1;1] * [1;-@Inf@] ; [1;1] * [1;@Inf@] ; [1;1] * [1;5] ; [1;1] * [1;1] ; [1;1] * [1;0] ; [1;1] * [0;@NaN@] ; [1;1] * [0;-@Inf@] ; [1;1] * [0;@Inf@] ; [1;1] * [0;5] ; [1;1] * [0;1] ; [1;1] * [0;0] ; [1;0] * @NaN@ ; [1;0] * -@Inf@ ; [1;0] * @Inf@ ; [1;0] * 5 ; [1;0] * 1 ; [1;0] * 0 ; [1;0] * [@NaN@] ; [1;0] * [-@Inf@] ; [1;0] * [@Inf@] ; [1;0] * [5] ; [1;0] * [1] ; [1;0] * [0] ; [1;0] * [@NaN@;@NaN@] ; [1;0] * [@NaN@;-@Inf@] ; [1;0] * [@NaN@;@Inf@] ; [1;0] * [@NaN@;5] ; [1;0] * [@NaN@;1] ; [1;0] * [@NaN@;0] ; [1;0] * [-@Inf@;@NaN@] ; [1;0] * [-@Inf@;-@Inf@] ; [1;0] * [-@Inf@;@Inf@] ; [1;0] * [-@Inf@;5] ; [1;0] * [-@Inf@;1] ; [1;0] * [-@Inf@;0] ; [1;0] * [@Inf@;@NaN@] ; [1;0] * [@Inf@;-@Inf@] ; [1;0] * [@Inf@;@Inf@] ; [1;0] * [@Inf@;5] ; [1;0] * [@Inf@;1] ; [1;0] * [@Inf@;0] ; [1;0] * [5;@NaN@] ; [1;0] * [5;-@Inf@] ; [1;0] * [5;@Inf@] ; [1;0] * [5;5] ; [1;0] * [5;1] ; [1;0] * [5;0] ; [1;0] * [1;@NaN@] ; [1;0] * [1;-@Inf@] ; [1;0] * [1;@Inf@] ; [1;0] * [1;5] ; [1;0] * [1;1] ; [1;0] * [1;0] ; [1;0] * [0;@NaN@] ; [1;0] * [0;-@Inf@] ; [1;0] * [0;@Inf@] ; [1;0] * [0;5] ; [1;0] * [0;1] ; [1;0] * [0;0] ; [0;@NaN@] * @NaN@ ; [0;@NaN@] * -@Inf@ ; [0;@NaN@] * @Inf@ ; [0;@NaN@] * 5 ; [0;@NaN@] * 1 ; [0;@NaN@] * 0 ; [0;@NaN@] * [@NaN@] ; [0;@NaN@] * [-@Inf@] ; [0;@NaN@] * [@Inf@] ; [0;@NaN@] * [5] ; [0;@NaN@] * [1] ; [0;@NaN@] * [0] ; [0;@NaN@] * [@NaN@;@NaN@] ; [0;@NaN@] * [@NaN@;-@Inf@] ; [0;@NaN@] * [@NaN@;@Inf@] ; [0;@NaN@] * [@NaN@;5] ; [0;@NaN@] * [@NaN@;1] ; [0;@NaN@] * [@NaN@;0] ; [0;@NaN@] * [-@Inf@;@NaN@] ; [0;@NaN@] * [-@Inf@;-@Inf@] ; [0;@NaN@] * [-@Inf@;@Inf@] ; [0;@NaN@] * [-@Inf@;5] ; [0;@NaN@] * [-@Inf@;1] ; [0;@NaN@] * [-@Inf@;0] ; [0;@NaN@] * [@Inf@;@NaN@] ; [0;@NaN@] * [@Inf@;-@Inf@] ; [0;@NaN@] * [@Inf@;@Inf@] ; [0;@NaN@] * [@Inf@;5] ; [0;@NaN@] * [@Inf@;1] ; [0;@NaN@] * [@Inf@;0] ; [0;@NaN@] * [5;@NaN@] ; [0;@NaN@] * [5;-@Inf@] ; [0;@NaN@] * [5;@Inf@] ; [0;@NaN@] * [5;5] ; [0;@NaN@] * [5;1] ; [0;@NaN@] * [5;0] ; [0;@NaN@] * [1;@NaN@] ; [0;@NaN@] * [1;-@Inf@] ; [0;@NaN@] * [1;@Inf@] ; [0;@NaN@] * [1;5] ; [0;@NaN@] * [1;1] ; [0;@NaN@] * [1;0] ; [0;@NaN@] * [0;@NaN@] ; [0;@NaN@] * [0;-@Inf@] ; [0;@NaN@] * [0;@Inf@] ; [0;@NaN@] * [0;5] ; [0;@NaN@] * [0;1] ; [0;@NaN@] * [0;0] ; [0;-@Inf@] * @NaN@ ; [0;-@Inf@] * -@Inf@ ; [0;-@Inf@] * @Inf@ ; [0;-@Inf@] * 5 ; [0;-@Inf@] * 1 ; [0;-@Inf@] * 0 ; [0;-@Inf@] * [@NaN@] ; [0;-@Inf@] * [-@Inf@] ; [0;-@Inf@] * [@Inf@] ; [0;-@Inf@] * [5] ; [0;-@Inf@] * [1] ; [0;-@Inf@] * [0] ; [0;-@Inf@] * [@NaN@;@NaN@] ; [0;-@Inf@] * [@NaN@;-@Inf@] ; [0;-@Inf@] * [@NaN@;@Inf@] ; [0;-@Inf@] * [@NaN@;5] ; [0;-@Inf@] * [@NaN@;1] ; [0;-@Inf@] * [@NaN@;0] ; [0;-@Inf@] * [-@Inf@;@NaN@] ; [0;-@Inf@] * [-@Inf@;-@Inf@] ; [0;-@Inf@] * [-@Inf@;@Inf@] ; [0;-@Inf@] * [-@Inf@;5] ; [0;-@Inf@] * [-@Inf@;1] ; [0;-@Inf@] * [-@Inf@;0] ; [0;-@Inf@] * [@Inf@;@NaN@] ; [0;-@Inf@] * [@Inf@;-@Inf@] ; [0;-@Inf@] * [@Inf@;@Inf@] ; [0;-@Inf@] * [@Inf@;5] ; [0;-@Inf@] * [@Inf@;1] ; [0;-@Inf@] * [@Inf@;0] ; [0;-@Inf@] * [5;@NaN@] ; [0;-@Inf@] * [5;-@Inf@] ; [0;-@Inf@] * [5;@Inf@] ; [0;-@Inf@] * [5;5] ; [0;-@Inf@] * [5;1] ; [0;-@Inf@] * [5;0] ; [0;-@Inf@] * [1;@NaN@] ; [0;-@Inf@] * [1;-@Inf@] ; [0;-@Inf@] * [1;@Inf@] ; [0;-@Inf@] * [1;5] ; [0;-@Inf@] * [1;1] ; [0;-@Inf@] * [1;0] ; [0;-@Inf@] * [0;@NaN@] ; [0;-@Inf@] * [0;-@Inf@] ; [0;-@Inf@] * [0;@Inf@] ; [0;-@Inf@] * [0;5] ; [0;-@Inf@] * [0;1] ; [0;-@Inf@] * [0;0] ; [0;@Inf@] * @NaN@ ; [0;@Inf@] * -@Inf@ ; [0;@Inf@] * @Inf@ ; [0;@Inf@] * 5 ; [0;@Inf@] * 1 ; [0;@Inf@] * 0 ; [0;@Inf@] * [@NaN@] ; [0;@Inf@] * [-@Inf@] ; [0;@Inf@] * [@Inf@] ; [0;@Inf@] * [5] ; [0;@Inf@] * [1] ; [0;@Inf@] * [0] ; [0;@Inf@] * [@NaN@;@NaN@] ; [0;@Inf@] * [@NaN@;-@Inf@] ; [0;@Inf@] * [@NaN@;@Inf@] ; [0;@Inf@] * [@NaN@;5] ; [0;@Inf@] * [@NaN@;1] ; [0;@Inf@] * [@NaN@;0] ; [0;@Inf@] * [-@Inf@;@NaN@] ; [0;@Inf@] * [-@Inf@;-@Inf@] ; [0;@Inf@] * [-@Inf@;@Inf@] ; [0;@Inf@] * [-@Inf@;5] ; [0;@Inf@] * [-@Inf@;1] ; [0;@Inf@] * [-@Inf@;0] ; [0;@Inf@] * [@Inf@;@NaN@] ; [0;@Inf@] * [@Inf@;-@Inf@] ; [0;@Inf@] * [@Inf@;@Inf@] ; [0;@Inf@] * [@Inf@;5] ; [0;@Inf@] * [@Inf@;1] ; [0;@Inf@] * [@Inf@;0] ; [0;@Inf@] * [5;@NaN@] ; [0;@Inf@] * [5;-@Inf@] ; [0;@Inf@] * [5;@Inf@] ; [0;@Inf@] * [5;5] ; [0;@Inf@] * [5;1] ; [0;@Inf@] * [5;0] ; [0;@Inf@] * [1;@NaN@] ; [0;@Inf@] * [1;-@Inf@] ; [0;@Inf@] * [1;@Inf@] ; [0;@Inf@] * [1;5] ; [0;@Inf@] * [1;1] ; [0;@Inf@] * [1;0] ; [0;@Inf@] * [0;@NaN@] ; [0;@Inf@] * [0;-@Inf@] ; [0;@Inf@] * [0;@Inf@] ; [0;@Inf@] * [0;5] ; [0;@Inf@] * [0;1] ; [0;@Inf@] * [0;0] ; [0;5] * @NaN@ ; [0;5] * -@Inf@ ; [0;5] * @Inf@ ; [0;5] * 5 ; [0;5] * 1 ; [0;5] * 0 ; [0;5] * [@NaN@] ; [0;5] * [-@Inf@] ; [0;5] * [@Inf@] ; [0;5] * [5] ; [0;5] * [1] ; [0;5] * [0] ; [0;5] * [@NaN@;@NaN@] ; [0;5] * [@NaN@;-@Inf@] ; [0;5] * [@NaN@;@Inf@] ; [0;5] * [@NaN@;5] ; [0;5] * [@NaN@;1] ; [0;5] * [@NaN@;0] ; [0;5] * [-@Inf@;@NaN@] ; [0;5] * [-@Inf@;-@Inf@] ; [0;5] * [-@Inf@;@Inf@] ; [0;5] * [-@Inf@;5] ; [0;5] * [-@Inf@;1] ; [0;5] * [-@Inf@;0] ; [0;5] * [@Inf@;@NaN@] ; [0;5] * [@Inf@;-@Inf@] ; [0;5] * [@Inf@;@Inf@] ; [0;5] * [@Inf@;5] ; [0;5] * [@Inf@;1] ; [0;5] * [@Inf@;0] ; [0;5] * [5;@NaN@] ; [0;5] * [5;-@Inf@] ; [0;5] * [5;@Inf@] ; [0;5] * [5;5] ; [0;5] * [5;1] ; [0;5] * [5;0] ; [0;5] * [1;@NaN@] ; [0;5] * [1;-@Inf@] ; [0;5] * [1;@Inf@] ; [0;5] * [1;5] ; [0;5] * [1;1] ; [0;5] * [1;0] ; [0;5] * [0;@NaN@] ; [0;5] * [0;-@Inf@] ; [0;5] * [0;@Inf@] ; [0;5] * [0;5] ; [0;5] * [0;1] ; [0;5] * [0;0] ; [0;1] * @NaN@ ; [0;1] * -@Inf@ ; [0;1] * @Inf@ ; [0;1] * 5 ; [0;1] * 1 ; [0;1] * 0 ; [0;1] * [@NaN@] ; [0;1] * [-@Inf@] ; [0;1] * [@Inf@] ; [0;1] * [5] ; [0;1] * [1] ; [0;1] * [0] ; [0;1] * [@NaN@;@NaN@] ; [0;1] * [@NaN@;-@Inf@] ; [0;1] * [@NaN@;@Inf@] ; [0;1] * [@NaN@;5] ; [0;1] * [@NaN@;1] ; [0;1] * [@NaN@;0] ; [0;1] * [-@Inf@;@NaN@] ; [0;1] * [-@Inf@;-@Inf@] ; [0;1] * [-@Inf@;@Inf@] ; [0;1] * [-@Inf@;5] ; [0;1] * [-@Inf@;1] ; [0;1] * [-@Inf@;0] ; [0;1] * [@Inf@;@NaN@] ; [0;1] * [@Inf@;-@Inf@] ; [0;1] * [@Inf@;@Inf@] ; [0;1] * [@Inf@;5] ; [0;1] * [@Inf@;1] ; [0;1] * [@Inf@;0] ; [0;1] * [5;@NaN@] ; [0;1] * [5;-@Inf@] ; [0;1] * [5;@Inf@] ; [0;1] * [5;5] ; [0;1] * [5;1] ; [0;1] * [5;0] ; [0;1] * [1;@NaN@] ; [0;1] * [1;-@Inf@] ; [0;1] * [1;@Inf@] ; [0;1] * [1;5] ; [0;1] * [1;1] ; [0;1] * [1;0] ; [0;1] * [0;@NaN@] ; [0;1] * [0;-@Inf@] ; [0;1] * [0;@Inf@] ; [0;1] * [0;5] ; [0;1] * [0;1] ; [0;1] * [0;0] ; [0;0] * @NaN@ ; [0;0] * -@Inf@ ; [0;0] * @Inf@ ; [0;0] * 5 ; [0;0] * 1 ; [0;0] * 0 ; [0;0] * [@NaN@] ; [0;0] * [-@Inf@] ; [0;0] * [@Inf@] ; [0;0] * [5] ; [0;0] * [1] ; [0;0] * [0] ; [0;0] * [@NaN@;@NaN@] ; [0;0] * [@NaN@;-@Inf@] ; [0;0] * [@NaN@;@Inf@] ; [0;0] * [@NaN@;5] ; [0;0] * [@NaN@;1] ; [0;0] * [@NaN@;0] ; [0;0] * [-@Inf@;@NaN@] ; [0;0] * [-@Inf@;-@Inf@] ; [0;0] * [-@Inf@;@Inf@] ; [0;0] * [-@Inf@;5] ; [0;0] * [-@Inf@;1] ; [0;0] * [-@Inf@;0] ; [0;0] * [@Inf@;@NaN@] ; [0;0] * [@Inf@;-@Inf@] ; [0;0] * [@Inf@;@Inf@] ; [0;0] * [@Inf@;5] ; [0;0] * [@Inf@;1] ; [0;0] * [@Inf@;0] ; [0;0] * [5;@NaN@] ; [0;0] * [5;-@Inf@] ; [0;0] * [5;@Inf@] ; [0;0] * [5;5] ; [0;0] * [5;1] ; [0;0] * [5;0] ; [0;0] * [1;@NaN@] ; [0;0] * [1;-@Inf@] ; [0;0] * [1;@Inf@] ; [0;0] * [1;5] ; [0;0] * [1;1] ; [0;0] * [1;0] ; [0;0] * [0;@NaN@] ; [0;0] * [0;-@Inf@] ; [0;0] * [0;@Inf@] ; [0;0] * [0;5] ; [0;0] * [0;1] ; [0;0] * [0;0] ; @NaN@ / @NaN@ ; @NaN@ / -@Inf@ ; @NaN@ / @Inf@ ; @NaN@ / 5 ; @NaN@ / 1 ; @NaN@ / 0 ; @NaN@ / [@NaN@] ; @NaN@ / [-@Inf@] ; @NaN@ / [@Inf@] ; @NaN@ / [5] ; @NaN@ / [1] ; @NaN@ / [0] ; @NaN@ / [@NaN@;@NaN@] ; @NaN@ / [@NaN@;-@Inf@] ; @NaN@ / [@NaN@;@Inf@] ; @NaN@ / [@NaN@;5] ; @NaN@ / [@NaN@;1] ; @NaN@ / [@NaN@;0] ; @NaN@ / [-@Inf@;@NaN@] ; @NaN@ / [-@Inf@;-@Inf@] ; @NaN@ / [-@Inf@;@Inf@] ; @NaN@ / [-@Inf@;5] ; @NaN@ / [-@Inf@;1] ; @NaN@ / [-@Inf@;0] ; @NaN@ / [@Inf@;@NaN@] ; @NaN@ / [@Inf@;-@Inf@] ; @NaN@ / [@Inf@;@Inf@] ; @NaN@ / [@Inf@;5] ; @NaN@ / [@Inf@;1] ; @NaN@ / [@Inf@;0] ; @NaN@ / [5;@NaN@] ; @NaN@ / [5;-@Inf@] ; @NaN@ / [5;@Inf@] ; @NaN@ / [5;5] ; @NaN@ / [5;1] ; @NaN@ / [5;0] ; @NaN@ / [1;@NaN@] ; @NaN@ / [1;-@Inf@] ; @NaN@ / [1;@Inf@] ; @NaN@ / [1;5] ; @NaN@ / [1;1] ; @NaN@ / [1;0] ; @NaN@ / [0;@NaN@] ; @NaN@ / [0;-@Inf@] ; @NaN@ / [0;@Inf@] ; @NaN@ / [0;5] ; @NaN@ / [0;1] ; @NaN@ / [0;0] ; -@Inf@ / @NaN@ ; -@Inf@ / -@Inf@ ; -@Inf@ / @Inf@ ; -@Inf@ / 5 ; -@Inf@ / 1 ; -@Inf@ / 0 ; -@Inf@ / [@NaN@] ; -@Inf@ / [-@Inf@] ; -@Inf@ / [@Inf@] ; -@Inf@ / [5] ; -@Inf@ / [1] ; -@Inf@ / [0] ; -@Inf@ / [@NaN@;@NaN@] ; -@Inf@ / [@NaN@;-@Inf@] ; -@Inf@ / [@NaN@;@Inf@] ; -@Inf@ / [@NaN@;5] ; -@Inf@ / [@NaN@;1] ; -@Inf@ / [@NaN@;0] ; -@Inf@ / [-@Inf@;@NaN@] ; -@Inf@ / [-@Inf@;-@Inf@] ; -@Inf@ / [-@Inf@;@Inf@] ; -@Inf@ / [-@Inf@;5] ; -@Inf@ / [-@Inf@;1] ; -@Inf@ / [-@Inf@;0] ; -@Inf@ / [@Inf@;@NaN@] ; -@Inf@ / [@Inf@;-@Inf@] ; -@Inf@ / [@Inf@;@Inf@] ; -@Inf@ / [@Inf@;5] ; -@Inf@ / [@Inf@;1] ; -@Inf@ / [@Inf@;0] ; -@Inf@ / [5;@NaN@] ; -@Inf@ / [5;-@Inf@] ; -@Inf@ / [5;@Inf@] ; -@Inf@ / [5;5] ; -@Inf@ / [5;1] ; -@Inf@ / [5;0] ; -@Inf@ / [1;@NaN@] ; -@Inf@ / [1;-@Inf@] ; -@Inf@ / [1;@Inf@] ; -@Inf@ / [1;5] ; -@Inf@ / [1;1] ; -@Inf@ / [1;0] ; -@Inf@ / [0;@NaN@] ; -@Inf@ / [0;-@Inf@] ; -@Inf@ / [0;@Inf@] ; -@Inf@ / [0;5] ; -@Inf@ / [0;1] ; -@Inf@ / [0;0] ; @Inf@ / @NaN@ ; @Inf@ / -@Inf@ ; @Inf@ / @Inf@ ; @Inf@ / 5 ; @Inf@ / 1 ; @Inf@ / 0 ; @Inf@ / [@NaN@] ; @Inf@ / [-@Inf@] ; @Inf@ / [@Inf@] ; @Inf@ / [5] ; @Inf@ / [1] ; @Inf@ / [0] ; @Inf@ / [@NaN@;@NaN@] ; @Inf@ / [@NaN@;-@Inf@] ; @Inf@ / [@NaN@;@Inf@] ; @Inf@ / [@NaN@;5] ; @Inf@ / [@NaN@;1] ; @Inf@ / [@NaN@;0] ; @Inf@ / [-@Inf@;@NaN@] ; @Inf@ / [-@Inf@;-@Inf@] ; @Inf@ / [-@Inf@;@Inf@] ; @Inf@ / [-@Inf@;5] ; @Inf@ / [-@Inf@;1] ; @Inf@ / [-@Inf@;0] ; @Inf@ / [@Inf@;@NaN@] ; @Inf@ / [@Inf@;-@Inf@] ; @Inf@ / [@Inf@;@Inf@] ; @Inf@ / [@Inf@;5] ; @Inf@ / [@Inf@;1] ; @Inf@ / [@Inf@;0] ; @Inf@ / [5;@NaN@] ; @Inf@ / [5;-@Inf@] ; @Inf@ / [5;@Inf@] ; @Inf@ / [5;5] ; @Inf@ / [5;1] ; @Inf@ / [5;0] ; @Inf@ / [1;@NaN@] ; @Inf@ / [1;-@Inf@] ; @Inf@ / [1;@Inf@] ; @Inf@ / [1;5] ; @Inf@ / [1;1] ; @Inf@ / [1;0] ; @Inf@ / [0;@NaN@] ; @Inf@ / [0;-@Inf@] ; @Inf@ / [0;@Inf@] ; @Inf@ / [0;5] ; @Inf@ / [0;1] ; @Inf@ / [0;0] ; 5 / @NaN@ ; 5 / -@Inf@ ; 5 / @Inf@ ; 5 / 5 ; 5 / 1 ; 5 / 0 ; 5 / [@NaN@] ; 5 / [-@Inf@] ; 5 / [@Inf@] ; 5 / [5] ; 5 / [1] ; 5 / [0] ; 5 / [@NaN@;@NaN@] ; 5 / [@NaN@;-@Inf@] ; 5 / [@NaN@;@Inf@] ; 5 / [@NaN@;5] ; 5 / [@NaN@;1] ; 5 / [@NaN@;0] ; 5 / [-@Inf@;@NaN@] ; 5 / [-@Inf@;-@Inf@] ; 5 / [-@Inf@;@Inf@] ; 5 / [-@Inf@;5] ; 5 / [-@Inf@;1] ; 5 / [-@Inf@;0] ; 5 / [@Inf@;@NaN@] ; 5 / [@Inf@;-@Inf@] ; 5 / [@Inf@;@Inf@] ; 5 / [@Inf@;5] ; 5 / [@Inf@;1] ; 5 / [@Inf@;0] ; 5 / [5;@NaN@] ; 5 / [5;-@Inf@] ; 5 / [5;@Inf@] ; 5 / [5;5] ; 5 / [5;1] ; 5 / [5;0] ; 5 / [1;@NaN@] ; 5 / [1;-@Inf@] ; 5 / [1;@Inf@] ; 5 / [1;5] ; 5 / [1;1] ; 5 / [1;0] ; 5 / [0;@NaN@] ; 5 / [0;-@Inf@] ; 5 / [0;@Inf@] ; 5 / [0;5] ; 5 / [0;1] ; 5 / [0;0] ; 1 / @NaN@ ; 1 / -@Inf@ ; 1 / @Inf@ ; 1 / 5 ; 1 / 1 ; 1 / 0 ; 1 / [@NaN@] ; 1 / [-@Inf@] ; 1 / [@Inf@] ; 1 / [5] ; 1 / [1] ; 1 / [0] ; 1 / [@NaN@;@NaN@] ; 1 / [@NaN@;-@Inf@] ; 1 / [@NaN@;@Inf@] ; 1 / [@NaN@;5] ; 1 / [@NaN@;1] ; 1 / [@NaN@;0] ; 1 / [-@Inf@;@NaN@] ; 1 / [-@Inf@;-@Inf@] ; 1 / [-@Inf@;@Inf@] ; 1 / [-@Inf@;5] ; 1 / [-@Inf@;1] ; 1 / [-@Inf@;0] ; 1 / [@Inf@;@NaN@] ; 1 / [@Inf@;-@Inf@] ; 1 / [@Inf@;@Inf@] ; 1 / [@Inf@;5] ; 1 / [@Inf@;1] ; 1 / [@Inf@;0] ; 1 / [5;@NaN@] ; 1 / [5;-@Inf@] ; 1 / [5;@Inf@] ; 1 / [5;5] ; 1 / [5;1] ; 1 / [5;0] ; 1 / [1;@NaN@] ; 1 / [1;-@Inf@] ; 1 / [1;@Inf@] ; 1 / [1;5] ; 1 / [1;1] ; 1 / [1;0] ; 1 / [0;@NaN@] ; 1 / [0;-@Inf@] ; 1 / [0;@Inf@] ; 1 / [0;5] ; 1 / [0;1] ; 1 / [0;0] ; 0 / @NaN@ ; 0 / -@Inf@ ; 0 / @Inf@ ; 0 / 5 ; 0 / 1 ; 0 / 0 ; 0 / [@NaN@] ; 0 / [-@Inf@] ; 0 / [@Inf@] ; 0 / [5] ; 0 / [1] ; 0 / [0] ; 0 / [@NaN@;@NaN@] ; 0 / [@NaN@;-@Inf@] ; 0 / [@NaN@;@Inf@] ; 0 / [@NaN@;5] ; 0 / [@NaN@;1] ; 0 / [@NaN@;0] ; 0 / [-@Inf@;@NaN@] ; 0 / [-@Inf@;-@Inf@] ; 0 / [-@Inf@;@Inf@] ; 0 / [-@Inf@;5] ; 0 / [-@Inf@;1] ; 0 / [-@Inf@;0] ; 0 / [@Inf@;@NaN@] ; 0 / [@Inf@;-@Inf@] ; 0 / [@Inf@;@Inf@] ; 0 / [@Inf@;5] ; 0 / [@Inf@;1] ; 0 / [@Inf@;0] ; 0 / [5;@NaN@] ; 0 / [5;-@Inf@] ; 0 / [5;@Inf@] ; 0 / [5;5] ; 0 / [5;1] ; 0 / [5;0] ; 0 / [1;@NaN@] ; 0 / [1;-@Inf@] ; 0 / [1;@Inf@] ; 0 / [1;5] ; 0 / [1;1] ; 0 / [1;0] ; 0 / [0;@NaN@] ; 0 / [0;-@Inf@] ; 0 / [0;@Inf@] ; 0 / [0;5] ; 0 / [0;1] ; 0 / [0;0] ; [@NaN@] / @NaN@ ; [@NaN@] / -@Inf@ ; [@NaN@] / @Inf@ ; [@NaN@] / 5 ; [@NaN@] / 1 ; [@NaN@] / 0 ; [@NaN@] / [@NaN@] ; [@NaN@] / [-@Inf@] ; [@NaN@] / [@Inf@] ; [@NaN@] / [5] ; [@NaN@] / [1] ; [@NaN@] / [0] ; [@NaN@] / [@NaN@;@NaN@] ; [@NaN@] / [@NaN@;-@Inf@] ; [@NaN@] / [@NaN@;@Inf@] ; [@NaN@] / [@NaN@;5] ; [@NaN@] / [@NaN@;1] ; [@NaN@] / [@NaN@;0] ; [@NaN@] / [-@Inf@;@NaN@] ; [@NaN@] / [-@Inf@;-@Inf@] ; [@NaN@] / [-@Inf@;@Inf@] ; [@NaN@] / [-@Inf@;5] ; [@NaN@] / [-@Inf@;1] ; [@NaN@] / [-@Inf@;0] ; [@NaN@] / [@Inf@;@NaN@] ; [@NaN@] / [@Inf@;-@Inf@] ; [@NaN@] / [@Inf@;@Inf@] ; [@NaN@] / [@Inf@;5] ; [@NaN@] / [@Inf@;1] ; [@NaN@] / [@Inf@;0] ; [@NaN@] / [5;@NaN@] ; [@NaN@] / [5;-@Inf@] ; [@NaN@] / [5;@Inf@] ; [@NaN@] / [5;5] ; [@NaN@] / [5;1] ; [@NaN@] / [5;0] ; [@NaN@] / [1;@NaN@] ; [@NaN@] / [1;-@Inf@] ; [@NaN@] / [1;@Inf@] ; [@NaN@] / [1;5] ; [@NaN@] / [1;1] ; [@NaN@] / [1;0] ; [@NaN@] / [0;@NaN@] ; [@NaN@] / [0;-@Inf@] ; [@NaN@] / [0;@Inf@] ; [@NaN@] / [0;5] ; [@NaN@] / [0;1] ; [@NaN@] / [0;0] ; [-@Inf@] / @NaN@ ; [-@Inf@] / -@Inf@ ; [-@Inf@] / @Inf@ ; [-@Inf@] / 5 ; [-@Inf@] / 1 ; [-@Inf@] / 0 ; [-@Inf@] / [@NaN@] ; [-@Inf@] / [-@Inf@] ; [-@Inf@] / [@Inf@] ; [-@Inf@] / [5] ; [-@Inf@] / [1] ; [-@Inf@] / [0] ; [-@Inf@] / [@NaN@;@NaN@] ; [-@Inf@] / [@NaN@;-@Inf@] ; [-@Inf@] / [@NaN@;@Inf@] ; [-@Inf@] / [@NaN@;5] ; [-@Inf@] / [@NaN@;1] ; [-@Inf@] / [@NaN@;0] ; [-@Inf@] / [-@Inf@;@NaN@] ; [-@Inf@] / [-@Inf@;-@Inf@] ; [-@Inf@] / [-@Inf@;@Inf@] ; [-@Inf@] / [-@Inf@;5] ; [-@Inf@] / [-@Inf@;1] ; [-@Inf@] / [-@Inf@;0] ; [-@Inf@] / [@Inf@;@NaN@] ; [-@Inf@] / [@Inf@;-@Inf@] ; [-@Inf@] / [@Inf@;@Inf@] ; [-@Inf@] / [@Inf@;5] ; [-@Inf@] / [@Inf@;1] ; [-@Inf@] / [@Inf@;0] ; [-@Inf@] / [5;@NaN@] ; [-@Inf@] / [5;-@Inf@] ; [-@Inf@] / [5;@Inf@] ; [-@Inf@] / [5;5] ; [-@Inf@] / [5;1] ; [-@Inf@] / [5;0] ; [-@Inf@] / [1;@NaN@] ; [-@Inf@] / [1;-@Inf@] ; [-@Inf@] / [1;@Inf@] ; [-@Inf@] / [1;5] ; [-@Inf@] / [1;1] ; [-@Inf@] / [1;0] ; [-@Inf@] / [0;@NaN@] ; [-@Inf@] / [0;-@Inf@] ; [-@Inf@] / [0;@Inf@] ; [-@Inf@] / [0;5] ; [-@Inf@] / [0;1] ; [-@Inf@] / [0;0] ; [@Inf@] / @NaN@ ; [@Inf@] / -@Inf@ ; [@Inf@] / @Inf@ ; [@Inf@] / 5 ; [@Inf@] / 1 ; [@Inf@] / 0 ; [@Inf@] / [@NaN@] ; [@Inf@] / [-@Inf@] ; [@Inf@] / [@Inf@] ; [@Inf@] / [5] ; [@Inf@] / [1] ; [@Inf@] / [0] ; [@Inf@] / [@NaN@;@NaN@] ; [@Inf@] / [@NaN@;-@Inf@] ; [@Inf@] / [@NaN@;@Inf@] ; [@Inf@] / [@NaN@;5] ; [@Inf@] / [@NaN@;1] ; [@Inf@] / [@NaN@;0] ; [@Inf@] / [-@Inf@;@NaN@] ; [@Inf@] / [-@Inf@;-@Inf@] ; [@Inf@] / [-@Inf@;@Inf@] ; [@Inf@] / [-@Inf@;5] ; [@Inf@] / [-@Inf@;1] ; [@Inf@] / [-@Inf@;0] ; [@Inf@] / [@Inf@;@NaN@] ; [@Inf@] / [@Inf@;-@Inf@] ; [@Inf@] / [@Inf@;@Inf@] ; [@Inf@] / [@Inf@;5] ; [@Inf@] / [@Inf@;1] ; [@Inf@] / [@Inf@;0] ; [@Inf@] / [5;@NaN@] ; [@Inf@] / [5;-@Inf@] ; [@Inf@] / [5;@Inf@] ; [@Inf@] / [5;5] ; [@Inf@] / [5;1] ; [@Inf@] / [5;0] ; [@Inf@] / [1;@NaN@] ; [@Inf@] / [1;-@Inf@] ; [@Inf@] / [1;@Inf@] ; [@Inf@] / [1;5] ; [@Inf@] / [1;1] ; [@Inf@] / [1;0] ; [@Inf@] / [0;@NaN@] ; [@Inf@] / [0;-@Inf@] ; [@Inf@] / [0;@Inf@] ; [@Inf@] / [0;5] ; [@Inf@] / [0;1] ; [@Inf@] / [0;0] ; [5] / @NaN@ ; [5] / -@Inf@ ; [5] / @Inf@ ; [5] / 5 ; [5] / 1 ; [5] / 0 ; [5] / [@NaN@] ; [5] / [-@Inf@] ; [5] / [@Inf@] ; [5] / [5] ; [5] / [1] ; [5] / [0] ; [5] / [@NaN@;@NaN@] ; [5] / [@NaN@;-@Inf@] ; [5] / [@NaN@;@Inf@] ; [5] / [@NaN@;5] ; [5] / [@NaN@;1] ; [5] / [@NaN@;0] ; [5] / [-@Inf@;@NaN@] ; [5] / [-@Inf@;-@Inf@] ; [5] / [-@Inf@;@Inf@] ; [5] / [-@Inf@;5] ; [5] / [-@Inf@;1] ; [5] / [-@Inf@;0] ; [5] / [@Inf@;@NaN@] ; [5] / [@Inf@;-@Inf@] ; [5] / [@Inf@;@Inf@] ; [5] / [@Inf@;5] ; [5] / [@Inf@;1] ; [5] / [@Inf@;0] ; [5] / [5;@NaN@] ; [5] / [5;-@Inf@] ; [5] / [5;@Inf@] ; [5] / [5;5] ; [5] / [5;1] ; [5] / [5;0] ; [5] / [1;@NaN@] ; [5] / [1;-@Inf@] ; [5] / [1;@Inf@] ; [5] / [1;5] ; [5] / [1;1] ; [5] / [1;0] ; [5] / [0;@NaN@] ; [5] / [0;-@Inf@] ; [5] / [0;@Inf@] ; [5] / [0;5] ; [5] / [0;1] ; [5] / [0;0] ; [1] / @NaN@ ; [1] / -@Inf@ ; [1] / @Inf@ ; [1] / 5 ; [1] / 1 ; [1] / 0 ; [1] / [@NaN@] ; [1] / [-@Inf@] ; [1] / [@Inf@] ; [1] / [5] ; [1] / [1] ; [1] / [0] ; [1] / [@NaN@;@NaN@] ; [1] / [@NaN@;-@Inf@] ; [1] / [@NaN@;@Inf@] ; [1] / [@NaN@;5] ; [1] / [@NaN@;1] ; [1] / [@NaN@;0] ; [1] / [-@Inf@;@NaN@] ; [1] / [-@Inf@;-@Inf@] ; [1] / [-@Inf@;@Inf@] ; [1] / [-@Inf@;5] ; [1] / [-@Inf@;1] ; [1] / [-@Inf@;0] ; [1] / [@Inf@;@NaN@] ; [1] / [@Inf@;-@Inf@] ; [1] / [@Inf@;@Inf@] ; [1] / [@Inf@;5] ; [1] / [@Inf@;1] ; [1] / [@Inf@;0] ; [1] / [5;@NaN@] ; [1] / [5;-@Inf@] ; [1] / [5;@Inf@] ; [1] / [5;5] ; [1] / [5;1] ; [1] / [5;0] ; [1] / [1;@NaN@] ; [1] / [1;-@Inf@] ; [1] / [1;@Inf@] ; [1] / [1;5] ; [1] / [1;1] ; [1] / [1;0] ; [1] / [0;@NaN@] ; [1] / [0;-@Inf@] ; [1] / [0;@Inf@] ; [1] / [0;5] ; [1] / [0;1] ; [1] / [0;0] ; [0] / @NaN@ ; [0] / -@Inf@ ; [0] / @Inf@ ; [0] / 5 ; [0] / 1 ; [0] / 0 ; [0] / [@NaN@] ; [0] / [-@Inf@] ; [0] / [@Inf@] ; [0] / [5] ; [0] / [1] ; [0] / [0] ; [0] / [@NaN@;@NaN@] ; [0] / [@NaN@;-@Inf@] ; [0] / [@NaN@;@Inf@] ; [0] / [@NaN@;5] ; [0] / [@NaN@;1] ; [0] / [@NaN@;0] ; [0] / [-@Inf@;@NaN@] ; [0] / [-@Inf@;-@Inf@] ; [0] / [-@Inf@;@Inf@] ; [0] / [-@Inf@;5] ; [0] / [-@Inf@;1] ; [0] / [-@Inf@;0] ; [0] / [@Inf@;@NaN@] ; [0] / [@Inf@;-@Inf@] ; [0] / [@Inf@;@Inf@] ; [0] / [@Inf@;5] ; [0] / [@Inf@;1] ; [0] / [@Inf@;0] ; [0] / [5;@NaN@] ; [0] / [5;-@Inf@] ; [0] / [5;@Inf@] ; [0] / [5;5] ; [0] / [5;1] ; [0] / [5;0] ; [0] / [1;@NaN@] ; [0] / [1;-@Inf@] ; [0] / [1;@Inf@] ; [0] / [1;5] ; [0] / [1;1] ; [0] / [1;0] ; [0] / [0;@NaN@] ; [0] / [0;-@Inf@] ; [0] / [0;@Inf@] ; [0] / [0;5] ; [0] / [0;1] ; [0] / [0;0] ; [@NaN@;@NaN@] / @NaN@ ; [@NaN@;@NaN@] / -@Inf@ ; [@NaN@;@NaN@] / @Inf@ ; [@NaN@;@NaN@] / 5 ; [@NaN@;@NaN@] / 1 ; [@NaN@;@NaN@] / 0 ; [@NaN@;@NaN@] / [@NaN@] ; [@NaN@;@NaN@] / [-@Inf@] ; [@NaN@;@NaN@] / [@Inf@] ; [@NaN@;@NaN@] / [5] ; [@NaN@;@NaN@] / [1] ; [@NaN@;@NaN@] / [0] ; [@NaN@;@NaN@] / [@NaN@;@NaN@] ; [@NaN@;@NaN@] / [@NaN@;-@Inf@] ; [@NaN@;@NaN@] / [@NaN@;@Inf@] ; [@NaN@;@NaN@] / [@NaN@;5] ; [@NaN@;@NaN@] / [@NaN@;1] ; [@NaN@;@NaN@] / [@NaN@;0] ; [@NaN@;@NaN@] / [-@Inf@;@NaN@] ; [@NaN@;@NaN@] / [-@Inf@;-@Inf@] ; [@NaN@;@NaN@] / [-@Inf@;@Inf@] ; [@NaN@;@NaN@] / [-@Inf@;5] ; [@NaN@;@NaN@] / [-@Inf@;1] ; [@NaN@;@NaN@] / [-@Inf@;0] ; [@NaN@;@NaN@] / [@Inf@;@NaN@] ; [@NaN@;@NaN@] / [@Inf@;-@Inf@] ; [@NaN@;@NaN@] / [@Inf@;@Inf@] ; [@NaN@;@NaN@] / [@Inf@;5] ; [@NaN@;@NaN@] / [@Inf@;1] ; [@NaN@;@NaN@] / [@Inf@;0] ; [@NaN@;@NaN@] / [5;@NaN@] ; [@NaN@;@NaN@] / [5;-@Inf@] ; [@NaN@;@NaN@] / [5;@Inf@] ; [@NaN@;@NaN@] / [5;5] ; [@NaN@;@NaN@] / [5;1] ; [@NaN@;@NaN@] / [5;0] ; [@NaN@;@NaN@] / [1;@NaN@] ; [@NaN@;@NaN@] / [1;-@Inf@] ; [@NaN@;@NaN@] / [1;@Inf@] ; [@NaN@;@NaN@] / [1;5] ; [@NaN@;@NaN@] / [1;1] ; [@NaN@;@NaN@] / [1;0] ; [@NaN@;@NaN@] / [0;@NaN@] ; [@NaN@;@NaN@] / [0;-@Inf@] ; [@NaN@;@NaN@] / [0;@Inf@] ; [@NaN@;@NaN@] / [0;5] ; [@NaN@;@NaN@] / [0;1] ; [@NaN@;@NaN@] / [0;0] ; [@NaN@;-@Inf@] / @NaN@ ; [@NaN@;-@Inf@] / -@Inf@ ; [@NaN@;-@Inf@] / @Inf@ ; [@NaN@;-@Inf@] / 5 ; [@NaN@;-@Inf@] / 1 ; [@NaN@;-@Inf@] / 0 ; [@NaN@;-@Inf@] / [@NaN@] ; [@NaN@;-@Inf@] / [-@Inf@] ; [@NaN@;-@Inf@] / [@Inf@] ; [@NaN@;-@Inf@] / [5] ; [@NaN@;-@Inf@] / [1] ; [@NaN@;-@Inf@] / [0] ; [@NaN@;-@Inf@] / [@NaN@;@NaN@] ; [@NaN@;-@Inf@] / [@NaN@;-@Inf@] ; [@NaN@;-@Inf@] / [@NaN@;@Inf@] ; [@NaN@;-@Inf@] / [@NaN@;5] ; [@NaN@;-@Inf@] / [@NaN@;1] ; [@NaN@;-@Inf@] / [@NaN@;0] ; [@NaN@;-@Inf@] / [-@Inf@;@NaN@] ; [@NaN@;-@Inf@] / [-@Inf@;-@Inf@] ; [@NaN@;-@Inf@] / [-@Inf@;@Inf@] ; [@NaN@;-@Inf@] / [-@Inf@;5] ; [@NaN@;-@Inf@] / [-@Inf@;1] ; [@NaN@;-@Inf@] / [-@Inf@;0] ; [@NaN@;-@Inf@] / [@Inf@;@NaN@] ; [@NaN@;-@Inf@] / [@Inf@;-@Inf@] ; [@NaN@;-@Inf@] / [@Inf@;@Inf@] ; [@NaN@;-@Inf@] / [@Inf@;5] ; [@NaN@;-@Inf@] / [@Inf@;1] ; [@NaN@;-@Inf@] / [@Inf@;0] ; [@NaN@;-@Inf@] / [5;@NaN@] ; [@NaN@;-@Inf@] / [5;-@Inf@] ; [@NaN@;-@Inf@] / [5;@Inf@] ; [@NaN@;-@Inf@] / [5;5] ; [@NaN@;-@Inf@] / [5;1] ; [@NaN@;-@Inf@] / [5;0] ; [@NaN@;-@Inf@] / [1;@NaN@] ; [@NaN@;-@Inf@] / [1;-@Inf@] ; [@NaN@;-@Inf@] / [1;@Inf@] ; [@NaN@;-@Inf@] / [1;5] ; [@NaN@;-@Inf@] / [1;1] ; [@NaN@;-@Inf@] / [1;0] ; [@NaN@;-@Inf@] / [0;@NaN@] ; [@NaN@;-@Inf@] / [0;-@Inf@] ; [@NaN@;-@Inf@] / [0;@Inf@] ; [@NaN@;-@Inf@] / [0;5] ; [@NaN@;-@Inf@] / [0;1] ; [@NaN@;-@Inf@] / [0;0] ; [@NaN@;@Inf@] / @NaN@ ; [@NaN@;@Inf@] / -@Inf@ ; [@NaN@;@Inf@] / @Inf@ ; [@NaN@;@Inf@] / 5 ; [@NaN@;@Inf@] / 1 ; [@NaN@;@Inf@] / 0 ; [@NaN@;@Inf@] / [@NaN@] ; [@NaN@;@Inf@] / [-@Inf@] ; [@NaN@;@Inf@] / [@Inf@] ; [@NaN@;@Inf@] / [5] ; [@NaN@;@Inf@] / [1] ; [@NaN@;@Inf@] / [0] ; [@NaN@;@Inf@] / [@NaN@;@NaN@] ; [@NaN@;@Inf@] / [@NaN@;-@Inf@] ; [@NaN@;@Inf@] / [@NaN@;@Inf@] ; [@NaN@;@Inf@] / [@NaN@;5] ; [@NaN@;@Inf@] / [@NaN@;1] ; [@NaN@;@Inf@] / [@NaN@;0] ; [@NaN@;@Inf@] / [-@Inf@;@NaN@] ; [@NaN@;@Inf@] / [-@Inf@;-@Inf@] ; [@NaN@;@Inf@] / [-@Inf@;@Inf@] ; [@NaN@;@Inf@] / [-@Inf@;5] ; [@NaN@;@Inf@] / [-@Inf@;1] ; [@NaN@;@Inf@] / [-@Inf@;0] ; [@NaN@;@Inf@] / [@Inf@;@NaN@] ; [@NaN@;@Inf@] / [@Inf@;-@Inf@] ; [@NaN@;@Inf@] / [@Inf@;@Inf@] ; [@NaN@;@Inf@] / [@Inf@;5] ; [@NaN@;@Inf@] / [@Inf@;1] ; [@NaN@;@Inf@] / [@Inf@;0] ; [@NaN@;@Inf@] / [5;@NaN@] ; [@NaN@;@Inf@] / [5;-@Inf@] ; [@NaN@;@Inf@] / [5;@Inf@] ; [@NaN@;@Inf@] / [5;5] ; [@NaN@;@Inf@] / [5;1] ; [@NaN@;@Inf@] / [5;0] ; [@NaN@;@Inf@] / [1;@NaN@] ; [@NaN@;@Inf@] / [1;-@Inf@] ; [@NaN@;@Inf@] / [1;@Inf@] ; [@NaN@;@Inf@] / [1;5] ; [@NaN@;@Inf@] / [1;1] ; [@NaN@;@Inf@] / [1;0] ; [@NaN@;@Inf@] / [0;@NaN@] ; [@NaN@;@Inf@] / [0;-@Inf@] ; [@NaN@;@Inf@] / [0;@Inf@] ; [@NaN@;@Inf@] / [0;5] ; [@NaN@;@Inf@] / [0;1] ; [@NaN@;@Inf@] / [0;0] ; [@NaN@;5] / @NaN@ ; [@NaN@;5] / -@Inf@ ; [@NaN@;5] / @Inf@ ; [@NaN@;5] / 5 ; [@NaN@;5] / 1 ; [@NaN@;5] / 0 ; [@NaN@;5] / [@NaN@] ; [@NaN@;5] / [-@Inf@] ; [@NaN@;5] / [@Inf@] ; [@NaN@;5] / [5] ; [@NaN@;5] / [1] ; [@NaN@;5] / [0] ; [@NaN@;5] / [@NaN@;@NaN@] ; [@NaN@;5] / [@NaN@;-@Inf@] ; [@NaN@;5] / [@NaN@;@Inf@] ; [@NaN@;5] / [@NaN@;5] ; [@NaN@;5] / [@NaN@;1] ; [@NaN@;5] / [@NaN@;0] ; [@NaN@;5] / [-@Inf@;@NaN@] ; [@NaN@;5] / [-@Inf@;-@Inf@] ; [@NaN@;5] / [-@Inf@;@Inf@] ; [@NaN@;5] / [-@Inf@;5] ; [@NaN@;5] / [-@Inf@;1] ; [@NaN@;5] / [-@Inf@;0] ; [@NaN@;5] / [@Inf@;@NaN@] ; [@NaN@;5] / [@Inf@;-@Inf@] ; [@NaN@;5] / [@Inf@;@Inf@] ; [@NaN@;5] / [@Inf@;5] ; [@NaN@;5] / [@Inf@;1] ; [@NaN@;5] / [@Inf@;0] ; [@NaN@;5] / [5;@NaN@] ; [@NaN@;5] / [5;-@Inf@] ; [@NaN@;5] / [5;@Inf@] ; [@NaN@;5] / [5;5] ; [@NaN@;5] / [5;1] ; [@NaN@;5] / [5;0] ; [@NaN@;5] / [1;@NaN@] ; [@NaN@;5] / [1;-@Inf@] ; [@NaN@;5] / [1;@Inf@] ; [@NaN@;5] / [1;5] ; [@NaN@;5] / [1;1] ; [@NaN@;5] / [1;0] ; [@NaN@;5] / [0;@NaN@] ; [@NaN@;5] / [0;-@Inf@] ; [@NaN@;5] / [0;@Inf@] ; [@NaN@;5] / [0;5] ; [@NaN@;5] / [0;1] ; [@NaN@;5] / [0;0] ; [@NaN@;1] / @NaN@ ; [@NaN@;1] / -@Inf@ ; [@NaN@;1] / @Inf@ ; [@NaN@;1] / 5 ; [@NaN@;1] / 1 ; [@NaN@;1] / 0 ; [@NaN@;1] / [@NaN@] ; [@NaN@;1] / [-@Inf@] ; [@NaN@;1] / [@Inf@] ; [@NaN@;1] / [5] ; [@NaN@;1] / [1] ; [@NaN@;1] / [0] ; [@NaN@;1] / [@NaN@;@NaN@] ; [@NaN@;1] / [@NaN@;-@Inf@] ; [@NaN@;1] / [@NaN@;@Inf@] ; [@NaN@;1] / [@NaN@;5] ; [@NaN@;1] / [@NaN@;1] ; [@NaN@;1] / [@NaN@;0] ; [@NaN@;1] / [-@Inf@;@NaN@] ; [@NaN@;1] / [-@Inf@;-@Inf@] ; [@NaN@;1] / [-@Inf@;@Inf@] ; [@NaN@;1] / [-@Inf@;5] ; [@NaN@;1] / [-@Inf@;1] ; [@NaN@;1] / [-@Inf@;0] ; [@NaN@;1] / [@Inf@;@NaN@] ; [@NaN@;1] / [@Inf@;-@Inf@] ; [@NaN@;1] / [@Inf@;@Inf@] ; [@NaN@;1] / [@Inf@;5] ; [@NaN@;1] / [@Inf@;1] ; [@NaN@;1] / [@Inf@;0] ; [@NaN@;1] / [5;@NaN@] ; [@NaN@;1] / [5;-@Inf@] ; [@NaN@;1] / [5;@Inf@] ; [@NaN@;1] / [5;5] ; [@NaN@;1] / [5;1] ; [@NaN@;1] / [5;0] ; [@NaN@;1] / [1;@NaN@] ; [@NaN@;1] / [1;-@Inf@] ; [@NaN@;1] / [1;@Inf@] ; [@NaN@;1] / [1;5] ; [@NaN@;1] / [1;1] ; [@NaN@;1] / [1;0] ; [@NaN@;1] / [0;@NaN@] ; [@NaN@;1] / [0;-@Inf@] ; [@NaN@;1] / [0;@Inf@] ; [@NaN@;1] / [0;5] ; [@NaN@;1] / [0;1] ; [@NaN@;1] / [0;0] ; [@NaN@;0] / @NaN@ ; [@NaN@;0] / -@Inf@ ; [@NaN@;0] / @Inf@ ; [@NaN@;0] / 5 ; [@NaN@;0] / 1 ; [@NaN@;0] / 0 ; [@NaN@;0] / [@NaN@] ; [@NaN@;0] / [-@Inf@] ; [@NaN@;0] / [@Inf@] ; [@NaN@;0] / [5] ; [@NaN@;0] / [1] ; [@NaN@;0] / [0] ; [@NaN@;0] / [@NaN@;@NaN@] ; [@NaN@;0] / [@NaN@;-@Inf@] ; [@NaN@;0] / [@NaN@;@Inf@] ; [@NaN@;0] / [@NaN@;5] ; [@NaN@;0] / [@NaN@;1] ; [@NaN@;0] / [@NaN@;0] ; [@NaN@;0] / [-@Inf@;@NaN@] ; [@NaN@;0] / [-@Inf@;-@Inf@] ; [@NaN@;0] / [-@Inf@;@Inf@] ; [@NaN@;0] / [-@Inf@;5] ; [@NaN@;0] / [-@Inf@;1] ; [@NaN@;0] / [-@Inf@;0] ; [@NaN@;0] / [@Inf@;@NaN@] ; [@NaN@;0] / [@Inf@;-@Inf@] ; [@NaN@;0] / [@Inf@;@Inf@] ; [@NaN@;0] / [@Inf@;5] ; [@NaN@;0] / [@Inf@;1] ; [@NaN@;0] / [@Inf@;0] ; [@NaN@;0] / [5;@NaN@] ; [@NaN@;0] / [5;-@Inf@] ; [@NaN@;0] / [5;@Inf@] ; [@NaN@;0] / [5;5] ; [@NaN@;0] / [5;1] ; [@NaN@;0] / [5;0] ; [@NaN@;0] / [1;@NaN@] ; [@NaN@;0] / [1;-@Inf@] ; [@NaN@;0] / [1;@Inf@] ; [@NaN@;0] / [1;5] ; [@NaN@;0] / [1;1] ; [@NaN@;0] / [1;0] ; [@NaN@;0] / [0;@NaN@] ; [@NaN@;0] / [0;-@Inf@] ; [@NaN@;0] / [0;@Inf@] ; [@NaN@;0] / [0;5] ; [@NaN@;0] / [0;1] ; [@NaN@;0] / [0;0] ; [-@Inf@;@NaN@] / @NaN@ ; [-@Inf@;@NaN@] / -@Inf@ ; [-@Inf@;@NaN@] / @Inf@ ; [-@Inf@;@NaN@] / 5 ; [-@Inf@;@NaN@] / 1 ; [-@Inf@;@NaN@] / 0 ; [-@Inf@;@NaN@] / [@NaN@] ; [-@Inf@;@NaN@] / [-@Inf@] ; [-@Inf@;@NaN@] / [@Inf@] ; [-@Inf@;@NaN@] / [5] ; [-@Inf@;@NaN@] / [1] ; [-@Inf@;@NaN@] / [0] ; [-@Inf@;@NaN@] / [@NaN@;@NaN@] ; [-@Inf@;@NaN@] / [@NaN@;-@Inf@] ; [-@Inf@;@NaN@] / [@NaN@;@Inf@] ; [-@Inf@;@NaN@] / [@NaN@;5] ; [-@Inf@;@NaN@] / [@NaN@;1] ; [-@Inf@;@NaN@] / [@NaN@;0] ; [-@Inf@;@NaN@] / [-@Inf@;@NaN@] ; [-@Inf@;@NaN@] / [-@Inf@;-@Inf@] ; [-@Inf@;@NaN@] / [-@Inf@;@Inf@] ; [-@Inf@;@NaN@] / [-@Inf@;5] ; [-@Inf@;@NaN@] / [-@Inf@;1] ; [-@Inf@;@NaN@] / [-@Inf@;0] ; [-@Inf@;@NaN@] / [@Inf@;@NaN@] ; [-@Inf@;@NaN@] / [@Inf@;-@Inf@] ; [-@Inf@;@NaN@] / [@Inf@;@Inf@] ; [-@Inf@;@NaN@] / [@Inf@;5] ; [-@Inf@;@NaN@] / [@Inf@;1] ; [-@Inf@;@NaN@] / [@Inf@;0] ; [-@Inf@;@NaN@] / [5;@NaN@] ; [-@Inf@;@NaN@] / [5;-@Inf@] ; [-@Inf@;@NaN@] / [5;@Inf@] ; [-@Inf@;@NaN@] / [5;5] ; [-@Inf@;@NaN@] / [5;1] ; [-@Inf@;@NaN@] / [5;0] ; [-@Inf@;@NaN@] / [1;@NaN@] ; [-@Inf@;@NaN@] / [1;-@Inf@] ; [-@Inf@;@NaN@] / [1;@Inf@] ; [-@Inf@;@NaN@] / [1;5] ; [-@Inf@;@NaN@] / [1;1] ; [-@Inf@;@NaN@] / [1;0] ; [-@Inf@;@NaN@] / [0;@NaN@] ; [-@Inf@;@NaN@] / [0;-@Inf@] ; [-@Inf@;@NaN@] / [0;@Inf@] ; [-@Inf@;@NaN@] / [0;5] ; [-@Inf@;@NaN@] / [0;1] ; [-@Inf@;@NaN@] / [0;0] ; [-@Inf@;-@Inf@] / @NaN@ ; [-@Inf@;-@Inf@] / -@Inf@ ; [-@Inf@;-@Inf@] / @Inf@ ; [-@Inf@;-@Inf@] / 5 ; [-@Inf@;-@Inf@] / 1 ; [-@Inf@;-@Inf@] / 0 ; [-@Inf@;-@Inf@] / [@NaN@] ; [-@Inf@;-@Inf@] / [-@Inf@] ; [-@Inf@;-@Inf@] / [@Inf@] ; [-@Inf@;-@Inf@] / [5] ; [-@Inf@;-@Inf@] / [1] ; [-@Inf@;-@Inf@] / [0] ; [-@Inf@;-@Inf@] / [@NaN@;@NaN@] ; [-@Inf@;-@Inf@] / [@NaN@;-@Inf@] ; [-@Inf@;-@Inf@] / [@NaN@;@Inf@] ; [-@Inf@;-@Inf@] / [@NaN@;5] ; [-@Inf@;-@Inf@] / [@NaN@;1] ; [-@Inf@;-@Inf@] / [@NaN@;0] ; [-@Inf@;-@Inf@] / [-@Inf@;@NaN@] ; [-@Inf@;-@Inf@] / [-@Inf@;-@Inf@] ; [-@Inf@;-@Inf@] / [-@Inf@;@Inf@] ; [-@Inf@;-@Inf@] / [-@Inf@;5] ; [-@Inf@;-@Inf@] / [-@Inf@;1] ; [-@Inf@;-@Inf@] / [-@Inf@;0] ; [-@Inf@;-@Inf@] / [@Inf@;@NaN@] ; [-@Inf@;-@Inf@] / [@Inf@;-@Inf@] ; [-@Inf@;-@Inf@] / [@Inf@;@Inf@] ; [-@Inf@;-@Inf@] / [@Inf@;5] ; [-@Inf@;-@Inf@] / [@Inf@;1] ; [-@Inf@;-@Inf@] / [@Inf@;0] ; [-@Inf@;-@Inf@] / [5;@NaN@] ; [-@Inf@;-@Inf@] / [5;-@Inf@] ; [-@Inf@;-@Inf@] / [5;@Inf@] ; [-@Inf@;-@Inf@] / [5;5] ; [-@Inf@;-@Inf@] / [5;1] ; [-@Inf@;-@Inf@] / [5;0] ; [-@Inf@;-@Inf@] / [1;@NaN@] ; [-@Inf@;-@Inf@] / [1;-@Inf@] ; [-@Inf@;-@Inf@] / [1;@Inf@] ; [-@Inf@;-@Inf@] / [1;5] ; [-@Inf@;-@Inf@] / [1;1] ; [-@Inf@;-@Inf@] / [1;0] ; [-@Inf@;-@Inf@] / [0;@NaN@] ; [-@Inf@;-@Inf@] / [0;-@Inf@] ; [-@Inf@;-@Inf@] / [0;@Inf@] ; [-@Inf@;-@Inf@] / [0;5] ; [-@Inf@;-@Inf@] / [0;1] ; [-@Inf@;-@Inf@] / [0;0] ; [-@Inf@;@Inf@] / @NaN@ ; [-@Inf@;@Inf@] / -@Inf@ ; [-@Inf@;@Inf@] / @Inf@ ; [-@Inf@;@Inf@] / 5 ; [-@Inf@;@Inf@] / 1 ; [-@Inf@;@Inf@] / 0 ; [-@Inf@;@Inf@] / [@NaN@] ; [-@Inf@;@Inf@] / [-@Inf@] ; [-@Inf@;@Inf@] / [@Inf@] ; [-@Inf@;@Inf@] / [5] ; [-@Inf@;@Inf@] / [1] ; [-@Inf@;@Inf@] / [0] ; [-@Inf@;@Inf@] / [@NaN@;@NaN@] ; [-@Inf@;@Inf@] / [@NaN@;-@Inf@] ; [-@Inf@;@Inf@] / [@NaN@;@Inf@] ; [-@Inf@;@Inf@] / [@NaN@;5] ; [-@Inf@;@Inf@] / [@NaN@;1] ; [-@Inf@;@Inf@] / [@NaN@;0] ; [-@Inf@;@Inf@] / [-@Inf@;@NaN@] ; [-@Inf@;@Inf@] / [-@Inf@;-@Inf@] ; [-@Inf@;@Inf@] / [-@Inf@;@Inf@] ; [-@Inf@;@Inf@] / [-@Inf@;5] ; [-@Inf@;@Inf@] / [-@Inf@;1] ; [-@Inf@;@Inf@] / [-@Inf@;0] ; [-@Inf@;@Inf@] / [@Inf@;@NaN@] ; [-@Inf@;@Inf@] / [@Inf@;-@Inf@] ; [-@Inf@;@Inf@] / [@Inf@;@Inf@] ; [-@Inf@;@Inf@] / [@Inf@;5] ; [-@Inf@;@Inf@] / [@Inf@;1] ; [-@Inf@;@Inf@] / [@Inf@;0] ; [-@Inf@;@Inf@] / [5;@NaN@] ; [-@Inf@;@Inf@] / [5;-@Inf@] ; [-@Inf@;@Inf@] / [5;@Inf@] ; [-@Inf@;@Inf@] / [5;5] ; [-@Inf@;@Inf@] / [5;1] ; [-@Inf@;@Inf@] / [5;0] ; [-@Inf@;@Inf@] / [1;@NaN@] ; [-@Inf@;@Inf@] / [1;-@Inf@] ; [-@Inf@;@Inf@] / [1;@Inf@] ; [-@Inf@;@Inf@] / [1;5] ; [-@Inf@;@Inf@] / [1;1] ; [-@Inf@;@Inf@] / [1;0] ; [-@Inf@;@Inf@] / [0;@NaN@] ; [-@Inf@;@Inf@] / [0;-@Inf@] ; [-@Inf@;@Inf@] / [0;@Inf@] ; [-@Inf@;@Inf@] / [0;5] ; [-@Inf@;@Inf@] / [0;1] ; [-@Inf@;@Inf@] / [0;0] ; [-@Inf@;5] / @NaN@ ; [-@Inf@;5] / -@Inf@ ; [-@Inf@;5] / @Inf@ ; [-@Inf@;5] / 5 ; [-@Inf@;5] / 1 ; [-@Inf@;5] / 0 ; [-@Inf@;5] / [@NaN@] ; [-@Inf@;5] / [-@Inf@] ; [-@Inf@;5] / [@Inf@] ; [-@Inf@;5] / [5] ; [-@Inf@;5] / [1] ; [-@Inf@;5] / [0] ; [-@Inf@;5] / [@NaN@;@NaN@] ; [-@Inf@;5] / [@NaN@;-@Inf@] ; [-@Inf@;5] / [@NaN@;@Inf@] ; [-@Inf@;5] / [@NaN@;5] ; [-@Inf@;5] / [@NaN@;1] ; [-@Inf@;5] / [@NaN@;0] ; [-@Inf@;5] / [-@Inf@;@NaN@] ; [-@Inf@;5] / [-@Inf@;-@Inf@] ; [-@Inf@;5] / [-@Inf@;@Inf@] ; [-@Inf@;5] / [-@Inf@;5] ; [-@Inf@;5] / [-@Inf@;1] ; [-@Inf@;5] / [-@Inf@;0] ; [-@Inf@;5] / [@Inf@;@NaN@] ; [-@Inf@;5] / [@Inf@;-@Inf@] ; [-@Inf@;5] / [@Inf@;@Inf@] ; [-@Inf@;5] / [@Inf@;5] ; [-@Inf@;5] / [@Inf@;1] ; [-@Inf@;5] / [@Inf@;0] ; [-@Inf@;5] / [5;@NaN@] ; [-@Inf@;5] / [5;-@Inf@] ; [-@Inf@;5] / [5;@Inf@] ; [-@Inf@;5] / [5;5] ; [-@Inf@;5] / [5;1] ; [-@Inf@;5] / [5;0] ; [-@Inf@;5] / [1;@NaN@] ; [-@Inf@;5] / [1;-@Inf@] ; [-@Inf@;5] / [1;@Inf@] ; [-@Inf@;5] / [1;5] ; [-@Inf@;5] / [1;1] ; [-@Inf@;5] / [1;0] ; [-@Inf@;5] / [0;@NaN@] ; [-@Inf@;5] / [0;-@Inf@] ; [-@Inf@;5] / [0;@Inf@] ; [-@Inf@;5] / [0;5] ; [-@Inf@;5] / [0;1] ; [-@Inf@;5] / [0;0] ; [-@Inf@;1] / @NaN@ ; [-@Inf@;1] / -@Inf@ ; [-@Inf@;1] / @Inf@ ; [-@Inf@;1] / 5 ; [-@Inf@;1] / 1 ; [-@Inf@;1] / 0 ; [-@Inf@;1] / [@NaN@] ; [-@Inf@;1] / [-@Inf@] ; [-@Inf@;1] / [@Inf@] ; [-@Inf@;1] / [5] ; [-@Inf@;1] / [1] ; [-@Inf@;1] / [0] ; [-@Inf@;1] / [@NaN@;@NaN@] ; [-@Inf@;1] / [@NaN@;-@Inf@] ; [-@Inf@;1] / [@NaN@;@Inf@] ; [-@Inf@;1] / [@NaN@;5] ; [-@Inf@;1] / [@NaN@;1] ; [-@Inf@;1] / [@NaN@;0] ; [-@Inf@;1] / [-@Inf@;@NaN@] ; [-@Inf@;1] / [-@Inf@;-@Inf@] ; [-@Inf@;1] / [-@Inf@;@Inf@] ; [-@Inf@;1] / [-@Inf@;5] ; [-@Inf@;1] / [-@Inf@;1] ; [-@Inf@;1] / [-@Inf@;0] ; [-@Inf@;1] / [@Inf@;@NaN@] ; [-@Inf@;1] / [@Inf@;-@Inf@] ; [-@Inf@;1] / [@Inf@;@Inf@] ; [-@Inf@;1] / [@Inf@;5] ; [-@Inf@;1] / [@Inf@;1] ; [-@Inf@;1] / [@Inf@;0] ; [-@Inf@;1] / [5;@NaN@] ; [-@Inf@;1] / [5;-@Inf@] ; [-@Inf@;1] / [5;@Inf@] ; [-@Inf@;1] / [5;5] ; [-@Inf@;1] / [5;1] ; [-@Inf@;1] / [5;0] ; [-@Inf@;1] / [1;@NaN@] ; [-@Inf@;1] / [1;-@Inf@] ; [-@Inf@;1] / [1;@Inf@] ; [-@Inf@;1] / [1;5] ; [-@Inf@;1] / [1;1] ; [-@Inf@;1] / [1;0] ; [-@Inf@;1] / [0;@NaN@] ; [-@Inf@;1] / [0;-@Inf@] ; [-@Inf@;1] / [0;@Inf@] ; [-@Inf@;1] / [0;5] ; [-@Inf@;1] / [0;1] ; [-@Inf@;1] / [0;0] ; [-@Inf@;0] / @NaN@ ; [-@Inf@;0] / -@Inf@ ; [-@Inf@;0] / @Inf@ ; [-@Inf@;0] / 5 ; [-@Inf@;0] / 1 ; [-@Inf@;0] / 0 ; [-@Inf@;0] / [@NaN@] ; [-@Inf@;0] / [-@Inf@] ; [-@Inf@;0] / [@Inf@] ; [-@Inf@;0] / [5] ; [-@Inf@;0] / [1] ; [-@Inf@;0] / [0] ; [-@Inf@;0] / [@NaN@;@NaN@] ; [-@Inf@;0] / [@NaN@;-@Inf@] ; [-@Inf@;0] / [@NaN@;@Inf@] ; [-@Inf@;0] / [@NaN@;5] ; [-@Inf@;0] / [@NaN@;1] ; [-@Inf@;0] / [@NaN@;0] ; [-@Inf@;0] / [-@Inf@;@NaN@] ; [-@Inf@;0] / [-@Inf@;-@Inf@] ; [-@Inf@;0] / [-@Inf@;@Inf@] ; [-@Inf@;0] / [-@Inf@;5] ; [-@Inf@;0] / [-@Inf@;1] ; [-@Inf@;0] / [-@Inf@;0] ; [-@Inf@;0] / [@Inf@;@NaN@] ; [-@Inf@;0] / [@Inf@;-@Inf@] ; [-@Inf@;0] / [@Inf@;@Inf@] ; [-@Inf@;0] / [@Inf@;5] ; [-@Inf@;0] / [@Inf@;1] ; [-@Inf@;0] / [@Inf@;0] ; [-@Inf@;0] / [5;@NaN@] ; [-@Inf@;0] / [5;-@Inf@] ; [-@Inf@;0] / [5;@Inf@] ; [-@Inf@;0] / [5;5] ; [-@Inf@;0] / [5;1] ; [-@Inf@;0] / [5;0] ; [-@Inf@;0] / [1;@NaN@] ; [-@Inf@;0] / [1;-@Inf@] ; [-@Inf@;0] / [1;@Inf@] ; [-@Inf@;0] / [1;5] ; [-@Inf@;0] / [1;1] ; [-@Inf@;0] / [1;0] ; [-@Inf@;0] / [0;@NaN@] ; [-@Inf@;0] / [0;-@Inf@] ; [-@Inf@;0] / [0;@Inf@] ; [-@Inf@;0] / [0;5] ; [-@Inf@;0] / [0;1] ; [-@Inf@;0] / [0;0] ; [@Inf@;@NaN@] / @NaN@ ; [@Inf@;@NaN@] / -@Inf@ ; [@Inf@;@NaN@] / @Inf@ ; [@Inf@;@NaN@] / 5 ; [@Inf@;@NaN@] / 1 ; [@Inf@;@NaN@] / 0 ; [@Inf@;@NaN@] / [@NaN@] ; [@Inf@;@NaN@] / [-@Inf@] ; [@Inf@;@NaN@] / [@Inf@] ; [@Inf@;@NaN@] / [5] ; [@Inf@;@NaN@] / [1] ; [@Inf@;@NaN@] / [0] ; [@Inf@;@NaN@] / [@NaN@;@NaN@] ; [@Inf@;@NaN@] / [@NaN@;-@Inf@] ; [@Inf@;@NaN@] / [@NaN@;@Inf@] ; [@Inf@;@NaN@] / [@NaN@;5] ; [@Inf@;@NaN@] / [@NaN@;1] ; [@Inf@;@NaN@] / [@NaN@;0] ; [@Inf@;@NaN@] / [-@Inf@;@NaN@] ; [@Inf@;@NaN@] / [-@Inf@;-@Inf@] ; [@Inf@;@NaN@] / [-@Inf@;@Inf@] ; [@Inf@;@NaN@] / [-@Inf@;5] ; [@Inf@;@NaN@] / [-@Inf@;1] ; [@Inf@;@NaN@] / [-@Inf@;0] ; [@Inf@;@NaN@] / [@Inf@;@NaN@] ; [@Inf@;@NaN@] / [@Inf@;-@Inf@] ; [@Inf@;@NaN@] / [@Inf@;@Inf@] ; [@Inf@;@NaN@] / [@Inf@;5] ; [@Inf@;@NaN@] / [@Inf@;1] ; [@Inf@;@NaN@] / [@Inf@;0] ; [@Inf@;@NaN@] / [5;@NaN@] ; [@Inf@;@NaN@] / [5;-@Inf@] ; [@Inf@;@NaN@] / [5;@Inf@] ; [@Inf@;@NaN@] / [5;5] ; [@Inf@;@NaN@] / [5;1] ; [@Inf@;@NaN@] / [5;0] ; [@Inf@;@NaN@] / [1;@NaN@] ; [@Inf@;@NaN@] / [1;-@Inf@] ; [@Inf@;@NaN@] / [1;@Inf@] ; [@Inf@;@NaN@] / [1;5] ; [@Inf@;@NaN@] / [1;1] ; [@Inf@;@NaN@] / [1;0] ; [@Inf@;@NaN@] / [0;@NaN@] ; [@Inf@;@NaN@] / [0;-@Inf@] ; [@Inf@;@NaN@] / [0;@Inf@] ; [@Inf@;@NaN@] / [0;5] ; [@Inf@;@NaN@] / [0;1] ; [@Inf@;@NaN@] / [0;0] ; [@Inf@;-@Inf@] / @NaN@ ; [@Inf@;-@Inf@] / -@Inf@ ; [@Inf@;-@Inf@] / @Inf@ ; [@Inf@;-@Inf@] / 5 ; [@Inf@;-@Inf@] / 1 ; [@Inf@;-@Inf@] / 0 ; [@Inf@;-@Inf@] / [@NaN@] ; [@Inf@;-@Inf@] / [-@Inf@] ; [@Inf@;-@Inf@] / [@Inf@] ; [@Inf@;-@Inf@] / [5] ; [@Inf@;-@Inf@] / [1] ; [@Inf@;-@Inf@] / [0] ; [@Inf@;-@Inf@] / [@NaN@;@NaN@] ; [@Inf@;-@Inf@] / [@NaN@;-@Inf@] ; [@Inf@;-@Inf@] / [@NaN@;@Inf@] ; [@Inf@;-@Inf@] / [@NaN@;5] ; [@Inf@;-@Inf@] / [@NaN@;1] ; [@Inf@;-@Inf@] / [@NaN@;0] ; [@Inf@;-@Inf@] / [-@Inf@;@NaN@] ; [@Inf@;-@Inf@] / [-@Inf@;-@Inf@] ; [@Inf@;-@Inf@] / [-@Inf@;@Inf@] ; [@Inf@;-@Inf@] / [-@Inf@;5] ; [@Inf@;-@Inf@] / [-@Inf@;1] ; [@Inf@;-@Inf@] / [-@Inf@;0] ; [@Inf@;-@Inf@] / [@Inf@;@NaN@] ; [@Inf@;-@Inf@] / [@Inf@;-@Inf@] ; [@Inf@;-@Inf@] / [@Inf@;@Inf@] ; [@Inf@;-@Inf@] / [@Inf@;5] ; [@Inf@;-@Inf@] / [@Inf@;1] ; [@Inf@;-@Inf@] / [@Inf@;0] ; [@Inf@;-@Inf@] / [5;@NaN@] ; [@Inf@;-@Inf@] / [5;-@Inf@] ; [@Inf@;-@Inf@] / [5;@Inf@] ; [@Inf@;-@Inf@] / [5;5] ; [@Inf@;-@Inf@] / [5;1] ; [@Inf@;-@Inf@] / [5;0] ; [@Inf@;-@Inf@] / [1;@NaN@] ; [@Inf@;-@Inf@] / [1;-@Inf@] ; [@Inf@;-@Inf@] / [1;@Inf@] ; [@Inf@;-@Inf@] / [1;5] ; [@Inf@;-@Inf@] / [1;1] ; [@Inf@;-@Inf@] / [1;0] ; [@Inf@;-@Inf@] / [0;@NaN@] ; [@Inf@;-@Inf@] / [0;-@Inf@] ; [@Inf@;-@Inf@] / [0;@Inf@] ; [@Inf@;-@Inf@] / [0;5] ; [@Inf@;-@Inf@] / [0;1] ; [@Inf@;-@Inf@] / [0;0] ; [@Inf@;@Inf@] / @NaN@ ; [@Inf@;@Inf@] / -@Inf@ ; [@Inf@;@Inf@] / @Inf@ ; [@Inf@;@Inf@] / 5 ; [@Inf@;@Inf@] / 1 ; [@Inf@;@Inf@] / 0 ; [@Inf@;@Inf@] / [@NaN@] ; [@Inf@;@Inf@] / [-@Inf@] ; [@Inf@;@Inf@] / [@Inf@] ; [@Inf@;@Inf@] / [5] ; [@Inf@;@Inf@] / [1] ; [@Inf@;@Inf@] / [0] ; [@Inf@;@Inf@] / [@NaN@;@NaN@] ; [@Inf@;@Inf@] / [@NaN@;-@Inf@] ; [@Inf@;@Inf@] / [@NaN@;@Inf@] ; [@Inf@;@Inf@] / [@NaN@;5] ; [@Inf@;@Inf@] / [@NaN@;1] ; [@Inf@;@Inf@] / [@NaN@;0] ; [@Inf@;@Inf@] / [-@Inf@;@NaN@] ; [@Inf@;@Inf@] / [-@Inf@;-@Inf@] ; [@Inf@;@Inf@] / [-@Inf@;@Inf@] ; [@Inf@;@Inf@] / [-@Inf@;5] ; [@Inf@;@Inf@] / [-@Inf@;1] ; [@Inf@;@Inf@] / [-@Inf@;0] ; [@Inf@;@Inf@] / [@Inf@;@NaN@] ; [@Inf@;@Inf@] / [@Inf@;-@Inf@] ; [@Inf@;@Inf@] / [@Inf@;@Inf@] ; [@Inf@;@Inf@] / [@Inf@;5] ; [@Inf@;@Inf@] / [@Inf@;1] ; [@Inf@;@Inf@] / [@Inf@;0] ; [@Inf@;@Inf@] / [5;@NaN@] ; [@Inf@;@Inf@] / [5;-@Inf@] ; [@Inf@;@Inf@] / [5;@Inf@] ; [@Inf@;@Inf@] / [5;5] ; [@Inf@;@Inf@] / [5;1] ; [@Inf@;@Inf@] / [5;0] ; [@Inf@;@Inf@] / [1;@NaN@] ; [@Inf@;@Inf@] / [1;-@Inf@] ; [@Inf@;@Inf@] / [1;@Inf@] ; [@Inf@;@Inf@] / [1;5] ; [@Inf@;@Inf@] / [1;1] ; [@Inf@;@Inf@] / [1;0] ; [@Inf@;@Inf@] / [0;@NaN@] ; [@Inf@;@Inf@] / [0;-@Inf@] ; [@Inf@;@Inf@] / [0;@Inf@] ; [@Inf@;@Inf@] / [0;5] ; [@Inf@;@Inf@] / [0;1] ; [@Inf@;@Inf@] / [0;0] ; [@Inf@;5] / @NaN@ ; [@Inf@;5] / -@Inf@ ; [@Inf@;5] / @Inf@ ; [@Inf@;5] / 5 ; [@Inf@;5] / 1 ; [@Inf@;5] / 0 ; [@Inf@;5] / [@NaN@] ; [@Inf@;5] / [-@Inf@] ; [@Inf@;5] / [@Inf@] ; [@Inf@;5] / [5] ; [@Inf@;5] / [1] ; [@Inf@;5] / [0] ; [@Inf@;5] / [@NaN@;@NaN@] ; [@Inf@;5] / [@NaN@;-@Inf@] ; [@Inf@;5] / [@NaN@;@Inf@] ; [@Inf@;5] / [@NaN@;5] ; [@Inf@;5] / [@NaN@;1] ; [@Inf@;5] / [@NaN@;0] ; [@Inf@;5] / [-@Inf@;@NaN@] ; [@Inf@;5] / [-@Inf@;-@Inf@] ; [@Inf@;5] / [-@Inf@;@Inf@] ; [@Inf@;5] / [-@Inf@;5] ; [@Inf@;5] / [-@Inf@;1] ; [@Inf@;5] / [-@Inf@;0] ; [@Inf@;5] / [@Inf@;@NaN@] ; [@Inf@;5] / [@Inf@;-@Inf@] ; [@Inf@;5] / [@Inf@;@Inf@] ; [@Inf@;5] / [@Inf@;5] ; [@Inf@;5] / [@Inf@;1] ; [@Inf@;5] / [@Inf@;0] ; [@Inf@;5] / [5;@NaN@] ; [@Inf@;5] / [5;-@Inf@] ; [@Inf@;5] / [5;@Inf@] ; [@Inf@;5] / [5;5] ; [@Inf@;5] / [5;1] ; [@Inf@;5] / [5;0] ; [@Inf@;5] / [1;@NaN@] ; [@Inf@;5] / [1;-@Inf@] ; [@Inf@;5] / [1;@Inf@] ; [@Inf@;5] / [1;5] ; [@Inf@;5] / [1;1] ; [@Inf@;5] / [1;0] ; [@Inf@;5] / [0;@NaN@] ; [@Inf@;5] / [0;-@Inf@] ; [@Inf@;5] / [0;@Inf@] ; [@Inf@;5] / [0;5] ; [@Inf@;5] / [0;1] ; [@Inf@;5] / [0;0] ; [@Inf@;1] / @NaN@ ; [@Inf@;1] / -@Inf@ ; [@Inf@;1] / @Inf@ ; [@Inf@;1] / 5 ; [@Inf@;1] / 1 ; [@Inf@;1] / 0 ; [@Inf@;1] / [@NaN@] ; [@Inf@;1] / [-@Inf@] ; [@Inf@;1] / [@Inf@] ; [@Inf@;1] / [5] ; [@Inf@;1] / [1] ; [@Inf@;1] / [0] ; [@Inf@;1] / [@NaN@;@NaN@] ; [@Inf@;1] / [@NaN@;-@Inf@] ; [@Inf@;1] / [@NaN@;@Inf@] ; [@Inf@;1] / [@NaN@;5] ; [@Inf@;1] / [@NaN@;1] ; [@Inf@;1] / [@NaN@;0] ; [@Inf@;1] / [-@Inf@;@NaN@] ; [@Inf@;1] / [-@Inf@;-@Inf@] ; [@Inf@;1] / [-@Inf@;@Inf@] ; [@Inf@;1] / [-@Inf@;5] ; [@Inf@;1] / [-@Inf@;1] ; [@Inf@;1] / [-@Inf@;0] ; [@Inf@;1] / [@Inf@;@NaN@] ; [@Inf@;1] / [@Inf@;-@Inf@] ; [@Inf@;1] / [@Inf@;@Inf@] ; [@Inf@;1] / [@Inf@;5] ; [@Inf@;1] / [@Inf@;1] ; [@Inf@;1] / [@Inf@;0] ; [@Inf@;1] / [5;@NaN@] ; [@Inf@;1] / [5;-@Inf@] ; [@Inf@;1] / [5;@Inf@] ; [@Inf@;1] / [5;5] ; [@Inf@;1] / [5;1] ; [@Inf@;1] / [5;0] ; [@Inf@;1] / [1;@NaN@] ; [@Inf@;1] / [1;-@Inf@] ; [@Inf@;1] / [1;@Inf@] ; [@Inf@;1] / [1;5] ; [@Inf@;1] / [1;1] ; [@Inf@;1] / [1;0] ; [@Inf@;1] / [0;@NaN@] ; [@Inf@;1] / [0;-@Inf@] ; [@Inf@;1] / [0;@Inf@] ; [@Inf@;1] / [0;5] ; [@Inf@;1] / [0;1] ; [@Inf@;1] / [0;0] ; [@Inf@;0] / @NaN@ ; [@Inf@;0] / -@Inf@ ; [@Inf@;0] / @Inf@ ; [@Inf@;0] / 5 ; [@Inf@;0] / 1 ; [@Inf@;0] / 0 ; [@Inf@;0] / [@NaN@] ; [@Inf@;0] / [-@Inf@] ; [@Inf@;0] / [@Inf@] ; [@Inf@;0] / [5] ; [@Inf@;0] / [1] ; [@Inf@;0] / [0] ; [@Inf@;0] / [@NaN@;@NaN@] ; [@Inf@;0] / [@NaN@;-@Inf@] ; [@Inf@;0] / [@NaN@;@Inf@] ; [@Inf@;0] / [@NaN@;5] ; [@Inf@;0] / [@NaN@;1] ; [@Inf@;0] / [@NaN@;0] ; [@Inf@;0] / [-@Inf@;@NaN@] ; [@Inf@;0] / [-@Inf@;-@Inf@] ; [@Inf@;0] / [-@Inf@;@Inf@] ; [@Inf@;0] / [-@Inf@;5] ; [@Inf@;0] / [-@Inf@;1] ; [@Inf@;0] / [-@Inf@;0] ; [@Inf@;0] / [@Inf@;@NaN@] ; [@Inf@;0] / [@Inf@;-@Inf@] ; [@Inf@;0] / [@Inf@;@Inf@] ; [@Inf@;0] / [@Inf@;5] ; [@Inf@;0] / [@Inf@;1] ; [@Inf@;0] / [@Inf@;0] ; [@Inf@;0] / [5;@NaN@] ; [@Inf@;0] / [5;-@Inf@] ; [@Inf@;0] / [5;@Inf@] ; [@Inf@;0] / [5;5] ; [@Inf@;0] / [5;1] ; [@Inf@;0] / [5;0] ; [@Inf@;0] / [1;@NaN@] ; [@Inf@;0] / [1;-@Inf@] ; [@Inf@;0] / [1;@Inf@] ; [@Inf@;0] / [1;5] ; [@Inf@;0] / [1;1] ; [@Inf@;0] / [1;0] ; [@Inf@;0] / [0;@NaN@] ; [@Inf@;0] / [0;-@Inf@] ; [@Inf@;0] / [0;@Inf@] ; [@Inf@;0] / [0;5] ; [@Inf@;0] / [0;1] ; [@Inf@;0] / [0;0] ; [5;@NaN@] / @NaN@ ; [5;@NaN@] / -@Inf@ ; [5;@NaN@] / @Inf@ ; [5;@NaN@] / 5 ; [5;@NaN@] / 1 ; [5;@NaN@] / 0 ; [5;@NaN@] / [@NaN@] ; [5;@NaN@] / [-@Inf@] ; [5;@NaN@] / [@Inf@] ; [5;@NaN@] / [5] ; [5;@NaN@] / [1] ; [5;@NaN@] / [0] ; [5;@NaN@] / [@NaN@;@NaN@] ; [5;@NaN@] / [@NaN@;-@Inf@] ; [5;@NaN@] / [@NaN@;@Inf@] ; [5;@NaN@] / [@NaN@;5] ; [5;@NaN@] / [@NaN@;1] ; [5;@NaN@] / [@NaN@;0] ; [5;@NaN@] / [-@Inf@;@NaN@] ; [5;@NaN@] / [-@Inf@;-@Inf@] ; [5;@NaN@] / [-@Inf@;@Inf@] ; [5;@NaN@] / [-@Inf@;5] ; [5;@NaN@] / [-@Inf@;1] ; [5;@NaN@] / [-@Inf@;0] ; [5;@NaN@] / [@Inf@;@NaN@] ; [5;@NaN@] / [@Inf@;-@Inf@] ; [5;@NaN@] / [@Inf@;@Inf@] ; [5;@NaN@] / [@Inf@;5] ; [5;@NaN@] / [@Inf@;1] ; [5;@NaN@] / [@Inf@;0] ; [5;@NaN@] / [5;@NaN@] ; [5;@NaN@] / [5;-@Inf@] ; [5;@NaN@] / [5;@Inf@] ; [5;@NaN@] / [5;5] ; [5;@NaN@] / [5;1] ; [5;@NaN@] / [5;0] ; [5;@NaN@] / [1;@NaN@] ; [5;@NaN@] / [1;-@Inf@] ; [5;@NaN@] / [1;@Inf@] ; [5;@NaN@] / [1;5] ; [5;@NaN@] / [1;1] ; [5;@NaN@] / [1;0] ; [5;@NaN@] / [0;@NaN@] ; [5;@NaN@] / [0;-@Inf@] ; [5;@NaN@] / [0;@Inf@] ; [5;@NaN@] / [0;5] ; [5;@NaN@] / [0;1] ; [5;@NaN@] / [0;0] ; [5;-@Inf@] / @NaN@ ; [5;-@Inf@] / -@Inf@ ; [5;-@Inf@] / @Inf@ ; [5;-@Inf@] / 5 ; [5;-@Inf@] / 1 ; [5;-@Inf@] / 0 ; [5;-@Inf@] / [@NaN@] ; [5;-@Inf@] / [-@Inf@] ; [5;-@Inf@] / [@Inf@] ; [5;-@Inf@] / [5] ; [5;-@Inf@] / [1] ; [5;-@Inf@] / [0] ; [5;-@Inf@] / [@NaN@;@NaN@] ; [5;-@Inf@] / [@NaN@;-@Inf@] ; [5;-@Inf@] / [@NaN@;@Inf@] ; [5;-@Inf@] / [@NaN@;5] ; [5;-@Inf@] / [@NaN@;1] ; [5;-@Inf@] / [@NaN@;0] ; [5;-@Inf@] / [-@Inf@;@NaN@] ; [5;-@Inf@] / [-@Inf@;-@Inf@] ; [5;-@Inf@] / [-@Inf@;@Inf@] ; [5;-@Inf@] / [-@Inf@;5] ; [5;-@Inf@] / [-@Inf@;1] ; [5;-@Inf@] / [-@Inf@;0] ; [5;-@Inf@] / [@Inf@;@NaN@] ; [5;-@Inf@] / [@Inf@;-@Inf@] ; [5;-@Inf@] / [@Inf@;@Inf@] ; [5;-@Inf@] / [@Inf@;5] ; [5;-@Inf@] / [@Inf@;1] ; [5;-@Inf@] / [@Inf@;0] ; [5;-@Inf@] / [5;@NaN@] ; [5;-@Inf@] / [5;-@Inf@] ; [5;-@Inf@] / [5;@Inf@] ; [5;-@Inf@] / [5;5] ; [5;-@Inf@] / [5;1] ; [5;-@Inf@] / [5;0] ; [5;-@Inf@] / [1;@NaN@] ; [5;-@Inf@] / [1;-@Inf@] ; [5;-@Inf@] / [1;@Inf@] ; [5;-@Inf@] / [1;5] ; [5;-@Inf@] / [1;1] ; [5;-@Inf@] / [1;0] ; [5;-@Inf@] / [0;@NaN@] ; [5;-@Inf@] / [0;-@Inf@] ; [5;-@Inf@] / [0;@Inf@] ; [5;-@Inf@] / [0;5] ; [5;-@Inf@] / [0;1] ; [5;-@Inf@] / [0;0] ; [5;@Inf@] / @NaN@ ; [5;@Inf@] / -@Inf@ ; [5;@Inf@] / @Inf@ ; [5;@Inf@] / 5 ; [5;@Inf@] / 1 ; [5;@Inf@] / 0 ; [5;@Inf@] / [@NaN@] ; [5;@Inf@] / [-@Inf@] ; [5;@Inf@] / [@Inf@] ; [5;@Inf@] / [5] ; [5;@Inf@] / [1] ; [5;@Inf@] / [0] ; [5;@Inf@] / [@NaN@;@NaN@] ; [5;@Inf@] / [@NaN@;-@Inf@] ; [5;@Inf@] / [@NaN@;@Inf@] ; [5;@Inf@] / [@NaN@;5] ; [5;@Inf@] / [@NaN@;1] ; [5;@Inf@] / [@NaN@;0] ; [5;@Inf@] / [-@Inf@;@NaN@] ; [5;@Inf@] / [-@Inf@;-@Inf@] ; [5;@Inf@] / [-@Inf@;@Inf@] ; [5;@Inf@] / [-@Inf@;5] ; [5;@Inf@] / [-@Inf@;1] ; [5;@Inf@] / [-@Inf@;0] ; [5;@Inf@] / [@Inf@;@NaN@] ; [5;@Inf@] / [@Inf@;-@Inf@] ; [5;@Inf@] / [@Inf@;@Inf@] ; [5;@Inf@] / [@Inf@;5] ; [5;@Inf@] / [@Inf@;1] ; [5;@Inf@] / [@Inf@;0] ; [5;@Inf@] / [5;@NaN@] ; [5;@Inf@] / [5;-@Inf@] ; [5;@Inf@] / [5;@Inf@] ; [5;@Inf@] / [5;5] ; [5;@Inf@] / [5;1] ; [5;@Inf@] / [5;0] ; [5;@Inf@] / [1;@NaN@] ; [5;@Inf@] / [1;-@Inf@] ; [5;@Inf@] / [1;@Inf@] ; [5;@Inf@] / [1;5] ; [5;@Inf@] / [1;1] ; [5;@Inf@] / [1;0] ; [5;@Inf@] / [0;@NaN@] ; [5;@Inf@] / [0;-@Inf@] ; [5;@Inf@] / [0;@Inf@] ; [5;@Inf@] / [0;5] ; [5;@Inf@] / [0;1] ; [5;@Inf@] / [0;0] ; [5;5] / @NaN@ ; [5;5] / -@Inf@ ; [5;5] / @Inf@ ; [5;5] / 5 ; [5;5] / 1 ; [5;5] / 0 ; [5;5] / [@NaN@] ; [5;5] / [-@Inf@] ; [5;5] / [@Inf@] ; [5;5] / [5] ; [5;5] / [1] ; [5;5] / [0] ; [5;5] / [@NaN@;@NaN@] ; [5;5] / [@NaN@;-@Inf@] ; [5;5] / [@NaN@;@Inf@] ; [5;5] / [@NaN@;5] ; [5;5] / [@NaN@;1] ; [5;5] / [@NaN@;0] ; [5;5] / [-@Inf@;@NaN@] ; [5;5] / [-@Inf@;-@Inf@] ; [5;5] / [-@Inf@;@Inf@] ; [5;5] / [-@Inf@;5] ; [5;5] / [-@Inf@;1] ; [5;5] / [-@Inf@;0] ; [5;5] / [@Inf@;@NaN@] ; [5;5] / [@Inf@;-@Inf@] ; [5;5] / [@Inf@;@Inf@] ; [5;5] / [@Inf@;5] ; [5;5] / [@Inf@;1] ; [5;5] / [@Inf@;0] ; [5;5] / [5;@NaN@] ; [5;5] / [5;-@Inf@] ; [5;5] / [5;@Inf@] ; [5;5] / [5;5] ; [5;5] / [5;1] ; [5;5] / [5;0] ; [5;5] / [1;@NaN@] ; [5;5] / [1;-@Inf@] ; [5;5] / [1;@Inf@] ; [5;5] / [1;5] ; [5;5] / [1;1] ; [5;5] / [1;0] ; [5;5] / [0;@NaN@] ; [5;5] / [0;-@Inf@] ; [5;5] / [0;@Inf@] ; [5;5] / [0;5] ; [5;5] / [0;1] ; [5;5] / [0;0] ; [5;1] / @NaN@ ; [5;1] / -@Inf@ ; [5;1] / @Inf@ ; [5;1] / 5 ; [5;1] / 1 ; [5;1] / 0 ; [5;1] / [@NaN@] ; [5;1] / [-@Inf@] ; [5;1] / [@Inf@] ; [5;1] / [5] ; [5;1] / [1] ; [5;1] / [0] ; [5;1] / [@NaN@;@NaN@] ; [5;1] / [@NaN@;-@Inf@] ; [5;1] / [@NaN@;@Inf@] ; [5;1] / [@NaN@;5] ; [5;1] / [@NaN@;1] ; [5;1] / [@NaN@;0] ; [5;1] / [-@Inf@;@NaN@] ; [5;1] / [-@Inf@;-@Inf@] ; [5;1] / [-@Inf@;@Inf@] ; [5;1] / [-@Inf@;5] ; [5;1] / [-@Inf@;1] ; [5;1] / [-@Inf@;0] ; [5;1] / [@Inf@;@NaN@] ; [5;1] / [@Inf@;-@Inf@] ; [5;1] / [@Inf@;@Inf@] ; [5;1] / [@Inf@;5] ; [5;1] / [@Inf@;1] ; [5;1] / [@Inf@;0] ; [5;1] / [5;@NaN@] ; [5;1] / [5;-@Inf@] ; [5;1] / [5;@Inf@] ; [5;1] / [5;5] ; [5;1] / [5;1] ; [5;1] / [5;0] ; [5;1] / [1;@NaN@] ; [5;1] / [1;-@Inf@] ; [5;1] / [1;@Inf@] ; [5;1] / [1;5] ; [5;1] / [1;1] ; [5;1] / [1;0] ; [5;1] / [0;@NaN@] ; [5;1] / [0;-@Inf@] ; [5;1] / [0;@Inf@] ; [5;1] / [0;5] ; [5;1] / [0;1] ; [5;1] / [0;0] ; [5;0] / @NaN@ ; [5;0] / -@Inf@ ; [5;0] / @Inf@ ; [5;0] / 5 ; [5;0] / 1 ; [5;0] / 0 ; [5;0] / [@NaN@] ; [5;0] / [-@Inf@] ; [5;0] / [@Inf@] ; [5;0] / [5] ; [5;0] / [1] ; [5;0] / [0] ; [5;0] / [@NaN@;@NaN@] ; [5;0] / [@NaN@;-@Inf@] ; [5;0] / [@NaN@;@Inf@] ; [5;0] / [@NaN@;5] ; [5;0] / [@NaN@;1] ; [5;0] / [@NaN@;0] ; [5;0] / [-@Inf@;@NaN@] ; [5;0] / [-@Inf@;-@Inf@] ; [5;0] / [-@Inf@;@Inf@] ; [5;0] / [-@Inf@;5] ; [5;0] / [-@Inf@;1] ; [5;0] / [-@Inf@;0] ; [5;0] / [@Inf@;@NaN@] ; [5;0] / [@Inf@;-@Inf@] ; [5;0] / [@Inf@;@Inf@] ; [5;0] / [@Inf@;5] ; [5;0] / [@Inf@;1] ; [5;0] / [@Inf@;0] ; [5;0] / [5;@NaN@] ; [5;0] / [5;-@Inf@] ; [5;0] / [5;@Inf@] ; [5;0] / [5;5] ; [5;0] / [5;1] ; [5;0] / [5;0] ; [5;0] / [1;@NaN@] ; [5;0] / [1;-@Inf@] ; [5;0] / [1;@Inf@] ; [5;0] / [1;5] ; [5;0] / [1;1] ; [5;0] / [1;0] ; [5;0] / [0;@NaN@] ; [5;0] / [0;-@Inf@] ; [5;0] / [0;@Inf@] ; [5;0] / [0;5] ; [5;0] / [0;1] ; [5;0] / [0;0] ; [1;@NaN@] / @NaN@ ; [1;@NaN@] / -@Inf@ ; [1;@NaN@] / @Inf@ ; [1;@NaN@] / 5 ; [1;@NaN@] / 1 ; [1;@NaN@] / 0 ; [1;@NaN@] / [@NaN@] ; [1;@NaN@] / [-@Inf@] ; [1;@NaN@] / [@Inf@] ; [1;@NaN@] / [5] ; [1;@NaN@] / [1] ; [1;@NaN@] / [0] ; [1;@NaN@] / [@NaN@;@NaN@] ; [1;@NaN@] / [@NaN@;-@Inf@] ; [1;@NaN@] / [@NaN@;@Inf@] ; [1;@NaN@] / [@NaN@;5] ; [1;@NaN@] / [@NaN@;1] ; [1;@NaN@] / [@NaN@;0] ; [1;@NaN@] / [-@Inf@;@NaN@] ; [1;@NaN@] / [-@Inf@;-@Inf@] ; [1;@NaN@] / [-@Inf@;@Inf@] ; [1;@NaN@] / [-@Inf@;5] ; [1;@NaN@] / [-@Inf@;1] ; [1;@NaN@] / [-@Inf@;0] ; [1;@NaN@] / [@Inf@;@NaN@] ; [1;@NaN@] / [@Inf@;-@Inf@] ; [1;@NaN@] / [@Inf@;@Inf@] ; [1;@NaN@] / [@Inf@;5] ; [1;@NaN@] / [@Inf@;1] ; [1;@NaN@] / [@Inf@;0] ; [1;@NaN@] / [5;@NaN@] ; [1;@NaN@] / [5;-@Inf@] ; [1;@NaN@] / [5;@Inf@] ; [1;@NaN@] / [5;5] ; [1;@NaN@] / [5;1] ; [1;@NaN@] / [5;0] ; [1;@NaN@] / [1;@NaN@] ; [1;@NaN@] / [1;-@Inf@] ; [1;@NaN@] / [1;@Inf@] ; [1;@NaN@] / [1;5] ; [1;@NaN@] / [1;1] ; [1;@NaN@] / [1;0] ; [1;@NaN@] / [0;@NaN@] ; [1;@NaN@] / [0;-@Inf@] ; [1;@NaN@] / [0;@Inf@] ; [1;@NaN@] / [0;5] ; [1;@NaN@] / [0;1] ; [1;@NaN@] / [0;0] ; [1;-@Inf@] / @NaN@ ; [1;-@Inf@] / -@Inf@ ; [1;-@Inf@] / @Inf@ ; [1;-@Inf@] / 5 ; [1;-@Inf@] / 1 ; [1;-@Inf@] / 0 ; [1;-@Inf@] / [@NaN@] ; [1;-@Inf@] / [-@Inf@] ; [1;-@Inf@] / [@Inf@] ; [1;-@Inf@] / [5] ; [1;-@Inf@] / [1] ; [1;-@Inf@] / [0] ; [1;-@Inf@] / [@NaN@;@NaN@] ; [1;-@Inf@] / [@NaN@;-@Inf@] ; [1;-@Inf@] / [@NaN@;@Inf@] ; [1;-@Inf@] / [@NaN@;5] ; [1;-@Inf@] / [@NaN@;1] ; [1;-@Inf@] / [@NaN@;0] ; [1;-@Inf@] / [-@Inf@;@NaN@] ; [1;-@Inf@] / [-@Inf@;-@Inf@] ; [1;-@Inf@] / [-@Inf@;@Inf@] ; [1;-@Inf@] / [-@Inf@;5] ; [1;-@Inf@] / [-@Inf@;1] ; [1;-@Inf@] / [-@Inf@;0] ; [1;-@Inf@] / [@Inf@;@NaN@] ; [1;-@Inf@] / [@Inf@;-@Inf@] ; [1;-@Inf@] / [@Inf@;@Inf@] ; [1;-@Inf@] / [@Inf@;5] ; [1;-@Inf@] / [@Inf@;1] ; [1;-@Inf@] / [@Inf@;0] ; [1;-@Inf@] / [5;@NaN@] ; [1;-@Inf@] / [5;-@Inf@] ; [1;-@Inf@] / [5;@Inf@] ; [1;-@Inf@] / [5;5] ; [1;-@Inf@] / [5;1] ; [1;-@Inf@] / [5;0] ; [1;-@Inf@] / [1;@NaN@] ; [1;-@Inf@] / [1;-@Inf@] ; [1;-@Inf@] / [1;@Inf@] ; [1;-@Inf@] / [1;5] ; [1;-@Inf@] / [1;1] ; [1;-@Inf@] / [1;0] ; [1;-@Inf@] / [0;@NaN@] ; [1;-@Inf@] / [0;-@Inf@] ; [1;-@Inf@] / [0;@Inf@] ; [1;-@Inf@] / [0;5] ; [1;-@Inf@] / [0;1] ; [1;-@Inf@] / [0;0] ; [1;@Inf@] / @NaN@ ; [1;@Inf@] / -@Inf@ ; [1;@Inf@] / @Inf@ ; [1;@Inf@] / 5 ; [1;@Inf@] / 1 ; [1;@Inf@] / 0 ; [1;@Inf@] / [@NaN@] ; [1;@Inf@] / [-@Inf@] ; [1;@Inf@] / [@Inf@] ; [1;@Inf@] / [5] ; [1;@Inf@] / [1] ; [1;@Inf@] / [0] ; [1;@Inf@] / [@NaN@;@NaN@] ; [1;@Inf@] / [@NaN@;-@Inf@] ; [1;@Inf@] / [@NaN@;@Inf@] ; [1;@Inf@] / [@NaN@;5] ; [1;@Inf@] / [@NaN@;1] ; [1;@Inf@] / [@NaN@;0] ; [1;@Inf@] / [-@Inf@;@NaN@] ; [1;@Inf@] / [-@Inf@;-@Inf@] ; [1;@Inf@] / [-@Inf@;@Inf@] ; [1;@Inf@] / [-@Inf@;5] ; [1;@Inf@] / [-@Inf@;1] ; [1;@Inf@] / [-@Inf@;0] ; [1;@Inf@] / [@Inf@;@NaN@] ; [1;@Inf@] / [@Inf@;-@Inf@] ; [1;@Inf@] / [@Inf@;@Inf@] ; [1;@Inf@] / [@Inf@;5] ; [1;@Inf@] / [@Inf@;1] ; [1;@Inf@] / [@Inf@;0] ; [1;@Inf@] / [5;@NaN@] ; [1;@Inf@] / [5;-@Inf@] ; [1;@Inf@] / [5;@Inf@] ; [1;@Inf@] / [5;5] ; [1;@Inf@] / [5;1] ; [1;@Inf@] / [5;0] ; [1;@Inf@] / [1;@NaN@] ; [1;@Inf@] / [1;-@Inf@] ; [1;@Inf@] / [1;@Inf@] ; [1;@Inf@] / [1;5] ; [1;@Inf@] / [1;1] ; [1;@Inf@] / [1;0] ; [1;@Inf@] / [0;@NaN@] ; [1;@Inf@] / [0;-@Inf@] ; [1;@Inf@] / [0;@Inf@] ; [1;@Inf@] / [0;5] ; [1;@Inf@] / [0;1] ; [1;@Inf@] / [0;0] ; [1;5] / @NaN@ ; [1;5] / -@Inf@ ; [1;5] / @Inf@ ; [1;5] / 5 ; [1;5] / 1 ; [1;5] / 0 ; [1;5] / [@NaN@] ; [1;5] / [-@Inf@] ; [1;5] / [@Inf@] ; [1;5] / [5] ; [1;5] / [1] ; [1;5] / [0] ; [1;5] / [@NaN@;@NaN@] ; [1;5] / [@NaN@;-@Inf@] ; [1;5] / [@NaN@;@Inf@] ; [1;5] / [@NaN@;5] ; [1;5] / [@NaN@;1] ; [1;5] / [@NaN@;0] ; [1;5] / [-@Inf@;@NaN@] ; [1;5] / [-@Inf@;-@Inf@] ; [1;5] / [-@Inf@;@Inf@] ; [1;5] / [-@Inf@;5] ; [1;5] / [-@Inf@;1] ; [1;5] / [-@Inf@;0] ; [1;5] / [@Inf@;@NaN@] ; [1;5] / [@Inf@;-@Inf@] ; [1;5] / [@Inf@;@Inf@] ; [1;5] / [@Inf@;5] ; [1;5] / [@Inf@;1] ; [1;5] / [@Inf@;0] ; [1;5] / [5;@NaN@] ; [1;5] / [5;-@Inf@] ; [1;5] / [5;@Inf@] ; [1;5] / [5;5] ; [1;5] / [5;1] ; [1;5] / [5;0] ; [1;5] / [1;@NaN@] ; [1;5] / [1;-@Inf@] ; [1;5] / [1;@Inf@] ; [1;5] / [1;5] ; [1;5] / [1;1] ; [1;5] / [1;0] ; [1;5] / [0;@NaN@] ; [1;5] / [0;-@Inf@] ; [1;5] / [0;@Inf@] ; [1;5] / [0;5] ; [1;5] / [0;1] ; [1;5] / [0;0] ; [1;1] / @NaN@ ; [1;1] / -@Inf@ ; [1;1] / @Inf@ ; [1;1] / 5 ; [1;1] / 1 ; [1;1] / 0 ; [1;1] / [@NaN@] ; [1;1] / [-@Inf@] ; [1;1] / [@Inf@] ; [1;1] / [5] ; [1;1] / [1] ; [1;1] / [0] ; [1;1] / [@NaN@;@NaN@] ; [1;1] / [@NaN@;-@Inf@] ; [1;1] / [@NaN@;@Inf@] ; [1;1] / [@NaN@;5] ; [1;1] / [@NaN@;1] ; [1;1] / [@NaN@;0] ; [1;1] / [-@Inf@;@NaN@] ; [1;1] / [-@Inf@;-@Inf@] ; [1;1] / [-@Inf@;@Inf@] ; [1;1] / [-@Inf@;5] ; [1;1] / [-@Inf@;1] ; [1;1] / [-@Inf@;0] ; [1;1] / [@Inf@;@NaN@] ; [1;1] / [@Inf@;-@Inf@] ; [1;1] / [@Inf@;@Inf@] ; [1;1] / [@Inf@;5] ; [1;1] / [@Inf@;1] ; [1;1] / [@Inf@;0] ; [1;1] / [5;@NaN@] ; [1;1] / [5;-@Inf@] ; [1;1] / [5;@Inf@] ; [1;1] / [5;5] ; [1;1] / [5;1] ; [1;1] / [5;0] ; [1;1] / [1;@NaN@] ; [1;1] / [1;-@Inf@] ; [1;1] / [1;@Inf@] ; [1;1] / [1;5] ; [1;1] / [1;1] ; [1;1] / [1;0] ; [1;1] / [0;@NaN@] ; [1;1] / [0;-@Inf@] ; [1;1] / [0;@Inf@] ; [1;1] / [0;5] ; [1;1] / [0;1] ; [1;1] / [0;0] ; [1;0] / @NaN@ ; [1;0] / -@Inf@ ; [1;0] / @Inf@ ; [1;0] / 5 ; [1;0] / 1 ; [1;0] / 0 ; [1;0] / [@NaN@] ; [1;0] / [-@Inf@] ; [1;0] / [@Inf@] ; [1;0] / [5] ; [1;0] / [1] ; [1;0] / [0] ; [1;0] / [@NaN@;@NaN@] ; [1;0] / [@NaN@;-@Inf@] ; [1;0] / [@NaN@;@Inf@] ; [1;0] / [@NaN@;5] ; [1;0] / [@NaN@;1] ; [1;0] / [@NaN@;0] ; [1;0] / [-@Inf@;@NaN@] ; [1;0] / [-@Inf@;-@Inf@] ; [1;0] / [-@Inf@;@Inf@] ; [1;0] / [-@Inf@;5] ; [1;0] / [-@Inf@;1] ; [1;0] / [-@Inf@;0] ; [1;0] / [@Inf@;@NaN@] ; [1;0] / [@Inf@;-@Inf@] ; [1;0] / [@Inf@;@Inf@] ; [1;0] / [@Inf@;5] ; [1;0] / [@Inf@;1] ; [1;0] / [@Inf@;0] ; [1;0] / [5;@NaN@] ; [1;0] / [5;-@Inf@] ; [1;0] / [5;@Inf@] ; [1;0] / [5;5] ; [1;0] / [5;1] ; [1;0] / [5;0] ; [1;0] / [1;@NaN@] ; [1;0] / [1;-@Inf@] ; [1;0] / [1;@Inf@] ; [1;0] / [1;5] ; [1;0] / [1;1] ; [1;0] / [1;0] ; [1;0] / [0;@NaN@] ; [1;0] / [0;-@Inf@] ; [1;0] / [0;@Inf@] ; [1;0] / [0;5] ; [1;0] / [0;1] ; [1;0] / [0;0] ; [0;@NaN@] / @NaN@ ; [0;@NaN@] / -@Inf@ ; [0;@NaN@] / @Inf@ ; [0;@NaN@] / 5 ; [0;@NaN@] / 1 ; [0;@NaN@] / 0 ; [0;@NaN@] / [@NaN@] ; [0;@NaN@] / [-@Inf@] ; [0;@NaN@] / [@Inf@] ; [0;@NaN@] / [5] ; [0;@NaN@] / [1] ; [0;@NaN@] / [0] ; [0;@NaN@] / [@NaN@;@NaN@] ; [0;@NaN@] / [@NaN@;-@Inf@] ; [0;@NaN@] / [@NaN@;@Inf@] ; [0;@NaN@] / [@NaN@;5] ; [0;@NaN@] / [@NaN@;1] ; [0;@NaN@] / [@NaN@;0] ; [0;@NaN@] / [-@Inf@;@NaN@] ; [0;@NaN@] / [-@Inf@;-@Inf@] ; [0;@NaN@] / [-@Inf@;@Inf@] ; [0;@NaN@] / [-@Inf@;5] ; [0;@NaN@] / [-@Inf@;1] ; [0;@NaN@] / [-@Inf@;0] ; [0;@NaN@] / [@Inf@;@NaN@] ; [0;@NaN@] / [@Inf@;-@Inf@] ; [0;@NaN@] / [@Inf@;@Inf@] ; [0;@NaN@] / [@Inf@;5] ; [0;@NaN@] / [@Inf@;1] ; [0;@NaN@] / [@Inf@;0] ; [0;@NaN@] / [5;@NaN@] ; [0;@NaN@] / [5;-@Inf@] ; [0;@NaN@] / [5;@Inf@] ; [0;@NaN@] / [5;5] ; [0;@NaN@] / [5;1] ; [0;@NaN@] / [5;0] ; [0;@NaN@] / [1;@NaN@] ; [0;@NaN@] / [1;-@Inf@] ; [0;@NaN@] / [1;@Inf@] ; [0;@NaN@] / [1;5] ; [0;@NaN@] / [1;1] ; [0;@NaN@] / [1;0] ; [0;@NaN@] / [0;@NaN@] ; [0;@NaN@] / [0;-@Inf@] ; [0;@NaN@] / [0;@Inf@] ; [0;@NaN@] / [0;5] ; [0;@NaN@] / [0;1] ; [0;@NaN@] / [0;0] ; [0;-@Inf@] / @NaN@ ; [0;-@Inf@] / -@Inf@ ; [0;-@Inf@] / @Inf@ ; [0;-@Inf@] / 5 ; [0;-@Inf@] / 1 ; [0;-@Inf@] / 0 ; [0;-@Inf@] / [@NaN@] ; [0;-@Inf@] / [-@Inf@] ; [0;-@Inf@] / [@Inf@] ; [0;-@Inf@] / [5] ; [0;-@Inf@] / [1] ; [0;-@Inf@] / [0] ; [0;-@Inf@] / [@NaN@;@NaN@] ; [0;-@Inf@] / [@NaN@;-@Inf@] ; [0;-@Inf@] / [@NaN@;@Inf@] ; [0;-@Inf@] / [@NaN@;5] ; [0;-@Inf@] / [@NaN@;1] ; [0;-@Inf@] / [@NaN@;0] ; [0;-@Inf@] / [-@Inf@;@NaN@] ; [0;-@Inf@] / [-@Inf@;-@Inf@] ; [0;-@Inf@] / [-@Inf@;@Inf@] ; [0;-@Inf@] / [-@Inf@;5] ; [0;-@Inf@] / [-@Inf@;1] ; [0;-@Inf@] / [-@Inf@;0] ; [0;-@Inf@] / [@Inf@;@NaN@] ; [0;-@Inf@] / [@Inf@;-@Inf@] ; [0;-@Inf@] / [@Inf@;@Inf@] ; [0;-@Inf@] / [@Inf@;5] ; [0;-@Inf@] / [@Inf@;1] ; [0;-@Inf@] / [@Inf@;0] ; [0;-@Inf@] / [5;@NaN@] ; [0;-@Inf@] / [5;-@Inf@] ; [0;-@Inf@] / [5;@Inf@] ; [0;-@Inf@] / [5;5] ; [0;-@Inf@] / [5;1] ; [0;-@Inf@] / [5;0] ; [0;-@Inf@] / [1;@NaN@] ; [0;-@Inf@] / [1;-@Inf@] ; [0;-@Inf@] / [1;@Inf@] ; [0;-@Inf@] / [1;5] ; [0;-@Inf@] / [1;1] ; [0;-@Inf@] / [1;0] ; [0;-@Inf@] / [0;@NaN@] ; [0;-@Inf@] / [0;-@Inf@] ; [0;-@Inf@] / [0;@Inf@] ; [0;-@Inf@] / [0;5] ; [0;-@Inf@] / [0;1] ; [0;-@Inf@] / [0;0] ; [0;@Inf@] / @NaN@ ; [0;@Inf@] / -@Inf@ ; [0;@Inf@] / @Inf@ ; [0;@Inf@] / 5 ; [0;@Inf@] / 1 ; [0;@Inf@] / 0 ; [0;@Inf@] / [@NaN@] ; [0;@Inf@] / [-@Inf@] ; [0;@Inf@] / [@Inf@] ; [0;@Inf@] / [5] ; [0;@Inf@] / [1] ; [0;@Inf@] / [0] ; [0;@Inf@] / [@NaN@;@NaN@] ; [0;@Inf@] / [@NaN@;-@Inf@] ; [0;@Inf@] / [@NaN@;@Inf@] ; [0;@Inf@] / [@NaN@;5] ; [0;@Inf@] / [@NaN@;1] ; [0;@Inf@] / [@NaN@;0] ; [0;@Inf@] / [-@Inf@;@NaN@] ; [0;@Inf@] / [-@Inf@;-@Inf@] ; [0;@Inf@] / [-@Inf@;@Inf@] ; [0;@Inf@] / [-@Inf@;5] ; [0;@Inf@] / [-@Inf@;1] ; [0;@Inf@] / [-@Inf@;0] ; [0;@Inf@] / [@Inf@;@NaN@] ; [0;@Inf@] / [@Inf@;-@Inf@] ; [0;@Inf@] / [@Inf@;@Inf@] ; [0;@Inf@] / [@Inf@;5] ; [0;@Inf@] / [@Inf@;1] ; [0;@Inf@] / [@Inf@;0] ; [0;@Inf@] / [5;@NaN@] ; [0;@Inf@] / [5;-@Inf@] ; [0;@Inf@] / [5;@Inf@] ; [0;@Inf@] / [5;5] ; [0;@Inf@] / [5;1] ; [0;@Inf@] / [5;0] ; [0;@Inf@] / [1;@NaN@] ; [0;@Inf@] / [1;-@Inf@] ; [0;@Inf@] / [1;@Inf@] ; [0;@Inf@] / [1;5] ; [0;@Inf@] / [1;1] ; [0;@Inf@] / [1;0] ; [0;@Inf@] / [0;@NaN@] ; [0;@Inf@] / [0;-@Inf@] ; [0;@Inf@] / [0;@Inf@] ; [0;@Inf@] / [0;5] ; [0;@Inf@] / [0;1] ; [0;@Inf@] / [0;0] ; [0;5] / @NaN@ ; [0;5] / -@Inf@ ; [0;5] / @Inf@ ; [0;5] / 5 ; [0;5] / 1 ; [0;5] / 0 ; [0;5] / [@NaN@] ; [0;5] / [-@Inf@] ; [0;5] / [@Inf@] ; [0;5] / [5] ; [0;5] / [1] ; [0;5] / [0] ; [0;5] / [@NaN@;@NaN@] ; [0;5] / [@NaN@;-@Inf@] ; [0;5] / [@NaN@;@Inf@] ; [0;5] / [@NaN@;5] ; [0;5] / [@NaN@;1] ; [0;5] / [@NaN@;0] ; [0;5] / [-@Inf@;@NaN@] ; [0;5] / [-@Inf@;-@Inf@] ; [0;5] / [-@Inf@;@Inf@] ; [0;5] / [-@Inf@;5] ; [0;5] / [-@Inf@;1] ; [0;5] / [-@Inf@;0] ; [0;5] / [@Inf@;@NaN@] ; [0;5] / [@Inf@;-@Inf@] ; [0;5] / [@Inf@;@Inf@] ; [0;5] / [@Inf@;5] ; [0;5] / [@Inf@;1] ; [0;5] / [@Inf@;0] ; [0;5] / [5;@NaN@] ; [0;5] / [5;-@Inf@] ; [0;5] / [5;@Inf@] ; [0;5] / [5;5] ; [0;5] / [5;1] ; [0;5] / [5;0] ; [0;5] / [1;@NaN@] ; [0;5] / [1;-@Inf@] ; [0;5] / [1;@Inf@] ; [0;5] / [1;5] ; [0;5] / [1;1] ; [0;5] / [1;0] ; [0;5] / [0;@NaN@] ; [0;5] / [0;-@Inf@] ; [0;5] / [0;@Inf@] ; [0;5] / [0;5] ; [0;5] / [0;1] ; [0;5] / [0;0] ; [0;1] / @NaN@ ; [0;1] / -@Inf@ ; [0;1] / @Inf@ ; [0;1] / 5 ; [0;1] / 1 ; [0;1] / 0 ; [0;1] / [@NaN@] ; [0;1] / [-@Inf@] ; [0;1] / [@Inf@] ; [0;1] / [5] ; [0;1] / [1] ; [0;1] / [0] ; [0;1] / [@NaN@;@NaN@] ; [0;1] / [@NaN@;-@Inf@] ; [0;1] / [@NaN@;@Inf@] ; [0;1] / [@NaN@;5] ; [0;1] / [@NaN@;1] ; [0;1] / [@NaN@;0] ; [0;1] / [-@Inf@;@NaN@] ; [0;1] / [-@Inf@;-@Inf@] ; [0;1] / [-@Inf@;@Inf@] ; [0;1] / [-@Inf@;5] ; [0;1] / [-@Inf@;1] ; [0;1] / [-@Inf@;0] ; [0;1] / [@Inf@;@NaN@] ; [0;1] / [@Inf@;-@Inf@] ; [0;1] / [@Inf@;@Inf@] ; [0;1] / [@Inf@;5] ; [0;1] / [@Inf@;1] ; [0;1] / [@Inf@;0] ; [0;1] / [5;@NaN@] ; [0;1] / [5;-@Inf@] ; [0;1] / [5;@Inf@] ; [0;1] / [5;5] ; [0;1] / [5;1] ; [0;1] / [5;0] ; [0;1] / [1;@NaN@] ; [0;1] / [1;-@Inf@] ; [0;1] / [1;@Inf@] ; [0;1] / [1;5] ; [0;1] / [1;1] ; [0;1] / [1;0] ; [0;1] / [0;@NaN@] ; [0;1] / [0;-@Inf@] ; [0;1] / [0;@Inf@] ; [0;1] / [0;5] ; [0;1] / [0;1] ; [0;1] / [0;0] ; [0;0] / @NaN@ ; [0;0] / -@Inf@ ; [0;0] / @Inf@ ; [0;0] / 5 ; [0;0] / 1 ; [0;0] / 0 ; [0;0] / [@NaN@] ; [0;0] / [-@Inf@] ; [0;0] / [@Inf@] ; [0;0] / [5] ; [0;0] / [1] ; [0;0] / [0] ; [0;0] / [@NaN@;@NaN@] ; [0;0] / [@NaN@;-@Inf@] ; [0;0] / [@NaN@;@Inf@] ; [0;0] / [@NaN@;5] ; [0;0] / [@NaN@;1] ; [0;0] / [@NaN@;0] ; [0;0] / [-@Inf@;@NaN@] ; [0;0] / [-@Inf@;-@Inf@] ; [0;0] / [-@Inf@;@Inf@] ; [0;0] / [-@Inf@;5] ; [0;0] / [-@Inf@;1] ; [0;0] / [-@Inf@;0] ; [0;0] / [@Inf@;@NaN@] ; [0;0] / [@Inf@;-@Inf@] ; [0;0] / [@Inf@;@Inf@] ; [0;0] / [@Inf@;5] ; [0;0] / [@Inf@;1] ; [0;0] / [@Inf@;0] ; [0;0] / [5;@NaN@] ; [0;0] / [5;-@Inf@] ; [0;0] / [5;@Inf@] ; [0;0] / [5;5] ; [0;0] / [5;1] ; [0;0] / [5;0] ; [0;0] / [1;@NaN@] ; [0;0] / [1;-@Inf@] ; [0;0] / [1;@Inf@] ; [0;0] / [1;5] ; [0;0] / [1;1] ; [0;0] / [1;0] ; [0;0] / [0;@NaN@] ; [0;0] / [0;-@Inf@] ; [0;0] / [0;@Inf@] ; [0;0] / [0;5] ; [0;0] / [0;1] ; [0;0] / [0;0] ; @NaN@ ^ @NaN@ ; @NaN@ ^ -@Inf@ ; @NaN@ ^ @Inf@ ; @NaN@ ^ 5 ; @NaN@ ^ 1 ; @NaN@ ^ 0 ; @NaN@ ^ [@NaN@] ; @NaN@ ^ [-@Inf@] ; @NaN@ ^ [@Inf@] ; @NaN@ ^ [5] ; @NaN@ ^ [1] ; @NaN@ ^ [0] ; @NaN@ ^ [@NaN@;@NaN@] ; @NaN@ ^ [@NaN@;-@Inf@] ; @NaN@ ^ [@NaN@;@Inf@] ; @NaN@ ^ [@NaN@;5] ; @NaN@ ^ [@NaN@;1] ; @NaN@ ^ [@NaN@;0] ; @NaN@ ^ [-@Inf@;@NaN@] ; @NaN@ ^ [-@Inf@;-@Inf@] ; @NaN@ ^ [-@Inf@;@Inf@] ; @NaN@ ^ [-@Inf@;5] ; @NaN@ ^ [-@Inf@;1] ; @NaN@ ^ [-@Inf@;0] ; @NaN@ ^ [@Inf@;@NaN@] ; @NaN@ ^ [@Inf@;-@Inf@] ; @NaN@ ^ [@Inf@;@Inf@] ; @NaN@ ^ [@Inf@;5] ; @NaN@ ^ [@Inf@;1] ; @NaN@ ^ [@Inf@;0] ; @NaN@ ^ [5;@NaN@] ; @NaN@ ^ [5;-@Inf@] ; @NaN@ ^ [5;@Inf@] ; @NaN@ ^ [5;5] ; @NaN@ ^ [5;1] ; @NaN@ ^ [5;0] ; @NaN@ ^ [1;@NaN@] ; @NaN@ ^ [1;-@Inf@] ; @NaN@ ^ [1;@Inf@] ; @NaN@ ^ [1;5] ; @NaN@ ^ [1;1] ; @NaN@ ^ [1;0] ; @NaN@ ^ [0;@NaN@] ; @NaN@ ^ [0;-@Inf@] ; @NaN@ ^ [0;@Inf@] ; @NaN@ ^ [0;5] ; @NaN@ ^ [0;1] ; @NaN@ ^ [0;0] ; -@Inf@ ^ @NaN@ ; -@Inf@ ^ -@Inf@ ; -@Inf@ ^ @Inf@ ; -@Inf@ ^ 5 ; -@Inf@ ^ 1 ; -@Inf@ ^ 0 ; -@Inf@ ^ [@NaN@] ; -@Inf@ ^ [-@Inf@] ; -@Inf@ ^ [@Inf@] ; -@Inf@ ^ [5] ; -@Inf@ ^ [1] ; -@Inf@ ^ [0] ; -@Inf@ ^ [@NaN@;@NaN@] ; -@Inf@ ^ [@NaN@;-@Inf@] ; -@Inf@ ^ [@NaN@;@Inf@] ; -@Inf@ ^ [@NaN@;5] ; -@Inf@ ^ [@NaN@;1] ; -@Inf@ ^ [@NaN@;0] ; -@Inf@ ^ [-@Inf@;@NaN@] ; -@Inf@ ^ [-@Inf@;-@Inf@] ; -@Inf@ ^ [-@Inf@;@Inf@] ; -@Inf@ ^ [-@Inf@;5] ; -@Inf@ ^ [-@Inf@;1] ; -@Inf@ ^ [-@Inf@;0] ; -@Inf@ ^ [@Inf@;@NaN@] ; -@Inf@ ^ [@Inf@;-@Inf@] ; -@Inf@ ^ [@Inf@;@Inf@] ; -@Inf@ ^ [@Inf@;5] ; -@Inf@ ^ [@Inf@;1] ; -@Inf@ ^ [@Inf@;0] ; -@Inf@ ^ [5;@NaN@] ; -@Inf@ ^ [5;-@Inf@] ; -@Inf@ ^ [5;@Inf@] ; -@Inf@ ^ [5;5] ; -@Inf@ ^ [5;1] ; -@Inf@ ^ [5;0] ; -@Inf@ ^ [1;@NaN@] ; -@Inf@ ^ [1;-@Inf@] ; -@Inf@ ^ [1;@Inf@] ; -@Inf@ ^ [1;5] ; -@Inf@ ^ [1;1] ; -@Inf@ ^ [1;0] ; -@Inf@ ^ [0;@NaN@] ; -@Inf@ ^ [0;-@Inf@] ; -@Inf@ ^ [0;@Inf@] ; -@Inf@ ^ [0;5] ; -@Inf@ ^ [0;1] ; -@Inf@ ^ [0;0] ; @Inf@ ^ @NaN@ ; @Inf@ ^ -@Inf@ ; @Inf@ ^ @Inf@ ; @Inf@ ^ 5 ; @Inf@ ^ 1 ; @Inf@ ^ 0 ; @Inf@ ^ [@NaN@] ; @Inf@ ^ [-@Inf@] ; @Inf@ ^ [@Inf@] ; @Inf@ ^ [5] ; @Inf@ ^ [1] ; @Inf@ ^ [0] ; @Inf@ ^ [@NaN@;@NaN@] ; @Inf@ ^ [@NaN@;-@Inf@] ; @Inf@ ^ [@NaN@;@Inf@] ; @Inf@ ^ [@NaN@;5] ; @Inf@ ^ [@NaN@;1] ; @Inf@ ^ [@NaN@;0] ; @Inf@ ^ [-@Inf@;@NaN@] ; @Inf@ ^ [-@Inf@;-@Inf@] ; @Inf@ ^ [-@Inf@;@Inf@] ; @Inf@ ^ [-@Inf@;5] ; @Inf@ ^ [-@Inf@;1] ; @Inf@ ^ [-@Inf@;0] ; @Inf@ ^ [@Inf@;@NaN@] ; @Inf@ ^ [@Inf@;-@Inf@] ; @Inf@ ^ [@Inf@;@Inf@] ; @Inf@ ^ [@Inf@;5] ; @Inf@ ^ [@Inf@;1] ; @Inf@ ^ [@Inf@;0] ; @Inf@ ^ [5;@NaN@] ; @Inf@ ^ [5;-@Inf@] ; @Inf@ ^ [5;@Inf@] ; @Inf@ ^ [5;5] ; @Inf@ ^ [5;1] ; @Inf@ ^ [5;0] ; @Inf@ ^ [1;@NaN@] ; @Inf@ ^ [1;-@Inf@] ; @Inf@ ^ [1;@Inf@] ; @Inf@ ^ [1;5] ; @Inf@ ^ [1;1] ; @Inf@ ^ [1;0] ; @Inf@ ^ [0;@NaN@] ; @Inf@ ^ [0;-@Inf@] ; @Inf@ ^ [0;@Inf@] ; @Inf@ ^ [0;5] ; @Inf@ ^ [0;1] ; @Inf@ ^ [0;0] ; 5 ^ @NaN@ ; 5 ^ -@Inf@ ; 5 ^ @Inf@ ; 5 ^ 5 ; 5 ^ 1 ; 5 ^ 0 ; 5 ^ [@NaN@] ; 5 ^ [-@Inf@] ; 5 ^ [@Inf@] ; 5 ^ [5] ; 5 ^ [1] ; 5 ^ [0] ; 5 ^ [@NaN@;@NaN@] ; 5 ^ [@NaN@;-@Inf@] ; 5 ^ [@NaN@;@Inf@] ; 5 ^ [@NaN@;5] ; 5 ^ [@NaN@;1] ; 5 ^ [@NaN@;0] ; 5 ^ [-@Inf@;@NaN@] ; 5 ^ [-@Inf@;-@Inf@] ; 5 ^ [-@Inf@;@Inf@] ; 5 ^ [-@Inf@;5] ; 5 ^ [-@Inf@;1] ; 5 ^ [-@Inf@;0] ; 5 ^ [@Inf@;@NaN@] ; 5 ^ [@Inf@;-@Inf@] ; 5 ^ [@Inf@;@Inf@] ; 5 ^ [@Inf@;5] ; 5 ^ [@Inf@;1] ; 5 ^ [@Inf@;0] ; 5 ^ [5;@NaN@] ; 5 ^ [5;-@Inf@] ; 5 ^ [5;@Inf@] ; 5 ^ [5;5] ; 5 ^ [5;1] ; 5 ^ [5;0] ; 5 ^ [1;@NaN@] ; 5 ^ [1;-@Inf@] ; 5 ^ [1;@Inf@] ; 5 ^ [1;5] ; 5 ^ [1;1] ; 5 ^ [1;0] ; 5 ^ [0;@NaN@] ; 5 ^ [0;-@Inf@] ; 5 ^ [0;@Inf@] ; 5 ^ [0;5] ; 5 ^ [0;1] ; 5 ^ [0;0] ; 1 ^ @NaN@ ; 1 ^ -@Inf@ ; 1 ^ @Inf@ ; 1 ^ 5 ; 1 ^ 1 ; 1 ^ 0 ; 1 ^ [@NaN@] ; 1 ^ [-@Inf@] ; 1 ^ [@Inf@] ; 1 ^ [5] ; 1 ^ [1] ; 1 ^ [0] ; 1 ^ [@NaN@;@NaN@] ; 1 ^ [@NaN@;-@Inf@] ; 1 ^ [@NaN@;@Inf@] ; 1 ^ [@NaN@;5] ; 1 ^ [@NaN@;1] ; 1 ^ [@NaN@;0] ; 1 ^ [-@Inf@;@NaN@] ; 1 ^ [-@Inf@;-@Inf@] ; 1 ^ [-@Inf@;@Inf@] ; 1 ^ [-@Inf@;5] ; 1 ^ [-@Inf@;1] ; 1 ^ [-@Inf@;0] ; 1 ^ [@Inf@;@NaN@] ; 1 ^ [@Inf@;-@Inf@] ; 1 ^ [@Inf@;@Inf@] ; 1 ^ [@Inf@;5] ; 1 ^ [@Inf@;1] ; 1 ^ [@Inf@;0] ; 1 ^ [5;@NaN@] ; 1 ^ [5;-@Inf@] ; 1 ^ [5;@Inf@] ; 1 ^ [5;5] ; 1 ^ [5;1] ; 1 ^ [5;0] ; 1 ^ [1;@NaN@] ; 1 ^ [1;-@Inf@] ; 1 ^ [1;@Inf@] ; 1 ^ [1;5] ; 1 ^ [1;1] ; 1 ^ [1;0] ; 1 ^ [0;@NaN@] ; 1 ^ [0;-@Inf@] ; 1 ^ [0;@Inf@] ; 1 ^ [0;5] ; 1 ^ [0;1] ; 1 ^ [0;0] ; 0 ^ @NaN@ ; 0 ^ -@Inf@ ; 0 ^ @Inf@ ; 0 ^ 5 ; 0 ^ 1 ; 0 ^ 0 ; 0 ^ [@NaN@] ; 0 ^ [-@Inf@] ; 0 ^ [@Inf@] ; 0 ^ [5] ; 0 ^ [1] ; 0 ^ [0] ; 0 ^ [@NaN@;@NaN@] ; 0 ^ [@NaN@;-@Inf@] ; 0 ^ [@NaN@;@Inf@] ; 0 ^ [@NaN@;5] ; 0 ^ [@NaN@;1] ; 0 ^ [@NaN@;0] ; 0 ^ [-@Inf@;@NaN@] ; 0 ^ [-@Inf@;-@Inf@] ; 0 ^ [-@Inf@;@Inf@] ; 0 ^ [-@Inf@;5] ; 0 ^ [-@Inf@;1] ; 0 ^ [-@Inf@;0] ; 0 ^ [@Inf@;@NaN@] ; 0 ^ [@Inf@;-@Inf@] ; 0 ^ [@Inf@;@Inf@] ; 0 ^ [@Inf@;5] ; 0 ^ [@Inf@;1] ; 0 ^ [@Inf@;0] ; 0 ^ [5;@NaN@] ; 0 ^ [5;-@Inf@] ; 0 ^ [5;@Inf@] ; 0 ^ [5;5] ; 0 ^ [5;1] ; 0 ^ [5;0] ; 0 ^ [1;@NaN@] ; 0 ^ [1;-@Inf@] ; 0 ^ [1;@Inf@] ; 0 ^ [1;5] ; 0 ^ [1;1] ; 0 ^ [1;0] ; 0 ^ [0;@NaN@] ; 0 ^ [0;-@Inf@] ; 0 ^ [0;@Inf@] ; 0 ^ [0;5] ; 0 ^ [0;1] ; 0 ^ [0;0] ; [@NaN@] ^ @NaN@ ; [@NaN@] ^ -@Inf@ ; [@NaN@] ^ @Inf@ ; [@NaN@] ^ 5 ; [@NaN@] ^ 1 ; [@NaN@] ^ 0 ; [@NaN@] ^ [@NaN@] ; [@NaN@] ^ [-@Inf@] ; [@NaN@] ^ [@Inf@] ; [@NaN@] ^ [5] ; [@NaN@] ^ [1] ; [@NaN@] ^ [0] ; [@NaN@] ^ [@NaN@;@NaN@] ; [@NaN@] ^ [@NaN@;-@Inf@] ; [@NaN@] ^ [@NaN@;@Inf@] ; [@NaN@] ^ [@NaN@;5] ; [@NaN@] ^ [@NaN@;1] ; [@NaN@] ^ [@NaN@;0] ; [@NaN@] ^ [-@Inf@;@NaN@] ; [@NaN@] ^ [-@Inf@;-@Inf@] ; [@NaN@] ^ [-@Inf@;@Inf@] ; [@NaN@] ^ [-@Inf@;5] ; [@NaN@] ^ [-@Inf@;1] ; [@NaN@] ^ [-@Inf@;0] ; [@NaN@] ^ [@Inf@;@NaN@] ; [@NaN@] ^ [@Inf@;-@Inf@] ; [@NaN@] ^ [@Inf@;@Inf@] ; [@NaN@] ^ [@Inf@;5] ; [@NaN@] ^ [@Inf@;1] ; [@NaN@] ^ [@Inf@;0] ; [@NaN@] ^ [5;@NaN@] ; [@NaN@] ^ [5;-@Inf@] ; [@NaN@] ^ [5;@Inf@] ; [@NaN@] ^ [5;5] ; [@NaN@] ^ [5;1] ; [@NaN@] ^ [5;0] ; [@NaN@] ^ [1;@NaN@] ; [@NaN@] ^ [1;-@Inf@] ; [@NaN@] ^ [1;@Inf@] ; [@NaN@] ^ [1;5] ; [@NaN@] ^ [1;1] ; [@NaN@] ^ [1;0] ; [@NaN@] ^ [0;@NaN@] ; [@NaN@] ^ [0;-@Inf@] ; [@NaN@] ^ [0;@Inf@] ; [@NaN@] ^ [0;5] ; [@NaN@] ^ [0;1] ; [@NaN@] ^ [0;0] ; [-@Inf@] ^ @NaN@ ; [-@Inf@] ^ -@Inf@ ; [-@Inf@] ^ @Inf@ ; [-@Inf@] ^ 5 ; [-@Inf@] ^ 1 ; [-@Inf@] ^ 0 ; [-@Inf@] ^ [@NaN@] ; [-@Inf@] ^ [-@Inf@] ; [-@Inf@] ^ [@Inf@] ; [-@Inf@] ^ [5] ; [-@Inf@] ^ [1] ; [-@Inf@] ^ [0] ; [-@Inf@] ^ [@NaN@;@NaN@] ; [-@Inf@] ^ [@NaN@;-@Inf@] ; [-@Inf@] ^ [@NaN@;@Inf@] ; [-@Inf@] ^ [@NaN@;5] ; [-@Inf@] ^ [@NaN@;1] ; [-@Inf@] ^ [@NaN@;0] ; [-@Inf@] ^ [-@Inf@;@NaN@] ; [-@Inf@] ^ [-@Inf@;-@Inf@] ; [-@Inf@] ^ [-@Inf@;@Inf@] ; [-@Inf@] ^ [-@Inf@;5] ; [-@Inf@] ^ [-@Inf@;1] ; [-@Inf@] ^ [-@Inf@;0] ; [-@Inf@] ^ [@Inf@;@NaN@] ; [-@Inf@] ^ [@Inf@;-@Inf@] ; [-@Inf@] ^ [@Inf@;@Inf@] ; [-@Inf@] ^ [@Inf@;5] ; [-@Inf@] ^ [@Inf@;1] ; [-@Inf@] ^ [@Inf@;0] ; [-@Inf@] ^ [5;@NaN@] ; [-@Inf@] ^ [5;-@Inf@] ; [-@Inf@] ^ [5;@Inf@] ; [-@Inf@] ^ [5;5] ; [-@Inf@] ^ [5;1] ; [-@Inf@] ^ [5;0] ; [-@Inf@] ^ [1;@NaN@] ; [-@Inf@] ^ [1;-@Inf@] ; [-@Inf@] ^ [1;@Inf@] ; [-@Inf@] ^ [1;5] ; [-@Inf@] ^ [1;1] ; [-@Inf@] ^ [1;0] ; [-@Inf@] ^ [0;@NaN@] ; [-@Inf@] ^ [0;-@Inf@] ; [-@Inf@] ^ [0;@Inf@] ; [-@Inf@] ^ [0;5] ; [-@Inf@] ^ [0;1] ; [-@Inf@] ^ [0;0] ; [@Inf@] ^ @NaN@ ; [@Inf@] ^ -@Inf@ ; [@Inf@] ^ @Inf@ ; [@Inf@] ^ 5 ; [@Inf@] ^ 1 ; [@Inf@] ^ 0 ; [@Inf@] ^ [@NaN@] ; [@Inf@] ^ [-@Inf@] ; [@Inf@] ^ [@Inf@] ; [@Inf@] ^ [5] ; [@Inf@] ^ [1] ; [@Inf@] ^ [0] ; [@Inf@] ^ [@NaN@;@NaN@] ; [@Inf@] ^ [@NaN@;-@Inf@] ; [@Inf@] ^ [@NaN@;@Inf@] ; [@Inf@] ^ [@NaN@;5] ; [@Inf@] ^ [@NaN@;1] ; [@Inf@] ^ [@NaN@;0] ; [@Inf@] ^ [-@Inf@;@NaN@] ; [@Inf@] ^ [-@Inf@;-@Inf@] ; [@Inf@] ^ [-@Inf@;@Inf@] ; [@Inf@] ^ [-@Inf@;5] ; [@Inf@] ^ [-@Inf@;1] ; [@Inf@] ^ [-@Inf@;0] ; [@Inf@] ^ [@Inf@;@NaN@] ; [@Inf@] ^ [@Inf@;-@Inf@] ; [@Inf@] ^ [@Inf@;@Inf@] ; [@Inf@] ^ [@Inf@;5] ; [@Inf@] ^ [@Inf@;1] ; [@Inf@] ^ [@Inf@;0] ; [@Inf@] ^ [5;@NaN@] ; [@Inf@] ^ [5;-@Inf@] ; [@Inf@] ^ [5;@Inf@] ; [@Inf@] ^ [5;5] ; [@Inf@] ^ [5;1] ; [@Inf@] ^ [5;0] ; [@Inf@] ^ [1;@NaN@] ; [@Inf@] ^ [1;-@Inf@] ; [@Inf@] ^ [1;@Inf@] ; [@Inf@] ^ [1;5] ; [@Inf@] ^ [1;1] ; [@Inf@] ^ [1;0] ; [@Inf@] ^ [0;@NaN@] ; [@Inf@] ^ [0;-@Inf@] ; [@Inf@] ^ [0;@Inf@] ; [@Inf@] ^ [0;5] ; [@Inf@] ^ [0;1] ; [@Inf@] ^ [0;0] ; [5] ^ @NaN@ ; [5] ^ -@Inf@ ; [5] ^ @Inf@ ; [5] ^ 5 ; [5] ^ 1 ; [5] ^ 0 ; [5] ^ [@NaN@] ; [5] ^ [-@Inf@] ; [5] ^ [@Inf@] ; [5] ^ [5] ; [5] ^ [1] ; [5] ^ [0] ; [5] ^ [@NaN@;@NaN@] ; [5] ^ [@NaN@;-@Inf@] ; [5] ^ [@NaN@;@Inf@] ; [5] ^ [@NaN@;5] ; [5] ^ [@NaN@;1] ; [5] ^ [@NaN@;0] ; [5] ^ [-@Inf@;@NaN@] ; [5] ^ [-@Inf@;-@Inf@] ; [5] ^ [-@Inf@;@Inf@] ; [5] ^ [-@Inf@;5] ; [5] ^ [-@Inf@;1] ; [5] ^ [-@Inf@;0] ; [5] ^ [@Inf@;@NaN@] ; [5] ^ [@Inf@;-@Inf@] ; [5] ^ [@Inf@;@Inf@] ; [5] ^ [@Inf@;5] ; [5] ^ [@Inf@;1] ; [5] ^ [@Inf@;0] ; [5] ^ [5;@NaN@] ; [5] ^ [5;-@Inf@] ; [5] ^ [5;@Inf@] ; [5] ^ [5;5] ; [5] ^ [5;1] ; [5] ^ [5;0] ; [5] ^ [1;@NaN@] ; [5] ^ [1;-@Inf@] ; [5] ^ [1;@Inf@] ; [5] ^ [1;5] ; [5] ^ [1;1] ; [5] ^ [1;0] ; [5] ^ [0;@NaN@] ; [5] ^ [0;-@Inf@] ; [5] ^ [0;@Inf@] ; [5] ^ [0;5] ; [5] ^ [0;1] ; [5] ^ [0;0] ; [1] ^ @NaN@ ; [1] ^ -@Inf@ ; [1] ^ @Inf@ ; [1] ^ 5 ; [1] ^ 1 ; [1] ^ 0 ; [1] ^ [@NaN@] ; [1] ^ [-@Inf@] ; [1] ^ [@Inf@] ; [1] ^ [5] ; [1] ^ [1] ; [1] ^ [0] ; [1] ^ [@NaN@;@NaN@] ; [1] ^ [@NaN@;-@Inf@] ; [1] ^ [@NaN@;@Inf@] ; [1] ^ [@NaN@;5] ; [1] ^ [@NaN@;1] ; [1] ^ [@NaN@;0] ; [1] ^ [-@Inf@;@NaN@] ; [1] ^ [-@Inf@;-@Inf@] ; [1] ^ [-@Inf@;@Inf@] ; [1] ^ [-@Inf@;5] ; [1] ^ [-@Inf@;1] ; [1] ^ [-@Inf@;0] ; [1] ^ [@Inf@;@NaN@] ; [1] ^ [@Inf@;-@Inf@] ; [1] ^ [@Inf@;@Inf@] ; [1] ^ [@Inf@;5] ; [1] ^ [@Inf@;1] ; [1] ^ [@Inf@;0] ; [1] ^ [5;@NaN@] ; [1] ^ [5;-@Inf@] ; [1] ^ [5;@Inf@] ; [1] ^ [5;5] ; [1] ^ [5;1] ; [1] ^ [5;0] ; [1] ^ [1;@NaN@] ; [1] ^ [1;-@Inf@] ; [1] ^ [1;@Inf@] ; [1] ^ [1;5] ; [1] ^ [1;1] ; [1] ^ [1;0] ; [1] ^ [0;@NaN@] ; [1] ^ [0;-@Inf@] ; [1] ^ [0;@Inf@] ; [1] ^ [0;5] ; [1] ^ [0;1] ; [1] ^ [0;0] ; [0] ^ @NaN@ ; [0] ^ -@Inf@ ; [0] ^ @Inf@ ; [0] ^ 5 ; [0] ^ 1 ; [0] ^ 0 ; [0] ^ [@NaN@] ; [0] ^ [-@Inf@] ; [0] ^ [@Inf@] ; [0] ^ [5] ; [0] ^ [1] ; [0] ^ [0] ; [0] ^ [@NaN@;@NaN@] ; [0] ^ [@NaN@;-@Inf@] ; [0] ^ [@NaN@;@Inf@] ; [0] ^ [@NaN@;5] ; [0] ^ [@NaN@;1] ; [0] ^ [@NaN@;0] ; [0] ^ [-@Inf@;@NaN@] ; [0] ^ [-@Inf@;-@Inf@] ; [0] ^ [-@Inf@;@Inf@] ; [0] ^ [-@Inf@;5] ; [0] ^ [-@Inf@;1] ; [0] ^ [-@Inf@;0] ; [0] ^ [@Inf@;@NaN@] ; [0] ^ [@Inf@;-@Inf@] ; [0] ^ [@Inf@;@Inf@] ; [0] ^ [@Inf@;5] ; [0] ^ [@Inf@;1] ; [0] ^ [@Inf@;0] ; [0] ^ [5;@NaN@] ; [0] ^ [5;-@Inf@] ; [0] ^ [5;@Inf@] ; [0] ^ [5;5] ; [0] ^ [5;1] ; [0] ^ [5;0] ; [0] ^ [1;@NaN@] ; [0] ^ [1;-@Inf@] ; [0] ^ [1;@Inf@] ; [0] ^ [1;5] ; [0] ^ [1;1] ; [0] ^ [1;0] ; [0] ^ [0;@NaN@] ; [0] ^ [0;-@Inf@] ; [0] ^ [0;@Inf@] ; [0] ^ [0;5] ; [0] ^ [0;1] ; [0] ^ [0;0] ; [@NaN@;@NaN@] ^ @NaN@ ; [@NaN@;@NaN@] ^ -@Inf@ ; [@NaN@;@NaN@] ^ @Inf@ ; [@NaN@;@NaN@] ^ 5 ; [@NaN@;@NaN@] ^ 1 ; [@NaN@;@NaN@] ^ 0 ; [@NaN@;@NaN@] ^ [@NaN@] ; [@NaN@;@NaN@] ^ [-@Inf@] ; [@NaN@;@NaN@] ^ [@Inf@] ; [@NaN@;@NaN@] ^ [5] ; [@NaN@;@NaN@] ^ [1] ; [@NaN@;@NaN@] ^ [0] ; [@NaN@;@NaN@] ^ [@NaN@;@NaN@] ; [@NaN@;@NaN@] ^ [@NaN@;-@Inf@] ; [@NaN@;@NaN@] ^ [@NaN@;@Inf@] ; [@NaN@;@NaN@] ^ [@NaN@;5] ; [@NaN@;@NaN@] ^ [@NaN@;1] ; [@NaN@;@NaN@] ^ [@NaN@;0] ; [@NaN@;@NaN@] ^ [-@Inf@;@NaN@] ; [@NaN@;@NaN@] ^ [-@Inf@;-@Inf@] ; [@NaN@;@NaN@] ^ [-@Inf@;@Inf@] ; [@NaN@;@NaN@] ^ [-@Inf@;5] ; [@NaN@;@NaN@] ^ [-@Inf@;1] ; [@NaN@;@NaN@] ^ [-@Inf@;0] ; [@NaN@;@NaN@] ^ [@Inf@;@NaN@] ; [@NaN@;@NaN@] ^ [@Inf@;-@Inf@] ; [@NaN@;@NaN@] ^ [@Inf@;@Inf@] ; [@NaN@;@NaN@] ^ [@Inf@;5] ; [@NaN@;@NaN@] ^ [@Inf@;1] ; [@NaN@;@NaN@] ^ [@Inf@;0] ; [@NaN@;@NaN@] ^ [5;@NaN@] ; [@NaN@;@NaN@] ^ [5;-@Inf@] ; [@NaN@;@NaN@] ^ [5;@Inf@] ; [@NaN@;@NaN@] ^ [5;5] ; [@NaN@;@NaN@] ^ [5;1] ; [@NaN@;@NaN@] ^ [5;0] ; [@NaN@;@NaN@] ^ [1;@NaN@] ; [@NaN@;@NaN@] ^ [1;-@Inf@] ; [@NaN@;@NaN@] ^ [1;@Inf@] ; [@NaN@;@NaN@] ^ [1;5] ; [@NaN@;@NaN@] ^ [1;1] ; [@NaN@;@NaN@] ^ [1;0] ; [@NaN@;@NaN@] ^ [0;@NaN@] ; [@NaN@;@NaN@] ^ [0;-@Inf@] ; [@NaN@;@NaN@] ^ [0;@Inf@] ; [@NaN@;@NaN@] ^ [0;5] ; [@NaN@;@NaN@] ^ [0;1] ; [@NaN@;@NaN@] ^ [0;0] ; [@NaN@;-@Inf@] ^ @NaN@ ; [@NaN@;-@Inf@] ^ -@Inf@ ; [@NaN@;-@Inf@] ^ @Inf@ ; [@NaN@;-@Inf@] ^ 5 ; [@NaN@;-@Inf@] ^ 1 ; [@NaN@;-@Inf@] ^ 0 ; [@NaN@;-@Inf@] ^ [@NaN@] ; [@NaN@;-@Inf@] ^ [-@Inf@] ; [@NaN@;-@Inf@] ^ [@Inf@] ; [@NaN@;-@Inf@] ^ [5] ; [@NaN@;-@Inf@] ^ [1] ; [@NaN@;-@Inf@] ^ [0] ; [@NaN@;-@Inf@] ^ [@NaN@;@NaN@] ; [@NaN@;-@Inf@] ^ [@NaN@;-@Inf@] ; [@NaN@;-@Inf@] ^ [@NaN@;@Inf@] ; [@NaN@;-@Inf@] ^ [@NaN@;5] ; [@NaN@;-@Inf@] ^ [@NaN@;1] ; [@NaN@;-@Inf@] ^ [@NaN@;0] ; [@NaN@;-@Inf@] ^ [-@Inf@;@NaN@] ; [@NaN@;-@Inf@] ^ [-@Inf@;-@Inf@] ; [@NaN@;-@Inf@] ^ [-@Inf@;@Inf@] ; [@NaN@;-@Inf@] ^ [-@Inf@;5] ; [@NaN@;-@Inf@] ^ [-@Inf@;1] ; [@NaN@;-@Inf@] ^ [-@Inf@;0] ; [@NaN@;-@Inf@] ^ [@Inf@;@NaN@] ; [@NaN@;-@Inf@] ^ [@Inf@;-@Inf@] ; [@NaN@;-@Inf@] ^ [@Inf@;@Inf@] ; [@NaN@;-@Inf@] ^ [@Inf@;5] ; [@NaN@;-@Inf@] ^ [@Inf@;1] ; [@NaN@;-@Inf@] ^ [@Inf@;0] ; [@NaN@;-@Inf@] ^ [5;@NaN@] ; [@NaN@;-@Inf@] ^ [5;-@Inf@] ; [@NaN@;-@Inf@] ^ [5;@Inf@] ; [@NaN@;-@Inf@] ^ [5;5] ; [@NaN@;-@Inf@] ^ [5;1] ; [@NaN@;-@Inf@] ^ [5;0] ; [@NaN@;-@Inf@] ^ [1;@NaN@] ; [@NaN@;-@Inf@] ^ [1;-@Inf@] ; [@NaN@;-@Inf@] ^ [1;@Inf@] ; [@NaN@;-@Inf@] ^ [1;5] ; [@NaN@;-@Inf@] ^ [1;1] ; [@NaN@;-@Inf@] ^ [1;0] ; [@NaN@;-@Inf@] ^ [0;@NaN@] ; [@NaN@;-@Inf@] ^ [0;-@Inf@] ; [@NaN@;-@Inf@] ^ [0;@Inf@] ; [@NaN@;-@Inf@] ^ [0;5] ; [@NaN@;-@Inf@] ^ [0;1] ; [@NaN@;-@Inf@] ^ [0;0] ; [@NaN@;@Inf@] ^ @NaN@ ; [@NaN@;@Inf@] ^ -@Inf@ ; [@NaN@;@Inf@] ^ @Inf@ ; [@NaN@;@Inf@] ^ 5 ; [@NaN@;@Inf@] ^ 1 ; [@NaN@;@Inf@] ^ 0 ; [@NaN@;@Inf@] ^ [@NaN@] ; [@NaN@;@Inf@] ^ [-@Inf@] ; [@NaN@;@Inf@] ^ [@Inf@] ; [@NaN@;@Inf@] ^ [5] ; [@NaN@;@Inf@] ^ [1] ; [@NaN@;@Inf@] ^ [0] ; [@NaN@;@Inf@] ^ [@NaN@;@NaN@] ; [@NaN@;@Inf@] ^ [@NaN@;-@Inf@] ; [@NaN@;@Inf@] ^ [@NaN@;@Inf@] ; [@NaN@;@Inf@] ^ [@NaN@;5] ; [@NaN@;@Inf@] ^ [@NaN@;1] ; [@NaN@;@Inf@] ^ [@NaN@;0] ; [@NaN@;@Inf@] ^ [-@Inf@;@NaN@] ; [@NaN@;@Inf@] ^ [-@Inf@;-@Inf@] ; [@NaN@;@Inf@] ^ [-@Inf@;@Inf@] ; [@NaN@;@Inf@] ^ [-@Inf@;5] ; [@NaN@;@Inf@] ^ [-@Inf@;1] ; [@NaN@;@Inf@] ^ [-@Inf@;0] ; [@NaN@;@Inf@] ^ [@Inf@;@NaN@] ; [@NaN@;@Inf@] ^ [@Inf@;-@Inf@] ; [@NaN@;@Inf@] ^ [@Inf@;@Inf@] ; [@NaN@;@Inf@] ^ [@Inf@;5] ; [@NaN@;@Inf@] ^ [@Inf@;1] ; [@NaN@;@Inf@] ^ [@Inf@;0] ; [@NaN@;@Inf@] ^ [5;@NaN@] ; [@NaN@;@Inf@] ^ [5;-@Inf@] ; [@NaN@;@Inf@] ^ [5;@Inf@] ; [@NaN@;@Inf@] ^ [5;5] ; [@NaN@;@Inf@] ^ [5;1] ; [@NaN@;@Inf@] ^ [5;0] ; [@NaN@;@Inf@] ^ [1;@NaN@] ; [@NaN@;@Inf@] ^ [1;-@Inf@] ; [@NaN@;@Inf@] ^ [1;@Inf@] ; [@NaN@;@Inf@] ^ [1;5] ; [@NaN@;@Inf@] ^ [1;1] ; [@NaN@;@Inf@] ^ [1;0] ; [@NaN@;@Inf@] ^ [0;@NaN@] ; [@NaN@;@Inf@] ^ [0;-@Inf@] ; [@NaN@;@Inf@] ^ [0;@Inf@] ; [@NaN@;@Inf@] ^ [0;5] ; [@NaN@;@Inf@] ^ [0;1] ; [@NaN@;@Inf@] ^ [0;0] ; [@NaN@;5] ^ @NaN@ ; [@NaN@;5] ^ -@Inf@ ; [@NaN@;5] ^ @Inf@ ; [@NaN@;5] ^ 5 ; [@NaN@;5] ^ 1 ; [@NaN@;5] ^ 0 ; [@NaN@;5] ^ [@NaN@] ; [@NaN@;5] ^ [-@Inf@] ; [@NaN@;5] ^ [@Inf@] ; [@NaN@;5] ^ [5] ; [@NaN@;5] ^ [1] ; [@NaN@;5] ^ [0] ; [@NaN@;5] ^ [@NaN@;@NaN@] ; [@NaN@;5] ^ [@NaN@;-@Inf@] ; [@NaN@;5] ^ [@NaN@;@Inf@] ; [@NaN@;5] ^ [@NaN@;5] ; [@NaN@;5] ^ [@NaN@;1] ; [@NaN@;5] ^ [@NaN@;0] ; [@NaN@;5] ^ [-@Inf@;@NaN@] ; [@NaN@;5] ^ [-@Inf@;-@Inf@] ; [@NaN@;5] ^ [-@Inf@;@Inf@] ; [@NaN@;5] ^ [-@Inf@;5] ; [@NaN@;5] ^ [-@Inf@;1] ; [@NaN@;5] ^ [-@Inf@;0] ; [@NaN@;5] ^ [@Inf@;@NaN@] ; [@NaN@;5] ^ [@Inf@;-@Inf@] ; [@NaN@;5] ^ [@Inf@;@Inf@] ; [@NaN@;5] ^ [@Inf@;5] ; [@NaN@;5] ^ [@Inf@;1] ; [@NaN@;5] ^ [@Inf@;0] ; [@NaN@;5] ^ [5;@NaN@] ; [@NaN@;5] ^ [5;-@Inf@] ; [@NaN@;5] ^ [5;@Inf@] ; [@NaN@;5] ^ [5;5] ; [@NaN@;5] ^ [5;1] ; [@NaN@;5] ^ [5;0] ; [@NaN@;5] ^ [1;@NaN@] ; [@NaN@;5] ^ [1;-@Inf@] ; [@NaN@;5] ^ [1;@Inf@] ; [@NaN@;5] ^ [1;5] ; [@NaN@;5] ^ [1;1] ; [@NaN@;5] ^ [1;0] ; [@NaN@;5] ^ [0;@NaN@] ; [@NaN@;5] ^ [0;-@Inf@] ; [@NaN@;5] ^ [0;@Inf@] ; [@NaN@;5] ^ [0;5] ; [@NaN@;5] ^ [0;1] ; [@NaN@;5] ^ [0;0] ; [@NaN@;1] ^ @NaN@ ; [@NaN@;1] ^ -@Inf@ ; [@NaN@;1] ^ @Inf@ ; [@NaN@;1] ^ 5 ; [@NaN@;1] ^ 1 ; [@NaN@;1] ^ 0 ; [@NaN@;1] ^ [@NaN@] ; [@NaN@;1] ^ [-@Inf@] ; [@NaN@;1] ^ [@Inf@] ; [@NaN@;1] ^ [5] ; [@NaN@;1] ^ [1] ; [@NaN@;1] ^ [0] ; [@NaN@;1] ^ [@NaN@;@NaN@] ; [@NaN@;1] ^ [@NaN@;-@Inf@] ; [@NaN@;1] ^ [@NaN@;@Inf@] ; [@NaN@;1] ^ [@NaN@;5] ; [@NaN@;1] ^ [@NaN@;1] ; [@NaN@;1] ^ [@NaN@;0] ; [@NaN@;1] ^ [-@Inf@;@NaN@] ; [@NaN@;1] ^ [-@Inf@;-@Inf@] ; [@NaN@;1] ^ [-@Inf@;@Inf@] ; [@NaN@;1] ^ [-@Inf@;5] ; [@NaN@;1] ^ [-@Inf@;1] ; [@NaN@;1] ^ [-@Inf@;0] ; [@NaN@;1] ^ [@Inf@;@NaN@] ; [@NaN@;1] ^ [@Inf@;-@Inf@] ; [@NaN@;1] ^ [@Inf@;@Inf@] ; [@NaN@;1] ^ [@Inf@;5] ; [@NaN@;1] ^ [@Inf@;1] ; [@NaN@;1] ^ [@Inf@;0] ; [@NaN@;1] ^ [5;@NaN@] ; [@NaN@;1] ^ [5;-@Inf@] ; [@NaN@;1] ^ [5;@Inf@] ; [@NaN@;1] ^ [5;5] ; [@NaN@;1] ^ [5;1] ; [@NaN@;1] ^ [5;0] ; [@NaN@;1] ^ [1;@NaN@] ; [@NaN@;1] ^ [1;-@Inf@] ; [@NaN@;1] ^ [1;@Inf@] ; [@NaN@;1] ^ [1;5] ; [@NaN@;1] ^ [1;1] ; [@NaN@;1] ^ [1;0] ; [@NaN@;1] ^ [0;@NaN@] ; [@NaN@;1] ^ [0;-@Inf@] ; [@NaN@;1] ^ [0;@Inf@] ; [@NaN@;1] ^ [0;5] ; [@NaN@;1] ^ [0;1] ; [@NaN@;1] ^ [0;0] ; [@NaN@;0] ^ @NaN@ ; [@NaN@;0] ^ -@Inf@ ; [@NaN@;0] ^ @Inf@ ; [@NaN@;0] ^ 5 ; [@NaN@;0] ^ 1 ; [@NaN@;0] ^ 0 ; [@NaN@;0] ^ [@NaN@] ; [@NaN@;0] ^ [-@Inf@] ; [@NaN@;0] ^ [@Inf@] ; [@NaN@;0] ^ [5] ; [@NaN@;0] ^ [1] ; [@NaN@;0] ^ [0] ; [@NaN@;0] ^ [@NaN@;@NaN@] ; [@NaN@;0] ^ [@NaN@;-@Inf@] ; [@NaN@;0] ^ [@NaN@;@Inf@] ; [@NaN@;0] ^ [@NaN@;5] ; [@NaN@;0] ^ [@NaN@;1] ; [@NaN@;0] ^ [@NaN@;0] ; [@NaN@;0] ^ [-@Inf@;@NaN@] ; [@NaN@;0] ^ [-@Inf@;-@Inf@] ; [@NaN@;0] ^ [-@Inf@;@Inf@] ; [@NaN@;0] ^ [-@Inf@;5] ; [@NaN@;0] ^ [-@Inf@;1] ; [@NaN@;0] ^ [-@Inf@;0] ; [@NaN@;0] ^ [@Inf@;@NaN@] ; [@NaN@;0] ^ [@Inf@;-@Inf@] ; [@NaN@;0] ^ [@Inf@;@Inf@] ; [@NaN@;0] ^ [@Inf@;5] ; [@NaN@;0] ^ [@Inf@;1] ; [@NaN@;0] ^ [@Inf@;0] ; [@NaN@;0] ^ [5;@NaN@] ; [@NaN@;0] ^ [5;-@Inf@] ; [@NaN@;0] ^ [5;@Inf@] ; [@NaN@;0] ^ [5;5] ; [@NaN@;0] ^ [5;1] ; [@NaN@;0] ^ [5;0] ; [@NaN@;0] ^ [1;@NaN@] ; [@NaN@;0] ^ [1;-@Inf@] ; [@NaN@;0] ^ [1;@Inf@] ; [@NaN@;0] ^ [1;5] ; [@NaN@;0] ^ [1;1] ; [@NaN@;0] ^ [1;0] ; [@NaN@;0] ^ [0;@NaN@] ; [@NaN@;0] ^ [0;-@Inf@] ; [@NaN@;0] ^ [0;@Inf@] ; [@NaN@;0] ^ [0;5] ; [@NaN@;0] ^ [0;1] ; [@NaN@;0] ^ [0;0] ; [-@Inf@;@NaN@] ^ @NaN@ ; [-@Inf@;@NaN@] ^ -@Inf@ ; [-@Inf@;@NaN@] ^ @Inf@ ; [-@Inf@;@NaN@] ^ 5 ; [-@Inf@;@NaN@] ^ 1 ; [-@Inf@;@NaN@] ^ 0 ; [-@Inf@;@NaN@] ^ [@NaN@] ; [-@Inf@;@NaN@] ^ [-@Inf@] ; [-@Inf@;@NaN@] ^ [@Inf@] ; [-@Inf@;@NaN@] ^ [5] ; [-@Inf@;@NaN@] ^ [1] ; [-@Inf@;@NaN@] ^ [0] ; [-@Inf@;@NaN@] ^ [@NaN@;@NaN@] ; [-@Inf@;@NaN@] ^ [@NaN@;-@Inf@] ; [-@Inf@;@NaN@] ^ [@NaN@;@Inf@] ; [-@Inf@;@NaN@] ^ [@NaN@;5] ; [-@Inf@;@NaN@] ^ [@NaN@;1] ; [-@Inf@;@NaN@] ^ [@NaN@;0] ; [-@Inf@;@NaN@] ^ [-@Inf@;@NaN@] ; [-@Inf@;@NaN@] ^ [-@Inf@;-@Inf@] ; [-@Inf@;@NaN@] ^ [-@Inf@;@Inf@] ; [-@Inf@;@NaN@] ^ [-@Inf@;5] ; [-@Inf@;@NaN@] ^ [-@Inf@;1] ; [-@Inf@;@NaN@] ^ [-@Inf@;0] ; [-@Inf@;@NaN@] ^ [@Inf@;@NaN@] ; [-@Inf@;@NaN@] ^ [@Inf@;-@Inf@] ; [-@Inf@;@NaN@] ^ [@Inf@;@Inf@] ; [-@Inf@;@NaN@] ^ [@Inf@;5] ; [-@Inf@;@NaN@] ^ [@Inf@;1] ; [-@Inf@;@NaN@] ^ [@Inf@;0] ; [-@Inf@;@NaN@] ^ [5;@NaN@] ; [-@Inf@;@NaN@] ^ [5;-@Inf@] ; [-@Inf@;@NaN@] ^ [5;@Inf@] ; [-@Inf@;@NaN@] ^ [5;5] ; [-@Inf@;@NaN@] ^ [5;1] ; [-@Inf@;@NaN@] ^ [5;0] ; [-@Inf@;@NaN@] ^ [1;@NaN@] ; [-@Inf@;@NaN@] ^ [1;-@Inf@] ; [-@Inf@;@NaN@] ^ [1;@Inf@] ; [-@Inf@;@NaN@] ^ [1;5] ; [-@Inf@;@NaN@] ^ [1;1] ; [-@Inf@;@NaN@] ^ [1;0] ; [-@Inf@;@NaN@] ^ [0;@NaN@] ; [-@Inf@;@NaN@] ^ [0;-@Inf@] ; [-@Inf@;@NaN@] ^ [0;@Inf@] ; [-@Inf@;@NaN@] ^ [0;5] ; [-@Inf@;@NaN@] ^ [0;1] ; [-@Inf@;@NaN@] ^ [0;0] ; [-@Inf@;-@Inf@] ^ @NaN@ ; [-@Inf@;-@Inf@] ^ -@Inf@ ; [-@Inf@;-@Inf@] ^ @Inf@ ; [-@Inf@;-@Inf@] ^ 5 ; [-@Inf@;-@Inf@] ^ 1 ; [-@Inf@;-@Inf@] ^ 0 ; [-@Inf@;-@Inf@] ^ [@NaN@] ; [-@Inf@;-@Inf@] ^ [-@Inf@] ; [-@Inf@;-@Inf@] ^ [@Inf@] ; [-@Inf@;-@Inf@] ^ [5] ; [-@Inf@;-@Inf@] ^ [1] ; [-@Inf@;-@Inf@] ^ [0] ; [-@Inf@;-@Inf@] ^ [@NaN@;@NaN@] ; [-@Inf@;-@Inf@] ^ [@NaN@;-@Inf@] ; [-@Inf@;-@Inf@] ^ [@NaN@;@Inf@] ; [-@Inf@;-@Inf@] ^ [@NaN@;5] ; [-@Inf@;-@Inf@] ^ [@NaN@;1] ; [-@Inf@;-@Inf@] ^ [@NaN@;0] ; [-@Inf@;-@Inf@] ^ [-@Inf@;@NaN@] ; [-@Inf@;-@Inf@] ^ [-@Inf@;-@Inf@] ; [-@Inf@;-@Inf@] ^ [-@Inf@;@Inf@] ; [-@Inf@;-@Inf@] ^ [-@Inf@;5] ; [-@Inf@;-@Inf@] ^ [-@Inf@;1] ; [-@Inf@;-@Inf@] ^ [-@Inf@;0] ; [-@Inf@;-@Inf@] ^ [@Inf@;@NaN@] ; [-@Inf@;-@Inf@] ^ [@Inf@;-@Inf@] ; [-@Inf@;-@Inf@] ^ [@Inf@;@Inf@] ; [-@Inf@;-@Inf@] ^ [@Inf@;5] ; [-@Inf@;-@Inf@] ^ [@Inf@;1] ; [-@Inf@;-@Inf@] ^ [@Inf@;0] ; [-@Inf@;-@Inf@] ^ [5;@NaN@] ; [-@Inf@;-@Inf@] ^ [5;-@Inf@] ; [-@Inf@;-@Inf@] ^ [5;@Inf@] ; [-@Inf@;-@Inf@] ^ [5;5] ; [-@Inf@;-@Inf@] ^ [5;1] ; [-@Inf@;-@Inf@] ^ [5;0] ; [-@Inf@;-@Inf@] ^ [1;@NaN@] ; [-@Inf@;-@Inf@] ^ [1;-@Inf@] ; [-@Inf@;-@Inf@] ^ [1;@Inf@] ; [-@Inf@;-@Inf@] ^ [1;5] ; [-@Inf@;-@Inf@] ^ [1;1] ; [-@Inf@;-@Inf@] ^ [1;0] ; [-@Inf@;-@Inf@] ^ [0;@NaN@] ; [-@Inf@;-@Inf@] ^ [0;-@Inf@] ; [-@Inf@;-@Inf@] ^ [0;@Inf@] ; [-@Inf@;-@Inf@] ^ [0;5] ; [-@Inf@;-@Inf@] ^ [0;1] ; [-@Inf@;-@Inf@] ^ [0;0] ; [-@Inf@;@Inf@] ^ @NaN@ ; [-@Inf@;@Inf@] ^ -@Inf@ ; [-@Inf@;@Inf@] ^ @Inf@ ; [-@Inf@;@Inf@] ^ 5 ; [-@Inf@;@Inf@] ^ 1 ; [-@Inf@;@Inf@] ^ 0 ; [-@Inf@;@Inf@] ^ [@NaN@] ; [-@Inf@;@Inf@] ^ [-@Inf@] ; [-@Inf@;@Inf@] ^ [@Inf@] ; [-@Inf@;@Inf@] ^ [5] ; [-@Inf@;@Inf@] ^ [1] ; [-@Inf@;@Inf@] ^ [0] ; [-@Inf@;@Inf@] ^ [@NaN@;@NaN@] ; [-@Inf@;@Inf@] ^ [@NaN@;-@Inf@] ; [-@Inf@;@Inf@] ^ [@NaN@;@Inf@] ; [-@Inf@;@Inf@] ^ [@NaN@;5] ; [-@Inf@;@Inf@] ^ [@NaN@;1] ; [-@Inf@;@Inf@] ^ [@NaN@;0] ; [-@Inf@;@Inf@] ^ [-@Inf@;@NaN@] ; [-@Inf@;@Inf@] ^ [-@Inf@;-@Inf@] ; [-@Inf@;@Inf@] ^ [-@Inf@;@Inf@] ; [-@Inf@;@Inf@] ^ [-@Inf@;5] ; [-@Inf@;@Inf@] ^ [-@Inf@;1] ; [-@Inf@;@Inf@] ^ [-@Inf@;0] ; [-@Inf@;@Inf@] ^ [@Inf@;@NaN@] ; [-@Inf@;@Inf@] ^ [@Inf@;-@Inf@] ; [-@Inf@;@Inf@] ^ [@Inf@;@Inf@] ; [-@Inf@;@Inf@] ^ [@Inf@;5] ; [-@Inf@;@Inf@] ^ [@Inf@;1] ; [-@Inf@;@Inf@] ^ [@Inf@;0] ; [-@Inf@;@Inf@] ^ [5;@NaN@] ; [-@Inf@;@Inf@] ^ [5;-@Inf@] ; [-@Inf@;@Inf@] ^ [5;@Inf@] ; [-@Inf@;@Inf@] ^ [5;5] ; [-@Inf@;@Inf@] ^ [5;1] ; [-@Inf@;@Inf@] ^ [5;0] ; [-@Inf@;@Inf@] ^ [1;@NaN@] ; [-@Inf@;@Inf@] ^ [1;-@Inf@] ; [-@Inf@;@Inf@] ^ [1;@Inf@] ; [-@Inf@;@Inf@] ^ [1;5] ; [-@Inf@;@Inf@] ^ [1;1] ; [-@Inf@;@Inf@] ^ [1;0] ; [-@Inf@;@Inf@] ^ [0;@NaN@] ; [-@Inf@;@Inf@] ^ [0;-@Inf@] ; [-@Inf@;@Inf@] ^ [0;@Inf@] ; [-@Inf@;@Inf@] ^ [0;5] ; [-@Inf@;@Inf@] ^ [0;1] ; [-@Inf@;@Inf@] ^ [0;0] ; [-@Inf@;5] ^ @NaN@ ; [-@Inf@;5] ^ -@Inf@ ; [-@Inf@;5] ^ @Inf@ ; [-@Inf@;5] ^ 5 ; [-@Inf@;5] ^ 1 ; [-@Inf@;5] ^ 0 ; [-@Inf@;5] ^ [@NaN@] ; [-@Inf@;5] ^ [-@Inf@] ; [-@Inf@;5] ^ [@Inf@] ; [-@Inf@;5] ^ [5] ; [-@Inf@;5] ^ [1] ; [-@Inf@;5] ^ [0] ; [-@Inf@;5] ^ [@NaN@;@NaN@] ; [-@Inf@;5] ^ [@NaN@;-@Inf@] ; [-@Inf@;5] ^ [@NaN@;@Inf@] ; [-@Inf@;5] ^ [@NaN@;5] ; [-@Inf@;5] ^ [@NaN@;1] ; [-@Inf@;5] ^ [@NaN@;0] ; [-@Inf@;5] ^ [-@Inf@;@NaN@] ; [-@Inf@;5] ^ [-@Inf@;-@Inf@] ; [-@Inf@;5] ^ [-@Inf@;@Inf@] ; [-@Inf@;5] ^ [-@Inf@;5] ; [-@Inf@;5] ^ [-@Inf@;1] ; [-@Inf@;5] ^ [-@Inf@;0] ; [-@Inf@;5] ^ [@Inf@;@NaN@] ; [-@Inf@;5] ^ [@Inf@;-@Inf@] ; [-@Inf@;5] ^ [@Inf@;@Inf@] ; [-@Inf@;5] ^ [@Inf@;5] ; [-@Inf@;5] ^ [@Inf@;1] ; [-@Inf@;5] ^ [@Inf@;0] ; [-@Inf@;5] ^ [5;@NaN@] ; [-@Inf@;5] ^ [5;-@Inf@] ; [-@Inf@;5] ^ [5;@Inf@] ; [-@Inf@;5] ^ [5;5] ; [-@Inf@;5] ^ [5;1] ; [-@Inf@;5] ^ [5;0] ; [-@Inf@;5] ^ [1;@NaN@] ; [-@Inf@;5] ^ [1;-@Inf@] ; [-@Inf@;5] ^ [1;@Inf@] ; [-@Inf@;5] ^ [1;5] ; [-@Inf@;5] ^ [1;1] ; [-@Inf@;5] ^ [1;0] ; [-@Inf@;5] ^ [0;@NaN@] ; [-@Inf@;5] ^ [0;-@Inf@] ; [-@Inf@;5] ^ [0;@Inf@] ; [-@Inf@;5] ^ [0;5] ; [-@Inf@;5] ^ [0;1] ; [-@Inf@;5] ^ [0;0] ; [-@Inf@;1] ^ @NaN@ ; [-@Inf@;1] ^ -@Inf@ ; [-@Inf@;1] ^ @Inf@ ; [-@Inf@;1] ^ 5 ; [-@Inf@;1] ^ 1 ; [-@Inf@;1] ^ 0 ; [-@Inf@;1] ^ [@NaN@] ; [-@Inf@;1] ^ [-@Inf@] ; [-@Inf@;1] ^ [@Inf@] ; [-@Inf@;1] ^ [5] ; [-@Inf@;1] ^ [1] ; [-@Inf@;1] ^ [0] ; [-@Inf@;1] ^ [@NaN@;@NaN@] ; [-@Inf@;1] ^ [@NaN@;-@Inf@] ; [-@Inf@;1] ^ [@NaN@;@Inf@] ; [-@Inf@;1] ^ [@NaN@;5] ; [-@Inf@;1] ^ [@NaN@;1] ; [-@Inf@;1] ^ [@NaN@;0] ; [-@Inf@;1] ^ [-@Inf@;@NaN@] ; [-@Inf@;1] ^ [-@Inf@;-@Inf@] ; [-@Inf@;1] ^ [-@Inf@;@Inf@] ; [-@Inf@;1] ^ [-@Inf@;5] ; [-@Inf@;1] ^ [-@Inf@;1] ; [-@Inf@;1] ^ [-@Inf@;0] ; [-@Inf@;1] ^ [@Inf@;@NaN@] ; [-@Inf@;1] ^ [@Inf@;-@Inf@] ; [-@Inf@;1] ^ [@Inf@;@Inf@] ; [-@Inf@;1] ^ [@Inf@;5] ; [-@Inf@;1] ^ [@Inf@;1] ; [-@Inf@;1] ^ [@Inf@;0] ; [-@Inf@;1] ^ [5;@NaN@] ; [-@Inf@;1] ^ [5;-@Inf@] ; [-@Inf@;1] ^ [5;@Inf@] ; [-@Inf@;1] ^ [5;5] ; [-@Inf@;1] ^ [5;1] ; [-@Inf@;1] ^ [5;0] ; [-@Inf@;1] ^ [1;@NaN@] ; [-@Inf@;1] ^ [1;-@Inf@] ; [-@Inf@;1] ^ [1;@Inf@] ; [-@Inf@;1] ^ [1;5] ; [-@Inf@;1] ^ [1;1] ; [-@Inf@;1] ^ [1;0] ; [-@Inf@;1] ^ [0;@NaN@] ; [-@Inf@;1] ^ [0;-@Inf@] ; [-@Inf@;1] ^ [0;@Inf@] ; [-@Inf@;1] ^ [0;5] ; [-@Inf@;1] ^ [0;1] ; [-@Inf@;1] ^ [0;0] ; [-@Inf@;0] ^ @NaN@ ; [-@Inf@;0] ^ -@Inf@ ; [-@Inf@;0] ^ @Inf@ ; [-@Inf@;0] ^ 5 ; [-@Inf@;0] ^ 1 ; [-@Inf@;0] ^ 0 ; [-@Inf@;0] ^ [@NaN@] ; [-@Inf@;0] ^ [-@Inf@] ; [-@Inf@;0] ^ [@Inf@] ; [-@Inf@;0] ^ [5] ; [-@Inf@;0] ^ [1] ; [-@Inf@;0] ^ [0] ; [-@Inf@;0] ^ [@NaN@;@NaN@] ; [-@Inf@;0] ^ [@NaN@;-@Inf@] ; [-@Inf@;0] ^ [@NaN@;@Inf@] ; [-@Inf@;0] ^ [@NaN@;5] ; [-@Inf@;0] ^ [@NaN@;1] ; [-@Inf@;0] ^ [@NaN@;0] ; [-@Inf@;0] ^ [-@Inf@;@NaN@] ; [-@Inf@;0] ^ [-@Inf@;-@Inf@] ; [-@Inf@;0] ^ [-@Inf@;@Inf@] ; [-@Inf@;0] ^ [-@Inf@;5] ; [-@Inf@;0] ^ [-@Inf@;1] ; [-@Inf@;0] ^ [-@Inf@;0] ; [-@Inf@;0] ^ [@Inf@;@NaN@] ; [-@Inf@;0] ^ [@Inf@;-@Inf@] ; [-@Inf@;0] ^ [@Inf@;@Inf@] ; [-@Inf@;0] ^ [@Inf@;5] ; [-@Inf@;0] ^ [@Inf@;1] ; [-@Inf@;0] ^ [@Inf@;0] ; [-@Inf@;0] ^ [5;@NaN@] ; [-@Inf@;0] ^ [5;-@Inf@] ; [-@Inf@;0] ^ [5;@Inf@] ; [-@Inf@;0] ^ [5;5] ; [-@Inf@;0] ^ [5;1] ; [-@Inf@;0] ^ [5;0] ; [-@Inf@;0] ^ [1;@NaN@] ; [-@Inf@;0] ^ [1;-@Inf@] ; [-@Inf@;0] ^ [1;@Inf@] ; [-@Inf@;0] ^ [1;5] ; [-@Inf@;0] ^ [1;1] ; [-@Inf@;0] ^ [1;0] ; [-@Inf@;0] ^ [0;@NaN@] ; [-@Inf@;0] ^ [0;-@Inf@] ; [-@Inf@;0] ^ [0;@Inf@] ; [-@Inf@;0] ^ [0;5] ; [-@Inf@;0] ^ [0;1] ; [-@Inf@;0] ^ [0;0] ; [@Inf@;@NaN@] ^ @NaN@ ; [@Inf@;@NaN@] ^ -@Inf@ ; [@Inf@;@NaN@] ^ @Inf@ ; [@Inf@;@NaN@] ^ 5 ; [@Inf@;@NaN@] ^ 1 ; [@Inf@;@NaN@] ^ 0 ; [@Inf@;@NaN@] ^ [@NaN@] ; [@Inf@;@NaN@] ^ [-@Inf@] ; [@Inf@;@NaN@] ^ [@Inf@] ; [@Inf@;@NaN@] ^ [5] ; [@Inf@;@NaN@] ^ [1] ; [@Inf@;@NaN@] ^ [0] ; [@Inf@;@NaN@] ^ [@NaN@;@NaN@] ; [@Inf@;@NaN@] ^ [@NaN@;-@Inf@] ; [@Inf@;@NaN@] ^ [@NaN@;@Inf@] ; [@Inf@;@NaN@] ^ [@NaN@;5] ; [@Inf@;@NaN@] ^ [@NaN@;1] ; [@Inf@;@NaN@] ^ [@NaN@;0] ; [@Inf@;@NaN@] ^ [-@Inf@;@NaN@] ; [@Inf@;@NaN@] ^ [-@Inf@;-@Inf@] ; [@Inf@;@NaN@] ^ [-@Inf@;@Inf@] ; [@Inf@;@NaN@] ^ [-@Inf@;5] ; [@Inf@;@NaN@] ^ [-@Inf@;1] ; [@Inf@;@NaN@] ^ [-@Inf@;0] ; [@Inf@;@NaN@] ^ [@Inf@;@NaN@] ; [@Inf@;@NaN@] ^ [@Inf@;-@Inf@] ; [@Inf@;@NaN@] ^ [@Inf@;@Inf@] ; [@Inf@;@NaN@] ^ [@Inf@;5] ; [@Inf@;@NaN@] ^ [@Inf@;1] ; [@Inf@;@NaN@] ^ [@Inf@;0] ; [@Inf@;@NaN@] ^ [5;@NaN@] ; [@Inf@;@NaN@] ^ [5;-@Inf@] ; [@Inf@;@NaN@] ^ [5;@Inf@] ; [@Inf@;@NaN@] ^ [5;5] ; [@Inf@;@NaN@] ^ [5;1] ; [@Inf@;@NaN@] ^ [5;0] ; [@Inf@;@NaN@] ^ [1;@NaN@] ; [@Inf@;@NaN@] ^ [1;-@Inf@] ; [@Inf@;@NaN@] ^ [1;@Inf@] ; [@Inf@;@NaN@] ^ [1;5] ; [@Inf@;@NaN@] ^ [1;1] ; [@Inf@;@NaN@] ^ [1;0] ; [@Inf@;@NaN@] ^ [0;@NaN@] ; [@Inf@;@NaN@] ^ [0;-@Inf@] ; [@Inf@;@NaN@] ^ [0;@Inf@] ; [@Inf@;@NaN@] ^ [0;5] ; [@Inf@;@NaN@] ^ [0;1] ; [@Inf@;@NaN@] ^ [0;0] ; [@Inf@;-@Inf@] ^ @NaN@ ; [@Inf@;-@Inf@] ^ -@Inf@ ; [@Inf@;-@Inf@] ^ @Inf@ ; [@Inf@;-@Inf@] ^ 5 ; [@Inf@;-@Inf@] ^ 1 ; [@Inf@;-@Inf@] ^ 0 ; [@Inf@;-@Inf@] ^ [@NaN@] ; [@Inf@;-@Inf@] ^ [-@Inf@] ; [@Inf@;-@Inf@] ^ [@Inf@] ; [@Inf@;-@Inf@] ^ [5] ; [@Inf@;-@Inf@] ^ [1] ; [@Inf@;-@Inf@] ^ [0] ; [@Inf@;-@Inf@] ^ [@NaN@;@NaN@] ; [@Inf@;-@Inf@] ^ [@NaN@;-@Inf@] ; [@Inf@;-@Inf@] ^ [@NaN@;@Inf@] ; [@Inf@;-@Inf@] ^ [@NaN@;5] ; [@Inf@;-@Inf@] ^ [@NaN@;1] ; [@Inf@;-@Inf@] ^ [@NaN@;0] ; [@Inf@;-@Inf@] ^ [-@Inf@;@NaN@] ; [@Inf@;-@Inf@] ^ [-@Inf@;-@Inf@] ; [@Inf@;-@Inf@] ^ [-@Inf@;@Inf@] ; [@Inf@;-@Inf@] ^ [-@Inf@;5] ; [@Inf@;-@Inf@] ^ [-@Inf@;1] ; [@Inf@;-@Inf@] ^ [-@Inf@;0] ; [@Inf@;-@Inf@] ^ [@Inf@;@NaN@] ; [@Inf@;-@Inf@] ^ [@Inf@;-@Inf@] ; [@Inf@;-@Inf@] ^ [@Inf@;@Inf@] ; [@Inf@;-@Inf@] ^ [@Inf@;5] ; [@Inf@;-@Inf@] ^ [@Inf@;1] ; [@Inf@;-@Inf@] ^ [@Inf@;0] ; [@Inf@;-@Inf@] ^ [5;@NaN@] ; [@Inf@;-@Inf@] ^ [5;-@Inf@] ; [@Inf@;-@Inf@] ^ [5;@Inf@] ; [@Inf@;-@Inf@] ^ [5;5] ; [@Inf@;-@Inf@] ^ [5;1] ; [@Inf@;-@Inf@] ^ [5;0] ; [@Inf@;-@Inf@] ^ [1;@NaN@] ; [@Inf@;-@Inf@] ^ [1;-@Inf@] ; [@Inf@;-@Inf@] ^ [1;@Inf@] ; [@Inf@;-@Inf@] ^ [1;5] ; [@Inf@;-@Inf@] ^ [1;1] ; [@Inf@;-@Inf@] ^ [1;0] ; [@Inf@;-@Inf@] ^ [0;@NaN@] ; [@Inf@;-@Inf@] ^ [0;-@Inf@] ; [@Inf@;-@Inf@] ^ [0;@Inf@] ; [@Inf@;-@Inf@] ^ [0;5] ; [@Inf@;-@Inf@] ^ [0;1] ; [@Inf@;-@Inf@] ^ [0;0] ; [@Inf@;@Inf@] ^ @NaN@ ; [@Inf@;@Inf@] ^ -@Inf@ ; [@Inf@;@Inf@] ^ @Inf@ ; [@Inf@;@Inf@] ^ 5 ; [@Inf@;@Inf@] ^ 1 ; [@Inf@;@Inf@] ^ 0 ; [@Inf@;@Inf@] ^ [@NaN@] ; [@Inf@;@Inf@] ^ [-@Inf@] ; [@Inf@;@Inf@] ^ [@Inf@] ; [@Inf@;@Inf@] ^ [5] ; [@Inf@;@Inf@] ^ [1] ; [@Inf@;@Inf@] ^ [0] ; [@Inf@;@Inf@] ^ [@NaN@;@NaN@] ; [@Inf@;@Inf@] ^ [@NaN@;-@Inf@] ; [@Inf@;@Inf@] ^ [@NaN@;@Inf@] ; [@Inf@;@Inf@] ^ [@NaN@;5] ; [@Inf@;@Inf@] ^ [@NaN@;1] ; [@Inf@;@Inf@] ^ [@NaN@;0] ; [@Inf@;@Inf@] ^ [-@Inf@;@NaN@] ; [@Inf@;@Inf@] ^ [-@Inf@;-@Inf@] ; [@Inf@;@Inf@] ^ [-@Inf@;@Inf@] ; [@Inf@;@Inf@] ^ [-@Inf@;5] ; [@Inf@;@Inf@] ^ [-@Inf@;1] ; [@Inf@;@Inf@] ^ [-@Inf@;0] ; [@Inf@;@Inf@] ^ [@Inf@;@NaN@] ; [@Inf@;@Inf@] ^ [@Inf@;-@Inf@] ; [@Inf@;@Inf@] ^ [@Inf@;@Inf@] ; [@Inf@;@Inf@] ^ [@Inf@;5] ; [@Inf@;@Inf@] ^ [@Inf@;1] ; [@Inf@;@Inf@] ^ [@Inf@;0] ; [@Inf@;@Inf@] ^ [5;@NaN@] ; [@Inf@;@Inf@] ^ [5;-@Inf@] ; [@Inf@;@Inf@] ^ [5;@Inf@] ; [@Inf@;@Inf@] ^ [5;5] ; [@Inf@;@Inf@] ^ [5;1] ; [@Inf@;@Inf@] ^ [5;0] ; [@Inf@;@Inf@] ^ [1;@NaN@] ; [@Inf@;@Inf@] ^ [1;-@Inf@] ; [@Inf@;@Inf@] ^ [1;@Inf@] ; [@Inf@;@Inf@] ^ [1;5] ; [@Inf@;@Inf@] ^ [1;1] ; [@Inf@;@Inf@] ^ [1;0] ; [@Inf@;@Inf@] ^ [0;@NaN@] ; [@Inf@;@Inf@] ^ [0;-@Inf@] ; [@Inf@;@Inf@] ^ [0;@Inf@] ; [@Inf@;@Inf@] ^ [0;5] ; [@Inf@;@Inf@] ^ [0;1] ; [@Inf@;@Inf@] ^ [0;0] ; [@Inf@;5] ^ @NaN@ ; [@Inf@;5] ^ -@Inf@ ; [@Inf@;5] ^ @Inf@ ; [@Inf@;5] ^ 5 ; [@Inf@;5] ^ 1 ; [@Inf@;5] ^ 0 ; [@Inf@;5] ^ [@NaN@] ; [@Inf@;5] ^ [-@Inf@] ; [@Inf@;5] ^ [@Inf@] ; [@Inf@;5] ^ [5] ; [@Inf@;5] ^ [1] ; [@Inf@;5] ^ [0] ; [@Inf@;5] ^ [@NaN@;@NaN@] ; [@Inf@;5] ^ [@NaN@;-@Inf@] ; [@Inf@;5] ^ [@NaN@;@Inf@] ; [@Inf@;5] ^ [@NaN@;5] ; [@Inf@;5] ^ [@NaN@;1] ; [@Inf@;5] ^ [@NaN@;0] ; [@Inf@;5] ^ [-@Inf@;@NaN@] ; [@Inf@;5] ^ [-@Inf@;-@Inf@] ; [@Inf@;5] ^ [-@Inf@;@Inf@] ; [@Inf@;5] ^ [-@Inf@;5] ; [@Inf@;5] ^ [-@Inf@;1] ; [@Inf@;5] ^ [-@Inf@;0] ; [@Inf@;5] ^ [@Inf@;@NaN@] ; [@Inf@;5] ^ [@Inf@;-@Inf@] ; [@Inf@;5] ^ [@Inf@;@Inf@] ; [@Inf@;5] ^ [@Inf@;5] ; [@Inf@;5] ^ [@Inf@;1] ; [@Inf@;5] ^ [@Inf@;0] ; [@Inf@;5] ^ [5;@NaN@] ; [@Inf@;5] ^ [5;-@Inf@] ; [@Inf@;5] ^ [5;@Inf@] ; [@Inf@;5] ^ [5;5] ; [@Inf@;5] ^ [5;1] ; [@Inf@;5] ^ [5;0] ; [@Inf@;5] ^ [1;@NaN@] ; [@Inf@;5] ^ [1;-@Inf@] ; [@Inf@;5] ^ [1;@Inf@] ; [@Inf@;5] ^ [1;5] ; [@Inf@;5] ^ [1;1] ; [@Inf@;5] ^ [1;0] ; [@Inf@;5] ^ [0;@NaN@] ; [@Inf@;5] ^ [0;-@Inf@] ; [@Inf@;5] ^ [0;@Inf@] ; [@Inf@;5] ^ [0;5] ; [@Inf@;5] ^ [0;1] ; [@Inf@;5] ^ [0;0] ; [@Inf@;1] ^ @NaN@ ; [@Inf@;1] ^ -@Inf@ ; [@Inf@;1] ^ @Inf@ ; [@Inf@;1] ^ 5 ; [@Inf@;1] ^ 1 ; [@Inf@;1] ^ 0 ; [@Inf@;1] ^ [@NaN@] ; [@Inf@;1] ^ [-@Inf@] ; [@Inf@;1] ^ [@Inf@] ; [@Inf@;1] ^ [5] ; [@Inf@;1] ^ [1] ; [@Inf@;1] ^ [0] ; [@Inf@;1] ^ [@NaN@;@NaN@] ; [@Inf@;1] ^ [@NaN@;-@Inf@] ; [@Inf@;1] ^ [@NaN@;@Inf@] ; [@Inf@;1] ^ [@NaN@;5] ; [@Inf@;1] ^ [@NaN@;1] ; [@Inf@;1] ^ [@NaN@;0] ; [@Inf@;1] ^ [-@Inf@;@NaN@] ; [@Inf@;1] ^ [-@Inf@;-@Inf@] ; [@Inf@;1] ^ [-@Inf@;@Inf@] ; [@Inf@;1] ^ [-@Inf@;5] ; [@Inf@;1] ^ [-@Inf@;1] ; [@Inf@;1] ^ [-@Inf@;0] ; [@Inf@;1] ^ [@Inf@;@NaN@] ; [@Inf@;1] ^ [@Inf@;-@Inf@] ; [@Inf@;1] ^ [@Inf@;@Inf@] ; [@Inf@;1] ^ [@Inf@;5] ; [@Inf@;1] ^ [@Inf@;1] ; [@Inf@;1] ^ [@Inf@;0] ; [@Inf@;1] ^ [5;@NaN@] ; [@Inf@;1] ^ [5;-@Inf@] ; [@Inf@;1] ^ [5;@Inf@] ; [@Inf@;1] ^ [5;5] ; [@Inf@;1] ^ [5;1] ; [@Inf@;1] ^ [5;0] ; [@Inf@;1] ^ [1;@NaN@] ; [@Inf@;1] ^ [1;-@Inf@] ; [@Inf@;1] ^ [1;@Inf@] ; [@Inf@;1] ^ [1;5] ; [@Inf@;1] ^ [1;1] ; [@Inf@;1] ^ [1;0] ; [@Inf@;1] ^ [0;@NaN@] ; [@Inf@;1] ^ [0;-@Inf@] ; [@Inf@;1] ^ [0;@Inf@] ; [@Inf@;1] ^ [0;5] ; [@Inf@;1] ^ [0;1] ; [@Inf@;1] ^ [0;0] ; [@Inf@;0] ^ @NaN@ ; [@Inf@;0] ^ -@Inf@ ; [@Inf@;0] ^ @Inf@ ; [@Inf@;0] ^ 5 ; [@Inf@;0] ^ 1 ; [@Inf@;0] ^ 0 ; [@Inf@;0] ^ [@NaN@] ; [@Inf@;0] ^ [-@Inf@] ; [@Inf@;0] ^ [@Inf@] ; [@Inf@;0] ^ [5] ; [@Inf@;0] ^ [1] ; [@Inf@;0] ^ [0] ; [@Inf@;0] ^ [@NaN@;@NaN@] ; [@Inf@;0] ^ [@NaN@;-@Inf@] ; [@Inf@;0] ^ [@NaN@;@Inf@] ; [@Inf@;0] ^ [@NaN@;5] ; [@Inf@;0] ^ [@NaN@;1] ; [@Inf@;0] ^ [@NaN@;0] ; [@Inf@;0] ^ [-@Inf@;@NaN@] ; [@Inf@;0] ^ [-@Inf@;-@Inf@] ; [@Inf@;0] ^ [-@Inf@;@Inf@] ; [@Inf@;0] ^ [-@Inf@;5] ; [@Inf@;0] ^ [-@Inf@;1] ; [@Inf@;0] ^ [-@Inf@;0] ; [@Inf@;0] ^ [@Inf@;@NaN@] ; [@Inf@;0] ^ [@Inf@;-@Inf@] ; [@Inf@;0] ^ [@Inf@;@Inf@] ; [@Inf@;0] ^ [@Inf@;5] ; [@Inf@;0] ^ [@Inf@;1] ; [@Inf@;0] ^ [@Inf@;0] ; [@Inf@;0] ^ [5;@NaN@] ; [@Inf@;0] ^ [5;-@Inf@] ; [@Inf@;0] ^ [5;@Inf@] ; [@Inf@;0] ^ [5;5] ; [@Inf@;0] ^ [5;1] ; [@Inf@;0] ^ [5;0] ; [@Inf@;0] ^ [1;@NaN@] ; [@Inf@;0] ^ [1;-@Inf@] ; [@Inf@;0] ^ [1;@Inf@] ; [@Inf@;0] ^ [1;5] ; [@Inf@;0] ^ [1;1] ; [@Inf@;0] ^ [1;0] ; [@Inf@;0] ^ [0;@NaN@] ; [@Inf@;0] ^ [0;-@Inf@] ; [@Inf@;0] ^ [0;@Inf@] ; [@Inf@;0] ^ [0;5] ; [@Inf@;0] ^ [0;1] ; [@Inf@;0] ^ [0;0] ; [5;@NaN@] ^ @NaN@ ; [5;@NaN@] ^ -@Inf@ ; [5;@NaN@] ^ @Inf@ ; [5;@NaN@] ^ 5 ; [5;@NaN@] ^ 1 ; [5;@NaN@] ^ 0 ; [5;@NaN@] ^ [@NaN@] ; [5;@NaN@] ^ [-@Inf@] ; [5;@NaN@] ^ [@Inf@] ; [5;@NaN@] ^ [5] ; [5;@NaN@] ^ [1] ; [5;@NaN@] ^ [0] ; [5;@NaN@] ^ [@NaN@;@NaN@] ; [5;@NaN@] ^ [@NaN@;-@Inf@] ; [5;@NaN@] ^ [@NaN@;@Inf@] ; [5;@NaN@] ^ [@NaN@;5] ; [5;@NaN@] ^ [@NaN@;1] ; [5;@NaN@] ^ [@NaN@;0] ; [5;@NaN@] ^ [-@Inf@;@NaN@] ; [5;@NaN@] ^ [-@Inf@;-@Inf@] ; [5;@NaN@] ^ [-@Inf@;@Inf@] ; [5;@NaN@] ^ [-@Inf@;5] ; [5;@NaN@] ^ [-@Inf@;1] ; [5;@NaN@] ^ [-@Inf@;0] ; [5;@NaN@] ^ [@Inf@;@NaN@] ; [5;@NaN@] ^ [@Inf@;-@Inf@] ; [5;@NaN@] ^ [@Inf@;@Inf@] ; [5;@NaN@] ^ [@Inf@;5] ; [5;@NaN@] ^ [@Inf@;1] ; [5;@NaN@] ^ [@Inf@;0] ; [5;@NaN@] ^ [5;@NaN@] ; [5;@NaN@] ^ [5;-@Inf@] ; [5;@NaN@] ^ [5;@Inf@] ; [5;@NaN@] ^ [5;5] ; [5;@NaN@] ^ [5;1] ; [5;@NaN@] ^ [5;0] ; [5;@NaN@] ^ [1;@NaN@] ; [5;@NaN@] ^ [1;-@Inf@] ; [5;@NaN@] ^ [1;@Inf@] ; [5;@NaN@] ^ [1;5] ; [5;@NaN@] ^ [1;1] ; [5;@NaN@] ^ [1;0] ; [5;@NaN@] ^ [0;@NaN@] ; [5;@NaN@] ^ [0;-@Inf@] ; [5;@NaN@] ^ [0;@Inf@] ; [5;@NaN@] ^ [0;5] ; [5;@NaN@] ^ [0;1] ; [5;@NaN@] ^ [0;0] ; [5;-@Inf@] ^ @NaN@ ; [5;-@Inf@] ^ -@Inf@ ; [5;-@Inf@] ^ @Inf@ ; [5;-@Inf@] ^ 5 ; [5;-@Inf@] ^ 1 ; [5;-@Inf@] ^ 0 ; [5;-@Inf@] ^ [@NaN@] ; [5;-@Inf@] ^ [-@Inf@] ; [5;-@Inf@] ^ [@Inf@] ; [5;-@Inf@] ^ [5] ; [5;-@Inf@] ^ [1] ; [5;-@Inf@] ^ [0] ; [5;-@Inf@] ^ [@NaN@;@NaN@] ; [5;-@Inf@] ^ [@NaN@;-@Inf@] ; [5;-@Inf@] ^ [@NaN@;@Inf@] ; [5;-@Inf@] ^ [@NaN@;5] ; [5;-@Inf@] ^ [@NaN@;1] ; [5;-@Inf@] ^ [@NaN@;0] ; [5;-@Inf@] ^ [-@Inf@;@NaN@] ; [5;-@Inf@] ^ [-@Inf@;-@Inf@] ; [5;-@Inf@] ^ [-@Inf@;@Inf@] ; [5;-@Inf@] ^ [-@Inf@;5] ; [5;-@Inf@] ^ [-@Inf@;1] ; [5;-@Inf@] ^ [-@Inf@;0] ; [5;-@Inf@] ^ [@Inf@;@NaN@] ; [5;-@Inf@] ^ [@Inf@;-@Inf@] ; [5;-@Inf@] ^ [@Inf@;@Inf@] ; [5;-@Inf@] ^ [@Inf@;5] ; [5;-@Inf@] ^ [@Inf@;1] ; [5;-@Inf@] ^ [@Inf@;0] ; [5;-@Inf@] ^ [5;@NaN@] ; [5;-@Inf@] ^ [5;-@Inf@] ; [5;-@Inf@] ^ [5;@Inf@] ; [5;-@Inf@] ^ [5;5] ; [5;-@Inf@] ^ [5;1] ; [5;-@Inf@] ^ [5;0] ; [5;-@Inf@] ^ [1;@NaN@] ; [5;-@Inf@] ^ [1;-@Inf@] ; [5;-@Inf@] ^ [1;@Inf@] ; [5;-@Inf@] ^ [1;5] ; [5;-@Inf@] ^ [1;1] ; [5;-@Inf@] ^ [1;0] ; [5;-@Inf@] ^ [0;@NaN@] ; [5;-@Inf@] ^ [0;-@Inf@] ; [5;-@Inf@] ^ [0;@Inf@] ; [5;-@Inf@] ^ [0;5] ; [5;-@Inf@] ^ [0;1] ; [5;-@Inf@] ^ [0;0] ; [5;@Inf@] ^ @NaN@ ; [5;@Inf@] ^ -@Inf@ ; [5;@Inf@] ^ @Inf@ ; [5;@Inf@] ^ 5 ; [5;@Inf@] ^ 1 ; [5;@Inf@] ^ 0 ; [5;@Inf@] ^ [@NaN@] ; [5;@Inf@] ^ [-@Inf@] ; [5;@Inf@] ^ [@Inf@] ; [5;@Inf@] ^ [5] ; [5;@Inf@] ^ [1] ; [5;@Inf@] ^ [0] ; [5;@Inf@] ^ [@NaN@;@NaN@] ; [5;@Inf@] ^ [@NaN@;-@Inf@] ; [5;@Inf@] ^ [@NaN@;@Inf@] ; [5;@Inf@] ^ [@NaN@;5] ; [5;@Inf@] ^ [@NaN@;1] ; [5;@Inf@] ^ [@NaN@;0] ; [5;@Inf@] ^ [-@Inf@;@NaN@] ; [5;@Inf@] ^ [-@Inf@;-@Inf@] ; [5;@Inf@] ^ [-@Inf@;@Inf@] ; [5;@Inf@] ^ [-@Inf@;5] ; [5;@Inf@] ^ [-@Inf@;1] ; [5;@Inf@] ^ [-@Inf@;0] ; [5;@Inf@] ^ [@Inf@;@NaN@] ; [5;@Inf@] ^ [@Inf@;-@Inf@] ; [5;@Inf@] ^ [@Inf@;@Inf@] ; [5;@Inf@] ^ [@Inf@;5] ; [5;@Inf@] ^ [@Inf@;1] ; [5;@Inf@] ^ [@Inf@;0] ; [5;@Inf@] ^ [5;@NaN@] ; [5;@Inf@] ^ [5;-@Inf@] ; [5;@Inf@] ^ [5;@Inf@] ; [5;@Inf@] ^ [5;5] ; [5;@Inf@] ^ [5;1] ; [5;@Inf@] ^ [5;0] ; [5;@Inf@] ^ [1;@NaN@] ; [5;@Inf@] ^ [1;-@Inf@] ; [5;@Inf@] ^ [1;@Inf@] ; [5;@Inf@] ^ [1;5] ; [5;@Inf@] ^ [1;1] ; [5;@Inf@] ^ [1;0] ; [5;@Inf@] ^ [0;@NaN@] ; [5;@Inf@] ^ [0;-@Inf@] ; [5;@Inf@] ^ [0;@Inf@] ; [5;@Inf@] ^ [0;5] ; [5;@Inf@] ^ [0;1] ; [5;@Inf@] ^ [0;0] ; [5;5] ^ @NaN@ ; [5;5] ^ -@Inf@ ; [5;5] ^ @Inf@ ; [5;5] ^ 5 ; [5;5] ^ 1 ; [5;5] ^ 0 ; [5;5] ^ [@NaN@] ; [5;5] ^ [-@Inf@] ; [5;5] ^ [@Inf@] ; [5;5] ^ [5] ; [5;5] ^ [1] ; [5;5] ^ [0] ; [5;5] ^ [@NaN@;@NaN@] ; [5;5] ^ [@NaN@;-@Inf@] ; [5;5] ^ [@NaN@;@Inf@] ; [5;5] ^ [@NaN@;5] ; [5;5] ^ [@NaN@;1] ; [5;5] ^ [@NaN@;0] ; [5;5] ^ [-@Inf@;@NaN@] ; [5;5] ^ [-@Inf@;-@Inf@] ; [5;5] ^ [-@Inf@;@Inf@] ; [5;5] ^ [-@Inf@;5] ; [5;5] ^ [-@Inf@;1] ; [5;5] ^ [-@Inf@;0] ; [5;5] ^ [@Inf@;@NaN@] ; [5;5] ^ [@Inf@;-@Inf@] ; [5;5] ^ [@Inf@;@Inf@] ; [5;5] ^ [@Inf@;5] ; [5;5] ^ [@Inf@;1] ; [5;5] ^ [@Inf@;0] ; [5;5] ^ [5;@NaN@] ; [5;5] ^ [5;-@Inf@] ; [5;5] ^ [5;@Inf@] ; [5;5] ^ [5;5] ; [5;5] ^ [5;1] ; [5;5] ^ [5;0] ; [5;5] ^ [1;@NaN@] ; [5;5] ^ [1;-@Inf@] ; [5;5] ^ [1;@Inf@] ; [5;5] ^ [1;5] ; [5;5] ^ [1;1] ; [5;5] ^ [1;0] ; [5;5] ^ [0;@NaN@] ; [5;5] ^ [0;-@Inf@] ; [5;5] ^ [0;@Inf@] ; [5;5] ^ [0;5] ; [5;5] ^ [0;1] ; [5;5] ^ [0;0] ; [5;1] ^ @NaN@ ; [5;1] ^ -@Inf@ ; [5;1] ^ @Inf@ ; [5;1] ^ 5 ; [5;1] ^ 1 ; [5;1] ^ 0 ; [5;1] ^ [@NaN@] ; [5;1] ^ [-@Inf@] ; [5;1] ^ [@Inf@] ; [5;1] ^ [5] ; [5;1] ^ [1] ; [5;1] ^ [0] ; [5;1] ^ [@NaN@;@NaN@] ; [5;1] ^ [@NaN@;-@Inf@] ; [5;1] ^ [@NaN@;@Inf@] ; [5;1] ^ [@NaN@;5] ; [5;1] ^ [@NaN@;1] ; [5;1] ^ [@NaN@;0] ; [5;1] ^ [-@Inf@;@NaN@] ; [5;1] ^ [-@Inf@;-@Inf@] ; [5;1] ^ [-@Inf@;@Inf@] ; [5;1] ^ [-@Inf@;5] ; [5;1] ^ [-@Inf@;1] ; [5;1] ^ [-@Inf@;0] ; [5;1] ^ [@Inf@;@NaN@] ; [5;1] ^ [@Inf@;-@Inf@] ; [5;1] ^ [@Inf@;@Inf@] ; [5;1] ^ [@Inf@;5] ; [5;1] ^ [@Inf@;1] ; [5;1] ^ [@Inf@;0] ; [5;1] ^ [5;@NaN@] ; [5;1] ^ [5;-@Inf@] ; [5;1] ^ [5;@Inf@] ; [5;1] ^ [5;5] ; [5;1] ^ [5;1] ; [5;1] ^ [5;0] ; [5;1] ^ [1;@NaN@] ; [5;1] ^ [1;-@Inf@] ; [5;1] ^ [1;@Inf@] ; [5;1] ^ [1;5] ; [5;1] ^ [1;1] ; [5;1] ^ [1;0] ; [5;1] ^ [0;@NaN@] ; [5;1] ^ [0;-@Inf@] ; [5;1] ^ [0;@Inf@] ; [5;1] ^ [0;5] ; [5;1] ^ [0;1] ; [5;1] ^ [0;0] ; [5;0] ^ @NaN@ ; [5;0] ^ -@Inf@ ; [5;0] ^ @Inf@ ; [5;0] ^ 5 ; [5;0] ^ 1 ; [5;0] ^ 0 ; [5;0] ^ [@NaN@] ; [5;0] ^ [-@Inf@] ; [5;0] ^ [@Inf@] ; [5;0] ^ [5] ; [5;0] ^ [1] ; [5;0] ^ [0] ; [5;0] ^ [@NaN@;@NaN@] ; [5;0] ^ [@NaN@;-@Inf@] ; [5;0] ^ [@NaN@;@Inf@] ; [5;0] ^ [@NaN@;5] ; [5;0] ^ [@NaN@;1] ; [5;0] ^ [@NaN@;0] ; [5;0] ^ [-@Inf@;@NaN@] ; [5;0] ^ [-@Inf@;-@Inf@] ; [5;0] ^ [-@Inf@;@Inf@] ; [5;0] ^ [-@Inf@;5] ; [5;0] ^ [-@Inf@;1] ; [5;0] ^ [-@Inf@;0] ; [5;0] ^ [@Inf@;@NaN@] ; [5;0] ^ [@Inf@;-@Inf@] ; [5;0] ^ [@Inf@;@Inf@] ; [5;0] ^ [@Inf@;5] ; [5;0] ^ [@Inf@;1] ; [5;0] ^ [@Inf@;0] ; [5;0] ^ [5;@NaN@] ; [5;0] ^ [5;-@Inf@] ; [5;0] ^ [5;@Inf@] ; [5;0] ^ [5;5] ; [5;0] ^ [5;1] ; [5;0] ^ [5;0] ; [5;0] ^ [1;@NaN@] ; [5;0] ^ [1;-@Inf@] ; [5;0] ^ [1;@Inf@] ; [5;0] ^ [1;5] ; [5;0] ^ [1;1] ; [5;0] ^ [1;0] ; [5;0] ^ [0;@NaN@] ; [5;0] ^ [0;-@Inf@] ; [5;0] ^ [0;@Inf@] ; [5;0] ^ [0;5] ; [5;0] ^ [0;1] ; [5;0] ^ [0;0] ; [1;@NaN@] ^ @NaN@ ; [1;@NaN@] ^ -@Inf@ ; [1;@NaN@] ^ @Inf@ ; [1;@NaN@] ^ 5 ; [1;@NaN@] ^ 1 ; [1;@NaN@] ^ 0 ; [1;@NaN@] ^ [@NaN@] ; [1;@NaN@] ^ [-@Inf@] ; [1;@NaN@] ^ [@Inf@] ; [1;@NaN@] ^ [5] ; [1;@NaN@] ^ [1] ; [1;@NaN@] ^ [0] ; [1;@NaN@] ^ [@NaN@;@NaN@] ; [1;@NaN@] ^ [@NaN@;-@Inf@] ; [1;@NaN@] ^ [@NaN@;@Inf@] ; [1;@NaN@] ^ [@NaN@;5] ; [1;@NaN@] ^ [@NaN@;1] ; [1;@NaN@] ^ [@NaN@;0] ; [1;@NaN@] ^ [-@Inf@;@NaN@] ; [1;@NaN@] ^ [-@Inf@;-@Inf@] ; [1;@NaN@] ^ [-@Inf@;@Inf@] ; [1;@NaN@] ^ [-@Inf@;5] ; [1;@NaN@] ^ [-@Inf@;1] ; [1;@NaN@] ^ [-@Inf@;0] ; [1;@NaN@] ^ [@Inf@;@NaN@] ; [1;@NaN@] ^ [@Inf@;-@Inf@] ; [1;@NaN@] ^ [@Inf@;@Inf@] ; [1;@NaN@] ^ [@Inf@;5] ; [1;@NaN@] ^ [@Inf@;1] ; [1;@NaN@] ^ [@Inf@;0] ; [1;@NaN@] ^ [5;@NaN@] ; [1;@NaN@] ^ [5;-@Inf@] ; [1;@NaN@] ^ [5;@Inf@] ; [1;@NaN@] ^ [5;5] ; [1;@NaN@] ^ [5;1] ; [1;@NaN@] ^ [5;0] ; [1;@NaN@] ^ [1;@NaN@] ; [1;@NaN@] ^ [1;-@Inf@] ; [1;@NaN@] ^ [1;@Inf@] ; [1;@NaN@] ^ [1;5] ; [1;@NaN@] ^ [1;1] ; [1;@NaN@] ^ [1;0] ; [1;@NaN@] ^ [0;@NaN@] ; [1;@NaN@] ^ [0;-@Inf@] ; [1;@NaN@] ^ [0;@Inf@] ; [1;@NaN@] ^ [0;5] ; [1;@NaN@] ^ [0;1] ; [1;@NaN@] ^ [0;0] ; [1;-@Inf@] ^ @NaN@ ; [1;-@Inf@] ^ -@Inf@ ; [1;-@Inf@] ^ @Inf@ ; [1;-@Inf@] ^ 5 ; [1;-@Inf@] ^ 1 ; [1;-@Inf@] ^ 0 ; [1;-@Inf@] ^ [@NaN@] ; [1;-@Inf@] ^ [-@Inf@] ; [1;-@Inf@] ^ [@Inf@] ; [1;-@Inf@] ^ [5] ; [1;-@Inf@] ^ [1] ; [1;-@Inf@] ^ [0] ; [1;-@Inf@] ^ [@NaN@;@NaN@] ; [1;-@Inf@] ^ [@NaN@;-@Inf@] ; [1;-@Inf@] ^ [@NaN@;@Inf@] ; [1;-@Inf@] ^ [@NaN@;5] ; [1;-@Inf@] ^ [@NaN@;1] ; [1;-@Inf@] ^ [@NaN@;0] ; [1;-@Inf@] ^ [-@Inf@;@NaN@] ; [1;-@Inf@] ^ [-@Inf@;-@Inf@] ; [1;-@Inf@] ^ [-@Inf@;@Inf@] ; [1;-@Inf@] ^ [-@Inf@;5] ; [1;-@Inf@] ^ [-@Inf@;1] ; [1;-@Inf@] ^ [-@Inf@;0] ; [1;-@Inf@] ^ [@Inf@;@NaN@] ; [1;-@Inf@] ^ [@Inf@;-@Inf@] ; [1;-@Inf@] ^ [@Inf@;@Inf@] ; [1;-@Inf@] ^ [@Inf@;5] ; [1;-@Inf@] ^ [@Inf@;1] ; [1;-@Inf@] ^ [@Inf@;0] ; [1;-@Inf@] ^ [5;@NaN@] ; [1;-@Inf@] ^ [5;-@Inf@] ; [1;-@Inf@] ^ [5;@Inf@] ; [1;-@Inf@] ^ [5;5] ; [1;-@Inf@] ^ [5;1] ; [1;-@Inf@] ^ [5;0] ; [1;-@Inf@] ^ [1;@NaN@] ; [1;-@Inf@] ^ [1;-@Inf@] ; [1;-@Inf@] ^ [1;@Inf@] ; [1;-@Inf@] ^ [1;5] ; [1;-@Inf@] ^ [1;1] ; [1;-@Inf@] ^ [1;0] ; [1;-@Inf@] ^ [0;@NaN@] ; [1;-@Inf@] ^ [0;-@Inf@] ; [1;-@Inf@] ^ [0;@Inf@] ; [1;-@Inf@] ^ [0;5] ; [1;-@Inf@] ^ [0;1] ; [1;-@Inf@] ^ [0;0] ; [1;@Inf@] ^ @NaN@ ; [1;@Inf@] ^ -@Inf@ ; [1;@Inf@] ^ @Inf@ ; [1;@Inf@] ^ 5 ; [1;@Inf@] ^ 1 ; [1;@Inf@] ^ 0 ; [1;@Inf@] ^ [@NaN@] ; [1;@Inf@] ^ [-@Inf@] ; [1;@Inf@] ^ [@Inf@] ; [1;@Inf@] ^ [5] ; [1;@Inf@] ^ [1] ; [1;@Inf@] ^ [0] ; [1;@Inf@] ^ [@NaN@;@NaN@] ; [1;@Inf@] ^ [@NaN@;-@Inf@] ; [1;@Inf@] ^ [@NaN@;@Inf@] ; [1;@Inf@] ^ [@NaN@;5] ; [1;@Inf@] ^ [@NaN@;1] ; [1;@Inf@] ^ [@NaN@;0] ; [1;@Inf@] ^ [-@Inf@;@NaN@] ; [1;@Inf@] ^ [-@Inf@;-@Inf@] ; [1;@Inf@] ^ [-@Inf@;@Inf@] ; [1;@Inf@] ^ [-@Inf@;5] ; [1;@Inf@] ^ [-@Inf@;1] ; [1;@Inf@] ^ [-@Inf@;0] ; [1;@Inf@] ^ [@Inf@;@NaN@] ; [1;@Inf@] ^ [@Inf@;-@Inf@] ; [1;@Inf@] ^ [@Inf@;@Inf@] ; [1;@Inf@] ^ [@Inf@;5] ; [1;@Inf@] ^ [@Inf@;1] ; [1;@Inf@] ^ [@Inf@;0] ; [1;@Inf@] ^ [5;@NaN@] ; [1;@Inf@] ^ [5;-@Inf@] ; [1;@Inf@] ^ [5;@Inf@] ; [1;@Inf@] ^ [5;5] ; [1;@Inf@] ^ [5;1] ; [1;@Inf@] ^ [5;0] ; [1;@Inf@] ^ [1;@NaN@] ; [1;@Inf@] ^ [1;-@Inf@] ; [1;@Inf@] ^ [1;@Inf@] ; [1;@Inf@] ^ [1;5] ; [1;@Inf@] ^ [1;1] ; [1;@Inf@] ^ [1;0] ; [1;@Inf@] ^ [0;@NaN@] ; [1;@Inf@] ^ [0;-@Inf@] ; [1;@Inf@] ^ [0;@Inf@] ; [1;@Inf@] ^ [0;5] ; [1;@Inf@] ^ [0;1] ; [1;@Inf@] ^ [0;0] ; [1;5] ^ @NaN@ ; [1;5] ^ -@Inf@ ; [1;5] ^ @Inf@ ; [1;5] ^ 5 ; [1;5] ^ 1 ; [1;5] ^ 0 ; [1;5] ^ [@NaN@] ; [1;5] ^ [-@Inf@] ; [1;5] ^ [@Inf@] ; [1;5] ^ [5] ; [1;5] ^ [1] ; [1;5] ^ [0] ; [1;5] ^ [@NaN@;@NaN@] ; [1;5] ^ [@NaN@;-@Inf@] ; [1;5] ^ [@NaN@;@Inf@] ; [1;5] ^ [@NaN@;5] ; [1;5] ^ [@NaN@;1] ; [1;5] ^ [@NaN@;0] ; [1;5] ^ [-@Inf@;@NaN@] ; [1;5] ^ [-@Inf@;-@Inf@] ; [1;5] ^ [-@Inf@;@Inf@] ; [1;5] ^ [-@Inf@;5] ; [1;5] ^ [-@Inf@;1] ; [1;5] ^ [-@Inf@;0] ; [1;5] ^ [@Inf@;@NaN@] ; [1;5] ^ [@Inf@;-@Inf@] ; [1;5] ^ [@Inf@;@Inf@] ; [1;5] ^ [@Inf@;5] ; [1;5] ^ [@Inf@;1] ; [1;5] ^ [@Inf@;0] ; [1;5] ^ [5;@NaN@] ; [1;5] ^ [5;-@Inf@] ; [1;5] ^ [5;@Inf@] ; [1;5] ^ [5;5] ; [1;5] ^ [5;1] ; [1;5] ^ [5;0] ; [1;5] ^ [1;@NaN@] ; [1;5] ^ [1;-@Inf@] ; [1;5] ^ [1;@Inf@] ; [1;5] ^ [1;5] ; [1;5] ^ [1;1] ; [1;5] ^ [1;0] ; [1;5] ^ [0;@NaN@] ; [1;5] ^ [0;-@Inf@] ; [1;5] ^ [0;@Inf@] ; [1;5] ^ [0;5] ; [1;5] ^ [0;1] ; [1;5] ^ [0;0] ; [1;1] ^ @NaN@ ; [1;1] ^ -@Inf@ ; [1;1] ^ @Inf@ ; [1;1] ^ 5 ; [1;1] ^ 1 ; [1;1] ^ 0 ; [1;1] ^ [@NaN@] ; [1;1] ^ [-@Inf@] ; [1;1] ^ [@Inf@] ; [1;1] ^ [5] ; [1;1] ^ [1] ; [1;1] ^ [0] ; [1;1] ^ [@NaN@;@NaN@] ; [1;1] ^ [@NaN@;-@Inf@] ; [1;1] ^ [@NaN@;@Inf@] ; [1;1] ^ [@NaN@;5] ; [1;1] ^ [@NaN@;1] ; [1;1] ^ [@NaN@;0] ; [1;1] ^ [-@Inf@;@NaN@] ; [1;1] ^ [-@Inf@;-@Inf@] ; [1;1] ^ [-@Inf@;@Inf@] ; [1;1] ^ [-@Inf@;5] ; [1;1] ^ [-@Inf@;1] ; [1;1] ^ [-@Inf@;0] ; [1;1] ^ [@Inf@;@NaN@] ; [1;1] ^ [@Inf@;-@Inf@] ; [1;1] ^ [@Inf@;@Inf@] ; [1;1] ^ [@Inf@;5] ; [1;1] ^ [@Inf@;1] ; [1;1] ^ [@Inf@;0] ; [1;1] ^ [5;@NaN@] ; [1;1] ^ [5;-@Inf@] ; [1;1] ^ [5;@Inf@] ; [1;1] ^ [5;5] ; [1;1] ^ [5;1] ; [1;1] ^ [5;0] ; [1;1] ^ [1;@NaN@] ; [1;1] ^ [1;-@Inf@] ; [1;1] ^ [1;@Inf@] ; [1;1] ^ [1;5] ; [1;1] ^ [1;1] ; [1;1] ^ [1;0] ; [1;1] ^ [0;@NaN@] ; [1;1] ^ [0;-@Inf@] ; [1;1] ^ [0;@Inf@] ; [1;1] ^ [0;5] ; [1;1] ^ [0;1] ; [1;1] ^ [0;0] ; [1;0] ^ @NaN@ ; [1;0] ^ -@Inf@ ; [1;0] ^ @Inf@ ; [1;0] ^ 5 ; [1;0] ^ 1 ; [1;0] ^ 0 ; [1;0] ^ [@NaN@] ; [1;0] ^ [-@Inf@] ; [1;0] ^ [@Inf@] ; [1;0] ^ [5] ; [1;0] ^ [1] ; [1;0] ^ [0] ; [1;0] ^ [@NaN@;@NaN@] ; [1;0] ^ [@NaN@;-@Inf@] ; [1;0] ^ [@NaN@;@Inf@] ; [1;0] ^ [@NaN@;5] ; [1;0] ^ [@NaN@;1] ; [1;0] ^ [@NaN@;0] ; [1;0] ^ [-@Inf@;@NaN@] ; [1;0] ^ [-@Inf@;-@Inf@] ; [1;0] ^ [-@Inf@;@Inf@] ; [1;0] ^ [-@Inf@;5] ; [1;0] ^ [-@Inf@;1] ; [1;0] ^ [-@Inf@;0] ; [1;0] ^ [@Inf@;@NaN@] ; [1;0] ^ [@Inf@;-@Inf@] ; [1;0] ^ [@Inf@;@Inf@] ; [1;0] ^ [@Inf@;5] ; [1;0] ^ [@Inf@;1] ; [1;0] ^ [@Inf@;0] ; [1;0] ^ [5;@NaN@] ; [1;0] ^ [5;-@Inf@] ; [1;0] ^ [5;@Inf@] ; [1;0] ^ [5;5] ; [1;0] ^ [5;1] ; [1;0] ^ [5;0] ; [1;0] ^ [1;@NaN@] ; [1;0] ^ [1;-@Inf@] ; [1;0] ^ [1;@Inf@] ; [1;0] ^ [1;5] ; [1;0] ^ [1;1] ; [1;0] ^ [1;0] ; [1;0] ^ [0;@NaN@] ; [1;0] ^ [0;-@Inf@] ; [1;0] ^ [0;@Inf@] ; [1;0] ^ [0;5] ; [1;0] ^ [0;1] ; [1;0] ^ [0;0] ; [0;@NaN@] ^ @NaN@ ; [0;@NaN@] ^ -@Inf@ ; [0;@NaN@] ^ @Inf@ ; [0;@NaN@] ^ 5 ; [0;@NaN@] ^ 1 ; [0;@NaN@] ^ 0 ; [0;@NaN@] ^ [@NaN@] ; [0;@NaN@] ^ [-@Inf@] ; [0;@NaN@] ^ [@Inf@] ; [0;@NaN@] ^ [5] ; [0;@NaN@] ^ [1] ; [0;@NaN@] ^ [0] ; [0;@NaN@] ^ [@NaN@;@NaN@] ; [0;@NaN@] ^ [@NaN@;-@Inf@] ; [0;@NaN@] ^ [@NaN@;@Inf@] ; [0;@NaN@] ^ [@NaN@;5] ; [0;@NaN@] ^ [@NaN@;1] ; [0;@NaN@] ^ [@NaN@;0] ; [0;@NaN@] ^ [-@Inf@;@NaN@] ; [0;@NaN@] ^ [-@Inf@;-@Inf@] ; [0;@NaN@] ^ [-@Inf@;@Inf@] ; [0;@NaN@] ^ [-@Inf@;5] ; [0;@NaN@] ^ [-@Inf@;1] ; [0;@NaN@] ^ [-@Inf@;0] ; [0;@NaN@] ^ [@Inf@;@NaN@] ; [0;@NaN@] ^ [@Inf@;-@Inf@] ; [0;@NaN@] ^ [@Inf@;@Inf@] ; [0;@NaN@] ^ [@Inf@;5] ; [0;@NaN@] ^ [@Inf@;1] ; [0;@NaN@] ^ [@Inf@;0] ; [0;@NaN@] ^ [5;@NaN@] ; [0;@NaN@] ^ [5;-@Inf@] ; [0;@NaN@] ^ [5;@Inf@] ; [0;@NaN@] ^ [5;5] ; [0;@NaN@] ^ [5;1] ; [0;@NaN@] ^ [5;0] ; [0;@NaN@] ^ [1;@NaN@] ; [0;@NaN@] ^ [1;-@Inf@] ; [0;@NaN@] ^ [1;@Inf@] ; [0;@NaN@] ^ [1;5] ; [0;@NaN@] ^ [1;1] ; [0;@NaN@] ^ [1;0] ; [0;@NaN@] ^ [0;@NaN@] ; [0;@NaN@] ^ [0;-@Inf@] ; [0;@NaN@] ^ [0;@Inf@] ; [0;@NaN@] ^ [0;5] ; [0;@NaN@] ^ [0;1] ; [0;@NaN@] ^ [0;0] ; [0;-@Inf@] ^ @NaN@ ; [0;-@Inf@] ^ -@Inf@ ; [0;-@Inf@] ^ @Inf@ ; [0;-@Inf@] ^ 5 ; [0;-@Inf@] ^ 1 ; [0;-@Inf@] ^ 0 ; [0;-@Inf@] ^ [@NaN@] ; [0;-@Inf@] ^ [-@Inf@] ; [0;-@Inf@] ^ [@Inf@] ; [0;-@Inf@] ^ [5] ; [0;-@Inf@] ^ [1] ; [0;-@Inf@] ^ [0] ; [0;-@Inf@] ^ [@NaN@;@NaN@] ; [0;-@Inf@] ^ [@NaN@;-@Inf@] ; [0;-@Inf@] ^ [@NaN@;@Inf@] ; [0;-@Inf@] ^ [@NaN@;5] ; [0;-@Inf@] ^ [@NaN@;1] ; [0;-@Inf@] ^ [@NaN@;0] ; [0;-@Inf@] ^ [-@Inf@;@NaN@] ; [0;-@Inf@] ^ [-@Inf@;-@Inf@] ; [0;-@Inf@] ^ [-@Inf@;@Inf@] ; [0;-@Inf@] ^ [-@Inf@;5] ; [0;-@Inf@] ^ [-@Inf@;1] ; [0;-@Inf@] ^ [-@Inf@;0] ; [0;-@Inf@] ^ [@Inf@;@NaN@] ; [0;-@Inf@] ^ [@Inf@;-@Inf@] ; [0;-@Inf@] ^ [@Inf@;@Inf@] ; [0;-@Inf@] ^ [@Inf@;5] ; [0;-@Inf@] ^ [@Inf@;1] ; [0;-@Inf@] ^ [@Inf@;0] ; [0;-@Inf@] ^ [5;@NaN@] ; [0;-@Inf@] ^ [5;-@Inf@] ; [0;-@Inf@] ^ [5;@Inf@] ; [0;-@Inf@] ^ [5;5] ; [0;-@Inf@] ^ [5;1] ; [0;-@Inf@] ^ [5;0] ; [0;-@Inf@] ^ [1;@NaN@] ; [0;-@Inf@] ^ [1;-@Inf@] ; [0;-@Inf@] ^ [1;@Inf@] ; [0;-@Inf@] ^ [1;5] ; [0;-@Inf@] ^ [1;1] ; [0;-@Inf@] ^ [1;0] ; [0;-@Inf@] ^ [0;@NaN@] ; [0;-@Inf@] ^ [0;-@Inf@] ; [0;-@Inf@] ^ [0;@Inf@] ; [0;-@Inf@] ^ [0;5] ; [0;-@Inf@] ^ [0;1] ; [0;-@Inf@] ^ [0;0] ; [0;@Inf@] ^ @NaN@ ; [0;@Inf@] ^ -@Inf@ ; [0;@Inf@] ^ @Inf@ ; [0;@Inf@] ^ 5 ; [0;@Inf@] ^ 1 ; [0;@Inf@] ^ 0 ; [0;@Inf@] ^ [@NaN@] ; [0;@Inf@] ^ [-@Inf@] ; [0;@Inf@] ^ [@Inf@] ; [0;@Inf@] ^ [5] ; [0;@Inf@] ^ [1] ; [0;@Inf@] ^ [0] ; [0;@Inf@] ^ [@NaN@;@NaN@] ; [0;@Inf@] ^ [@NaN@;-@Inf@] ; [0;@Inf@] ^ [@NaN@;@Inf@] ; [0;@Inf@] ^ [@NaN@;5] ; [0;@Inf@] ^ [@NaN@;1] ; [0;@Inf@] ^ [@NaN@;0] ; [0;@Inf@] ^ [-@Inf@;@NaN@] ; [0;@Inf@] ^ [-@Inf@;-@Inf@] ; [0;@Inf@] ^ [-@Inf@;@Inf@] ; [0;@Inf@] ^ [-@Inf@;5] ; [0;@Inf@] ^ [-@Inf@;1] ; [0;@Inf@] ^ [-@Inf@;0] ; [0;@Inf@] ^ [@Inf@;@NaN@] ; [0;@Inf@] ^ [@Inf@;-@Inf@] ; [0;@Inf@] ^ [@Inf@;@Inf@] ; [0;@Inf@] ^ [@Inf@;5] ; [0;@Inf@] ^ [@Inf@;1] ; [0;@Inf@] ^ [@Inf@;0] ; [0;@Inf@] ^ [5;@NaN@] ; [0;@Inf@] ^ [5;-@Inf@] ; [0;@Inf@] ^ [5;@Inf@] ; [0;@Inf@] ^ [5;5] ; [0;@Inf@] ^ [5;1] ; [0;@Inf@] ^ [5;0] ; [0;@Inf@] ^ [1;@NaN@] ; [0;@Inf@] ^ [1;-@Inf@] ; [0;@Inf@] ^ [1;@Inf@] ; [0;@Inf@] ^ [1;5] ; [0;@Inf@] ^ [1;1] ; [0;@Inf@] ^ [1;0] ; [0;@Inf@] ^ [0;@NaN@] ; [0;@Inf@] ^ [0;-@Inf@] ; [0;@Inf@] ^ [0;@Inf@] ; [0;@Inf@] ^ [0;5] ; [0;@Inf@] ^ [0;1] ; [0;@Inf@] ^ [0;0] ; [0;5] ^ @NaN@ ; [0;5] ^ -@Inf@ ; [0;5] ^ @Inf@ ; [0;5] ^ 5 ; [0;5] ^ 1 ; [0;5] ^ 0 ; [0;5] ^ [@NaN@] ; [0;5] ^ [-@Inf@] ; [0;5] ^ [@Inf@] ; [0;5] ^ [5] ; [0;5] ^ [1] ; [0;5] ^ [0] ; [0;5] ^ [@NaN@;@NaN@] ; [0;5] ^ [@NaN@;-@Inf@] ; [0;5] ^ [@NaN@;@Inf@] ; [0;5] ^ [@NaN@;5] ; [0;5] ^ [@NaN@;1] ; [0;5] ^ [@NaN@;0] ; [0;5] ^ [-@Inf@;@NaN@] ; [0;5] ^ [-@Inf@;-@Inf@] ; [0;5] ^ [-@Inf@;@Inf@] ; [0;5] ^ [-@Inf@;5] ; [0;5] ^ [-@Inf@;1] ; [0;5] ^ [-@Inf@;0] ; [0;5] ^ [@Inf@;@NaN@] ; [0;5] ^ [@Inf@;-@Inf@] ; [0;5] ^ [@Inf@;@Inf@] ; [0;5] ^ [@Inf@;5] ; [0;5] ^ [@Inf@;1] ; [0;5] ^ [@Inf@;0] ; [0;5] ^ [5;@NaN@] ; [0;5] ^ [5;-@Inf@] ; [0;5] ^ [5;@Inf@] ; [0;5] ^ [5;5] ; [0;5] ^ [5;1] ; [0;5] ^ [5;0] ; [0;5] ^ [1;@NaN@] ; [0;5] ^ [1;-@Inf@] ; [0;5] ^ [1;@Inf@] ; [0;5] ^ [1;5] ; [0;5] ^ [1;1] ; [0;5] ^ [1;0] ; [0;5] ^ [0;@NaN@] ; [0;5] ^ [0;-@Inf@] ; [0;5] ^ [0;@Inf@] ; [0;5] ^ [0;5] ; [0;5] ^ [0;1] ; [0;5] ^ [0;0] ; [0;1] ^ @NaN@ ; [0;1] ^ -@Inf@ ; [0;1] ^ @Inf@ ; [0;1] ^ 5 ; [0;1] ^ 1 ; [0;1] ^ 0 ; [0;1] ^ [@NaN@] ; [0;1] ^ [-@Inf@] ; [0;1] ^ [@Inf@] ; [0;1] ^ [5] ; [0;1] ^ [1] ; [0;1] ^ [0] ; [0;1] ^ [@NaN@;@NaN@] ; [0;1] ^ [@NaN@;-@Inf@] ; [0;1] ^ [@NaN@;@Inf@] ; [0;1] ^ [@NaN@;5] ; [0;1] ^ [@NaN@;1] ; [0;1] ^ [@NaN@;0] ; [0;1] ^ [-@Inf@;@NaN@] ; [0;1] ^ [-@Inf@;-@Inf@] ; [0;1] ^ [-@Inf@;@Inf@] ; [0;1] ^ [-@Inf@;5] ; [0;1] ^ [-@Inf@;1] ; [0;1] ^ [-@Inf@;0] ; [0;1] ^ [@Inf@;@NaN@] ; [0;1] ^ [@Inf@;-@Inf@] ; [0;1] ^ [@Inf@;@Inf@] ; [0;1] ^ [@Inf@;5] ; [0;1] ^ [@Inf@;1] ; [0;1] ^ [@Inf@;0] ; [0;1] ^ [5;@NaN@] ; [0;1] ^ [5;-@Inf@] ; [0;1] ^ [5;@Inf@] ; [0;1] ^ [5;5] ; [0;1] ^ [5;1] ; [0;1] ^ [5;0] ; [0;1] ^ [1;@NaN@] ; [0;1] ^ [1;-@Inf@] ; [0;1] ^ [1;@Inf@] ; [0;1] ^ [1;5] ; [0;1] ^ [1;1] ; [0;1] ^ [1;0] ; [0;1] ^ [0;@NaN@] ; [0;1] ^ [0;-@Inf@] ; [0;1] ^ [0;@Inf@] ; [0;1] ^ [0;5] ; [0;1] ^ [0;1] ; [0;1] ^ [0;0] ; [0;0] ^ @NaN@ ; [0;0] ^ -@Inf@ ; [0;0] ^ @Inf@ ; [0;0] ^ 5 ; [0;0] ^ 1 ; [0;0] ^ 0 ; [0;0] ^ [@NaN@] ; [0;0] ^ [-@Inf@] ; [0;0] ^ [@Inf@] ; [0;0] ^ [5] ; [0;0] ^ [1] ; [0;0] ^ [0] ; [0;0] ^ [@NaN@;@NaN@] ; [0;0] ^ [@NaN@;-@Inf@] ; [0;0] ^ [@NaN@;@Inf@] ; [0;0] ^ [@NaN@;5] ; [0;0] ^ [@NaN@;1] ; [0;0] ^ [@NaN@;0] ; [0;0] ^ [-@Inf@;@NaN@] ; [0;0] ^ [-@Inf@;-@Inf@] ; [0;0] ^ [-@Inf@;@Inf@] ; [0;0] ^ [-@Inf@;5] ; [0;0] ^ [-@Inf@;1] ; [0;0] ^ [-@Inf@;0] ; [0;0] ^ [@Inf@;@NaN@] ; [0;0] ^ [@Inf@;-@Inf@] ; [0;0] ^ [@Inf@;@Inf@] ; [0;0] ^ [@Inf@;5] ; [0;0] ^ [@Inf@;1] ; [0;0] ^ [@Inf@;0] ; [0;0] ^ [5;@NaN@] ; [0;0] ^ [5;-@Inf@] ; [0;0] ^ [5;@Inf@] ; [0;0] ^ [5;5] ; [0;0] ^ [5;1] ; [0;0] ^ [5;0] ; [0;0] ^ [1;@NaN@] ; [0;0] ^ [1;-@Inf@] ; [0;0] ^ [1;@Inf@] ; [0;0] ^ [1;5] ; [0;0] ^ [1;1] ; [0;0] ^ [1;0] ; [0;0] ^ [0;@NaN@] ; [0;0] ^ [0;-@Inf@] ; [0;0] ^ [0;@Inf@] ; [0;0] ^ [0;5] ; [0;0] ^ [0;1] ; [0;0] ^ [0;0] ; restart; sollya-6.0+ds/tests-tool/check028.sollya.reference000066400000000000000000003663721300174114700221110ustar00rootroot00000000000000The tool has been restarted. NaN NaN NaN NaN NaN NaN [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] NaN -infty NaN -infty -infty -infty [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] NaN NaN infty infty infty infty [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] NaN -infty infty 10 6 5 [NaN;NaN] [-infty;-infty] [infty;infty] [10;10] [6;6] [5;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [-infty;infty] [infty;infty] [10;infty] [6;infty] [5;infty] [NaN;NaN] [-infty;10] [10;infty] [10;10] [6;10] [5;10] [NaN;NaN] [-infty;6] [6;infty] [6;10] [6;6] [5;6] [NaN;NaN] [-infty;5] [5;infty] [5;10] [5;6] [5;5] NaN -infty infty 6 2 1 [NaN;NaN] [-infty;-infty] [infty;infty] [6;6] [2;2] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [-infty;infty] [infty;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [-infty;6] [6;infty] [6;6] [2;6] [1;6] [NaN;NaN] [-infty;2] [2;infty] [2;6] [2;2] [1;2] [NaN;NaN] [-infty;1] [1;infty] [1;6] [1;2] [1;1] NaN -infty infty 5 1 0 [NaN;NaN] [-infty;-infty] [infty;infty] [5;5] [1;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;5] [5;infty] [5;5] [1;5] [0;5] [NaN;NaN] [-infty;1] [1;infty] [1;5] [1;1] [0;1] [NaN;NaN] [-infty;0] [0;infty] [0;5] [0;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;-infty] [infty;infty] [10;10] [6;6] [5;5] [NaN;NaN] [-infty;-infty] [infty;infty] [10;10] [6;6] [5;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [-infty;infty] [infty;infty] [10;infty] [6;infty] [5;infty] [NaN;NaN] [-infty;10] [10;infty] [10;10] [6;10] [5;10] [NaN;NaN] [-infty;6] [6;infty] [6;10] [6;6] [5;6] [NaN;NaN] [-infty;5] [5;infty] [5;10] [5;6] [5;5] [NaN;NaN] [-infty;-infty] [infty;infty] [6;6] [2;2] [1;1] [NaN;NaN] [-infty;-infty] [infty;infty] [6;6] [2;2] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [-infty;infty] [infty;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [-infty;6] [6;infty] [6;6] [2;6] [1;6] [NaN;NaN] [-infty;2] [2;infty] [2;6] [2;2] [1;2] [NaN;NaN] [-infty;1] [1;infty] [1;6] [1;2] [1;1] [NaN;NaN] [-infty;-infty] [infty;infty] [5;5] [1;1] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;5] [1;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;5] [5;infty] [5;5] [1;5] [0;5] [NaN;NaN] [-infty;1] [1;infty] [1;5] [1;1] [0;1] [NaN;NaN] [-infty;0] [0;infty] [0;5] [0;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;10] [-infty;infty] [-infty;10] [-infty;10] [-infty;10] [NaN;NaN] [-infty;6] [-infty;infty] [-infty;10] [-infty;6] [-infty;6] [NaN;NaN] [-infty;5] [-infty;infty] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;6] [-infty;infty] [-infty;6] [-infty;6] [-infty;6] [NaN;NaN] [-infty;2] [-infty;infty] [-infty;6] [-infty;2] [-infty;2] [NaN;NaN] [-infty;1] [-infty;infty] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;5] [-infty;infty] [-infty;5] [-infty;5] [-infty;5] [NaN;NaN] [-infty;1] [-infty;infty] [-infty;5] [-infty;1] [-infty;1] [NaN;NaN] [-infty;0] [-infty;infty] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [10;infty] [6;infty] [5;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [10;infty] [6;infty] [5;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [10;infty] [6;infty] [5;infty] [NaN;NaN] [-infty;infty] [10;infty] [10;infty] [6;infty] [5;infty] [NaN;NaN] [-infty;infty] [6;infty] [6;infty] [6;infty] [5;infty] [NaN;NaN] [-infty;infty] [5;infty] [5;infty] [5;infty] [5;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [-infty;infty] [6;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [-infty;infty] [2;infty] [2;infty] [2;infty] [1;infty] [NaN;NaN] [-infty;infty] [1;infty] [1;infty] [1;infty] [1;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;infty] [5;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;infty] [1;infty] [1;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;10] [-infty;infty] [-infty;10] [-infty;10] [-infty;10] [NaN;NaN] [-infty;6] [-infty;infty] [-infty;10] [-infty;6] [-infty;6] [NaN;NaN] [-infty;5] [-infty;infty] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [NaN;NaN] [infty;infty] [10;infty] [6;infty] [5;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [10;infty] [6;infty] [5;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [10;infty] [6;infty] [5;infty] [NaN;NaN] [-infty;infty] [10;infty] [10;infty] [6;infty] [5;infty] [NaN;NaN] [-infty;infty] [6;infty] [6;infty] [6;infty] [5;infty] [NaN;NaN] [-infty;infty] [5;infty] [5;infty] [5;infty] [5;infty] [NaN;NaN] [-infty;-infty] [infty;infty] [10;10] [6;6] [5;5] [NaN;NaN] [-infty;-infty] [infty;infty] [10;10] [6;6] [5;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [-infty;infty] [infty;infty] [10;infty] [6;infty] [5;infty] [NaN;NaN] [-infty;10] [10;infty] [10;10] [6;10] [5;10] [NaN;NaN] [-infty;6] [6;infty] [6;10] [6;6] [5;6] [NaN;NaN] [-infty;5] [5;infty] [5;10] [5;6] [5;5] [NaN;NaN] [-infty;-infty] [infty;infty] [6;10] [2;6] [1;5] [NaN;NaN] [-infty;-infty] [infty;infty] [6;10] [2;6] [1;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [-infty;infty] [infty;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [-infty;10] [6;infty] [6;10] [2;10] [1;10] [NaN;NaN] [-infty;6] [2;infty] [2;10] [2;6] [1;6] [NaN;NaN] [-infty;5] [1;infty] [1;10] [1;6] [1;5] [NaN;NaN] [-infty;-infty] [infty;infty] [5;10] [1;6] [0;5] [NaN;NaN] [-infty;-infty] [infty;infty] [5;10] [1;6] [0;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;10] [5;infty] [5;10] [1;10] [0;10] [NaN;NaN] [-infty;6] [1;infty] [1;10] [1;6] [0;6] [NaN;NaN] [-infty;5] [0;infty] [0;10] [0;6] [0;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;6] [-infty;infty] [-infty;6] [-infty;6] [-infty;6] [NaN;NaN] [-infty;2] [-infty;infty] [-infty;6] [-infty;2] [-infty;2] [NaN;NaN] [-infty;1] [-infty;infty] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [NaN;NaN] [infty;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [-infty;infty] [6;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [-infty;infty] [2;infty] [2;infty] [2;infty] [1;infty] [NaN;NaN] [-infty;infty] [1;infty] [1;infty] [1;infty] [1;infty] [NaN;NaN] [-infty;-infty] [infty;infty] [6;10] [2;6] [1;5] [NaN;NaN] [-infty;-infty] [infty;infty] [6;10] [2;6] [1;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [-infty;infty] [infty;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [-infty;10] [6;infty] [6;10] [2;10] [1;10] [NaN;NaN] [-infty;6] [2;infty] [2;10] [2;6] [1;6] [NaN;NaN] [-infty;5] [1;infty] [1;10] [1;6] [1;5] [NaN;NaN] [-infty;-infty] [infty;infty] [6;6] [2;2] [1;1] [NaN;NaN] [-infty;-infty] [infty;infty] [6;6] [2;2] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [-infty;infty] [infty;infty] [6;infty] [2;infty] [1;infty] [NaN;NaN] [-infty;6] [6;infty] [6;6] [2;6] [1;6] [NaN;NaN] [-infty;2] [2;infty] [2;6] [2;2] [1;2] [NaN;NaN] [-infty;1] [1;infty] [1;6] [1;2] [1;1] [NaN;NaN] [-infty;-infty] [infty;infty] [5;6] [1;2] [0;1] [NaN;NaN] [-infty;-infty] [infty;infty] [5;6] [1;2] [0;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;6] [5;infty] [5;6] [1;6] [0;6] [NaN;NaN] [-infty;2] [1;infty] [1;6] [1;2] [0;2] [NaN;NaN] [-infty;1] [0;infty] [0;6] [0;2] [0;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [-infty;-infty] [NaN;NaN] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;5] [-infty;infty] [-infty;5] [-infty;5] [-infty;5] [NaN;NaN] [-infty;1] [-infty;infty] [-infty;5] [-infty;1] [-infty;1] [NaN;NaN] [-infty;0] [-infty;infty] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [NaN;NaN] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [NaN;NaN] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;infty] [5;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;infty] [1;infty] [1;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;-infty] [infty;infty] [5;10] [1;6] [0;5] [NaN;NaN] [-infty;-infty] [infty;infty] [5;10] [1;6] [0;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;10] [-infty;6] [-infty;5] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;10] [5;infty] [5;10] [1;10] [0;10] [NaN;NaN] [-infty;6] [1;infty] [1;10] [1;6] [0;6] [NaN;NaN] [-infty;5] [0;infty] [0;10] [0;6] [0;5] [NaN;NaN] [-infty;-infty] [infty;infty] [5;6] [1;2] [0;1] [NaN;NaN] [-infty;-infty] [infty;infty] [5;6] [1;2] [0;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;6] [-infty;2] [-infty;1] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;6] [5;infty] [5;6] [1;6] [0;6] [NaN;NaN] [-infty;2] [1;infty] [1;6] [1;2] [0;2] [NaN;NaN] [-infty;1] [0;infty] [0;6] [0;2] [0;1] [NaN;NaN] [-infty;-infty] [infty;infty] [5;5] [1;1] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;5] [1;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;5] [5;infty] [5;5] [1;5] [0;5] [NaN;NaN] [-infty;1] [1;infty] [1;5] [1;1] [0;1] [NaN;NaN] [-infty;0] [0;infty] [0;5] [0;1] [0;0] NaN NaN NaN NaN NaN NaN [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] NaN NaN -infty -infty -infty -infty [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] NaN infty NaN infty infty infty [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] NaN infty -infty 0 4 5 [NaN;NaN] [infty;infty] [-infty;-infty] [0;0] [4;4] [5;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [0;infty] [4;infty] [5;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [0;infty] [-infty;0] [0;0] [0;4] [0;5] [NaN;NaN] [4;infty] [-infty;4] [0;4] [4;4] [4;5] [NaN;NaN] [5;infty] [-infty;5] [0;5] [4;5] [5;5] NaN infty -infty -4 0 1 [NaN;NaN] [infty;infty] [-infty;-infty] [-4;-4] [0;0] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [-4;infty] [-infty;-4] [-4;-4] [-4;0] [-4;1] [NaN;NaN] [0;infty] [-infty;0] [-4;0] [0;0] [0;1] [NaN;NaN] [1;infty] [-infty;1] [-4;1] [0;1] [1;1] NaN infty -infty -5 -1 0 [NaN;NaN] [infty;infty] [-infty;-infty] [-5;-5] [-1;-1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-5] [-infty;-1] [-infty;0] [NaN;NaN] [-5;infty] [-infty;-5] [-5;-5] [-5;-1] [-5;0] [NaN;NaN] [-1;infty] [-infty;-1] [-5;-1] [-1;-1] [-1;0] [NaN;NaN] [0;infty] [-infty;0] [-5;0] [-1;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [infty;infty] [-infty;-infty] [0;0] [4;4] [5;5] [NaN;NaN] [infty;infty] [-infty;-infty] [0;0] [4;4] [5;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [0;infty] [4;infty] [5;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [0;infty] [-infty;0] [0;0] [0;4] [0;5] [NaN;NaN] [4;infty] [-infty;4] [0;4] [4;4] [4;5] [NaN;NaN] [5;infty] [-infty;5] [0;5] [4;5] [5;5] [NaN;NaN] [infty;infty] [-infty;-infty] [-4;-4] [0;0] [1;1] [NaN;NaN] [infty;infty] [-infty;-infty] [-4;-4] [0;0] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [-4;infty] [-infty;-4] [-4;-4] [-4;0] [-4;1] [NaN;NaN] [0;infty] [-infty;0] [-4;0] [0;0] [0;1] [NaN;NaN] [1;infty] [-infty;1] [-4;1] [0;1] [1;1] [NaN;NaN] [infty;infty] [-infty;-infty] [-5;-5] [-1;-1] [0;0] [NaN;NaN] [infty;infty] [-infty;-infty] [-5;-5] [-1;-1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-5] [-infty;-1] [-infty;0] [NaN;NaN] [-5;infty] [-infty;-5] [-5;-5] [-5;-1] [-5;0] [NaN;NaN] [-1;infty] [-infty;-1] [-5;-1] [-1;-1] [-1;0] [NaN;NaN] [0;infty] [-infty;0] [-5;0] [-1;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [-infty;infty] [-infty;4] [-infty;4] [-infty;4] [-infty;5] [NaN;NaN] [-infty;infty] [-infty;5] [-infty;5] [-infty;5] [-infty;5] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [-infty;infty] [-infty;-4] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;1] [NaN;NaN] [-infty;infty] [-infty;1] [-infty;1] [-infty;1] [-infty;1] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-5] [-infty;-1] [-infty;0] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-5] [-infty;-1] [-infty;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-5] [-infty;-1] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;-5] [-infty;-5] [-infty;-1] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;-1] [-infty;-1] [-infty;-1] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [0;infty] [4;infty] [5;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [0;infty] [4;infty] [5;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [0;infty] [4;infty] [5;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [0;infty] [-infty;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [4;infty] [-infty;infty] [0;infty] [4;infty] [4;infty] [NaN;NaN] [5;infty] [-infty;infty] [0;infty] [4;infty] [5;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-4;infty] [-infty;infty] [-4;infty] [-4;infty] [-4;infty] [NaN;NaN] [0;infty] [-infty;infty] [-4;infty] [0;infty] [0;infty] [NaN;NaN] [1;infty] [-infty;infty] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-5;infty] [-infty;infty] [-5;infty] [-5;infty] [-5;infty] [NaN;NaN] [-1;infty] [-infty;infty] [-5;infty] [-1;infty] [-1;infty] [NaN;NaN] [0;infty] [-infty;infty] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [-infty;infty] [-infty;4] [-infty;4] [-infty;4] [-infty;5] [NaN;NaN] [-infty;infty] [-infty;5] [-infty;5] [-infty;5] [-infty;5] [NaN;NaN] [infty;infty] [NaN;NaN] [0;infty] [4;infty] [5;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [0;infty] [4;infty] [5;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [0;infty] [4;infty] [5;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [0;infty] [-infty;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [4;infty] [-infty;infty] [0;infty] [4;infty] [4;infty] [NaN;NaN] [5;infty] [-infty;infty] [0;infty] [4;infty] [5;infty] [NaN;NaN] [infty;infty] [-infty;-infty] [0;0] [4;4] [5;5] [NaN;NaN] [infty;infty] [-infty;-infty] [0;0] [4;4] [5;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [0;infty] [4;infty] [5;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [0;infty] [-infty;0] [0;0] [0;4] [0;5] [NaN;NaN] [4;infty] [-infty;4] [0;4] [4;4] [4;5] [NaN;NaN] [5;infty] [-infty;5] [0;5] [4;5] [5;5] [NaN;NaN] [infty;infty] [-infty;-infty] [-4;0] [0;4] [1;5] [NaN;NaN] [infty;infty] [-infty;-infty] [-4;0] [0;4] [1;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [-4;infty] [-infty;0] [-4;0] [-4;4] [-4;5] [NaN;NaN] [0;infty] [-infty;4] [-4;4] [0;4] [0;5] [NaN;NaN] [1;infty] [-infty;5] [-4;5] [0;5] [1;5] [NaN;NaN] [infty;infty] [-infty;-infty] [-5;0] [-1;4] [0;5] [NaN;NaN] [infty;infty] [-infty;-infty] [-5;0] [-1;4] [0;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [-5;infty] [-infty;0] [-5;0] [-5;4] [-5;5] [NaN;NaN] [-1;infty] [-infty;4] [-5;4] [-1;4] [-1;5] [NaN;NaN] [0;infty] [-infty;5] [-5;5] [-1;5] [0;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [-infty;infty] [-infty;-4] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;1] [NaN;NaN] [-infty;infty] [-infty;1] [-infty;1] [-infty;1] [-infty;1] [NaN;NaN] [infty;infty] [NaN;NaN] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-4;infty] [-infty;infty] [-4;infty] [-4;infty] [-4;infty] [NaN;NaN] [0;infty] [-infty;infty] [-4;infty] [0;infty] [0;infty] [NaN;NaN] [1;infty] [-infty;infty] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [infty;infty] [-infty;-infty] [-4;0] [0;4] [1;5] [NaN;NaN] [infty;infty] [-infty;-infty] [-4;0] [0;4] [1;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [-4;infty] [-infty;0] [-4;0] [-4;4] [-4;5] [NaN;NaN] [0;infty] [-infty;4] [-4;4] [0;4] [0;5] [NaN;NaN] [1;infty] [-infty;5] [-4;5] [0;5] [1;5] [NaN;NaN] [infty;infty] [-infty;-infty] [-4;-4] [0;0] [1;1] [NaN;NaN] [infty;infty] [-infty;-infty] [-4;-4] [0;0] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-4;infty] [0;infty] [1;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [-4;infty] [-infty;-4] [-4;-4] [-4;0] [-4;1] [NaN;NaN] [0;infty] [-infty;0] [-4;0] [0;0] [0;1] [NaN;NaN] [1;infty] [-infty;1] [-4;1] [0;1] [1;1] [NaN;NaN] [infty;infty] [-infty;-infty] [-5;-4] [-1;0] [0;1] [NaN;NaN] [infty;infty] [-infty;-infty] [-5;-4] [-1;0] [0;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [-5;infty] [-infty;-4] [-5;-4] [-5;0] [-5;1] [NaN;NaN] [-1;infty] [-infty;0] [-5;0] [-1;0] [-1;1] [NaN;NaN] [0;infty] [-infty;1] [-5;1] [-1;1] [0;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-5] [-infty;-1] [-infty;0] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-5] [-infty;-1] [-infty;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-5] [-infty;-1] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;-5] [-infty;-5] [-infty;-1] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;-1] [-infty;-1] [-infty;-1] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [infty;infty] [NaN;NaN] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [infty;infty] [NaN;NaN] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-5;infty] [-infty;infty] [-5;infty] [-5;infty] [-5;infty] [NaN;NaN] [-1;infty] [-infty;infty] [-5;infty] [-1;infty] [-1;infty] [NaN;NaN] [0;infty] [-infty;infty] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [infty;infty] [-infty;-infty] [-5;0] [-1;4] [0;5] [NaN;NaN] [infty;infty] [-infty;-infty] [-5;0] [-1;4] [0;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;0] [-infty;4] [-infty;5] [NaN;NaN] [-5;infty] [-infty;0] [-5;0] [-5;4] [-5;5] [NaN;NaN] [-1;infty] [-infty;4] [-5;4] [-1;4] [-1;5] [NaN;NaN] [0;infty] [-infty;5] [-5;5] [-1;5] [0;5] [NaN;NaN] [infty;infty] [-infty;-infty] [-5;-4] [-1;0] [0;1] [NaN;NaN] [infty;infty] [-infty;-infty] [-5;-4] [-1;0] [0;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-4] [-infty;0] [-infty;1] [NaN;NaN] [-5;infty] [-infty;-4] [-5;-4] [-5;0] [-5;1] [NaN;NaN] [-1;infty] [-infty;0] [-5;0] [-1;0] [-1;1] [NaN;NaN] [0;infty] [-infty;1] [-5;1] [-1;1] [0;1] [NaN;NaN] [infty;infty] [-infty;-infty] [-5;-5] [-1;-1] [0;0] [NaN;NaN] [infty;infty] [-infty;-infty] [-5;-5] [-1;-1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-5;infty] [-1;infty] [0;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-5] [-infty;-1] [-infty;0] [NaN;NaN] [-5;infty] [-infty;-5] [-5;-5] [-5;-1] [-5;0] [NaN;NaN] [-1;infty] [-infty;-1] [-5;-1] [-1;-1] [-1;0] [NaN;NaN] [0;infty] [-infty;0] [-5;0] [-1;0] [0;0] NaN NaN NaN NaN NaN NaN [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] NaN infty -infty -infty -infty NaN [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] NaN -infty infty infty infty NaN [NaN;NaN] [-infty;-infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;-infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] NaN -infty infty 25 5 0 [NaN;NaN] [-infty;-infty] [infty;infty] [25;25] [5;5] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;25] [-infty;5] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [25;infty] [5;infty] [0;infty] [NaN;NaN] [-infty;25] [25;infty] [25;25] [5;25] [0;25] [NaN;NaN] [-infty;5] [5;infty] [5;25] [5;5] [0;5] [NaN;NaN] [-infty;0] [0;infty] [0;25] [0;5] [0;0] NaN -infty infty 5 1 0 [NaN;NaN] [-infty;-infty] [infty;infty] [5;5] [1;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;5] [5;infty] [5;5] [1;5] [0;5] [NaN;NaN] [-infty;1] [1;infty] [1;5] [1;1] [0;1] [NaN;NaN] [-infty;0] [0;infty] [0;5] [0;1] [0;0] NaN NaN NaN 0 0 0 [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;-infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [infty;infty] [25;25] [5;5] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [25;25] [5;5] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;25] [-infty;5] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [25;infty] [5;infty] [0;infty] [NaN;NaN] [-infty;25] [25;infty] [25;25] [5;25] [0;25] [NaN;NaN] [-infty;5] [5;infty] [5;25] [5;5] [0;5] [NaN;NaN] [-infty;0] [0;infty] [0;25] [0;5] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;5] [1;1] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;5] [1;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;5] [5;infty] [5;5] [1;5] [0;5] [NaN;NaN] [-infty;1] [1;infty] [1;5] [1;1] [0;1] [NaN;NaN] [-infty;0] [0;infty] [0;5] [0;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [0;0] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [0;0] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;25] [-infty;5] [0;0] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;25] [-infty;5] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;25] [-infty;25] [-infty;25] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;25] [-infty;5] [-infty;5] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;25] [-infty;5] [0;0] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;5] [-infty;1] [0;0] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;5] [-infty;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;5] [-infty;5] [-infty;5] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;5] [-infty;1] [-infty;1] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;5] [-infty;1] [0;0] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;0] [-infty;0] [0;0] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;0] [-infty;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [0;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [0;infty] [-infty;0] [-infty;0] [-infty;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [0;0] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;-infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [-infty;-infty] [infty;infty] [25;infty] [5;infty] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [25;infty] [5;infty] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [25;infty] [5;infty] [0;infty] [NaN;NaN] [-infty;infty] [25;infty] [25;infty] [5;infty] [0;infty] [NaN;NaN] [-infty;infty] [5;infty] [5;infty] [5;infty] [0;infty] [NaN;NaN] [-infty;0] [0;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;infty] [1;infty] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;infty] [1;infty] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;infty] [5;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;infty] [1;infty] [1;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;0] [0;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;0] [0;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;25] [-infty;5] [0;0] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;25] [-infty;5] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;25] [-infty;25] [-infty;25] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;25] [-infty;5] [-infty;5] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;25] [-infty;5] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [25;infty] [5;infty] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [25;infty] [5;infty] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [25;infty] [5;infty] [0;infty] [NaN;NaN] [-infty;infty] [25;infty] [25;infty] [5;infty] [0;infty] [NaN;NaN] [-infty;infty] [5;infty] [5;infty] [5;infty] [0;infty] [NaN;NaN] [-infty;0] [0;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [25;25] [5;5] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [25;25] [5;5] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;25] [-infty;5] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [25;infty] [5;infty] [0;infty] [NaN;NaN] [-infty;25] [25;infty] [25;25] [5;25] [0;25] [NaN;NaN] [-infty;5] [5;infty] [5;25] [5;5] [0;5] [NaN;NaN] [-infty;0] [0;infty] [0;25] [0;5] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;25] [1;5] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;25] [1;5] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;25] [-infty;5] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;25] [5;infty] [5;25] [1;25] [0;25] [NaN;NaN] [-infty;5] [1;infty] [1;25] [1;5] [0;5] [NaN;NaN] [-infty;0] [0;infty] [0;25] [0;5] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [0;25] [0;5] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [0;25] [0;5] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;25] [-infty;5] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;25] [0;infty] [0;25] [0;25] [0;25] [NaN;NaN] [-infty;5] [0;infty] [0;25] [0;5] [0;5] [NaN;NaN] [-infty;0] [0;infty] [0;25] [0;5] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;5] [-infty;1] [0;0] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;5] [-infty;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;5] [-infty;5] [-infty;5] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;5] [-infty;1] [-infty;1] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;5] [-infty;1] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;infty] [1;infty] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;infty] [1;infty] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;infty] [5;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;infty] [1;infty] [1;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;0] [0;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;25] [1;5] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;25] [1;5] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;25] [-infty;5] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;25] [5;infty] [5;25] [1;25] [0;25] [NaN;NaN] [-infty;5] [1;infty] [1;25] [1;5] [0;5] [NaN;NaN] [-infty;0] [0;infty] [0;25] [0;5] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;5] [1;1] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [5;5] [1;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [5;infty] [1;infty] [0;infty] [NaN;NaN] [-infty;5] [5;infty] [5;5] [1;5] [0;5] [NaN;NaN] [-infty;1] [1;infty] [1;5] [1;1] [0;1] [NaN;NaN] [-infty;0] [0;infty] [0;5] [0;1] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [0;5] [0;1] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [0;5] [0;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;5] [0;infty] [0;5] [0;5] [0;5] [NaN;NaN] [-infty;1] [0;infty] [0;5] [0;1] [0;1] [NaN;NaN] [-infty;0] [0;infty] [0;5] [0;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;0] [-infty;0] [0;0] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;0] [-infty;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [0;infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [0;infty] [-infty;0] [-infty;0] [-infty;0] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;0] [0;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [0;25] [0;5] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [0;25] [0;5] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;25] [-infty;5] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;25] [0;infty] [0;25] [0;25] [0;25] [NaN;NaN] [-infty;5] [0;infty] [0;25] [0;5] [0;5] [NaN;NaN] [-infty;0] [0;infty] [0;25] [0;5] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [0;5] [0;1] [0;0] [NaN;NaN] [-infty;-infty] [infty;infty] [0;5] [0;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;infty] [-infty;5] [-infty;1] [-infty;0] [NaN;NaN] [-infty;infty] [infty;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;5] [0;infty] [0;5] [0;5] [0;5] [NaN;NaN] [-infty;1] [0;infty] [0;5] [0;1] [0;1] [NaN;NaN] [-infty;0] [0;infty] [0;5] [0;1] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] NaN NaN NaN NaN NaN NaN [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] NaN NaN NaN -infty -infty NaN [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;infty] NaN NaN NaN infty infty NaN [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;-infty] [infty;infty] [infty;infty] [infty;infty] [-infty;infty] NaN 0 0 1 5 NaN [NaN;NaN] [0;0] [0;0] [1;1] [5;5] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;1] [0;5] [0;infty] [NaN;NaN] [-infty;infty] [0;1] [1;1] [1;5] [1;infty] [NaN;NaN] [-infty;infty] [0;5] [1;5] [5;5] [5;infty] [NaN;NaN] [-infty;0] [0;infty] [1;infty] [5;infty] [-infty;infty] NaN 0 0 0.2 1 NaN [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;0.2] [1;1] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;0.2] [0;1] [0;infty] [NaN;NaN] [-infty;infty] [0;0.2] [0.199999999999999999999999999999999999999999999999997;0.2] [0.199999999999999999999999999999999999999999999999997;1] [0.199999999999999999999999999999999999999999999999997;infty] [NaN;NaN] [-infty;infty] [0;1] [0.199999999999999999999999999999999999999999999999997;1] [1;1] [1;infty] [NaN;NaN] [-infty;0] [0;infty] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [-infty;infty] NaN 0 0 0 0 NaN [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;-infty] [infty;infty] [infty;infty] [infty;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [1;1] [5;5] [-infty;infty] [NaN;NaN] [0;0] [0;0] [1;1] [5;5] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;1] [0;5] [0;infty] [NaN;NaN] [-infty;infty] [0;1] [1;1] [1;5] [1;infty] [NaN;NaN] [-infty;infty] [0;5] [1;5] [5;5] [5;infty] [NaN;NaN] [-infty;0] [0;infty] [1;infty] [5;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;0.2] [1;1] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;0.2] [1;1] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;0.2] [0;1] [0;infty] [NaN;NaN] [-infty;infty] [0;0.2] [0.199999999999999999999999999999999999999999999999997;0.2] [0.199999999999999999999999999999999999999999999999997;1] [0.199999999999999999999999999999999999999999999999997;infty] [NaN;NaN] [-infty;infty] [0;1] [0.199999999999999999999999999999999999999999999999997;1] [1;1] [1;infty] [NaN;NaN] [-infty;0] [0;infty] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [infty;infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [-infty;1] [-infty;5] [-infty;infty] [NaN;NaN] [0;0] [0;0] [-infty;1] [-infty;5] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [0;0] [-infty;1] [-infty;5] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;1] [-infty;1] [-infty;5] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;5] [-infty;5] [-infty;5] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [-infty;0.2] [-infty;1] [-infty;infty] [NaN;NaN] [0;0] [0;0] [-infty;0.2] [-infty;1] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [0;0] [-infty;0.2] [-infty;1] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;0.2] [-infty;0.2] [-infty;1] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;1] [-infty;1] [-infty;1] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [-infty;0] [-infty;0] [-infty;infty] [NaN;NaN] [0;0] [0;0] [-infty;0] [-infty;0] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;0] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [0;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [infty;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;-infty] [NaN;NaN] [-infty;infty] [NaN;NaN] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [-infty;-infty] [infty;infty] [infty;infty] [infty;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [1;infty] [5;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [1;infty] [5;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [1;infty] [1;infty] [1;infty] [NaN;NaN] [-infty;infty] [0;infty] [1;infty] [5;infty] [5;infty] [NaN;NaN] [-infty;0] [0;infty] [1;infty] [5;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [0.199999999999999999999999999999999999999999999999997;infty] [0.199999999999999999999999999999999999999999999999997;infty] [0.199999999999999999999999999999999999999999999999997;infty] [NaN;NaN] [-infty;infty] [0;infty] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [1;infty] [NaN;NaN] [-infty;0] [0;infty] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;infty] [0;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;infty] [0;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;0] [0;infty] [0;infty] [0;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [-infty;1] [-infty;5] [-infty;infty] [NaN;NaN] [0;0] [0;0] [-infty;1] [-infty;5] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [0;0] [-infty;1] [-infty;5] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;1] [-infty;1] [-infty;5] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;5] [-infty;5] [-infty;5] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [1;infty] [5;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [1;infty] [5;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [1;infty] [1;infty] [1;infty] [NaN;NaN] [-infty;infty] [0;infty] [1;infty] [5;infty] [5;infty] [NaN;NaN] [-infty;0] [0;infty] [1;infty] [5;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [1;1] [5;5] [-infty;infty] [NaN;NaN] [0;0] [0;0] [1;1] [5;5] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;1] [0;5] [0;infty] [NaN;NaN] [-infty;infty] [0;1] [1;1] [1;5] [1;infty] [NaN;NaN] [-infty;infty] [0;5] [1;5] [5;5] [5;infty] [NaN;NaN] [-infty;0] [0;infty] [1;infty] [5;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;1] [1;5] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;1] [1;5] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;1] [0;5] [0;infty] [NaN;NaN] [-infty;infty] [0;1] [0.199999999999999999999999999999999999999999999999997;1] [0.199999999999999999999999999999999999999999999999997;5] [0.199999999999999999999999999999999999999999999999997;infty] [NaN;NaN] [-infty;infty] [0;5] [0.199999999999999999999999999999999999999999999999997;5] [1;5] [1;infty] [NaN;NaN] [-infty;0] [0;infty] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;1] [0;5] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;1] [0;5] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;1] [0;5] [0;infty] [NaN;NaN] [-infty;infty] [0;1] [0;1] [0;5] [0;infty] [NaN;NaN] [-infty;infty] [0;5] [0;5] [0;5] [0;infty] [NaN;NaN] [-infty;0] [0;infty] [0;infty] [0;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [-infty;0.2] [-infty;1] [-infty;infty] [NaN;NaN] [0;0] [0;0] [-infty;0.2] [-infty;1] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [-infty;infty] [0;0] [-infty;0.2] [-infty;1] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;0.2] [-infty;0.2] [-infty;1] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;1] [-infty;1] [-infty;1] [-infty;infty] [NaN;NaN] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [0.199999999999999999999999999999999999999999999999997;infty] [0.199999999999999999999999999999999999999999999999997;infty] [0.199999999999999999999999999999999999999999999999997;infty] [NaN;NaN] [-infty;infty] [0;infty] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [1;infty] [NaN;NaN] [-infty;0] [0;infty] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;1] [1;5] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;1] [1;5] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;1] [0;5] [0;infty] [NaN;NaN] [-infty;infty] [0;1] [0.199999999999999999999999999999999999999999999999997;1] [0.199999999999999999999999999999999999999999999999997;5] [0.199999999999999999999999999999999999999999999999997;infty] [NaN;NaN] [-infty;infty] [0;5] [0.199999999999999999999999999999999999999999999999997;5] [1;5] [1;infty] [NaN;NaN] [-infty;0] [0;infty] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;0.2] [1;1] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0.199999999999999999999999999999999999999999999999997;0.2] [1;1] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;0.2] [0;1] [0;infty] [NaN;NaN] [-infty;infty] [0;0.2] [0.199999999999999999999999999999999999999999999999997;0.2] [0.199999999999999999999999999999999999999999999999997;1] [0.199999999999999999999999999999999999999999999999997;infty] [NaN;NaN] [-infty;infty] [0;1] [0.199999999999999999999999999999999999999999999999997;1] [1;1] [1;infty] [NaN;NaN] [-infty;0] [0;infty] [0.199999999999999999999999999999999999999999999999997;infty] [1;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;0.2] [0;1] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;0.2] [0;1] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;0.2] [0;1] [0;infty] [NaN;NaN] [-infty;infty] [0;0.2] [0;0.2] [0;1] [0;infty] [NaN;NaN] [-infty;infty] [0;1] [0;1] [0;1] [0;infty] [NaN;NaN] [-infty;0] [0;infty] [0;infty] [0;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [-infty;0] [-infty;0] [-infty;infty] [NaN;NaN] [0;0] [0;0] [-infty;0] [-infty;0] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;0] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [-infty;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;0] [NaN;NaN] [0;infty] [-infty;0] [-infty;0] [-infty;0] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;infty] [0;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;infty] [0;infty] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [-infty;0] [0;infty] [0;infty] [0;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;1] [0;5] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;1] [0;5] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;1] [0;5] [0;infty] [NaN;NaN] [-infty;infty] [0;1] [0;1] [0;5] [0;infty] [NaN;NaN] [-infty;infty] [0;5] [0;5] [0;5] [0;infty] [NaN;NaN] [-infty;0] [0;infty] [0;infty] [0;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;0.2] [0;1] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;0.2] [0;1] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;infty] [-infty;infty] [-infty;infty] [-infty;0] [NaN;NaN] [-infty;infty] [0;0] [0;0.2] [0;1] [0;infty] [NaN;NaN] [-infty;infty] [0;0.2] [0;0.2] [0;1] [0;infty] [NaN;NaN] [-infty;infty] [0;1] [0;1] [0;1] [0;infty] [NaN;NaN] [-infty;0] [0;infty] [0;infty] [0;infty] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [-infty;infty] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] NaN NaN NaN NaN NaN NaN [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] NaN 0 -infty -infty -infty -1 [NaN;NaN] [0;0] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [-infty;0] [-infty;0] [-infty;0] [0;0] [NaN;NaN] [-infty;0] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;0] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [-infty;0] [-infty;-infty] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] [0;0] [-infty;-infty] [-infty;-infty] [-infty;-infty] [NaN;NaN] NaN 0 infty infty infty 1 [NaN;NaN] [0;0] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [0;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [0;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [0;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [0;0] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] NaN 0 infty 3125 5 1 [NaN;NaN] [0;0] [infty;infty] [3125;3125] [5;5] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;infty] [0;3125.0000000000000000000000000000000000000000000001] [0;5.0000000000000000000000000000000000000000000000002] [0;1] [NaN;NaN] [0;infty] [infty;infty] [3124.9999999999999999999999999999999999999999999999;infty] [4.9999999999999999999999999999999999999999999999998;infty] [1;infty] [NaN;NaN] [0;3125.0000000000000000000000000000000000000000000001] [3124.9999999999999999999999999999999999999999999999;infty] [3125;3125] [5;3125] [1;3125] [NaN;NaN] [0;5.0000000000000000000000000000000000000000000000002] [4.9999999999999999999999999999999999999999999999998;infty] [5;3125] [5;5] [1;5] [NaN;NaN] [0;1] [1;infty] [1;3125] [1;5] [1;1] NaN 1 1 1 1 1 [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [1;1] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [1;1] [1;1] [1;1] [NaN;NaN] [1;1] [NaN;NaN] [1;1] [1;1] [1;1] [NaN;NaN] [1;1] [1;1] [1;1] [1;1] [1;1] [NaN;NaN] [1;1] [1;1] [1;1] [1;1] [1;1] [NaN;NaN] [1;1] [1;1] [1;1] [1;1] [1;1] NaN infty 0 0 0 1 [NaN;NaN] [infty;infty] [0;0] [0;0] [0;0] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [0;infty] [0;infty] [0;infty] [infty;infty] [NaN;NaN] [0;infty] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;infty] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;infty] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [infty;infty] [0;0] [0;0] [0;0] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [0;0] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [0;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [0;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [0;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [0;0] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [0;0] [infty;infty] [3125;3125] [5;5] [1;1] [NaN;NaN] [0;0] [infty;infty] [3125;3125] [5;5] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;infty] [0;3125.0000000000000000000000000000000000000000000001] [0;5.0000000000000000000000000000000000000000000000002] [0;1] [NaN;NaN] [0;infty] [infty;infty] [3124.9999999999999999999999999999999999999999999999;infty] [4.9999999999999999999999999999999999999999999999998;infty] [1;infty] [NaN;NaN] [0;3125.0000000000000000000000000000000000000000000001] [3124.9999999999999999999999999999999999999999999999;infty] [3125;3125] [4.9999999999999999999999999999999999999999999999998;3125.0000000000000000000000000000000000000000000001] [1;3125.0000000000000000000000000000000000000000000001] [NaN;NaN] [0;5.0000000000000000000000000000000000000000000000002] [4.9999999999999999999999999999999999999999999999998;infty] [4.9999999999999999999999999999999999999999999999998;3125.0000000000000000000000000000000000000000000001] [5;5] [1;5.0000000000000000000000000000000000000000000000002] [NaN;NaN] [0;1] [1;infty] [1;3125.0000000000000000000000000000000000000000000001] [1;5.0000000000000000000000000000000000000000000000002] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [1;1] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [1;1] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [1;1] [1;1] [1;1] [NaN;NaN] [1;1] [NaN;NaN] [1;1] [1;1] [1;1] [NaN;NaN] [1;1] [1;1] [1;1] [1;1] [1;1] [NaN;NaN] [1;1] [1;1] [1;1] [1;1] [1;1] [NaN;NaN] [1;1] [1;1] [1;1] [1;1] [1;1] [NaN;NaN] [infty;infty] [0;0] [0;0] [0;0] [1;1] [NaN;NaN] [infty;infty] [0;0] [0;0] [0;0] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [0;infty] [0;infty] [0;infty] [infty;infty] [NaN;NaN] [0;infty] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;infty] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;infty] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [infty;infty] [0;0] [0;0] [0;0] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;-infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;3125] [-infty;5] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;3125] [-infty;5] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;3125] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;1] [-infty;1] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;1] [-infty;1] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;0] [-infty;0] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;0] [-infty;0] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [-infty;infty] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [NaN;NaN] [0;0] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [0;0] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;infty] [0;infty] [0;infty] [0;0] [NaN;NaN] [0;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [0;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [0;infty] [infty;infty] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [0;0] [infty;infty] [infty;infty] [infty;infty] [NaN;NaN] [NaN;NaN] [0;0] [infty;infty] [3125;infty] [5;infty] [1;1] [NaN;NaN] [0;0] [infty;infty] [3125;infty] [5;infty] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;infty] [0;infty] [0;infty] [0;1] [NaN;NaN] [0;infty] [infty;infty] [3124.9999999999999999999999999999999999999999999999;infty] [4.9999999999999999999999999999999999999999999999998;infty] [1;infty] [NaN;NaN] [0;infty] [3124.9999999999999999999999999999999999999999999999;infty] [3125;infty] [4.9999999999999999999999999999999999999999999999998;infty] [1;infty] [NaN;NaN] [0;infty] [4.9999999999999999999999999999999999999999999999998;infty] [4.9999999999999999999999999999999999999999999999998;infty] [5;infty] [1;infty] [NaN;NaN] [0;1] [1;infty] [1;infty] [1;infty] [1;1] [NaN;NaN] [0;0] [infty;infty] [1;infty] [1;infty] [1;1] [NaN;NaN] [0;0] [infty;infty] [1;infty] [1;infty] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;infty] [0;infty] [0;infty] [0;1] [NaN;NaN] [0;infty] [infty;infty] [1;infty] [1;infty] [1;infty] [NaN;NaN] [0;infty] [1;infty] [1;infty] [1;infty] [1;infty] [NaN;NaN] [0;infty] [1;infty] [1;infty] [1;infty] [1;infty] [NaN;NaN] [0;1] [1;infty] [1;infty] [1;infty] [1;1] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [1;1] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;3125] [-infty;5] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;3125] [-infty;5] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;3125] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;5] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [NaN;NaN] [0;0] [infty;infty] [3125;infty] [5;infty] [1;1] [NaN;NaN] [0;0] [infty;infty] [3125;infty] [5;infty] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;infty] [0;infty] [0;infty] [0;1] [NaN;NaN] [0;infty] [infty;infty] [3124.9999999999999999999999999999999999999999999999;infty] [4.9999999999999999999999999999999999999999999999998;infty] [1;infty] [NaN;NaN] [0;infty] [3124.9999999999999999999999999999999999999999999999;infty] [3125;infty] [4.9999999999999999999999999999999999999999999999998;infty] [1;infty] [NaN;NaN] [0;infty] [4.9999999999999999999999999999999999999999999999998;infty] [4.9999999999999999999999999999999999999999999999998;infty] [5;infty] [1;infty] [NaN;NaN] [0;1] [1;infty] [1;infty] [1;infty] [1;1] [NaN;NaN] [0;0] [infty;infty] [3125;3125] [5;5] [1;1] [NaN;NaN] [0;0] [infty;infty] [3125;3125] [5;5] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;infty] [0;3125.0000000000000000000000000000000000000000000001] [0;5.0000000000000000000000000000000000000000000000002] [0;1] [NaN;NaN] [0;infty] [infty;infty] [3124.9999999999999999999999999999999999999999999999;infty] [4.9999999999999999999999999999999999999999999999998;infty] [1;infty] [NaN;NaN] [0;3125.0000000000000000000000000000000000000000000001] [3124.9999999999999999999999999999999999999999999999;infty] [3125;3125] [4.9999999999999999999999999999999999999999999999998;3125.0000000000000000000000000000000000000000000001] [1;3125.0000000000000000000000000000000000000000000001] [NaN;NaN] [0;5.0000000000000000000000000000000000000000000000002] [4.9999999999999999999999999999999999999999999999998;infty] [4.9999999999999999999999999999999999999999999999998;3125.0000000000000000000000000000000000000000000001] [5;5] [1;5.0000000000000000000000000000000000000000000000002] [NaN;NaN] [0;1] [1;infty] [1;3125.0000000000000000000000000000000000000000000001] [1;5.0000000000000000000000000000000000000000000000002] [1;1] [NaN;NaN] [0;0] [infty;infty] [1;3125] [1;5] [1;1] [NaN;NaN] [0;0] [infty;infty] [1;3125] [1;5] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;infty] [0;3125.0000000000000000000000000000000000000000000001] [0;5.0000000000000000000000000000000000000000000000002] [0;1] [NaN;NaN] [0;infty] [infty;infty] [1;infty] [1;infty] [1;infty] [NaN;NaN] [0;3125.0000000000000000000000000000000000000000000001] [1;infty] [1;3125] [1;3125.0000000000000000000000000000000000000000000001] [1;3125.0000000000000000000000000000000000000000000001] [NaN;NaN] [0;5.0000000000000000000000000000000000000000000000002] [1;infty] [1;3125.0000000000000000000000000000000000000000000001] [1;5] [1;5.0000000000000000000000000000000000000000000000002] [NaN;NaN] [0;1] [1;infty] [1;3125.0000000000000000000000000000000000000000000001] [1;5.0000000000000000000000000000000000000000000000002] [1;1] [NaN;NaN] [0;infty] [0;infty] [0;3125] [0;5] [1;1] [NaN;NaN] [0;infty] [0;infty] [0;3125] [0;5] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [0;infty] [0;infty] [0;3125] [0;3125.0000000000000000000000000000000000000000000001] [0;3125.0000000000000000000000000000000000000000000001] [NaN;NaN] [0;infty] [0;infty] [0;3125.0000000000000000000000000000000000000000000001] [0;5] [0;5.0000000000000000000000000000000000000000000000002] [NaN;NaN] [0;infty] [0;infty] [0;3125.0000000000000000000000000000000000000000000001] [0;5.0000000000000000000000000000000000000000000000002] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;1] [-infty;1] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;1] [-infty;1] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [NaN;NaN] [0;0] [infty;infty] [1;infty] [1;infty] [1;1] [NaN;NaN] [0;0] [infty;infty] [1;infty] [1;infty] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;infty] [0;infty] [0;infty] [0;1] [NaN;NaN] [0;infty] [infty;infty] [1;infty] [1;infty] [1;infty] [NaN;NaN] [0;infty] [1;infty] [1;infty] [1;infty] [1;infty] [NaN;NaN] [0;infty] [1;infty] [1;infty] [1;infty] [1;infty] [NaN;NaN] [0;1] [1;infty] [1;infty] [1;infty] [1;1] [NaN;NaN] [0;0] [infty;infty] [1;3125] [1;5] [1;1] [NaN;NaN] [0;0] [infty;infty] [1;3125] [1;5] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;0] [0;infty] [0;3125.0000000000000000000000000000000000000000000001] [0;5.0000000000000000000000000000000000000000000000002] [0;1] [NaN;NaN] [0;infty] [infty;infty] [1;infty] [1;infty] [1;infty] [NaN;NaN] [0;3125.0000000000000000000000000000000000000000000001] [1;infty] [1;3125] [1;3125.0000000000000000000000000000000000000000000001] [1;3125.0000000000000000000000000000000000000000000001] [NaN;NaN] [0;5.0000000000000000000000000000000000000000000000002] [1;infty] [1;3125.0000000000000000000000000000000000000000000001] [1;5] [1;5.0000000000000000000000000000000000000000000000002] [NaN;NaN] [0;1] [1;infty] [1;3125.0000000000000000000000000000000000000000000001] [1;5.0000000000000000000000000000000000000000000000002] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [1;1] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [1;1] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [1;1] [1;1] [1;1] [NaN;NaN] [1;1] [NaN;NaN] [1;1] [1;1] [1;1] [NaN;NaN] [1;1] [1;1] [1;1] [1;1] [1;1] [NaN;NaN] [1;1] [1;1] [1;1] [1;1] [1;1] [NaN;NaN] [1;1] [1;1] [1;1] [1;1] [1;1] [NaN;NaN] [infty;infty] [0;0] [0;1] [0;1] [1;1] [NaN;NaN] [infty;infty] [0;0] [0;1] [0;1] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [0;infty] [0;infty] [0;infty] [1;infty] [NaN;NaN] [0;infty] [0;0] [0;1] [0;1] [0;1] [NaN;NaN] [0;infty] [0;1] [0;1] [0;1] [0;1] [NaN;NaN] [0;infty] [0;1] [0;1] [0;1] [0;1] [NaN;NaN] [1;infty] [0;1] [0;1] [0;1] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;0] [-infty;0] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;0] [-infty;0] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [-infty;0] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [1;1] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [1;1] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [1;1] [NaN;NaN] [0;infty] [0;infty] [0;3125] [0;5] [1;1] [NaN;NaN] [0;infty] [0;infty] [0;3125] [0;5] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [0;infty] [0;infty] [0;infty] [0;infty] [0;infty] [NaN;NaN] [0;infty] [0;infty] [0;3125] [0;3125.0000000000000000000000000000000000000000000001] [0;3125.0000000000000000000000000000000000000000000001] [NaN;NaN] [0;infty] [0;infty] [0;3125.0000000000000000000000000000000000000000000001] [0;5] [0;5.0000000000000000000000000000000000000000000000002] [NaN;NaN] [0;infty] [0;infty] [0;3125.0000000000000000000000000000000000000000000001] [0;5.0000000000000000000000000000000000000000000000002] [1;1] [NaN;NaN] [infty;infty] [0;0] [0;1] [0;1] [1;1] [NaN;NaN] [infty;infty] [0;0] [0;1] [0;1] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [0;infty] [0;infty] [0;infty] [1;infty] [NaN;NaN] [0;infty] [0;0] [0;1] [0;1] [0;1] [NaN;NaN] [0;infty] [0;1] [0;1] [0;1] [0;1] [NaN;NaN] [0;infty] [0;1] [0;1] [0;1] [0;1] [NaN;NaN] [1;infty] [0;1] [0;1] [0;1] [1;1] [NaN;NaN] [infty;infty] [0;0] [0;0] [0;0] [1;1] [NaN;NaN] [infty;infty] [0;0] [0;0] [0;0] [1;1] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [NaN;NaN] [infty;infty] [0;infty] [0;infty] [0;infty] [infty;infty] [NaN;NaN] [0;infty] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;infty] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [0;infty] [0;0] [0;0] [0;0] [0;0] [NaN;NaN] [infty;infty] [0;0] [0;0] [0;0] [1;1] The tool has been restarted. sollya-6.0+ds/tests-tool/check029.sollya000066400000000000000000002702231300174114700201420ustar00rootroot00000000000000restart; print("=============== Test number 1 ================"); /* Non-regression test for a segfault bug in fpminimax, fixed on November 20th 2015 */ fpminimax(exp(x),5,[|D,D,D,D,D|],[-1;1]); restart; print("=============== Test number 2 ================"); /* Non-regression test for bug #16632 */ /* The following example should not fall into an infinite loop */ f = 2473 - 4979*x/10 + 3971*x^2/100 - 157*x^3/100 + 77*x^4/2500 - 3*x^5/12500; points=4!; a=dirtyfindzeros(f, [10, 50]); length(a)==3; restart; print("=============== Test number 3 ================"); /* Non-regression test for bug #11966 */ /* The following example should not fall into an infinite loop */ points=4; dirtyfindzeros( (x-(2-1b-300))*(x-(2+1b-300)), [1,5]); restart; print("=============== Test number 4 ================"); /* Non-regression test for bug patched with commit bc748a402983af1c2b72e7faabc5c3344e2013cf */ p = implementpoly(5933108082745413b-47 + x * (8371870699358531b-57 + x * (-5019189491068933b-64 + x * (-1235985524236843b-65 + x * (5928085562303317b-76 + x * (7007054019943729b-80 + x * (-1400231163274209b-87 + x * (-2363983593233507b-92))))))),[-2961770179049179b-51;740442544762295b-49],3b-54,double,"f","implementation.c",honorcoeffprec); bashevaluate("tail -n 44 implementation.c"); restart; print("=============== Test number 5 ================"); /* Non regression test for bug [#20056] Division by zero when computing a degree */ p = ((1 + x)^3000); degree(diff(p)); restart; print("=============== Test number 6 ================"); /* Non regression test for bug [#19925] Convention used for hexadecimal display */ display=hexadecimal; 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 33; 33 == 0x84p-2; 33 == 0x42p-1; 33 == 0x21p0; 33 == 0x108p-3; 9993249 * 2^(-2); 9993249 * 2^(-2) == 0x2.61f084p20; 9993249 * 2^(-2) == 0x9.87c21p18; 0x7.abba18p-4; 0x7.abba2p-4; -0xa.88bd7p-8; -0xa.88bc8p-8; 0xb.69013p-12; -0x4.0fcb5p-8; 0xa.df75ap-8; -0x1.33194ep-4; 0x1.b403a8p-4; -0x2.45eb84p-4; 0x3.32ee9p-4; -0x5.55536p-4; -0x1.5554d8p0; -0x1.5554d8p20; -0xa.aaa6cp16; restart; print("=============== Test number 7 ================"); /* Non regression test for bug [#7085] Rounding to simple value with infinity overflow is wrong */ procedure insertIntoSet(S, e) { var res; var T, i, contained; contained = false; T = S; while ((!contained) && (T != [||])) do { i = head(T); T = tail(T); if (i == e) then { contained = true; }; }; if (contained) then { res = S; } else { res = e .: S; }; return res; }; procedure ulpSingle(X) { var absX, res; absX = abs(X); if (absX < 0x00800000) then { res = 1b-149; } else { res = 2^(floor(log2(absX)) - 24 + 1); }; return res; }; procedure ulpDouble(X) { var absX, res; absX = abs(X); if (absX < 0x0010000000000000) then { res = 1b-1074; } else { res = 2^(floor(log2(absX)) - 53 + 1); }; return res; }; procedure ulpNatif(X) { return 2^(floor(log2(abs(X))) - 165 + 1); }; procedure testsingle(X) { var res, absX, sgnX, E; if (X >= 340282356779733661637539395458142568448) then { res = infty; } else { if (X <= -340282356779733661637539395458142568448) then { res = -infty; } else { if (X < 0) then { absX = -X; sgnX = -1; } else { absX = X; sgnX = 1; }; if (absX <= 1b-150) then { res = 0; } else { E = floor(log2(absX)); if (E <= -126) then { E = -126; }; ulp = 2^(E - 24 + 1); res = ulp * nearestint(absX / ulp); }; res = sgnX * res; }; }; return res; }; write("Computing data to test rounding to single precision\n"); prec = 2000!; fudges = [| 1b-1800, 1b-1076, 1b-1075 |]; testvalues = [||]; for s in [| 1b-149, 0x007fffff, 0x7f7fffff |] do { u = ulpSingle(s); for t in [| s, s - 1/2 * u, s - 1/4 * u, s - 1/8 * u, s + 1/4 * u, s + 1/2 * u |] do { uu = ulpDouble(t); for r in [| t, t - 1/2 * uu, t - 1/4 * uu, t - 1/8 * uu, t + 1/4 * uu, t + 1/2 * uu |] do { uuu = ulpNatif(r); for z in [| r, r - 1/2 * uuu, r - 1/4 * uuu, r - 1/8 * uuu, r + 1/4 * uuu, r + 1/2 * uuu |] do { for f in fudges do { for v in [| z, -z, z - f, z + f, -z + f, -z - f |] do { testvalues = v .: testvalues; }; }; }; }; }; }; prec = 165!; roundingwarnings=on!; display = hexadecimal!; write("Starting actual test\n"); resvalues = [||]; okay = true; for v in testvalues do { sv = round(v, SG, RN); tv = testsingle(v); if (sv != tv) then { write("Wrong rounding to single precision detected for v = ", v, ", expected ", tv, ", got ", sv, " = "); printsingle(sv); okay = false; }; resvalues = insertIntoSet(resvalues, sv); }; if (okay) then { write("All test values for rounding to single precision have yielded a correct result.\n"); }; write("Now testing printsingle displaying\n"); for v in resvalues do { write(v, " = "); printsingle(v); }; write("End of test\n"); restart; print("=============== Test number 8 ================"); /* Non regression test for bug [#17196] Inconsistent behavior of evaluate */ evaluate(x * (2/sin(x)), 0) == evaluate(x * 2/sin(x), 0); restart; print("=============== Test number 9 ================"); /* Non regression test for bug [#14451] guessdegree has a strange behavior on point intervals */ guessdegree(1,[0.3125e-1;0.3125e-1],1b-20,1 / exp(x)); restart; print("=============== Test number 10 ================"); /* Non regression test for bug [#20070] getbacktrace does not conform to its documentation */ procedure test(l=...) { getbacktrace(); }; test @ [|1, "Coucou", 3...|]; restart; print("=============== Test number 10b ================"); /* Elementary test for getbacktrace */ procedure testA() { "Current backtrace:"; getbacktrace(); }; procedure testB(X) {"X = ", X; testA(); }; procedure testC(X, Y) {"X = ", X, ", Y = ", Y; testB(Y); }; testC(17, 42); restart; print("=============== Test number 10c ================"); /* getbacktrace at top level returns an empty list */ getbacktrace(); restart; print("=============== Test number 10d ================"); /* getbacktrace togther with objectname. Example of a procedure accepting a list as argument, and of a procedure with an arbitrary number of arguments */ procedure printnumargs(X) { var L, t; "number of arguments: ", X; L = getbacktrace(); "Backtrace:"; for t in L do { " " @ objectname(t.called_proc) @ ", ", t.passed_args; }; }; procedure numargs(l = ...) { if (length(l)>17) then "l[17] = ", l[17]; printnumargs(length(l)); }; procedure test1() { numargs @ [|25, 26, 27 ...|]; }; procedure test2(x) { numargs @ x; }; test1(); test2([|1,2,3|]); restart; print("=============== Test number 11 ================"); /* Non regression test for bug [#20071] Using annotatefunction leads to a unexpected approximation warning. */ verbosity = 1!; roundingwarnings = on!; prec = 80!; procedure EXP(X,n,p) { var res, oldPrec; oldPrec = prec; prec = p!; "Using procedure function exponential with X = ", X, ", n = ", n, ", p = ", p; res = exp(X); prec = oldPrec!; return res; }; g = function(EXP); p = 46768052394588893382516870161332864698044514954899b-165 + x * (23384026197294446691258465802074096632225783601255b-164 + x * (5846006549323611672948426613035653821819225877423b-163 + x * (3897337699549074448627696490806815137319821946501b-164 + x * (7794675399098148717422744621371434831048848817417b-167 + x * (24942961277114075921122941174178849425809856036737b-171 + x * (8314320425704876115613838900105097456456371179471b-172 + x * (19004160973039701371579356991645932289422670402995b-176 + x * (19004160972669324148912122254449912156003926801563b-179 + x * (33785175062542597526738679493857229456702396042255b-183 + x * (6757035113643674378393625988264926886191860669891b-184 + x * (9828414707511252769908089206114262766633532289937b-188 + x * (26208861108003813314724515233584738706961162212965b-193 + x * (32257064253325954315953742396999456577223350602741b-197 + x * (578429089657689569703509185903214676926704485495b-195 + x * 2467888542176675658523627105540996778984959471957b-201)))))))))))))); g= annotatefunction(g, p, [-1/2;1/2], [-475294848522543b-124;475294848522543b-124]); g(0.25); prec=53!; g(1/3); g(0.25); prec=80!; g(1/3); restart; print("=============== Test number 12 ================"); /* Non regression test for bug [#20094] NaN comparisons do not work as expected. */ NaN == NaN; NaN != NaN; b = NaN; b == b; b != b; error == error; error != error; a = error; a == a; a != a; a == @NaN@; a != @NaN@; b == error; b != error; a == b; a != b; match a with @NaN@: ("Is a NaN") default: ("Is not a NaN"); match error with @NaN@: ("Is a NaN") default: ("Is not a NaN"); match b with @NaN@: ("Is a NaN") default: ("Is not a NaN"); match @NaN@ with @NaN@: ("Is a NaN") default: ("Is not a NaN"); match [||] with @NaN@: ("Is a NaN") default: ("Is not a NaN"); restart; print("=============== Test number 13 ================"); FILENAME = "tmpFile-check029" @ __unique_id @ ".sollya"; COUNT = 0; print("procedure contains(elem, L) {") > FILENAME; print(" var t, res;") >> FILENAME; print(" res = false;") >> FILENAME; print(" for t in L do {") >> FILENAME; print(" if elem == t then res = true;") >> FILENAME; print(" };") >> FILENAME; print(" return res;") >> FILENAME; print("};\n") >> FILENAME; for A1 in [|true,false|] do { for A2 in [|true,false|] do { for A3 in [|true,false|] do { for B1 in [|true,false|] do { for B2 in [|true,false|] do { for B3 in [|true,false|] do { for C1 in [|true,false|] do { for C2 in [|true,false|] do { for C3 in [|true,false|] do { COUNT = COUNT + 1; if A1 then print("a" @ COUNT @ " = exp(x) + " @ COUNT @ ";") >> FILENAME; if B1 then print("b" @ COUNT @ " = cos(x);") >> FILENAME; if C1 then print("c" @ COUNT @ " = cos(x);") >> FILENAME; print("procedure test() {") >> FILENAME; if A2 then print(" var a" @ COUNT @ ";") >> FILENAME; if B2 then print(" var b" @ COUNT @ ";") >> FILENAME; if C2 then print(" var c" @ COUNT @ ";") >> FILENAME; if A2 then print(" a" @ COUNT @ " = cos(x);") >> FILENAME; if B2 then print(" b" @ COUNT @ " = exp(x) + " @ COUNT @ ";") >> FILENAME; if C2 then print(" c" @ COUNT @ " = cos(x);") >> FILENAME; print(" procedure test_inner() {") >> FILENAME; print(" var s, expected;") >> FILENAME; if A3 then print(" var a" @ COUNT @ ";") >> FILENAME; if B3 then print(" var b" @ COUNT @ ";") >> FILENAME; if C3 then print(" var c" @ COUNT @ ";") >> FILENAME; if A3 then print(" a" @ COUNT @ " = cos(x);") >> FILENAME; if B3 then print(" b" @ COUNT @ " = cos(x);") >> FILENAME; if C3 then print(" c" @ COUNT @ " = exp(x) + " @ COUNT @ ";") >> FILENAME; EXPECTED = [||]; if C3 then EXPECTED = EXPECTED :. ("c" @ COUNT); if (B2 && (!B3)) then EXPECTED = EXPECTED :. ("b" @ COUNT); if (A1 && (!A2) && (!A3)) then EXPECTED = EXPECTED :. ("a" @ COUNT); display = hexadecimal!; if EXPECTED == [||] then EXPECTED = [|"(exp(x)) + (" @ COUNT @ ")"|]; print(" s = objectname(exp(x) + " @ COUNT @ ");") >> FILENAME; display = decimal!; print(" expected = " @ EXPECTED @ ";") >> FILENAME; print(" if (exp(x) + " @ COUNT @ " != parse(s)) then print(\"Error detected [|A1,A2,A3,B1,B2,B3,C1,C2,C3|] = \", " @ [|A1,A2,A3,B1,B2,B3,C1,C2,C3|] @ ");") >> FILENAME; print(" if !contains(s, expected) then print(\"Unexpected \",s,\"(should belong to \", expected, \"). [|A1,A2,A3,B1,B2,B3,C1,C2,C3|] = \", " @ [|A1,A2,A3,B1,B2,B3,C1,C2,C3|] @ ");") >> FILENAME; print(" return void;") >> FILENAME; print(" };") >> FILENAME; print(" test_inner();") >> FILENAME; print(" return void;") >> FILENAME; print("};") >> FILENAME; print("test();\n") >> FILENAME; };};}; };};}; };};}; print("Running systematic tests for objectname..."); execute(FILENAME); print("Test run. Removing temporary file."); bashexecute("rm -rf " @ FILENAME); print("End of tests for objectname."); restart; print("=============== Test number 14 ================"); /* Non-regression test for bug fixed on 2016, July 27th */ /* The following example should not fall into an infinite loop */ prec = 350!; verbosity=0!; zero = 1b-100; dom = [zero;0x3fefffffffffffff]; q = x * (2918320636831873b-51 + x^2 * (-2812036178508593b-51 + x^2 * 3308766278594951b-51)); s = x * (9007199254740653b-53 + x^2 * (-3002399751552901b-54 + x^2 * (1200959899164001b-57 + x^2 * (-7320135585671187b-65 + x^2 * (1626678530493517b-69 + x^2 * (-7565607198486585b-78 + x^2 * 5975262180392203b-85)))))); c = 9007199254729395b-53 + x^2 * (-9007199253965425b-54 + x^2 * (3002399733779339b-56 + x^2 * (-6405116931749881b-62 + x^2 * (7319959653218259b-68 + x^2 * (-5198970630914559b-74 + x^2 * 4809296948379375b-81))))); t = s(q); h = c(q); r = x * h - t * sqrt(1 - x^2); p= remez(1-q/asin(x), [|r/asin(x), r^3/asin(x)|], dom, 1, 1e-2); print("Succeeded."); restart; print("=============== Test number 15 ================"); /* Non-regression test for bug #8867 */ /* The following examples should not fall into an infinite loop */ verbosity = 0!; b=round(pi,53,RD); p=remez(1,[|1,...,6|],[-1,b],1/sin(x)); print("Loop was not infinite"); restart; print("=============== Test number 15bis ================"); /* Non-regression test for bug #8867 */ /* The following examples should not fall into an infinite loop */ verbosity = 0!; prec=250; L = [|(x * 6215193255146273b-52 * sqrt(1 - x^2)) / x, (x^3 * 240084383221639362889634237063322305672153048417b-156 * sqrt(1 - x^2)) / x, (x^5 * 9274130135726315977204924027295787401259172547694862836311277722826903837042593b-260 * sqrt(1 - x^2)) / x, (x^7 * 358246915606274140191920304152769949749350577336553141294816968955983915567186730677646875115691472828069001697b-364 * sqrt(1 - x^2)) / x, (x^9 * 13838586548080362858940014402840360268995306239673696598277155473497177385003491303000131757744686625519952014193459235397229970270226467527713b-468 * sqrt(1 - x^2)) / x, 1, x^2 * 38628627198815724950998625790529b-104, x^4 * 1492170839265086001261130874140987270862577211466609670186099841b-208, x^6 * 57640511066914988424865872984169909598464624435858660244460993055001291786871802866265946205889b-312, x^8 * 2226573813553071122888224017176137039898190767752187705723358029551392386421767103114971542147284427945827772826758090820225281b-416|]; f = cos(x * 6215193255146273b-52) - sin(x * 6215193255146273b-52) * sqrt(1 - x^2)/x; p = remez(f,L,[1b-100;9007199254740991b-53]); print("Loop was not infinite"); restart; verbosity = 0!; print("----------- Additional tests for min and max ---------------"); temp = min([|-infty, -infty|]); write(1, ": min([|-infty, -infty|]) = ", temp, " vs. -infty\n"); temp = min([|-infty, infty|]); write(2, ": min([|-infty, infty|]) = ", temp, " vs. -infty\n"); temp = min([|-infty, NaN|]); write(3, ": min([|-infty, NaN|]) = ", temp, " vs. -infty\n"); temp = min([|-infty, 0|]); write(4, ": min([|-infty, 0|]) = ", temp, " vs. -infty\n"); temp = min([|-infty, sin(17 * (pi))|]); write(5, ": min([|-infty, sin(17 * (pi))|]) = ", temp, " vs. -infty\n"); temp = min([|-infty, sin(17 * (pi)) + 42|]); write(6, ": min([|-infty, sin(17 * (pi)) + 42|]) = ", temp, " vs. -infty\n"); temp = min([|-infty, 42|]); write(7, ": min([|-infty, 42|]) = ", temp, " vs. -infty\n"); temp = min([|-infty, 1664|]); write(8, ": min([|-infty, 1664|]) = ", temp, " vs. -infty\n"); temp = min([|-infty, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(9, ": min([|-infty, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. -infty\n"); temp = min([|-infty, exp(24 / 10)|]); write(10, ": min([|-infty, exp(24 / 10)|]) = ", temp, " vs. -infty\n"); temp = min([|-infty, log2(2076)|]); write(11, ": min([|-infty, log2(2076)|]) = ", temp, " vs. -infty\n"); temp = min([|-infty, -23|]); write(12, ": min([|-infty, -23|]) = ", temp, " vs. -infty\n"); temp = min([|-infty, 11.01953125|]); write(13, ": min([|-infty, 11.01953125|]) = ", temp, " vs. -infty\n"); temp = min([|infty, -infty|]); write(14, ": min([|infty, -infty|]) = ", temp, " vs. -infty\n"); temp = min([|infty, infty|]); write(15, ": min([|infty, infty|]) = ", temp, " vs. infty\n"); temp = min([|infty, NaN|]); write(16, ": min([|infty, NaN|]) = ", temp, " vs. infty\n"); temp = min([|infty, 0|]); write(17, ": min([|infty, 0|]) = ", temp, " vs. 0\n"); temp = min([|infty, sin(17 * (pi))|]); write(18, ": min([|infty, sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|infty, sin(17 * (pi)) + 42|]); write(19, ": min([|infty, sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min([|infty, 42|]); write(20, ": min([|infty, 42|]) = ", temp, " vs. 42\n"); temp = min([|infty, 1664|]); write(21, ": min([|infty, 1664|]) = ", temp, " vs. 1664\n"); temp = min([|infty, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(22, ": min([|infty, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|infty, exp(24 / 10)|]); write(23, ": min([|infty, exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = min([|infty, log2(2076)|]); write(24, ": min([|infty, log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = min([|infty, -23|]); write(25, ": min([|infty, -23|]) = ", temp, " vs. -23\n"); temp = min([|infty, 11.01953125|]); write(26, ": min([|infty, 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = min([|NaN, -infty|]); write(27, ": min([|NaN, -infty|]) = ", temp, " vs. -infty\n"); temp = min([|NaN, infty|]); write(28, ": min([|NaN, infty|]) = ", temp, " vs. infty\n"); temp = min([|NaN, NaN|]); write(29, ": min([|NaN, NaN|]) = ", temp, " vs. NaN\n"); temp = min([|NaN, 0|]); write(30, ": min([|NaN, 0|]) = ", temp, " vs. 0\n"); temp = min([|NaN, sin(17 * (pi))|]); write(31, ": min([|NaN, sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|NaN, sin(17 * (pi)) + 42|]); write(32, ": min([|NaN, sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min([|NaN, 42|]); write(33, ": min([|NaN, 42|]) = ", temp, " vs. 42\n"); temp = min([|NaN, 1664|]); write(34, ": min([|NaN, 1664|]) = ", temp, " vs. 1664\n"); temp = min([|NaN, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(35, ": min([|NaN, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|NaN, exp(24 / 10)|]); write(36, ": min([|NaN, exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = min([|NaN, log2(2076)|]); write(37, ": min([|NaN, log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = min([|NaN, -23|]); write(38, ": min([|NaN, -23|]) = ", temp, " vs. -23\n"); temp = min([|NaN, 11.01953125|]); write(39, ": min([|NaN, 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = min([|0, -infty|]); write(40, ": min([|0, -infty|]) = ", temp, " vs. -infty\n"); temp = min([|0, infty|]); write(41, ": min([|0, infty|]) = ", temp, " vs. 0\n"); temp = min([|0, NaN|]); write(42, ": min([|0, NaN|]) = ", temp, " vs. 0\n"); temp = min([|0, 0|]); write(43, ": min([|0, 0|]) = ", temp, " vs. 0\n"); temp = min([|0, sin(17 * (pi))|]); write(44, ": min([|0, sin(17 * (pi))|]) = ", temp, " vs. 0 or sin(17 * (pi))\n"); temp = min([|0, sin(17 * (pi)) + 42|]); write(45, ": min([|0, sin(17 * (pi)) + 42|]) = ", temp, " vs. 0\n"); temp = min([|0, 42|]); write(46, ": min([|0, 42|]) = ", temp, " vs. 0\n"); temp = min([|0, 1664|]); write(47, ": min([|0, 1664|]) = ", temp, " vs. 0\n"); temp = min([|0, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(48, ": min([|0, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. 0 or (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|0, exp(24 / 10)|]); write(49, ": min([|0, exp(24 / 10)|]) = ", temp, " vs. 0\n"); temp = min([|0, log2(2076)|]); write(50, ": min([|0, log2(2076)|]) = ", temp, " vs. 0\n"); temp = min([|0, -23|]); write(51, ": min([|0, -23|]) = ", temp, " vs. -23\n"); temp = min([|0, 11.01953125|]); write(52, ": min([|0, 11.01953125|]) = ", temp, " vs. 0\n"); temp = min([|sin(17 * (pi)), -infty|]); write(53, ": min([|sin(17 * (pi)), -infty|]) = ", temp, " vs. -infty\n"); temp = min([|sin(17 * (pi)), infty|]); write(54, ": min([|sin(17 * (pi)), infty|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|sin(17 * (pi)), NaN|]); write(55, ": min([|sin(17 * (pi)), NaN|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|sin(17 * (pi)), 0|]); write(56, ": min([|sin(17 * (pi)), 0|]) = ", temp, " vs. sin(17 * (pi)) or 0\n"); temp = min([|sin(17 * (pi)), sin(17 * (pi))|]); write(57, ": min([|sin(17 * (pi)), sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|sin(17 * (pi)), sin(17 * (pi)) + 42|]); write(58, ": min([|sin(17 * (pi)), sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|sin(17 * (pi)), 42|]); write(59, ": min([|sin(17 * (pi)), 42|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|sin(17 * (pi)), 1664|]); write(60, ": min([|sin(17 * (pi)), 1664|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|sin(17 * (pi)), (log2(13) / log2(17)) - (log(13) / log(17))|]); write(61, ": min([|sin(17 * (pi)), (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. sin(17 * (pi)) or (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|sin(17 * (pi)), exp(24 / 10)|]); write(62, ": min([|sin(17 * (pi)), exp(24 / 10)|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|sin(17 * (pi)), log2(2076)|]); write(63, ": min([|sin(17 * (pi)), log2(2076)|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|sin(17 * (pi)), -23|]); write(64, ": min([|sin(17 * (pi)), -23|]) = ", temp, " vs. -23\n"); temp = min([|sin(17 * (pi)), 11.01953125|]); write(65, ": min([|sin(17 * (pi)), 11.01953125|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|sin(17 * (pi)) + 42, -infty|]); write(66, ": min([|sin(17 * (pi)) + 42, -infty|]) = ", temp, " vs. -infty\n"); temp = min([|sin(17 * (pi)) + 42, infty|]); write(67, ": min([|sin(17 * (pi)) + 42, infty|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min([|sin(17 * (pi)) + 42, NaN|]); write(68, ": min([|sin(17 * (pi)) + 42, NaN|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min([|sin(17 * (pi)) + 42, 0|]); write(69, ": min([|sin(17 * (pi)) + 42, 0|]) = ", temp, " vs. 0\n"); temp = min([|sin(17 * (pi)) + 42, sin(17 * (pi))|]); write(70, ": min([|sin(17 * (pi)) + 42, sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|sin(17 * (pi)) + 42, sin(17 * (pi)) + 42|]); write(71, ": min([|sin(17 * (pi)) + 42, sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min([|sin(17 * (pi)) + 42, 42|]); write(72, ": min([|sin(17 * (pi)) + 42, 42|]) = ", temp, " vs. sin(17 * (pi)) + 42 or 42\n"); temp = min([|sin(17 * (pi)) + 42, 1664|]); write(73, ": min([|sin(17 * (pi)) + 42, 1664|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min([|sin(17 * (pi)) + 42, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(74, ": min([|sin(17 * (pi)) + 42, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|sin(17 * (pi)) + 42, exp(24 / 10)|]); write(75, ": min([|sin(17 * (pi)) + 42, exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = min([|sin(17 * (pi)) + 42, log2(2076)|]); write(76, ": min([|sin(17 * (pi)) + 42, log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = min([|sin(17 * (pi)) + 42, -23|]); write(77, ": min([|sin(17 * (pi)) + 42, -23|]) = ", temp, " vs. -23\n"); temp = min([|sin(17 * (pi)) + 42, 11.01953125|]); write(78, ": min([|sin(17 * (pi)) + 42, 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = min([|42, -infty|]); write(79, ": min([|42, -infty|]) = ", temp, " vs. -infty\n"); temp = min([|42, infty|]); write(80, ": min([|42, infty|]) = ", temp, " vs. 42\n"); temp = min([|42, NaN|]); write(81, ": min([|42, NaN|]) = ", temp, " vs. 42\n"); temp = min([|42, 0|]); write(82, ": min([|42, 0|]) = ", temp, " vs. 0\n"); temp = min([|42, sin(17 * (pi))|]); write(83, ": min([|42, sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|42, sin(17 * (pi)) + 42|]); write(84, ": min([|42, sin(17 * (pi)) + 42|]) = ", temp, " vs. 42 or sin(17 * (pi)) + 42\n"); temp = min([|42, 42|]); write(85, ": min([|42, 42|]) = ", temp, " vs. 42\n"); temp = min([|42, 1664|]); write(86, ": min([|42, 1664|]) = ", temp, " vs. 42\n"); temp = min([|42, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(87, ": min([|42, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|42, exp(24 / 10)|]); write(88, ": min([|42, exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = min([|42, log2(2076)|]); write(89, ": min([|42, log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = min([|42, -23|]); write(90, ": min([|42, -23|]) = ", temp, " vs. -23\n"); temp = min([|42, 11.01953125|]); write(91, ": min([|42, 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = min([|1664, -infty|]); write(92, ": min([|1664, -infty|]) = ", temp, " vs. -infty\n"); temp = min([|1664, infty|]); write(93, ": min([|1664, infty|]) = ", temp, " vs. 1664\n"); temp = min([|1664, NaN|]); write(94, ": min([|1664, NaN|]) = ", temp, " vs. 1664\n"); temp = min([|1664, 0|]); write(95, ": min([|1664, 0|]) = ", temp, " vs. 0\n"); temp = min([|1664, sin(17 * (pi))|]); write(96, ": min([|1664, sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|1664, sin(17 * (pi)) + 42|]); write(97, ": min([|1664, sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min([|1664, 42|]); write(98, ": min([|1664, 42|]) = ", temp, " vs. 42\n"); temp = min([|1664, 1664|]); write(99, ": min([|1664, 1664|]) = ", temp, " vs. 1664\n"); temp = min([|1664, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(100, ": min([|1664, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|1664, exp(24 / 10)|]); write(101, ": min([|1664, exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = min([|1664, log2(2076)|]); write(102, ": min([|1664, log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = min([|1664, -23|]); write(103, ": min([|1664, -23|]) = ", temp, " vs. -23\n"); temp = min([|1664, 11.01953125|]); write(104, ": min([|1664, 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), -infty|]); write(105, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), -infty|]) = ", temp, " vs. -infty\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), infty|]); write(106, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), infty|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), NaN|]); write(107, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), NaN|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), 0|]); write(108, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), 0|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17)) or 0\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi))|]); write(109, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17)) or sin(17 * (pi))\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi)) + 42|]); write(110, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi)) + 42|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), 42|]); write(111, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), 42|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), 1664|]); write(112, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), 1664|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), (log2(13) / log2(17)) - (log(13) / log(17))|]); write(113, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), exp(24 / 10)|]); write(114, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), exp(24 / 10)|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), log2(2076)|]); write(115, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), log2(2076)|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), -23|]); write(116, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), -23|]) = ", temp, " vs. -23\n"); temp = min([|(log2(13) / log2(17)) - (log(13) / log(17)), 11.01953125|]); write(117, ": min([|(log2(13) / log2(17)) - (log(13) / log(17)), 11.01953125|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|exp(24 / 10), -infty|]); write(118, ": min([|exp(24 / 10), -infty|]) = ", temp, " vs. -infty\n"); temp = min([|exp(24 / 10), infty|]); write(119, ": min([|exp(24 / 10), infty|]) = ", temp, " vs. exp(24 / 10)\n"); temp = min([|exp(24 / 10), NaN|]); write(120, ": min([|exp(24 / 10), NaN|]) = ", temp, " vs. exp(24 / 10)\n"); temp = min([|exp(24 / 10), 0|]); write(121, ": min([|exp(24 / 10), 0|]) = ", temp, " vs. 0\n"); temp = min([|exp(24 / 10), sin(17 * (pi))|]); write(122, ": min([|exp(24 / 10), sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|exp(24 / 10), sin(17 * (pi)) + 42|]); write(123, ": min([|exp(24 / 10), sin(17 * (pi)) + 42|]) = ", temp, " vs. exp(24 / 10)\n"); temp = min([|exp(24 / 10), 42|]); write(124, ": min([|exp(24 / 10), 42|]) = ", temp, " vs. exp(24 / 10)\n"); temp = min([|exp(24 / 10), 1664|]); write(125, ": min([|exp(24 / 10), 1664|]) = ", temp, " vs. exp(24 / 10)\n"); temp = min([|exp(24 / 10), (log2(13) / log2(17)) - (log(13) / log(17))|]); write(126, ": min([|exp(24 / 10), (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|exp(12 / 5), exp(12 / 5)|]); write(127, ": min([|exp(12 / 5), exp(12 / 5)|]) = ", temp, " vs. exp(12 / 5)\n"); temp = min([|exp(12 / 5), log2(2076)|]); write(128, ": min([|exp(12 / 5), log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = min([|exp(12 / 5), -23|]); write(129, ": min([|exp(12 / 5), -23|]) = ", temp, " vs. -23\n"); temp = min([|exp(12 / 5), 11.01953125|]); write(130, ": min([|exp(12 / 5), 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = min([|log2(2076), -infty|]); write(131, ": min([|log2(2076), -infty|]) = ", temp, " vs. -infty\n"); temp = min([|log2(2076), infty|]); write(132, ": min([|log2(2076), infty|]) = ", temp, " vs. log2(2076)\n"); temp = min([|log2(2076), NaN|]); write(133, ": min([|log2(2076), NaN|]) = ", temp, " vs. log2(2076)\n"); temp = min([|log2(2076), 0|]); write(134, ": min([|log2(2076), 0|]) = ", temp, " vs. 0\n"); temp = min([|log2(2076), sin(17 * (pi))|]); write(135, ": min([|log2(2076), sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|log2(2076), sin(17 * (pi)) + 42|]); write(136, ": min([|log2(2076), sin(17 * (pi)) + 42|]) = ", temp, " vs. log2(2076)\n"); temp = min([|log2(2076), 42|]); write(137, ": min([|log2(2076), 42|]) = ", temp, " vs. log2(2076)\n"); temp = min([|log2(2076), 1664|]); write(138, ": min([|log2(2076), 1664|]) = ", temp, " vs. log2(2076)\n"); temp = min([|log2(2076), (log2(13) / log2(17)) - (log(13) / log(17))|]); write(139, ": min([|log2(2076), (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|log2(2076), exp(24 / 10)|]); write(140, ": min([|log2(2076), exp(24 / 10)|]) = ", temp, " vs. log2(2076)\n"); temp = min([|log2(2076), log2(2076)|]); write(141, ": min([|log2(2076), log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = min([|log2(2076), -23|]); write(142, ": min([|log2(2076), -23|]) = ", temp, " vs. -23\n"); temp = min([|log2(2076), 11.01953125|]); write(143, ": min([|log2(2076), 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = min([|-23, -infty|]); write(144, ": min([|-23, -infty|]) = ", temp, " vs. -infty\n"); temp = min([|-23, infty|]); write(145, ": min([|-23, infty|]) = ", temp, " vs. -23\n"); temp = min([|-23, NaN|]); write(146, ": min([|-23, NaN|]) = ", temp, " vs. -23\n"); temp = min([|-23, 0|]); write(147, ": min([|-23, 0|]) = ", temp, " vs. -23\n"); temp = min([|-23, sin(17 * (pi))|]); write(148, ": min([|-23, sin(17 * (pi))|]) = ", temp, " vs. -23\n"); temp = min([|-23, sin(17 * (pi)) + 42|]); write(149, ": min([|-23, sin(17 * (pi)) + 42|]) = ", temp, " vs. -23\n"); temp = min([|-23, 42|]); write(150, ": min([|-23, 42|]) = ", temp, " vs. -23\n"); temp = min([|-23, 1664|]); write(151, ": min([|-23, 1664|]) = ", temp, " vs. -23\n"); temp = min([|-23, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(152, ": min([|-23, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. -23\n"); temp = min([|-23, exp(24 / 10)|]); write(153, ": min([|-23, exp(24 / 10)|]) = ", temp, " vs. -23\n"); temp = min([|-23, log2(2076)|]); write(154, ": min([|-23, log2(2076)|]) = ", temp, " vs. -23\n"); temp = min([|-23, -23|]); write(155, ": min([|-23, -23|]) = ", temp, " vs. -23\n"); temp = min([|-23, 11.01953125|]); write(156, ": min([|-23, 11.01953125|]) = ", temp, " vs. -23\n"); temp = min([|11.01953125, -infty|]); write(157, ": min([|11.01953125, -infty|]) = ", temp, " vs. -infty\n"); temp = min([|11.01953125, infty|]); write(158, ": min([|11.01953125, infty|]) = ", temp, " vs. 11.01953125\n"); temp = min([|11.01953125, NaN|]); write(159, ": min([|11.01953125, NaN|]) = ", temp, " vs. 11.01953125\n"); temp = min([|11.01953125, 0|]); write(160, ": min([|11.01953125, 0|]) = ", temp, " vs. 0\n"); temp = min([|11.01953125, sin(17 * (pi))|]); write(161, ": min([|11.01953125, sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = min([|11.01953125, sin(17 * (pi)) + 42|]); write(162, ": min([|11.01953125, sin(17 * (pi)) + 42|]) = ", temp, " vs. 11.01953125\n"); temp = min([|11.01953125, 42|]); write(163, ": min([|11.01953125, 42|]) = ", temp, " vs. 11.01953125\n"); temp = min([|11.01953125, 1664|]); write(164, ": min([|11.01953125, 1664|]) = ", temp, " vs. 11.01953125\n"); temp = min([|11.01953125, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(165, ": min([|11.01953125, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min([|11.01953125, exp(24 / 10)|]); write(166, ": min([|11.01953125, exp(24 / 10)|]) = ", temp, " vs. 11.01953125\n"); temp = min([|11.01953125, log2(2076)|]); write(167, ": min([|11.01953125, log2(2076)|]) = ", temp, " vs. 11.01953125\n"); temp = min([|11.01953125, -23|]); write(168, ": min([|11.01953125, -23|]) = ", temp, " vs. -23\n"); temp = min([|11.01953125, 11.01953125|]); write(169, ": min([|11.01953125, 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = min(-infty, -infty); write(170, ": min(-infty, -infty) = ", temp, " vs. -infty\n"); temp = min(-infty, infty); write(171, ": min(-infty, infty) = ", temp, " vs. -infty\n"); temp = min(-infty, NaN); write(172, ": min(-infty, NaN) = ", temp, " vs. -infty\n"); temp = min(-infty, 0); write(173, ": min(-infty, 0) = ", temp, " vs. -infty\n"); temp = min(-infty, sin(17 * (pi))); write(174, ": min(-infty, sin(17 * (pi))) = ", temp, " vs. -infty\n"); temp = min(-infty, sin(17 * (pi)) + 42); write(175, ": min(-infty, sin(17 * (pi)) + 42) = ", temp, " vs. -infty\n"); temp = min(-infty, 42); write(176, ": min(-infty, 42) = ", temp, " vs. -infty\n"); temp = min(-infty, 1664); write(177, ": min(-infty, 1664) = ", temp, " vs. -infty\n"); temp = min(-infty, (log2(13) / log2(17)) - (log(13) / log(17))); write(178, ": min(-infty, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. -infty\n"); temp = min(-infty, exp(24 / 10)); write(179, ": min(-infty, exp(24 / 10)) = ", temp, " vs. -infty\n"); temp = min(-infty, log2(2076)); write(180, ": min(-infty, log2(2076)) = ", temp, " vs. -infty\n"); temp = min(-infty, -23); write(181, ": min(-infty, -23) = ", temp, " vs. -infty\n"); temp = min(-infty, 11.01953125); write(182, ": min(-infty, 11.01953125) = ", temp, " vs. -infty\n"); temp = min(infty, -infty); write(183, ": min(infty, -infty) = ", temp, " vs. -infty\n"); temp = min(infty, infty); write(184, ": min(infty, infty) = ", temp, " vs. infty\n"); temp = min(infty, NaN); write(185, ": min(infty, NaN) = ", temp, " vs. infty\n"); temp = min(infty, 0); write(186, ": min(infty, 0) = ", temp, " vs. 0\n"); temp = min(infty, sin(17 * (pi))); write(187, ": min(infty, sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(infty, sin(17 * (pi)) + 42); write(188, ": min(infty, sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min(infty, 42); write(189, ": min(infty, 42) = ", temp, " vs. 42\n"); temp = min(infty, 1664); write(190, ": min(infty, 1664) = ", temp, " vs. 1664\n"); temp = min(infty, (log2(13) / log2(17)) - (log(13) / log(17))); write(191, ": min(infty, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min(infty, exp(24 / 10)); write(192, ": min(infty, exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = min(infty, log2(2076)); write(193, ": min(infty, log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = min(infty, -23); write(194, ": min(infty, -23) = ", temp, " vs. -23\n"); temp = min(infty, 11.01953125); write(195, ": min(infty, 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = min(NaN, -infty); write(196, ": min(NaN, -infty) = ", temp, " vs. -infty\n"); temp = min(NaN, infty); write(197, ": min(NaN, infty) = ", temp, " vs. infty\n"); temp = min(NaN, NaN); write(198, ": min(NaN, NaN) = ", temp, " vs. NaN\n"); temp = min(NaN, 0); write(199, ": min(NaN, 0) = ", temp, " vs. 0\n"); temp = min(NaN, sin(17 * (pi))); write(200, ": min(NaN, sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(NaN, sin(17 * (pi)) + 42); write(201, ": min(NaN, sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min(NaN, 42); write(202, ": min(NaN, 42) = ", temp, " vs. 42\n"); temp = min(NaN, 1664); write(203, ": min(NaN, 1664) = ", temp, " vs. 1664\n"); temp = min(NaN, (log2(13) / log2(17)) - (log(13) / log(17))); write(204, ": min(NaN, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min(NaN, exp(24 / 10)); write(205, ": min(NaN, exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = min(NaN, log2(2076)); write(206, ": min(NaN, log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = min(NaN, -23); write(207, ": min(NaN, -23) = ", temp, " vs. -23\n"); temp = min(NaN, 11.01953125); write(208, ": min(NaN, 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = min(0, -infty); write(209, ": min(0, -infty) = ", temp, " vs. -infty\n"); temp = min(0, infty); write(210, ": min(0, infty) = ", temp, " vs. 0\n"); temp = min(0, NaN); write(211, ": min(0, NaN) = ", temp, " vs. 0\n"); temp = min(0, 0); write(212, ": min(0, 0) = ", temp, " vs. 0\n"); temp = min(0, sin(17 * (pi))); write(213, ": min(0, sin(17 * (pi))) = ", temp, " vs. 0 or sin(17 * (pi))\n"); temp = min(0, sin(17 * (pi)) + 42); write(214, ": min(0, sin(17 * (pi)) + 42) = ", temp, " vs. 0\n"); temp = min(0, 42); write(215, ": min(0, 42) = ", temp, " vs. 0\n"); temp = min(0, 1664); write(216, ": min(0, 1664) = ", temp, " vs. 0\n"); temp = min(0, (log2(13) / log2(17)) - (log(13) / log(17))); write(217, ": min(0, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. 0 or (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min(0, exp(24 / 10)); write(218, ": min(0, exp(24 / 10)) = ", temp, " vs. 0\n"); temp = min(0, log2(2076)); write(219, ": min(0, log2(2076)) = ", temp, " vs. 0\n"); temp = min(0, -23); write(220, ": min(0, -23) = ", temp, " vs. -23\n"); temp = min(0, 11.01953125); write(221, ": min(0, 11.01953125) = ", temp, " vs. 0\n"); temp = min(sin(17 * (pi)), -infty); write(222, ": min(sin(17 * (pi)), -infty) = ", temp, " vs. -infty\n"); temp = min(sin(17 * (pi)), infty); write(223, ": min(sin(17 * (pi)), infty) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(sin(17 * (pi)), NaN); write(224, ": min(sin(17 * (pi)), NaN) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(sin(17 * (pi)), 0); write(225, ": min(sin(17 * (pi)), 0) = ", temp, " vs. sin(17 * (pi)) or 0\n"); temp = min(sin(17 * (pi)), sin(17 * (pi))); write(226, ": min(sin(17 * (pi)), sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(sin(17 * (pi)), sin(17 * (pi)) + 42); write(227, ": min(sin(17 * (pi)), sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(sin(17 * (pi)), 42); write(228, ": min(sin(17 * (pi)), 42) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(sin(17 * (pi)), 1664); write(229, ": min(sin(17 * (pi)), 1664) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(sin(17 * (pi)), (log2(13) / log2(17)) - (log(13) / log(17))); write(230, ": min(sin(17 * (pi)), (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. sin(17 * (pi)) or (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min(sin(17 * (pi)), exp(24 / 10)); write(231, ": min(sin(17 * (pi)), exp(24 / 10)) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(sin(17 * (pi)), log2(2076)); write(232, ": min(sin(17 * (pi)), log2(2076)) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(sin(17 * (pi)), -23); write(233, ": min(sin(17 * (pi)), -23) = ", temp, " vs. -23\n"); temp = min(sin(17 * (pi)), 11.01953125); write(234, ": min(sin(17 * (pi)), 11.01953125) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(sin(17 * (pi)) + 42, -infty); write(235, ": min(sin(17 * (pi)) + 42, -infty) = ", temp, " vs. -infty\n"); temp = min(sin(17 * (pi)) + 42, infty); write(236, ": min(sin(17 * (pi)) + 42, infty) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min(sin(17 * (pi)) + 42, NaN); write(237, ": min(sin(17 * (pi)) + 42, NaN) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min(sin(17 * (pi)) + 42, 0); write(238, ": min(sin(17 * (pi)) + 42, 0) = ", temp, " vs. 0\n"); temp = min(sin(17 * (pi)) + 42, sin(17 * (pi))); write(239, ": min(sin(17 * (pi)) + 42, sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(sin(17 * (pi)) + 42, sin(17 * (pi)) + 42); write(240, ": min(sin(17 * (pi)) + 42, sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min(sin(17 * (pi)) + 42, 42); write(241, ": min(sin(17 * (pi)) + 42, 42) = ", temp, " vs. sin(17 * (pi)) + 42 or 42\n"); temp = min(sin(17 * (pi)) + 42, 1664); write(242, ": min(sin(17 * (pi)) + 42, 1664) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min(sin(17 * (pi)) + 42, (log2(13) / log2(17)) - (log(13) / log(17))); write(243, ": min(sin(17 * (pi)) + 42, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min(sin(17 * (pi)) + 42, exp(24 / 10)); write(244, ": min(sin(17 * (pi)) + 42, exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = min(sin(17 * (pi)) + 42, log2(2076)); write(245, ": min(sin(17 * (pi)) + 42, log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = min(sin(17 * (pi)) + 42, -23); write(246, ": min(sin(17 * (pi)) + 42, -23) = ", temp, " vs. -23\n"); temp = min(sin(17 * (pi)) + 42, 11.01953125); write(247, ": min(sin(17 * (pi)) + 42, 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = min(42, -infty); write(248, ": min(42, -infty) = ", temp, " vs. -infty\n"); temp = min(42, infty); write(249, ": min(42, infty) = ", temp, " vs. 42\n"); temp = min(42, NaN); write(250, ": min(42, NaN) = ", temp, " vs. 42\n"); temp = min(42, 0); write(251, ": min(42, 0) = ", temp, " vs. 0\n"); temp = min(42, sin(17 * (pi))); write(252, ": min(42, sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(42, sin(17 * (pi)) + 42); write(253, ": min(42, sin(17 * (pi)) + 42) = ", temp, " vs. 42 or sin(17 * (pi)) + 42\n"); temp = min(42, 42); write(254, ": min(42, 42) = ", temp, " vs. 42\n"); temp = min(42, 1664); write(255, ": min(42, 1664) = ", temp, " vs. 42\n"); temp = min(42, (log2(13) / log2(17)) - (log(13) / log(17))); write(256, ": min(42, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min(42, exp(24 / 10)); write(257, ": min(42, exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = min(42, log2(2076)); write(258, ": min(42, log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = min(42, -23); write(259, ": min(42, -23) = ", temp, " vs. -23\n"); temp = min(42, 11.01953125); write(260, ": min(42, 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = min(1664, -infty); write(261, ": min(1664, -infty) = ", temp, " vs. -infty\n"); temp = min(1664, infty); write(262, ": min(1664, infty) = ", temp, " vs. 1664\n"); temp = min(1664, NaN); write(263, ": min(1664, NaN) = ", temp, " vs. 1664\n"); temp = min(1664, 0); write(264, ": min(1664, 0) = ", temp, " vs. 0\n"); temp = min(1664, sin(17 * (pi))); write(265, ": min(1664, sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(1664, sin(17 * (pi)) + 42); write(266, ": min(1664, sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = min(1664, 42); write(267, ": min(1664, 42) = ", temp, " vs. 42\n"); temp = min(1664, 1664); write(268, ": min(1664, 1664) = ", temp, " vs. 1664\n"); temp = min(1664, (log2(13) / log2(17)) - (log(13) / log(17))); write(269, ": min(1664, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min(1664, exp(24 / 10)); write(270, ": min(1664, exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = min(1664, log2(2076)); write(271, ": min(1664, log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = min(1664, -23); write(272, ": min(1664, -23) = ", temp, " vs. -23\n"); temp = min(1664, 11.01953125); write(273, ": min(1664, 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), -infty); write(274, ": min((log2(13) / log2(17)) - (log(13) / log(17)), -infty) = ", temp, " vs. -infty\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), infty); write(275, ": min((log2(13) / log2(17)) - (log(13) / log(17)), infty) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), NaN); write(276, ": min((log2(13) / log2(17)) - (log(13) / log(17)), NaN) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), 0); write(277, ": min((log2(13) / log2(17)) - (log(13) / log(17)), 0) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17)) or 0\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi))); write(278, ": min((log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17)) or sin(17 * (pi))\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi)) + 42); write(279, ": min((log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi)) + 42) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), 42); write(280, ": min((log2(13) / log2(17)) - (log(13) / log(17)), 42) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), 1664); write(281, ": min((log2(13) / log2(17)) - (log(13) / log(17)), 1664) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), (log2(13) / log2(17)) - (log(13) / log(17))); write(282, ": min((log2(13) / log2(17)) - (log(13) / log(17)), (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), exp(24 / 10)); write(283, ": min((log2(13) / log2(17)) - (log(13) / log(17)), exp(24 / 10)) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), log2(2076)); write(284, ": min((log2(13) / log2(17)) - (log(13) / log(17)), log2(2076)) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), -23); write(285, ": min((log2(13) / log2(17)) - (log(13) / log(17)), -23) = ", temp, " vs. -23\n"); temp = min((log2(13) / log2(17)) - (log(13) / log(17)), 11.01953125); write(286, ": min((log2(13) / log2(17)) - (log(13) / log(17)), 11.01953125) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min(exp(24 / 10), -infty); write(287, ": min(exp(24 / 10), -infty) = ", temp, " vs. -infty\n"); temp = min(exp(24 / 10), infty); write(288, ": min(exp(24 / 10), infty) = ", temp, " vs. exp(24 / 10)\n"); temp = min(exp(24 / 10), NaN); write(289, ": min(exp(24 / 10), NaN) = ", temp, " vs. exp(24 / 10)\n"); temp = min(exp(24 / 10), 0); write(290, ": min(exp(24 / 10), 0) = ", temp, " vs. 0\n"); temp = min(exp(24 / 10), sin(17 * (pi))); write(291, ": min(exp(24 / 10), sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(exp(24 / 10), sin(17 * (pi)) + 42); write(292, ": min(exp(24 / 10), sin(17 * (pi)) + 42) = ", temp, " vs. exp(24 / 10)\n"); temp = min(exp(24 / 10), 42); write(293, ": min(exp(24 / 10), 42) = ", temp, " vs. exp(24 / 10)\n"); temp = min(exp(24 / 10), 1664); write(294, ": min(exp(24 / 10), 1664) = ", temp, " vs. exp(24 / 10)\n"); temp = min(exp(24 / 10), (log2(13) / log2(17)) - (log(13) / log(17))); write(295, ": min(exp(24 / 10), (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min(exp(12 / 5), exp(12 / 5)); write(296, ": min(exp(12 / 5), exp(12 / 5)) = ", temp, " vs. exp(12 / 5)\n"); temp = min(exp(12 / 5), log2(2076)); write(297, ": min(exp(12 / 5), log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = min(exp(12 / 5), -23); write(298, ": min(exp(12 / 5), -23) = ", temp, " vs. -23\n"); temp = min(exp(12 / 5), 11.01953125); write(299, ": min(exp(12 / 5), 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = min(log2(2076), -infty); write(300, ": min(log2(2076), -infty) = ", temp, " vs. -infty\n"); temp = min(log2(2076), infty); write(301, ": min(log2(2076), infty) = ", temp, " vs. log2(2076)\n"); temp = min(log2(2076), NaN); write(302, ": min(log2(2076), NaN) = ", temp, " vs. log2(2076)\n"); temp = min(log2(2076), 0); write(303, ": min(log2(2076), 0) = ", temp, " vs. 0\n"); temp = min(log2(2076), sin(17 * (pi))); write(304, ": min(log2(2076), sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(log2(2076), sin(17 * (pi)) + 42); write(305, ": min(log2(2076), sin(17 * (pi)) + 42) = ", temp, " vs. log2(2076)\n"); temp = min(log2(2076), 42); write(306, ": min(log2(2076), 42) = ", temp, " vs. log2(2076)\n"); temp = min(log2(2076), 1664); write(307, ": min(log2(2076), 1664) = ", temp, " vs. log2(2076)\n"); temp = min(log2(2076), (log2(13) / log2(17)) - (log(13) / log(17))); write(308, ": min(log2(2076), (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min(log2(2076), exp(24 / 10)); write(309, ": min(log2(2076), exp(24 / 10)) = ", temp, " vs. log2(2076)\n"); temp = min(log2(2076), log2(2076)); write(310, ": min(log2(2076), log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = min(log2(2076), -23); write(311, ": min(log2(2076), -23) = ", temp, " vs. -23\n"); temp = min(log2(2076), 11.01953125); write(312, ": min(log2(2076), 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = min(-23, -infty); write(313, ": min(-23, -infty) = ", temp, " vs. -infty\n"); temp = min(-23, infty); write(314, ": min(-23, infty) = ", temp, " vs. -23\n"); temp = min(-23, NaN); write(315, ": min(-23, NaN) = ", temp, " vs. -23\n"); temp = min(-23, 0); write(316, ": min(-23, 0) = ", temp, " vs. -23\n"); temp = min(-23, sin(17 * (pi))); write(317, ": min(-23, sin(17 * (pi))) = ", temp, " vs. -23\n"); temp = min(-23, sin(17 * (pi)) + 42); write(318, ": min(-23, sin(17 * (pi)) + 42) = ", temp, " vs. -23\n"); temp = min(-23, 42); write(319, ": min(-23, 42) = ", temp, " vs. -23\n"); temp = min(-23, 1664); write(320, ": min(-23, 1664) = ", temp, " vs. -23\n"); temp = min(-23, (log2(13) / log2(17)) - (log(13) / log(17))); write(321, ": min(-23, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. -23\n"); temp = min(-23, exp(24 / 10)); write(322, ": min(-23, exp(24 / 10)) = ", temp, " vs. -23\n"); temp = min(-23, log2(2076)); write(323, ": min(-23, log2(2076)) = ", temp, " vs. -23\n"); temp = min(-23, -23); write(324, ": min(-23, -23) = ", temp, " vs. -23\n"); temp = min(-23, 11.01953125); write(325, ": min(-23, 11.01953125) = ", temp, " vs. -23\n"); temp = min(11.01953125, -infty); write(326, ": min(11.01953125, -infty) = ", temp, " vs. -infty\n"); temp = min(11.01953125, infty); write(327, ": min(11.01953125, infty) = ", temp, " vs. 11.01953125\n"); temp = min(11.01953125, NaN); write(328, ": min(11.01953125, NaN) = ", temp, " vs. 11.01953125\n"); temp = min(11.01953125, 0); write(329, ": min(11.01953125, 0) = ", temp, " vs. 0\n"); temp = min(11.01953125, sin(17 * (pi))); write(330, ": min(11.01953125, sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = min(11.01953125, sin(17 * (pi)) + 42); write(331, ": min(11.01953125, sin(17 * (pi)) + 42) = ", temp, " vs. 11.01953125\n"); temp = min(11.01953125, 42); write(332, ": min(11.01953125, 42) = ", temp, " vs. 11.01953125\n"); temp = min(11.01953125, 1664); write(333, ": min(11.01953125, 1664) = ", temp, " vs. 11.01953125\n"); temp = min(11.01953125, (log2(13) / log2(17)) - (log(13) / log(17))); write(334, ": min(11.01953125, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = min(11.01953125, exp(24 / 10)); write(335, ": min(11.01953125, exp(24 / 10)) = ", temp, " vs. 11.01953125\n"); temp = min(11.01953125, log2(2076)); write(336, ": min(11.01953125, log2(2076)) = ", temp, " vs. 11.01953125\n"); temp = min(11.01953125, -23); write(337, ": min(11.01953125, -23) = ", temp, " vs. -23\n"); temp = min(11.01953125, 11.01953125); write(338, ": min(11.01953125, 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = max([|-infty, -infty|]); write(339, ": max([|-infty, -infty|]) = ", temp, " vs. -infty\n"); temp = max([|-infty, infty|]); write(340, ": max([|-infty, infty|]) = ", temp, " vs. infty\n"); temp = max([|-infty, NaN|]); write(341, ": max([|-infty, NaN|]) = ", temp, " vs. -infty\n"); temp = max([|-infty, 0|]); write(342, ": max([|-infty, 0|]) = ", temp, " vs. 0\n"); temp = max([|-infty, sin(17 * (pi))|]); write(343, ": max([|-infty, sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = max([|-infty, sin(17 * (pi)) + 42|]); write(344, ": max([|-infty, sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|-infty, 42|]); write(345, ": max([|-infty, 42|]) = ", temp, " vs. 42\n"); temp = max([|-infty, 1664|]); write(346, ": max([|-infty, 1664|]) = ", temp, " vs. 1664\n"); temp = max([|-infty, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(347, ": max([|-infty, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max([|-infty, exp(24 / 10)|]); write(348, ": max([|-infty, exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|-infty, log2(2076)|]); write(349, ": max([|-infty, log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = max([|-infty, -23|]); write(350, ": max([|-infty, -23|]) = ", temp, " vs. -23\n"); temp = max([|-infty, 11.01953125|]); write(351, ": max([|-infty, 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = max([|infty, -infty|]); write(352, ": max([|infty, -infty|]) = ", temp, " vs. infty\n"); temp = max([|infty, infty|]); write(353, ": max([|infty, infty|]) = ", temp, " vs. infty\n"); temp = max([|infty, NaN|]); write(354, ": max([|infty, NaN|]) = ", temp, " vs. infty\n"); temp = max([|infty, 0|]); write(355, ": max([|infty, 0|]) = ", temp, " vs. infty\n"); temp = max([|infty, sin(17 * (pi))|]); write(356, ": max([|infty, sin(17 * (pi))|]) = ", temp, " vs. infty\n"); temp = max([|infty, sin(17 * (pi)) + 42|]); write(357, ": max([|infty, sin(17 * (pi)) + 42|]) = ", temp, " vs. infty\n"); temp = max([|infty, 42|]); write(358, ": max([|infty, 42|]) = ", temp, " vs. infty\n"); temp = max([|infty, 1664|]); write(359, ": max([|infty, 1664|]) = ", temp, " vs. infty\n"); temp = max([|infty, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(360, ": max([|infty, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. infty\n"); temp = max([|infty, exp(24 / 10)|]); write(361, ": max([|infty, exp(24 / 10)|]) = ", temp, " vs. infty\n"); temp = max([|infty, log2(2076)|]); write(362, ": max([|infty, log2(2076)|]) = ", temp, " vs. infty\n"); temp = max([|infty, -23|]); write(363, ": max([|infty, -23|]) = ", temp, " vs. infty\n"); temp = max([|infty, 11.01953125|]); write(364, ": max([|infty, 11.01953125|]) = ", temp, " vs. infty\n"); temp = max([|NaN, -infty|]); write(365, ": max([|NaN, -infty|]) = ", temp, " vs. -infty\n"); temp = max([|NaN, infty|]); write(366, ": max([|NaN, infty|]) = ", temp, " vs. infty\n"); temp = max([|NaN, NaN|]); write(367, ": max([|NaN, NaN|]) = ", temp, " vs. NaN\n"); temp = max([|NaN, 0|]); write(368, ": max([|NaN, 0|]) = ", temp, " vs. 0\n"); temp = max([|NaN, sin(17 * (pi))|]); write(369, ": max([|NaN, sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = max([|NaN, sin(17 * (pi)) + 42|]); write(370, ": max([|NaN, sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|NaN, 42|]); write(371, ": max([|NaN, 42|]) = ", temp, " vs. 42\n"); temp = max([|NaN, 1664|]); write(372, ": max([|NaN, 1664|]) = ", temp, " vs. 1664\n"); temp = max([|NaN, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(373, ": max([|NaN, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max([|NaN, exp(24 / 10)|]); write(374, ": max([|NaN, exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|NaN, log2(2076)|]); write(375, ": max([|NaN, log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = max([|NaN, -23|]); write(376, ": max([|NaN, -23|]) = ", temp, " vs. -23\n"); temp = max([|NaN, 11.01953125|]); write(377, ": max([|NaN, 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = max([|0, -infty|]); write(378, ": max([|0, -infty|]) = ", temp, " vs. 0\n"); temp = max([|0, infty|]); write(379, ": max([|0, infty|]) = ", temp, " vs. infty\n"); temp = max([|0, NaN|]); write(380, ": max([|0, NaN|]) = ", temp, " vs. 0\n"); temp = max([|0, 0|]); write(381, ": max([|0, 0|]) = ", temp, " vs. 0\n"); temp = max([|0, sin(17 * (pi))|]); write(382, ": max([|0, sin(17 * (pi))|]) = ", temp, " vs. 0 or sin(17 * (pi))\n"); temp = max([|0, sin(17 * (pi)) + 42|]); write(383, ": max([|0, sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|0, 42|]); write(384, ": max([|0, 42|]) = ", temp, " vs. 42\n"); temp = max([|0, 1664|]); write(385, ": max([|0, 1664|]) = ", temp, " vs. 1664\n"); temp = max([|0, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(386, ": max([|0, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. 0 or (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max([|0, exp(24 / 10)|]); write(387, ": max([|0, exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|0, log2(2076)|]); write(388, ": max([|0, log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = max([|0, -23|]); write(389, ": max([|0, -23|]) = ", temp, " vs. 0\n"); temp = max([|0, 11.01953125|]); write(390, ": max([|0, 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = max([|sin(17 * (pi)), -infty|]); write(391, ": max([|sin(17 * (pi)), -infty|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = max([|sin(17 * (pi)), infty|]); write(392, ": max([|sin(17 * (pi)), infty|]) = ", temp, " vs. infty\n"); temp = max([|sin(17 * (pi)), NaN|]); write(393, ": max([|sin(17 * (pi)), NaN|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = max([|sin(17 * (pi)), 0|]); write(394, ": max([|sin(17 * (pi)), 0|]) = ", temp, " vs. sin(17 * (pi)) or 0\n"); temp = max([|sin(17 * (pi)), sin(17 * (pi))|]); write(395, ": max([|sin(17 * (pi)), sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = max([|sin(17 * (pi)), sin(17 * (pi)) + 42|]); write(396, ": max([|sin(17 * (pi)), sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|sin(17 * (pi)), 42|]); write(397, ": max([|sin(17 * (pi)), 42|]) = ", temp, " vs. 42\n"); temp = max([|sin(17 * (pi)), 1664|]); write(398, ": max([|sin(17 * (pi)), 1664|]) = ", temp, " vs. 1664\n"); temp = max([|sin(17 * (pi)), (log2(13) / log2(17)) - (log(13) / log(17))|]); write(399, ": max([|sin(17 * (pi)), (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. sin(17 * (pi)) or (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max([|sin(17 * (pi)), exp(24 / 10)|]); write(400, ": max([|sin(17 * (pi)), exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|sin(17 * (pi)), log2(2076)|]); write(401, ": max([|sin(17 * (pi)), log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = max([|sin(17 * (pi)), -23|]); write(402, ": max([|sin(17 * (pi)), -23|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = max([|sin(17 * (pi)), 11.01953125|]); write(403, ": max([|sin(17 * (pi)), 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = max([|sin(17 * (pi)) + 42, -infty|]); write(404, ": max([|sin(17 * (pi)) + 42, -infty|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|sin(17 * (pi)) + 42, infty|]); write(405, ": max([|sin(17 * (pi)) + 42, infty|]) = ", temp, " vs. infty\n"); temp = max([|sin(17 * (pi)) + 42, NaN|]); write(406, ": max([|sin(17 * (pi)) + 42, NaN|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|sin(17 * (pi)) + 42, 0|]); write(407, ": max([|sin(17 * (pi)) + 42, 0|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|sin(17 * (pi)) + 42, sin(17 * (pi))|]); write(408, ": max([|sin(17 * (pi)) + 42, sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|sin(17 * (pi)) + 42, sin(17 * (pi)) + 42|]); write(409, ": max([|sin(17 * (pi)) + 42, sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|sin(17 * (pi)) + 42, 42|]); write(410, ": max([|sin(17 * (pi)) + 42, 42|]) = ", temp, " vs. sin(17 * (pi)) + 42 or 42\n"); temp = max([|sin(17 * (pi)) + 42, 1664|]); write(411, ": max([|sin(17 * (pi)) + 42, 1664|]) = ", temp, " vs. 1664\n"); temp = max([|sin(17 * (pi)) + 42, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(412, ": max([|sin(17 * (pi)) + 42, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|sin(17 * (pi)) + 42, exp(24 / 10)|]); write(413, ": max([|sin(17 * (pi)) + 42, exp(24 / 10)|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|sin(17 * (pi)) + 42, log2(2076)|]); write(414, ": max([|sin(17 * (pi)) + 42, log2(2076)|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|sin(17 * (pi)) + 42, -23|]); write(415, ": max([|sin(17 * (pi)) + 42, -23|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|sin(17 * (pi)) + 42, 11.01953125|]); write(416, ": max([|sin(17 * (pi)) + 42, 11.01953125|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|42, -infty|]); write(417, ": max([|42, -infty|]) = ", temp, " vs. 42\n"); temp = max([|42, infty|]); write(418, ": max([|42, infty|]) = ", temp, " vs. infty\n"); temp = max([|42, NaN|]); write(419, ": max([|42, NaN|]) = ", temp, " vs. 42\n"); temp = max([|42, 0|]); write(420, ": max([|42, 0|]) = ", temp, " vs. 42\n"); temp = max([|42, sin(17 * (pi))|]); write(421, ": max([|42, sin(17 * (pi))|]) = ", temp, " vs. 42\n"); temp = max([|42, sin(17 * (pi)) + 42|]); write(422, ": max([|42, sin(17 * (pi)) + 42|]) = ", temp, " vs. 42 or sin(17 * (pi)) + 42\n"); temp = max([|42, 42|]); write(423, ": max([|42, 42|]) = ", temp, " vs. 42\n"); temp = max([|42, 1664|]); write(424, ": max([|42, 1664|]) = ", temp, " vs. 1664\n"); temp = max([|42, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(425, ": max([|42, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. 42\n"); temp = max([|42, exp(24 / 10)|]); write(426, ": max([|42, exp(24 / 10)|]) = ", temp, " vs. 42\n"); temp = max([|42, log2(2076)|]); write(427, ": max([|42, log2(2076)|]) = ", temp, " vs. 42\n"); temp = max([|42, -23|]); write(428, ": max([|42, -23|]) = ", temp, " vs. 42\n"); temp = max([|42, 11.01953125|]); write(429, ": max([|42, 11.01953125|]) = ", temp, " vs. 42\n"); temp = max([|1664, -infty|]); write(430, ": max([|1664, -infty|]) = ", temp, " vs. 1664\n"); temp = max([|1664, infty|]); write(431, ": max([|1664, infty|]) = ", temp, " vs. infty\n"); temp = max([|1664, NaN|]); write(432, ": max([|1664, NaN|]) = ", temp, " vs. 1664\n"); temp = max([|1664, 0|]); write(433, ": max([|1664, 0|]) = ", temp, " vs. 1664\n"); temp = max([|1664, sin(17 * (pi))|]); write(434, ": max([|1664, sin(17 * (pi))|]) = ", temp, " vs. 1664\n"); temp = max([|1664, sin(17 * (pi)) + 42|]); write(435, ": max([|1664, sin(17 * (pi)) + 42|]) = ", temp, " vs. 1664\n"); temp = max([|1664, 42|]); write(436, ": max([|1664, 42|]) = ", temp, " vs. 1664\n"); temp = max([|1664, 1664|]); write(437, ": max([|1664, 1664|]) = ", temp, " vs. 1664\n"); temp = max([|1664, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(438, ": max([|1664, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. 1664\n"); temp = max([|1664, exp(24 / 10)|]); write(439, ": max([|1664, exp(24 / 10)|]) = ", temp, " vs. 1664\n"); temp = max([|1664, log2(2076)|]); write(440, ": max([|1664, log2(2076)|]) = ", temp, " vs. 1664\n"); temp = max([|1664, -23|]); write(441, ": max([|1664, -23|]) = ", temp, " vs. 1664\n"); temp = max([|1664, 11.01953125|]); write(442, ": max([|1664, 11.01953125|]) = ", temp, " vs. 1664\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), -infty|]); write(443, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), -infty|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), infty|]); write(444, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), infty|]) = ", temp, " vs. infty\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), NaN|]); write(445, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), NaN|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), 0|]); write(446, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), 0|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17)) or 0\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi))|]); write(447, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17)) or sin(17 * (pi))\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi)) + 42|]); write(448, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), 42|]); write(449, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), 42|]) = ", temp, " vs. 42\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), 1664|]); write(450, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), 1664|]) = ", temp, " vs. 1664\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), (log2(13) / log2(17)) - (log(13) / log(17))|]); write(451, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), exp(24 / 10)|]); write(452, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), log2(2076)|]); write(453, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), -23|]); write(454, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), -23|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max([|(log2(13) / log2(17)) - (log(13) / log(17)), 11.01953125|]); write(455, ": max([|(log2(13) / log2(17)) - (log(13) / log(17)), 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = max([|exp(24 / 10), -infty|]); write(456, ": max([|exp(24 / 10), -infty|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|exp(24 / 10), infty|]); write(457, ": max([|exp(24 / 10), infty|]) = ", temp, " vs. infty\n"); temp = max([|exp(24 / 10), NaN|]); write(458, ": max([|exp(24 / 10), NaN|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|exp(24 / 10), 0|]); write(459, ": max([|exp(24 / 10), 0|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|exp(24 / 10), sin(17 * (pi))|]); write(460, ": max([|exp(24 / 10), sin(17 * (pi))|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|exp(24 / 10), sin(17 * (pi)) + 42|]); write(461, ": max([|exp(24 / 10), sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|exp(24 / 10), 42|]); write(462, ": max([|exp(24 / 10), 42|]) = ", temp, " vs. 42\n"); temp = max([|exp(24 / 10), 1664|]); write(463, ": max([|exp(24 / 10), 1664|]) = ", temp, " vs. 1664\n"); temp = max([|exp(24 / 10), (log2(13) / log2(17)) - (log(13) / log(17))|]); write(464, ": max([|exp(24 / 10), (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|exp(12 / 5), exp(12 / 5)|]); write(465, ": max([|exp(12 / 5), exp(12 / 5)|]) = ", temp, " vs. exp(12 / 5)\n"); temp = max([|exp(12 / 5), log2(2076)|]); write(466, ": max([|exp(12 / 5), log2(2076)|]) = ", temp, " vs. exp(12 / 5)\n"); temp = max([|exp(12 / 5), -23|]); write(467, ": max([|exp(12 / 5), -23|]) = ", temp, " vs. exp(12 / 5)\n"); temp = max([|exp(12 / 5), 11.01953125|]); write(468, ": max([|exp(12 / 5), 11.01953125|]) = ", temp, " vs. exp(12 / 5)\n"); temp = max([|log2(2076), -infty|]); write(469, ": max([|log2(2076), -infty|]) = ", temp, " vs. log2(2076)\n"); temp = max([|log2(2076), infty|]); write(470, ": max([|log2(2076), infty|]) = ", temp, " vs. infty\n"); temp = max([|log2(2076), NaN|]); write(471, ": max([|log2(2076), NaN|]) = ", temp, " vs. log2(2076)\n"); temp = max([|log2(2076), 0|]); write(472, ": max([|log2(2076), 0|]) = ", temp, " vs. log2(2076)\n"); temp = max([|log2(2076), sin(17 * (pi))|]); write(473, ": max([|log2(2076), sin(17 * (pi))|]) = ", temp, " vs. log2(2076)\n"); temp = max([|log2(2076), sin(17 * (pi)) + 42|]); write(474, ": max([|log2(2076), sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|log2(2076), 42|]); write(475, ": max([|log2(2076), 42|]) = ", temp, " vs. 42\n"); temp = max([|log2(2076), 1664|]); write(476, ": max([|log2(2076), 1664|]) = ", temp, " vs. 1664\n"); temp = max([|log2(2076), (log2(13) / log2(17)) - (log(13) / log(17))|]); write(477, ": max([|log2(2076), (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. log2(2076)\n"); temp = max([|log2(2076), exp(24 / 10)|]); write(478, ": max([|log2(2076), exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|log2(2076), log2(2076)|]); write(479, ": max([|log2(2076), log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = max([|log2(2076), -23|]); write(480, ": max([|log2(2076), -23|]) = ", temp, " vs. log2(2076)\n"); temp = max([|log2(2076), 11.01953125|]); write(481, ": max([|log2(2076), 11.01953125|]) = ", temp, " vs. log2(2076)\n"); temp = max([|-23, -infty|]); write(482, ": max([|-23, -infty|]) = ", temp, " vs. -23\n"); temp = max([|-23, infty|]); write(483, ": max([|-23, infty|]) = ", temp, " vs. infty\n"); temp = max([|-23, NaN|]); write(484, ": max([|-23, NaN|]) = ", temp, " vs. -23\n"); temp = max([|-23, 0|]); write(485, ": max([|-23, 0|]) = ", temp, " vs. 0\n"); temp = max([|-23, sin(17 * (pi))|]); write(486, ": max([|-23, sin(17 * (pi))|]) = ", temp, " vs. sin(17 * (pi))\n"); temp = max([|-23, sin(17 * (pi)) + 42|]); write(487, ": max([|-23, sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|-23, 42|]); write(488, ": max([|-23, 42|]) = ", temp, " vs. 42\n"); temp = max([|-23, 1664|]); write(489, ": max([|-23, 1664|]) = ", temp, " vs. 1664\n"); temp = max([|-23, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(490, ": max([|-23, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max([|-23, exp(24 / 10)|]); write(491, ": max([|-23, exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|-23, log2(2076)|]); write(492, ": max([|-23, log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = max([|-23, -23|]); write(493, ": max([|-23, -23|]) = ", temp, " vs. -23\n"); temp = max([|-23, 11.01953125|]); write(494, ": max([|-23, 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = max([|11.01953125, -infty|]); write(495, ": max([|11.01953125, -infty|]) = ", temp, " vs. 11.01953125\n"); temp = max([|11.01953125, infty|]); write(496, ": max([|11.01953125, infty|]) = ", temp, " vs. infty\n"); temp = max([|11.01953125, NaN|]); write(497, ": max([|11.01953125, NaN|]) = ", temp, " vs. 11.01953125\n"); temp = max([|11.01953125, 0|]); write(498, ": max([|11.01953125, 0|]) = ", temp, " vs. 11.01953125\n"); temp = max([|11.01953125, sin(17 * (pi))|]); write(499, ": max([|11.01953125, sin(17 * (pi))|]) = ", temp, " vs. 11.01953125\n"); temp = max([|11.01953125, sin(17 * (pi)) + 42|]); write(500, ": max([|11.01953125, sin(17 * (pi)) + 42|]) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max([|11.01953125, 42|]); write(501, ": max([|11.01953125, 42|]) = ", temp, " vs. 42\n"); temp = max([|11.01953125, 1664|]); write(502, ": max([|11.01953125, 1664|]) = ", temp, " vs. 1664\n"); temp = max([|11.01953125, (log2(13) / log2(17)) - (log(13) / log(17))|]); write(503, ": max([|11.01953125, (log2(13) / log2(17)) - (log(13) / log(17))|]) = ", temp, " vs. 11.01953125\n"); temp = max([|11.01953125, exp(24 / 10)|]); write(504, ": max([|11.01953125, exp(24 / 10)|]) = ", temp, " vs. exp(24 / 10)\n"); temp = max([|11.01953125, log2(2076)|]); write(505, ": max([|11.01953125, log2(2076)|]) = ", temp, " vs. log2(2076)\n"); temp = max([|11.01953125, -23|]); write(506, ": max([|11.01953125, -23|]) = ", temp, " vs. 11.01953125\n"); temp = max([|11.01953125, 11.01953125|]); write(507, ": max([|11.01953125, 11.01953125|]) = ", temp, " vs. 11.01953125\n"); temp = max(-infty, -infty); write(508, ": max(-infty, -infty) = ", temp, " vs. -infty\n"); temp = max(-infty, infty); write(509, ": max(-infty, infty) = ", temp, " vs. infty\n"); temp = max(-infty, NaN); write(510, ": max(-infty, NaN) = ", temp, " vs. -infty\n"); temp = max(-infty, 0); write(511, ": max(-infty, 0) = ", temp, " vs. 0\n"); temp = max(-infty, sin(17 * (pi))); write(512, ": max(-infty, sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = max(-infty, sin(17 * (pi)) + 42); write(513, ": max(-infty, sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(-infty, 42); write(514, ": max(-infty, 42) = ", temp, " vs. 42\n"); temp = max(-infty, 1664); write(515, ": max(-infty, 1664) = ", temp, " vs. 1664\n"); temp = max(-infty, (log2(13) / log2(17)) - (log(13) / log(17))); write(516, ": max(-infty, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max(-infty, exp(24 / 10)); write(517, ": max(-infty, exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = max(-infty, log2(2076)); write(518, ": max(-infty, log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = max(-infty, -23); write(519, ": max(-infty, -23) = ", temp, " vs. -23\n"); temp = max(-infty, 11.01953125); write(520, ": max(-infty, 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = max(infty, -infty); write(521, ": max(infty, -infty) = ", temp, " vs. infty\n"); temp = max(infty, infty); write(522, ": max(infty, infty) = ", temp, " vs. infty\n"); temp = max(infty, NaN); write(523, ": max(infty, NaN) = ", temp, " vs. infty\n"); temp = max(infty, 0); write(524, ": max(infty, 0) = ", temp, " vs. infty\n"); temp = max(infty, sin(17 * (pi))); write(525, ": max(infty, sin(17 * (pi))) = ", temp, " vs. infty\n"); temp = max(infty, sin(17 * (pi)) + 42); write(526, ": max(infty, sin(17 * (pi)) + 42) = ", temp, " vs. infty\n"); temp = max(infty, 42); write(527, ": max(infty, 42) = ", temp, " vs. infty\n"); temp = max(infty, 1664); write(528, ": max(infty, 1664) = ", temp, " vs. infty\n"); temp = max(infty, (log2(13) / log2(17)) - (log(13) / log(17))); write(529, ": max(infty, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. infty\n"); temp = max(infty, exp(24 / 10)); write(530, ": max(infty, exp(24 / 10)) = ", temp, " vs. infty\n"); temp = max(infty, log2(2076)); write(531, ": max(infty, log2(2076)) = ", temp, " vs. infty\n"); temp = max(infty, -23); write(532, ": max(infty, -23) = ", temp, " vs. infty\n"); temp = max(infty, 11.01953125); write(533, ": max(infty, 11.01953125) = ", temp, " vs. infty\n"); temp = max(NaN, -infty); write(534, ": max(NaN, -infty) = ", temp, " vs. -infty\n"); temp = max(NaN, infty); write(535, ": max(NaN, infty) = ", temp, " vs. infty\n"); temp = max(NaN, NaN); write(536, ": max(NaN, NaN) = ", temp, " vs. NaN\n"); temp = max(NaN, 0); write(537, ": max(NaN, 0) = ", temp, " vs. 0\n"); temp = max(NaN, sin(17 * (pi))); write(538, ": max(NaN, sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = max(NaN, sin(17 * (pi)) + 42); write(539, ": max(NaN, sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(NaN, 42); write(540, ": max(NaN, 42) = ", temp, " vs. 42\n"); temp = max(NaN, 1664); write(541, ": max(NaN, 1664) = ", temp, " vs. 1664\n"); temp = max(NaN, (log2(13) / log2(17)) - (log(13) / log(17))); write(542, ": max(NaN, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max(NaN, exp(24 / 10)); write(543, ": max(NaN, exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = max(NaN, log2(2076)); write(544, ": max(NaN, log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = max(NaN, -23); write(545, ": max(NaN, -23) = ", temp, " vs. -23\n"); temp = max(NaN, 11.01953125); write(546, ": max(NaN, 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = max(0, -infty); write(547, ": max(0, -infty) = ", temp, " vs. 0\n"); temp = max(0, infty); write(548, ": max(0, infty) = ", temp, " vs. infty\n"); temp = max(0, NaN); write(549, ": max(0, NaN) = ", temp, " vs. 0\n"); temp = max(0, 0); write(550, ": max(0, 0) = ", temp, " vs. 0\n"); temp = max(0, sin(17 * (pi))); write(551, ": max(0, sin(17 * (pi))) = ", temp, " vs. 0 or sin(17 * (pi))\n"); temp = max(0, sin(17 * (pi)) + 42); write(552, ": max(0, sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(0, 42); write(553, ": max(0, 42) = ", temp, " vs. 42\n"); temp = max(0, 1664); write(554, ": max(0, 1664) = ", temp, " vs. 1664\n"); temp = max(0, (log2(13) / log2(17)) - (log(13) / log(17))); write(555, ": max(0, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. 0 or (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max(0, exp(24 / 10)); write(556, ": max(0, exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = max(0, log2(2076)); write(557, ": max(0, log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = max(0, -23); write(558, ": max(0, -23) = ", temp, " vs. 0\n"); temp = max(0, 11.01953125); write(559, ": max(0, 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = max(sin(17 * (pi)), -infty); write(560, ": max(sin(17 * (pi)), -infty) = ", temp, " vs. sin(17 * (pi))\n"); temp = max(sin(17 * (pi)), infty); write(561, ": max(sin(17 * (pi)), infty) = ", temp, " vs. infty\n"); temp = max(sin(17 * (pi)), NaN); write(562, ": max(sin(17 * (pi)), NaN) = ", temp, " vs. sin(17 * (pi))\n"); temp = max(sin(17 * (pi)), 0); write(563, ": max(sin(17 * (pi)), 0) = ", temp, " vs. sin(17 * (pi)) or 0\n"); temp = max(sin(17 * (pi)), sin(17 * (pi))); write(564, ": max(sin(17 * (pi)), sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = max(sin(17 * (pi)), sin(17 * (pi)) + 42); write(565, ": max(sin(17 * (pi)), sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(sin(17 * (pi)), 42); write(566, ": max(sin(17 * (pi)), 42) = ", temp, " vs. 42\n"); temp = max(sin(17 * (pi)), 1664); write(567, ": max(sin(17 * (pi)), 1664) = ", temp, " vs. 1664\n"); temp = max(sin(17 * (pi)), (log2(13) / log2(17)) - (log(13) / log(17))); write(568, ": max(sin(17 * (pi)), (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. sin(17 * (pi)) or (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max(sin(17 * (pi)), exp(24 / 10)); write(569, ": max(sin(17 * (pi)), exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = max(sin(17 * (pi)), log2(2076)); write(570, ": max(sin(17 * (pi)), log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = max(sin(17 * (pi)), -23); write(571, ": max(sin(17 * (pi)), -23) = ", temp, " vs. sin(17 * (pi))\n"); temp = max(sin(17 * (pi)), 11.01953125); write(572, ": max(sin(17 * (pi)), 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = max(sin(17 * (pi)) + 42, -infty); write(573, ": max(sin(17 * (pi)) + 42, -infty) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(sin(17 * (pi)) + 42, infty); write(574, ": max(sin(17 * (pi)) + 42, infty) = ", temp, " vs. infty\n"); temp = max(sin(17 * (pi)) + 42, NaN); write(575, ": max(sin(17 * (pi)) + 42, NaN) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(sin(17 * (pi)) + 42, 0); write(576, ": max(sin(17 * (pi)) + 42, 0) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(sin(17 * (pi)) + 42, sin(17 * (pi))); write(577, ": max(sin(17 * (pi)) + 42, sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(sin(17 * (pi)) + 42, sin(17 * (pi)) + 42); write(578, ": max(sin(17 * (pi)) + 42, sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(sin(17 * (pi)) + 42, 42); write(579, ": max(sin(17 * (pi)) + 42, 42) = ", temp, " vs. sin(17 * (pi)) + 42 or 42\n"); temp = max(sin(17 * (pi)) + 42, 1664); write(580, ": max(sin(17 * (pi)) + 42, 1664) = ", temp, " vs. 1664\n"); temp = max(sin(17 * (pi)) + 42, (log2(13) / log2(17)) - (log(13) / log(17))); write(581, ": max(sin(17 * (pi)) + 42, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(sin(17 * (pi)) + 42, exp(24 / 10)); write(582, ": max(sin(17 * (pi)) + 42, exp(24 / 10)) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(sin(17 * (pi)) + 42, log2(2076)); write(583, ": max(sin(17 * (pi)) + 42, log2(2076)) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(sin(17 * (pi)) + 42, -23); write(584, ": max(sin(17 * (pi)) + 42, -23) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(sin(17 * (pi)) + 42, 11.01953125); write(585, ": max(sin(17 * (pi)) + 42, 11.01953125) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(42, -infty); write(586, ": max(42, -infty) = ", temp, " vs. 42\n"); temp = max(42, infty); write(587, ": max(42, infty) = ", temp, " vs. infty\n"); temp = max(42, NaN); write(588, ": max(42, NaN) = ", temp, " vs. 42\n"); temp = max(42, 0); write(589, ": max(42, 0) = ", temp, " vs. 42\n"); temp = max(42, sin(17 * (pi))); write(590, ": max(42, sin(17 * (pi))) = ", temp, " vs. 42\n"); temp = max(42, sin(17 * (pi)) + 42); write(591, ": max(42, sin(17 * (pi)) + 42) = ", temp, " vs. 42 or sin(17 * (pi)) + 42\n"); temp = max(42, 42); write(592, ": max(42, 42) = ", temp, " vs. 42\n"); temp = max(42, 1664); write(593, ": max(42, 1664) = ", temp, " vs. 1664\n"); temp = max(42, (log2(13) / log2(17)) - (log(13) / log(17))); write(594, ": max(42, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. 42\n"); temp = max(42, exp(24 / 10)); write(595, ": max(42, exp(24 / 10)) = ", temp, " vs. 42\n"); temp = max(42, log2(2076)); write(596, ": max(42, log2(2076)) = ", temp, " vs. 42\n"); temp = max(42, -23); write(597, ": max(42, -23) = ", temp, " vs. 42\n"); temp = max(42, 11.01953125); write(598, ": max(42, 11.01953125) = ", temp, " vs. 42\n"); temp = max(1664, -infty); write(599, ": max(1664, -infty) = ", temp, " vs. 1664\n"); temp = max(1664, infty); write(600, ": max(1664, infty) = ", temp, " vs. infty\n"); temp = max(1664, NaN); write(601, ": max(1664, NaN) = ", temp, " vs. 1664\n"); temp = max(1664, 0); write(602, ": max(1664, 0) = ", temp, " vs. 1664\n"); temp = max(1664, sin(17 * (pi))); write(603, ": max(1664, sin(17 * (pi))) = ", temp, " vs. 1664\n"); temp = max(1664, sin(17 * (pi)) + 42); write(604, ": max(1664, sin(17 * (pi)) + 42) = ", temp, " vs. 1664\n"); temp = max(1664, 42); write(605, ": max(1664, 42) = ", temp, " vs. 1664\n"); temp = max(1664, 1664); write(606, ": max(1664, 1664) = ", temp, " vs. 1664\n"); temp = max(1664, (log2(13) / log2(17)) - (log(13) / log(17))); write(607, ": max(1664, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. 1664\n"); temp = max(1664, exp(24 / 10)); write(608, ": max(1664, exp(24 / 10)) = ", temp, " vs. 1664\n"); temp = max(1664, log2(2076)); write(609, ": max(1664, log2(2076)) = ", temp, " vs. 1664\n"); temp = max(1664, -23); write(610, ": max(1664, -23) = ", temp, " vs. 1664\n"); temp = max(1664, 11.01953125); write(611, ": max(1664, 11.01953125) = ", temp, " vs. 1664\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), -infty); write(612, ": max((log2(13) / log2(17)) - (log(13) / log(17)), -infty) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), infty); write(613, ": max((log2(13) / log2(17)) - (log(13) / log(17)), infty) = ", temp, " vs. infty\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), NaN); write(614, ": max((log2(13) / log2(17)) - (log(13) / log(17)), NaN) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), 0); write(615, ": max((log2(13) / log2(17)) - (log(13) / log(17)), 0) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17)) or 0\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi))); write(616, ": max((log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17)) or sin(17 * (pi))\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi)) + 42); write(617, ": max((log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), 42); write(618, ": max((log2(13) / log2(17)) - (log(13) / log(17)), 42) = ", temp, " vs. 42\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), 1664); write(619, ": max((log2(13) / log2(17)) - (log(13) / log(17)), 1664) = ", temp, " vs. 1664\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), (log2(13) / log2(17)) - (log(13) / log(17))); write(620, ": max((log2(13) / log2(17)) - (log(13) / log(17)), (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), exp(24 / 10)); write(621, ": max((log2(13) / log2(17)) - (log(13) / log(17)), exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), log2(2076)); write(622, ": max((log2(13) / log2(17)) - (log(13) / log(17)), log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), -23); write(623, ": max((log2(13) / log2(17)) - (log(13) / log(17)), -23) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max((log2(13) / log2(17)) - (log(13) / log(17)), 11.01953125); write(624, ": max((log2(13) / log2(17)) - (log(13) / log(17)), 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = max(exp(24 / 10), -infty); write(625, ": max(exp(24 / 10), -infty) = ", temp, " vs. exp(24 / 10)\n"); temp = max(exp(24 / 10), infty); write(626, ": max(exp(24 / 10), infty) = ", temp, " vs. infty\n"); temp = max(exp(24 / 10), NaN); write(627, ": max(exp(24 / 10), NaN) = ", temp, " vs. exp(24 / 10)\n"); temp = max(exp(24 / 10), 0); write(628, ": max(exp(24 / 10), 0) = ", temp, " vs. exp(24 / 10)\n"); temp = max(exp(24 / 10), sin(17 * (pi))); write(629, ": max(exp(24 / 10), sin(17 * (pi))) = ", temp, " vs. exp(24 / 10)\n"); temp = max(exp(24 / 10), sin(17 * (pi)) + 42); write(630, ": max(exp(24 / 10), sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(exp(24 / 10), 42); write(631, ": max(exp(24 / 10), 42) = ", temp, " vs. 42\n"); temp = max(exp(24 / 10), 1664); write(632, ": max(exp(24 / 10), 1664) = ", temp, " vs. 1664\n"); temp = max(exp(24 / 10), (log2(13) / log2(17)) - (log(13) / log(17))); write(633, ": max(exp(24 / 10), (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. exp(24 / 10)\n"); temp = max(exp(12 / 5), exp(12 / 5)); write(634, ": max(exp(12 / 5), exp(12 / 5)) = ", temp, " vs. exp(12 / 5)\n"); temp = max(exp(12 / 5), log2(2076)); write(635, ": max(exp(12 / 5), log2(2076)) = ", temp, " vs. exp(12 / 5)\n"); temp = max(exp(12 / 5), -23); write(636, ": max(exp(12 / 5), -23) = ", temp, " vs. exp(12 / 5)\n"); temp = max(exp(12 / 5), 11.01953125); write(637, ": max(exp(12 / 5), 11.01953125) = ", temp, " vs. exp(12 / 5)\n"); temp = max(log2(2076), -infty); write(638, ": max(log2(2076), -infty) = ", temp, " vs. log2(2076)\n"); temp = max(log2(2076), infty); write(639, ": max(log2(2076), infty) = ", temp, " vs. infty\n"); temp = max(log2(2076), NaN); write(640, ": max(log2(2076), NaN) = ", temp, " vs. log2(2076)\n"); temp = max(log2(2076), 0); write(641, ": max(log2(2076), 0) = ", temp, " vs. log2(2076)\n"); temp = max(log2(2076), sin(17 * (pi))); write(642, ": max(log2(2076), sin(17 * (pi))) = ", temp, " vs. log2(2076)\n"); temp = max(log2(2076), sin(17 * (pi)) + 42); write(643, ": max(log2(2076), sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(log2(2076), 42); write(644, ": max(log2(2076), 42) = ", temp, " vs. 42\n"); temp = max(log2(2076), 1664); write(645, ": max(log2(2076), 1664) = ", temp, " vs. 1664\n"); temp = max(log2(2076), (log2(13) / log2(17)) - (log(13) / log(17))); write(646, ": max(log2(2076), (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. log2(2076)\n"); temp = max(log2(2076), exp(24 / 10)); write(647, ": max(log2(2076), exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = max(log2(2076), log2(2076)); write(648, ": max(log2(2076), log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = max(log2(2076), -23); write(649, ": max(log2(2076), -23) = ", temp, " vs. log2(2076)\n"); temp = max(log2(2076), 11.01953125); write(650, ": max(log2(2076), 11.01953125) = ", temp, " vs. log2(2076)\n"); temp = max(-23, -infty); write(651, ": max(-23, -infty) = ", temp, " vs. -23\n"); temp = max(-23, infty); write(652, ": max(-23, infty) = ", temp, " vs. infty\n"); temp = max(-23, NaN); write(653, ": max(-23, NaN) = ", temp, " vs. -23\n"); temp = max(-23, 0); write(654, ": max(-23, 0) = ", temp, " vs. 0\n"); temp = max(-23, sin(17 * (pi))); write(655, ": max(-23, sin(17 * (pi))) = ", temp, " vs. sin(17 * (pi))\n"); temp = max(-23, sin(17 * (pi)) + 42); write(656, ": max(-23, sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(-23, 42); write(657, ": max(-23, 42) = ", temp, " vs. 42\n"); temp = max(-23, 1664); write(658, ": max(-23, 1664) = ", temp, " vs. 1664\n"); temp = max(-23, (log2(13) / log2(17)) - (log(13) / log(17))); write(659, ": max(-23, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. (log2(13) / log2(17)) - (log(13) / log(17))\n"); temp = max(-23, exp(24 / 10)); write(660, ": max(-23, exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = max(-23, log2(2076)); write(661, ": max(-23, log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = max(-23, -23); write(662, ": max(-23, -23) = ", temp, " vs. -23\n"); temp = max(-23, 11.01953125); write(663, ": max(-23, 11.01953125) = ", temp, " vs. 11.01953125\n"); temp = max(11.01953125, -infty); write(664, ": max(11.01953125, -infty) = ", temp, " vs. 11.01953125\n"); temp = max(11.01953125, infty); write(665, ": max(11.01953125, infty) = ", temp, " vs. infty\n"); temp = max(11.01953125, NaN); write(666, ": max(11.01953125, NaN) = ", temp, " vs. 11.01953125\n"); temp = max(11.01953125, 0); write(667, ": max(11.01953125, 0) = ", temp, " vs. 11.01953125\n"); temp = max(11.01953125, sin(17 * (pi))); write(668, ": max(11.01953125, sin(17 * (pi))) = ", temp, " vs. 11.01953125\n"); temp = max(11.01953125, sin(17 * (pi)) + 42); write(669, ": max(11.01953125, sin(17 * (pi)) + 42) = ", temp, " vs. sin(17 * (pi)) + 42\n"); temp = max(11.01953125, 42); write(670, ": max(11.01953125, 42) = ", temp, " vs. 42\n"); temp = max(11.01953125, 1664); write(671, ": max(11.01953125, 1664) = ", temp, " vs. 1664\n"); temp = max(11.01953125, (log2(13) / log2(17)) - (log(13) / log(17))); write(672, ": max(11.01953125, (log2(13) / log2(17)) - (log(13) / log(17))) = ", temp, " vs. 11.01953125\n"); temp = max(11.01953125, exp(24 / 10)); write(673, ": max(11.01953125, exp(24 / 10)) = ", temp, " vs. exp(24 / 10)\n"); temp = max(11.01953125, log2(2076)); write(674, ": max(11.01953125, log2(2076)) = ", temp, " vs. log2(2076)\n"); temp = max(11.01953125, -23); write(675, ": max(11.01953125, -23) = ", temp, " vs. 11.01953125\n"); temp = max(11.01953125, 11.01953125); write(676, ": max(11.01953125, 11.01953125) = ", temp, " vs. 11.01953125\n"); sollya-6.0+ds/tests-tool/check029.sollya.reference000066400000000000000000001454371300174114700221070ustar00rootroot00000000000000The tool has been restarted. =============== Test number 1 ================ Error in fpminimax: there is less formats indications than monomials Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error The tool has been restarted. =============== Test number 2 ================ true The tool has been restarted. =============== Test number 3 ================ The number of points has been set to 4. [|1.99999999999999999999999999999999999999999999999996, 2|] The tool has been restarted. =============== Test number 4 ================ Warning: the inferred precision of the 7th coefficient of the polynomial is greater than the necessary precision computed for this step. This may make the automatic determination of precisions useless. void f(double *f_resh, double x) { double f_t_1_0h; double f_t_2_0h; double f_t_3_0h; double f_t_4_0h; double f_t_5_0h; double f_t_6_0h; double f_t_7_0h; double f_t_8_0h; double f_t_9_0h; double f_t_10_0h; double f_t_11_0h; double f_t_12_0h; double f_t_13_0h; double f_t_14_0h; double f_t_15_0h, f_t_15_0m; f_t_1_0h = f_coeff_7h; f_t_2_0h = f_t_1_0h * x; f_t_3_0h = f_coeff_6h + f_t_2_0h; f_t_4_0h = f_t_3_0h * x; f_t_5_0h = f_coeff_5h + f_t_4_0h; f_t_6_0h = f_t_5_0h * x; f_t_7_0h = f_coeff_4h + f_t_6_0h; f_t_8_0h = f_t_7_0h * x; f_t_9_0h = f_coeff_3h + f_t_8_0h; f_t_10_0h = f_t_9_0h * x; f_t_11_0h = f_coeff_2h + f_t_10_0h; f_t_12_0h = f_t_11_0h * x; f_t_13_0h = f_coeff_1h + f_t_12_0h; f_t_14_0h = f_t_13_0h * x; Add12(f_t_15_0h,f_t_15_0m,f_coeff_0h,f_t_14_0h); *f_resh = f_t_15_0h; } The tool has been restarted. =============== Test number 5 ================ 2999 The tool has been restarted. =============== Test number 6 ================ Display mode is hexadecimal numbers. 0 0x1p0 0x1p1 0x1.8p1 0x1p2 0x1.4p2 0x1.8p2 0x1.cp2 0x1p3 0x1.2p3 0x1.4p3 0x1.6p3 0x1.8p3 0x1.ap3 0x1.cp3 0x1.ep3 0x1p4 0x1.08p5 true true true true 0x1.30f842p21 true true 0x1.eaee86p-2 0x1.eaee88p-2 -0x1.5117aep-5 -0x1.51179p-5 0x1.6d2026p-9 -0x1.03f2d4p-6 0x1.5beeb4p-5 -0x1.33194ep-4 0x1.b403a8p-4 -0x1.22f5c2p-3 0x1.997748p-3 -0x1.5554d8p-2 -0x1.5554d8p0 -0x1.5554d8p20 -0x1.5554d8p19 The tool has been restarted. =============== Test number 7 ================ Computing data to test rounding to single precision Starting actual test All test values for rounding to single precision have yielded a correct result. Now testing printsingle displaying 0 = 0x80000000 0x1p-149 = 0x00000001 -0x1p-149 = 0x80000001 0x1p-148 = 0x00000002 -0x1p-148 = 0x80000002 0x1.fffff8p-127 = 0x007ffffe -0x1.fffff8p-127 = 0x807ffffe 0x1.fffffcp-127 = 0x007fffff -0x1.fffffcp-127 = 0x807fffff 0x1p-126 = 0x00800000 -0x1p-126 = 0x80800000 0x1.fffffcp127 = 0x7f7ffffe -0x1.fffffcp127 = 0xff7ffffe 0x1.fffffep127 = 0x7f7fffff -0x1.fffffep127 = 0xff7fffff infty = 0x7f800000 -infty = 0xff800000 End of test The tool has been restarted. =============== Test number 8 ================ true The tool has been restarted. =============== Test number 9 ================ [0;0] The tool has been restarted. =============== Test number 10 ================ [|{ .passed_args = [|1, "Coucou", 3...|], .called_proc = proc(l = ...) { getbacktrace(); return void; } }|] The tool has been restarted. =============== Test number 10b ================ X = 17, Y = 42 X = 42 Current backtrace: [|{ .passed_args = [| |], .called_proc = proc() { "Current backtrace:"; getbacktrace(); return void; } }, { .passed_args = [|42|], .called_proc = proc(X) { "X = ", X; testA(); return void; } }, { .passed_args = [|17, 42|], .called_proc = proc(X, Y) { "X = ", X, ", Y = ", Y; testB(Y); return void; } }|] The tool has been restarted. =============== Test number 10c ================ [| |] The tool has been restarted. =============== Test number 10d ================ l[17] = 42 number of arguments: infty Backtrace: printnumargs, [|infty|] numargs, [|25, 26, 27...|] test1, [| |] number of arguments: 3 Backtrace: printnumargs, [|3|] numargs, [|1, 2, 3|] test2, [|[|1, 2, 3|]|] The tool has been restarted. =============== Test number 11 ================ Using procedure function exponential with X = [0.25;0.25], n = 0, p = 100 Warning: rounding has happened. The value displayed is a faithful rounding to 80 bits of the true result. 1.28402541668774148407342 Warning: rounding has happened. The value displayed is a faithful rounding to 53 bits of the true result. 1.3956124250860895 Warning: rounding has happened. The value displayed is a faithful rounding to 53 bits of the true result. 1.2840254166877414 Using procedure function exponential with X = [0.333333333333333333333333333333333333333333333333333333333;0.3333333333333333333333333333333333333333333333333333333334], n = 0, p = 190 Warning: rounding has happened. The value displayed is a faithful rounding to 80 bits of the true result. 1.395612425086089528628125 The tool has been restarted. =============== Test number 12 ================ false false false false false false Warning: the evaluation of one of the sides of an equality test yields error due to a syntax error or an error on a side-effect. The other side either also yields error due to an syntax or side-effect error or does not evaluate to error. The boolean returned may be meaningless. false Warning: the evaluation of one of the sides of an equality test yields error due to a syntax error or an error on a side-effect. The other side either also yields error due to an syntax or side-effect error or does not evaluate to error. The boolean returned may be meaningless. false Warning: the evaluation of one of the sides of an equality test yields error due to a syntax error or an error on a side-effect. The other side either also yields error due to an syntax or side-effect error or does not evaluate to error. The boolean returned may be meaningless. false Warning: the evaluation of one of the sides of an equality test yields error due to a syntax error or an error on a side-effect. The other side either also yields error due to an syntax or side-effect error or does not evaluate to error. The boolean returned may be meaningless. false false false Warning: the evaluation of one of the sides of an equality test yields error due to a syntax error or an error on a side-effect. The other side either also yields error due to an syntax or side-effect error or does not evaluate to error. The boolean returned may be meaningless. false Warning: the evaluation of one of the sides of an equality test yields error due to a syntax error or an error on a side-effect. The other side either also yields error due to an syntax or side-effect error or does not evaluate to error. The boolean returned may be meaningless. false Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error Warning: at least one of the given expressions or a subexpression is not correctly typed or its evaluation has failed because of some error on a side-effect. error Is a NaN Is a NaN Is not a NaN The tool has been restarted. =============== Test number 13 ================ Running systematic tests for objectname... Test run. Removing temporary file. End of tests for objectname. The tool has been restarted. =============== Test number 14 ================ Succeeded. The tool has been restarted. =============== Test number 15 ================ Loop was not infinite The tool has been restarted. =============== Test number 15bis ================ The precision has been set to 250 bits. Loop was not infinite The tool has been restarted. ----------- Additional tests for min and max --------------- 1: min([|-infty, -infty|]) = -infty vs. -infty 2: min([|-infty, infty|]) = -infty vs. -infty 3: min([|-infty, NaN|]) = -infty vs. -infty 4: min([|-infty, 0|]) = -infty vs. -infty 5: min([|-infty, sin(17 * (pi))|]) = -infty vs. -infty 6: min([|-infty, sin(17 * (pi)) + 42|]) = -infty vs. -infty 7: min([|-infty, 42|]) = -infty vs. -infty 8: min([|-infty, 1664|]) = -infty vs. -infty 9: min([|-infty, (log2(13) / log2(17)) - (log(13) / log(17))|]) = -infty vs. -infty 10: min([|-infty, exp(24 / 10)|]) = -infty vs. -infty 11: min([|-infty, log2(2076)|]) = -infty vs. -infty 12: min([|-infty, -23|]) = -infty vs. -infty 13: min([|-infty, 11.01953125|]) = -infty vs. -infty 14: min([|infty, -infty|]) = -infty vs. -infty 15: min([|infty, infty|]) = infty vs. infty 16: min([|infty, NaN|]) = infty vs. infty 17: min([|infty, 0|]) = 0 vs. 0 18: min([|infty, sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 19: min([|infty, sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 20: min([|infty, 42|]) = 42 vs. 42 21: min([|infty, 1664|]) = 1664 vs. 1664 22: min([|infty, (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 23: min([|infty, exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 24: min([|infty, log2(2076)|]) = log2(2076) vs. log2(2076) 25: min([|infty, -23|]) = -23 vs. -23 26: min([|infty, 11.01953125|]) = 11.01953125 vs. 11.01953125 27: min([|NaN, -infty|]) = -infty vs. -infty 28: min([|NaN, infty|]) = infty vs. infty 29: min([|NaN, NaN|]) = NaN vs. NaN 30: min([|NaN, 0|]) = 0 vs. 0 31: min([|NaN, sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 32: min([|NaN, sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 33: min([|NaN, 42|]) = 42 vs. 42 34: min([|NaN, 1664|]) = 1664 vs. 1664 35: min([|NaN, (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 36: min([|NaN, exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 37: min([|NaN, log2(2076)|]) = log2(2076) vs. log2(2076) 38: min([|NaN, -23|]) = -23 vs. -23 39: min([|NaN, 11.01953125|]) = 11.01953125 vs. 11.01953125 40: min([|0, -infty|]) = -infty vs. -infty 41: min([|0, infty|]) = 0 vs. 0 42: min([|0, NaN|]) = 0 vs. 0 43: min([|0, 0|]) = 0 vs. 0 44: min([|0, sin(17 * (pi))|]) = sin(17 * (pi)) vs. 0 or sin(17 * (pi)) 45: min([|0, sin(17 * (pi)) + 42|]) = 0 vs. 0 46: min([|0, 42|]) = 0 vs. 0 47: min([|0, 1664|]) = 0 vs. 0 48: min([|0, (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. 0 or (log2(13) / log2(17)) - (log(13) / log(17)) 49: min([|0, exp(24 / 10)|]) = 0 vs. 0 50: min([|0, log2(2076)|]) = 0 vs. 0 51: min([|0, -23|]) = -23 vs. -23 52: min([|0, 11.01953125|]) = 0 vs. 0 53: min([|sin(17 * (pi)), -infty|]) = -infty vs. -infty 54: min([|sin(17 * (pi)), infty|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 55: min([|sin(17 * (pi)), NaN|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 56: min([|sin(17 * (pi)), 0|]) = 0 vs. sin(17 * (pi)) or 0 57: min([|sin(17 * (pi)), sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 58: min([|sin(17 * (pi)), sin(17 * (pi)) + 42|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 59: min([|sin(17 * (pi)), 42|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 60: min([|sin(17 * (pi)), 1664|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 61: min([|sin(17 * (pi)), (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. sin(17 * (pi)) or (log2(13) / log2(17)) - (log(13) / log(17)) 62: min([|sin(17 * (pi)), exp(24 / 10)|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 63: min([|sin(17 * (pi)), log2(2076)|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 64: min([|sin(17 * (pi)), -23|]) = -23 vs. -23 65: min([|sin(17 * (pi)), 11.01953125|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 66: min([|sin(17 * (pi)) + 42, -infty|]) = -infty vs. -infty 67: min([|sin(17 * (pi)) + 42, infty|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 68: min([|sin(17 * (pi)) + 42, NaN|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 69: min([|sin(17 * (pi)) + 42, 0|]) = 0 vs. 0 70: min([|sin(17 * (pi)) + 42, sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 71: min([|sin(17 * (pi)) + 42, sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 72: min([|sin(17 * (pi)) + 42, 42|]) = 42 vs. sin(17 * (pi)) + 42 or 42 73: min([|sin(17 * (pi)) + 42, 1664|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 74: min([|sin(17 * (pi)) + 42, (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 75: min([|sin(17 * (pi)) + 42, exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 76: min([|sin(17 * (pi)) + 42, log2(2076)|]) = log2(2076) vs. log2(2076) 77: min([|sin(17 * (pi)) + 42, -23|]) = -23 vs. -23 78: min([|sin(17 * (pi)) + 42, 11.01953125|]) = 11.01953125 vs. 11.01953125 79: min([|42, -infty|]) = -infty vs. -infty 80: min([|42, infty|]) = 42 vs. 42 81: min([|42, NaN|]) = 42 vs. 42 82: min([|42, 0|]) = 0 vs. 0 83: min([|42, sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 84: min([|42, sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. 42 or sin(17 * (pi)) + 42 85: min([|42, 42|]) = 42 vs. 42 86: min([|42, 1664|]) = 42 vs. 42 87: min([|42, (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 88: min([|42, exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 89: min([|42, log2(2076)|]) = log2(2076) vs. log2(2076) 90: min([|42, -23|]) = -23 vs. -23 91: min([|42, 11.01953125|]) = 11.01953125 vs. 11.01953125 92: min([|1664, -infty|]) = -infty vs. -infty 93: min([|1664, infty|]) = 1664 vs. 1664 94: min([|1664, NaN|]) = 1664 vs. 1664 95: min([|1664, 0|]) = 0 vs. 0 96: min([|1664, sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 97: min([|1664, sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 98: min([|1664, 42|]) = 42 vs. 42 99: min([|1664, 1664|]) = 1664 vs. 1664 100: min([|1664, (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 101: min([|1664, exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 102: min([|1664, log2(2076)|]) = log2(2076) vs. log2(2076) 103: min([|1664, -23|]) = -23 vs. -23 104: min([|1664, 11.01953125|]) = 11.01953125 vs. 11.01953125 105: min([|(log2(13) / log2(17)) - (log(13) / log(17)), -infty|]) = -infty vs. -infty 106: min([|(log2(13) / log2(17)) - (log(13) / log(17)), infty|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 107: min([|(log2(13) / log2(17)) - (log(13) / log(17)), NaN|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 108: min([|(log2(13) / log2(17)) - (log(13) / log(17)), 0|]) = 0 vs. (log2(13) / log2(17)) - (log(13) / log(17)) or 0 109: min([|(log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi))|]) = sin(17 * (pi)) vs. (log2(13) / log2(17)) - (log(13) / log(17)) or sin(17 * (pi)) 110: min([|(log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi)) + 42|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 111: min([|(log2(13) / log2(17)) - (log(13) / log(17)), 42|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 112: min([|(log2(13) / log2(17)) - (log(13) / log(17)), 1664|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 113: min([|(log2(13) / log2(17)) - (log(13) / log(17)), (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 114: min([|(log2(13) / log2(17)) - (log(13) / log(17)), exp(24 / 10)|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 115: min([|(log2(13) / log2(17)) - (log(13) / log(17)), log2(2076)|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 116: min([|(log2(13) / log2(17)) - (log(13) / log(17)), -23|]) = -23 vs. -23 117: min([|(log2(13) / log2(17)) - (log(13) / log(17)), 11.01953125|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 118: min([|exp(24 / 10), -infty|]) = -infty vs. -infty 119: min([|exp(24 / 10), infty|]) = exp(24 / 10) vs. exp(24 / 10) 120: min([|exp(24 / 10), NaN|]) = exp(24 / 10) vs. exp(24 / 10) 121: min([|exp(24 / 10), 0|]) = 0 vs. 0 122: min([|exp(24 / 10), sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 123: min([|exp(24 / 10), sin(17 * (pi)) + 42|]) = exp(24 / 10) vs. exp(24 / 10) 124: min([|exp(24 / 10), 42|]) = exp(24 / 10) vs. exp(24 / 10) 125: min([|exp(24 / 10), 1664|]) = exp(24 / 10) vs. exp(24 / 10) 126: min([|exp(24 / 10), (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 127: min([|exp(12 / 5), exp(12 / 5)|]) = exp(12 / 5) vs. exp(12 / 5) 128: min([|exp(12 / 5), log2(2076)|]) = log2(2076) vs. log2(2076) 129: min([|exp(12 / 5), -23|]) = -23 vs. -23 130: min([|exp(12 / 5), 11.01953125|]) = 11.01953125 vs. 11.01953125 131: min([|log2(2076), -infty|]) = -infty vs. -infty 132: min([|log2(2076), infty|]) = log2(2076) vs. log2(2076) 133: min([|log2(2076), NaN|]) = log2(2076) vs. log2(2076) 134: min([|log2(2076), 0|]) = 0 vs. 0 135: min([|log2(2076), sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 136: min([|log2(2076), sin(17 * (pi)) + 42|]) = log2(2076) vs. log2(2076) 137: min([|log2(2076), 42|]) = log2(2076) vs. log2(2076) 138: min([|log2(2076), 1664|]) = log2(2076) vs. log2(2076) 139: min([|log2(2076), (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 140: min([|log2(2076), exp(24 / 10)|]) = log2(2076) vs. log2(2076) 141: min([|log2(2076), log2(2076)|]) = log2(2076) vs. log2(2076) 142: min([|log2(2076), -23|]) = -23 vs. -23 143: min([|log2(2076), 11.01953125|]) = 11.01953125 vs. 11.01953125 144: min([|-23, -infty|]) = -infty vs. -infty 145: min([|-23, infty|]) = -23 vs. -23 146: min([|-23, NaN|]) = -23 vs. -23 147: min([|-23, 0|]) = -23 vs. -23 148: min([|-23, sin(17 * (pi))|]) = -23 vs. -23 149: min([|-23, sin(17 * (pi)) + 42|]) = -23 vs. -23 150: min([|-23, 42|]) = -23 vs. -23 151: min([|-23, 1664|]) = -23 vs. -23 152: min([|-23, (log2(13) / log2(17)) - (log(13) / log(17))|]) = -23 vs. -23 153: min([|-23, exp(24 / 10)|]) = -23 vs. -23 154: min([|-23, log2(2076)|]) = -23 vs. -23 155: min([|-23, -23|]) = -23 vs. -23 156: min([|-23, 11.01953125|]) = -23 vs. -23 157: min([|11.01953125, -infty|]) = -infty vs. -infty 158: min([|11.01953125, infty|]) = 11.01953125 vs. 11.01953125 159: min([|11.01953125, NaN|]) = 11.01953125 vs. 11.01953125 160: min([|11.01953125, 0|]) = 0 vs. 0 161: min([|11.01953125, sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 162: min([|11.01953125, sin(17 * (pi)) + 42|]) = 11.01953125 vs. 11.01953125 163: min([|11.01953125, 42|]) = 11.01953125 vs. 11.01953125 164: min([|11.01953125, 1664|]) = 11.01953125 vs. 11.01953125 165: min([|11.01953125, (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 166: min([|11.01953125, exp(24 / 10)|]) = 11.01953125 vs. 11.01953125 167: min([|11.01953125, log2(2076)|]) = 11.01953125 vs. 11.01953125 168: min([|11.01953125, -23|]) = -23 vs. -23 169: min([|11.01953125, 11.01953125|]) = 11.01953125 vs. 11.01953125 170: min(-infty, -infty) = -infty vs. -infty 171: min(-infty, infty) = -infty vs. -infty 172: min(-infty, NaN) = -infty vs. -infty 173: min(-infty, 0) = -infty vs. -infty 174: min(-infty, sin(17 * (pi))) = -infty vs. -infty 175: min(-infty, sin(17 * (pi)) + 42) = -infty vs. -infty 176: min(-infty, 42) = -infty vs. -infty 177: min(-infty, 1664) = -infty vs. -infty 178: min(-infty, (log2(13) / log2(17)) - (log(13) / log(17))) = -infty vs. -infty 179: min(-infty, exp(24 / 10)) = -infty vs. -infty 180: min(-infty, log2(2076)) = -infty vs. -infty 181: min(-infty, -23) = -infty vs. -infty 182: min(-infty, 11.01953125) = -infty vs. -infty 183: min(infty, -infty) = -infty vs. -infty 184: min(infty, infty) = infty vs. infty 185: min(infty, NaN) = infty vs. infty 186: min(infty, 0) = 0 vs. 0 187: min(infty, sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 188: min(infty, sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 189: min(infty, 42) = 42 vs. 42 190: min(infty, 1664) = 1664 vs. 1664 191: min(infty, (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 192: min(infty, exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 193: min(infty, log2(2076)) = log2(2076) vs. log2(2076) 194: min(infty, -23) = -23 vs. -23 195: min(infty, 11.01953125) = 11.01953125 vs. 11.01953125 196: min(NaN, -infty) = -infty vs. -infty 197: min(NaN, infty) = infty vs. infty 198: min(NaN, NaN) = NaN vs. NaN 199: min(NaN, 0) = 0 vs. 0 200: min(NaN, sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 201: min(NaN, sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 202: min(NaN, 42) = 42 vs. 42 203: min(NaN, 1664) = 1664 vs. 1664 204: min(NaN, (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 205: min(NaN, exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 206: min(NaN, log2(2076)) = log2(2076) vs. log2(2076) 207: min(NaN, -23) = -23 vs. -23 208: min(NaN, 11.01953125) = 11.01953125 vs. 11.01953125 209: min(0, -infty) = -infty vs. -infty 210: min(0, infty) = 0 vs. 0 211: min(0, NaN) = 0 vs. 0 212: min(0, 0) = 0 vs. 0 213: min(0, sin(17 * (pi))) = sin(17 * (pi)) vs. 0 or sin(17 * (pi)) 214: min(0, sin(17 * (pi)) + 42) = 0 vs. 0 215: min(0, 42) = 0 vs. 0 216: min(0, 1664) = 0 vs. 0 217: min(0, (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. 0 or (log2(13) / log2(17)) - (log(13) / log(17)) 218: min(0, exp(24 / 10)) = 0 vs. 0 219: min(0, log2(2076)) = 0 vs. 0 220: min(0, -23) = -23 vs. -23 221: min(0, 11.01953125) = 0 vs. 0 222: min(sin(17 * (pi)), -infty) = -infty vs. -infty 223: min(sin(17 * (pi)), infty) = sin(17 * (pi)) vs. sin(17 * (pi)) 224: min(sin(17 * (pi)), NaN) = sin(17 * (pi)) vs. sin(17 * (pi)) 225: min(sin(17 * (pi)), 0) = 0 vs. sin(17 * (pi)) or 0 226: min(sin(17 * (pi)), sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 227: min(sin(17 * (pi)), sin(17 * (pi)) + 42) = sin(17 * (pi)) vs. sin(17 * (pi)) 228: min(sin(17 * (pi)), 42) = sin(17 * (pi)) vs. sin(17 * (pi)) 229: min(sin(17 * (pi)), 1664) = sin(17 * (pi)) vs. sin(17 * (pi)) 230: min(sin(17 * (pi)), (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. sin(17 * (pi)) or (log2(13) / log2(17)) - (log(13) / log(17)) 231: min(sin(17 * (pi)), exp(24 / 10)) = sin(17 * (pi)) vs. sin(17 * (pi)) 232: min(sin(17 * (pi)), log2(2076)) = sin(17 * (pi)) vs. sin(17 * (pi)) 233: min(sin(17 * (pi)), -23) = -23 vs. -23 234: min(sin(17 * (pi)), 11.01953125) = sin(17 * (pi)) vs. sin(17 * (pi)) 235: min(sin(17 * (pi)) + 42, -infty) = -infty vs. -infty 236: min(sin(17 * (pi)) + 42, infty) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 237: min(sin(17 * (pi)) + 42, NaN) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 238: min(sin(17 * (pi)) + 42, 0) = 0 vs. 0 239: min(sin(17 * (pi)) + 42, sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 240: min(sin(17 * (pi)) + 42, sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 241: min(sin(17 * (pi)) + 42, 42) = 42 vs. sin(17 * (pi)) + 42 or 42 242: min(sin(17 * (pi)) + 42, 1664) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 243: min(sin(17 * (pi)) + 42, (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 244: min(sin(17 * (pi)) + 42, exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 245: min(sin(17 * (pi)) + 42, log2(2076)) = log2(2076) vs. log2(2076) 246: min(sin(17 * (pi)) + 42, -23) = -23 vs. -23 247: min(sin(17 * (pi)) + 42, 11.01953125) = 11.01953125 vs. 11.01953125 248: min(42, -infty) = -infty vs. -infty 249: min(42, infty) = 42 vs. 42 250: min(42, NaN) = 42 vs. 42 251: min(42, 0) = 0 vs. 0 252: min(42, sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 253: min(42, sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. 42 or sin(17 * (pi)) + 42 254: min(42, 42) = 42 vs. 42 255: min(42, 1664) = 42 vs. 42 256: min(42, (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 257: min(42, exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 258: min(42, log2(2076)) = log2(2076) vs. log2(2076) 259: min(42, -23) = -23 vs. -23 260: min(42, 11.01953125) = 11.01953125 vs. 11.01953125 261: min(1664, -infty) = -infty vs. -infty 262: min(1664, infty) = 1664 vs. 1664 263: min(1664, NaN) = 1664 vs. 1664 264: min(1664, 0) = 0 vs. 0 265: min(1664, sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 266: min(1664, sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 267: min(1664, 42) = 42 vs. 42 268: min(1664, 1664) = 1664 vs. 1664 269: min(1664, (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 270: min(1664, exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 271: min(1664, log2(2076)) = log2(2076) vs. log2(2076) 272: min(1664, -23) = -23 vs. -23 273: min(1664, 11.01953125) = 11.01953125 vs. 11.01953125 274: min((log2(13) / log2(17)) - (log(13) / log(17)), -infty) = -infty vs. -infty 275: min((log2(13) / log2(17)) - (log(13) / log(17)), infty) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 276: min((log2(13) / log2(17)) - (log(13) / log(17)), NaN) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 277: min((log2(13) / log2(17)) - (log(13) / log(17)), 0) = 0 vs. (log2(13) / log2(17)) - (log(13) / log(17)) or 0 278: min((log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi))) = sin(17 * (pi)) vs. (log2(13) / log2(17)) - (log(13) / log(17)) or sin(17 * (pi)) 279: min((log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi)) + 42) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 280: min((log2(13) / log2(17)) - (log(13) / log(17)), 42) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 281: min((log2(13) / log2(17)) - (log(13) / log(17)), 1664) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 282: min((log2(13) / log2(17)) - (log(13) / log(17)), (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 283: min((log2(13) / log2(17)) - (log(13) / log(17)), exp(24 / 10)) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 284: min((log2(13) / log2(17)) - (log(13) / log(17)), log2(2076)) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 285: min((log2(13) / log2(17)) - (log(13) / log(17)), -23) = -23 vs. -23 286: min((log2(13) / log2(17)) - (log(13) / log(17)), 11.01953125) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 287: min(exp(24 / 10), -infty) = -infty vs. -infty 288: min(exp(24 / 10), infty) = exp(24 / 10) vs. exp(24 / 10) 289: min(exp(24 / 10), NaN) = exp(24 / 10) vs. exp(24 / 10) 290: min(exp(24 / 10), 0) = 0 vs. 0 291: min(exp(24 / 10), sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 292: min(exp(24 / 10), sin(17 * (pi)) + 42) = exp(24 / 10) vs. exp(24 / 10) 293: min(exp(24 / 10), 42) = exp(24 / 10) vs. exp(24 / 10) 294: min(exp(24 / 10), 1664) = exp(24 / 10) vs. exp(24 / 10) 295: min(exp(24 / 10), (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 296: min(exp(12 / 5), exp(12 / 5)) = exp(12 / 5) vs. exp(12 / 5) 297: min(exp(12 / 5), log2(2076)) = log2(2076) vs. log2(2076) 298: min(exp(12 / 5), -23) = -23 vs. -23 299: min(exp(12 / 5), 11.01953125) = 11.01953125 vs. 11.01953125 300: min(log2(2076), -infty) = -infty vs. -infty 301: min(log2(2076), infty) = log2(2076) vs. log2(2076) 302: min(log2(2076), NaN) = log2(2076) vs. log2(2076) 303: min(log2(2076), 0) = 0 vs. 0 304: min(log2(2076), sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 305: min(log2(2076), sin(17 * (pi)) + 42) = log2(2076) vs. log2(2076) 306: min(log2(2076), 42) = log2(2076) vs. log2(2076) 307: min(log2(2076), 1664) = log2(2076) vs. log2(2076) 308: min(log2(2076), (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 309: min(log2(2076), exp(24 / 10)) = log2(2076) vs. log2(2076) 310: min(log2(2076), log2(2076)) = log2(2076) vs. log2(2076) 311: min(log2(2076), -23) = -23 vs. -23 312: min(log2(2076), 11.01953125) = 11.01953125 vs. 11.01953125 313: min(-23, -infty) = -infty vs. -infty 314: min(-23, infty) = -23 vs. -23 315: min(-23, NaN) = -23 vs. -23 316: min(-23, 0) = -23 vs. -23 317: min(-23, sin(17 * (pi))) = -23 vs. -23 318: min(-23, sin(17 * (pi)) + 42) = -23 vs. -23 319: min(-23, 42) = -23 vs. -23 320: min(-23, 1664) = -23 vs. -23 321: min(-23, (log2(13) / log2(17)) - (log(13) / log(17))) = -23 vs. -23 322: min(-23, exp(24 / 10)) = -23 vs. -23 323: min(-23, log2(2076)) = -23 vs. -23 324: min(-23, -23) = -23 vs. -23 325: min(-23, 11.01953125) = -23 vs. -23 326: min(11.01953125, -infty) = -infty vs. -infty 327: min(11.01953125, infty) = 11.01953125 vs. 11.01953125 328: min(11.01953125, NaN) = 11.01953125 vs. 11.01953125 329: min(11.01953125, 0) = 0 vs. 0 330: min(11.01953125, sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 331: min(11.01953125, sin(17 * (pi)) + 42) = 11.01953125 vs. 11.01953125 332: min(11.01953125, 42) = 11.01953125 vs. 11.01953125 333: min(11.01953125, 1664) = 11.01953125 vs. 11.01953125 334: min(11.01953125, (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 335: min(11.01953125, exp(24 / 10)) = 11.01953125 vs. 11.01953125 336: min(11.01953125, log2(2076)) = 11.01953125 vs. 11.01953125 337: min(11.01953125, -23) = -23 vs. -23 338: min(11.01953125, 11.01953125) = 11.01953125 vs. 11.01953125 339: max([|-infty, -infty|]) = -infty vs. -infty 340: max([|-infty, infty|]) = infty vs. infty 341: max([|-infty, NaN|]) = -infty vs. -infty 342: max([|-infty, 0|]) = 0 vs. 0 343: max([|-infty, sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 344: max([|-infty, sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 345: max([|-infty, 42|]) = 42 vs. 42 346: max([|-infty, 1664|]) = 1664 vs. 1664 347: max([|-infty, (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 348: max([|-infty, exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 349: max([|-infty, log2(2076)|]) = log2(2076) vs. log2(2076) 350: max([|-infty, -23|]) = -23 vs. -23 351: max([|-infty, 11.01953125|]) = 11.01953125 vs. 11.01953125 352: max([|infty, -infty|]) = infty vs. infty 353: max([|infty, infty|]) = infty vs. infty 354: max([|infty, NaN|]) = infty vs. infty 355: max([|infty, 0|]) = infty vs. infty 356: max([|infty, sin(17 * (pi))|]) = infty vs. infty 357: max([|infty, sin(17 * (pi)) + 42|]) = infty vs. infty 358: max([|infty, 42|]) = infty vs. infty 359: max([|infty, 1664|]) = infty vs. infty 360: max([|infty, (log2(13) / log2(17)) - (log(13) / log(17))|]) = infty vs. infty 361: max([|infty, exp(24 / 10)|]) = infty vs. infty 362: max([|infty, log2(2076)|]) = infty vs. infty 363: max([|infty, -23|]) = infty vs. infty 364: max([|infty, 11.01953125|]) = infty vs. infty 365: max([|NaN, -infty|]) = -infty vs. -infty 366: max([|NaN, infty|]) = infty vs. infty 367: max([|NaN, NaN|]) = NaN vs. NaN 368: max([|NaN, 0|]) = 0 vs. 0 369: max([|NaN, sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 370: max([|NaN, sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 371: max([|NaN, 42|]) = 42 vs. 42 372: max([|NaN, 1664|]) = 1664 vs. 1664 373: max([|NaN, (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 374: max([|NaN, exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 375: max([|NaN, log2(2076)|]) = log2(2076) vs. log2(2076) 376: max([|NaN, -23|]) = -23 vs. -23 377: max([|NaN, 11.01953125|]) = 11.01953125 vs. 11.01953125 378: max([|0, -infty|]) = 0 vs. 0 379: max([|0, infty|]) = infty vs. infty 380: max([|0, NaN|]) = 0 vs. 0 381: max([|0, 0|]) = 0 vs. 0 382: max([|0, sin(17 * (pi))|]) = 0 vs. 0 or sin(17 * (pi)) 383: max([|0, sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 384: max([|0, 42|]) = 42 vs. 42 385: max([|0, 1664|]) = 1664 vs. 1664 386: max([|0, (log2(13) / log2(17)) - (log(13) / log(17))|]) = 0 vs. 0 or (log2(13) / log2(17)) - (log(13) / log(17)) 387: max([|0, exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 388: max([|0, log2(2076)|]) = log2(2076) vs. log2(2076) 389: max([|0, -23|]) = 0 vs. 0 390: max([|0, 11.01953125|]) = 11.01953125 vs. 11.01953125 391: max([|sin(17 * (pi)), -infty|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 392: max([|sin(17 * (pi)), infty|]) = infty vs. infty 393: max([|sin(17 * (pi)), NaN|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 394: max([|sin(17 * (pi)), 0|]) = sin(17 * (pi)) vs. sin(17 * (pi)) or 0 395: max([|sin(17 * (pi)), sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 396: max([|sin(17 * (pi)), sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 397: max([|sin(17 * (pi)), 42|]) = 42 vs. 42 398: max([|sin(17 * (pi)), 1664|]) = 1664 vs. 1664 399: max([|sin(17 * (pi)), (log2(13) / log2(17)) - (log(13) / log(17))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) or (log2(13) / log2(17)) - (log(13) / log(17)) 400: max([|sin(17 * (pi)), exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 401: max([|sin(17 * (pi)), log2(2076)|]) = log2(2076) vs. log2(2076) 402: max([|sin(17 * (pi)), -23|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 403: max([|sin(17 * (pi)), 11.01953125|]) = 11.01953125 vs. 11.01953125 404: max([|sin(17 * (pi)) + 42, -infty|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 405: max([|sin(17 * (pi)) + 42, infty|]) = infty vs. infty 406: max([|sin(17 * (pi)) + 42, NaN|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 407: max([|sin(17 * (pi)) + 42, 0|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 408: max([|sin(17 * (pi)) + 42, sin(17 * (pi))|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 409: max([|sin(17 * (pi)) + 42, sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 410: max([|sin(17 * (pi)) + 42, 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 or 42 411: max([|sin(17 * (pi)) + 42, 1664|]) = 1664 vs. 1664 412: max([|sin(17 * (pi)) + 42, (log2(13) / log2(17)) - (log(13) / log(17))|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 413: max([|sin(17 * (pi)) + 42, exp(24 / 10)|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 414: max([|sin(17 * (pi)) + 42, log2(2076)|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 415: max([|sin(17 * (pi)) + 42, -23|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 416: max([|sin(17 * (pi)) + 42, 11.01953125|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 417: max([|42, -infty|]) = 42 vs. 42 418: max([|42, infty|]) = infty vs. infty 419: max([|42, NaN|]) = 42 vs. 42 420: max([|42, 0|]) = 42 vs. 42 421: max([|42, sin(17 * (pi))|]) = 42 vs. 42 422: max([|42, sin(17 * (pi)) + 42|]) = 42 vs. 42 or sin(17 * (pi)) + 42 423: max([|42, 42|]) = 42 vs. 42 424: max([|42, 1664|]) = 1664 vs. 1664 425: max([|42, (log2(13) / log2(17)) - (log(13) / log(17))|]) = 42 vs. 42 426: max([|42, exp(24 / 10)|]) = 42 vs. 42 427: max([|42, log2(2076)|]) = 42 vs. 42 428: max([|42, -23|]) = 42 vs. 42 429: max([|42, 11.01953125|]) = 42 vs. 42 430: max([|1664, -infty|]) = 1664 vs. 1664 431: max([|1664, infty|]) = infty vs. infty 432: max([|1664, NaN|]) = 1664 vs. 1664 433: max([|1664, 0|]) = 1664 vs. 1664 434: max([|1664, sin(17 * (pi))|]) = 1664 vs. 1664 435: max([|1664, sin(17 * (pi)) + 42|]) = 1664 vs. 1664 436: max([|1664, 42|]) = 1664 vs. 1664 437: max([|1664, 1664|]) = 1664 vs. 1664 438: max([|1664, (log2(13) / log2(17)) - (log(13) / log(17))|]) = 1664 vs. 1664 439: max([|1664, exp(24 / 10)|]) = 1664 vs. 1664 440: max([|1664, log2(2076)|]) = 1664 vs. 1664 441: max([|1664, -23|]) = 1664 vs. 1664 442: max([|1664, 11.01953125|]) = 1664 vs. 1664 443: max([|(log2(13) / log2(17)) - (log(13) / log(17)), -infty|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 444: max([|(log2(13) / log2(17)) - (log(13) / log(17)), infty|]) = infty vs. infty 445: max([|(log2(13) / log2(17)) - (log(13) / log(17)), NaN|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 446: max([|(log2(13) / log2(17)) - (log(13) / log(17)), 0|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) or 0 447: max([|(log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) or sin(17 * (pi)) 448: max([|(log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 449: max([|(log2(13) / log2(17)) - (log(13) / log(17)), 42|]) = 42 vs. 42 450: max([|(log2(13) / log2(17)) - (log(13) / log(17)), 1664|]) = 1664 vs. 1664 451: max([|(log2(13) / log2(17)) - (log(13) / log(17)), (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 452: max([|(log2(13) / log2(17)) - (log(13) / log(17)), exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 453: max([|(log2(13) / log2(17)) - (log(13) / log(17)), log2(2076)|]) = log2(2076) vs. log2(2076) 454: max([|(log2(13) / log2(17)) - (log(13) / log(17)), -23|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 455: max([|(log2(13) / log2(17)) - (log(13) / log(17)), 11.01953125|]) = 11.01953125 vs. 11.01953125 456: max([|exp(24 / 10), -infty|]) = exp(24 / 10) vs. exp(24 / 10) 457: max([|exp(24 / 10), infty|]) = infty vs. infty 458: max([|exp(24 / 10), NaN|]) = exp(24 / 10) vs. exp(24 / 10) 459: max([|exp(24 / 10), 0|]) = exp(24 / 10) vs. exp(24 / 10) 460: max([|exp(24 / 10), sin(17 * (pi))|]) = exp(24 / 10) vs. exp(24 / 10) 461: max([|exp(24 / 10), sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 462: max([|exp(24 / 10), 42|]) = 42 vs. 42 463: max([|exp(24 / 10), 1664|]) = 1664 vs. 1664 464: max([|exp(24 / 10), (log2(13) / log2(17)) - (log(13) / log(17))|]) = exp(24 / 10) vs. exp(24 / 10) 465: max([|exp(12 / 5), exp(12 / 5)|]) = exp(12 / 5) vs. exp(12 / 5) 466: max([|exp(12 / 5), log2(2076)|]) = exp(12 / 5) vs. exp(12 / 5) 467: max([|exp(12 / 5), -23|]) = exp(12 / 5) vs. exp(12 / 5) 468: max([|exp(12 / 5), 11.01953125|]) = exp(12 / 5) vs. exp(12 / 5) 469: max([|log2(2076), -infty|]) = log2(2076) vs. log2(2076) 470: max([|log2(2076), infty|]) = infty vs. infty 471: max([|log2(2076), NaN|]) = log2(2076) vs. log2(2076) 472: max([|log2(2076), 0|]) = log2(2076) vs. log2(2076) 473: max([|log2(2076), sin(17 * (pi))|]) = log2(2076) vs. log2(2076) 474: max([|log2(2076), sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 475: max([|log2(2076), 42|]) = 42 vs. 42 476: max([|log2(2076), 1664|]) = 1664 vs. 1664 477: max([|log2(2076), (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(2076) vs. log2(2076) 478: max([|log2(2076), exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 479: max([|log2(2076), log2(2076)|]) = log2(2076) vs. log2(2076) 480: max([|log2(2076), -23|]) = log2(2076) vs. log2(2076) 481: max([|log2(2076), 11.01953125|]) = log2(2076) vs. log2(2076) 482: max([|-23, -infty|]) = -23 vs. -23 483: max([|-23, infty|]) = infty vs. infty 484: max([|-23, NaN|]) = -23 vs. -23 485: max([|-23, 0|]) = 0 vs. 0 486: max([|-23, sin(17 * (pi))|]) = sin(17 * (pi)) vs. sin(17 * (pi)) 487: max([|-23, sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 488: max([|-23, 42|]) = 42 vs. 42 489: max([|-23, 1664|]) = 1664 vs. 1664 490: max([|-23, (log2(13) / log2(17)) - (log(13) / log(17))|]) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 491: max([|-23, exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 492: max([|-23, log2(2076)|]) = log2(2076) vs. log2(2076) 493: max([|-23, -23|]) = -23 vs. -23 494: max([|-23, 11.01953125|]) = 11.01953125 vs. 11.01953125 495: max([|11.01953125, -infty|]) = 11.01953125 vs. 11.01953125 496: max([|11.01953125, infty|]) = infty vs. infty 497: max([|11.01953125, NaN|]) = 11.01953125 vs. 11.01953125 498: max([|11.01953125, 0|]) = 11.01953125 vs. 11.01953125 499: max([|11.01953125, sin(17 * (pi))|]) = 11.01953125 vs. 11.01953125 500: max([|11.01953125, sin(17 * (pi)) + 42|]) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 501: max([|11.01953125, 42|]) = 42 vs. 42 502: max([|11.01953125, 1664|]) = 1664 vs. 1664 503: max([|11.01953125, (log2(13) / log2(17)) - (log(13) / log(17))|]) = 11.01953125 vs. 11.01953125 504: max([|11.01953125, exp(24 / 10)|]) = exp(24 / 10) vs. exp(24 / 10) 505: max([|11.01953125, log2(2076)|]) = log2(2076) vs. log2(2076) 506: max([|11.01953125, -23|]) = 11.01953125 vs. 11.01953125 507: max([|11.01953125, 11.01953125|]) = 11.01953125 vs. 11.01953125 508: max(-infty, -infty) = -infty vs. -infty 509: max(-infty, infty) = infty vs. infty 510: max(-infty, NaN) = -infty vs. -infty 511: max(-infty, 0) = 0 vs. 0 512: max(-infty, sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 513: max(-infty, sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 514: max(-infty, 42) = 42 vs. 42 515: max(-infty, 1664) = 1664 vs. 1664 516: max(-infty, (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 517: max(-infty, exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 518: max(-infty, log2(2076)) = log2(2076) vs. log2(2076) 519: max(-infty, -23) = -23 vs. -23 520: max(-infty, 11.01953125) = 11.01953125 vs. 11.01953125 521: max(infty, -infty) = infty vs. infty 522: max(infty, infty) = infty vs. infty 523: max(infty, NaN) = infty vs. infty 524: max(infty, 0) = infty vs. infty 525: max(infty, sin(17 * (pi))) = infty vs. infty 526: max(infty, sin(17 * (pi)) + 42) = infty vs. infty 527: max(infty, 42) = infty vs. infty 528: max(infty, 1664) = infty vs. infty 529: max(infty, (log2(13) / log2(17)) - (log(13) / log(17))) = infty vs. infty 530: max(infty, exp(24 / 10)) = infty vs. infty 531: max(infty, log2(2076)) = infty vs. infty 532: max(infty, -23) = infty vs. infty 533: max(infty, 11.01953125) = infty vs. infty 534: max(NaN, -infty) = -infty vs. -infty 535: max(NaN, infty) = infty vs. infty 536: max(NaN, NaN) = NaN vs. NaN 537: max(NaN, 0) = 0 vs. 0 538: max(NaN, sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 539: max(NaN, sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 540: max(NaN, 42) = 42 vs. 42 541: max(NaN, 1664) = 1664 vs. 1664 542: max(NaN, (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 543: max(NaN, exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 544: max(NaN, log2(2076)) = log2(2076) vs. log2(2076) 545: max(NaN, -23) = -23 vs. -23 546: max(NaN, 11.01953125) = 11.01953125 vs. 11.01953125 547: max(0, -infty) = 0 vs. 0 548: max(0, infty) = infty vs. infty 549: max(0, NaN) = 0 vs. 0 550: max(0, 0) = 0 vs. 0 551: max(0, sin(17 * (pi))) = 0 vs. 0 or sin(17 * (pi)) 552: max(0, sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 553: max(0, 42) = 42 vs. 42 554: max(0, 1664) = 1664 vs. 1664 555: max(0, (log2(13) / log2(17)) - (log(13) / log(17))) = 0 vs. 0 or (log2(13) / log2(17)) - (log(13) / log(17)) 556: max(0, exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 557: max(0, log2(2076)) = log2(2076) vs. log2(2076) 558: max(0, -23) = 0 vs. 0 559: max(0, 11.01953125) = 11.01953125 vs. 11.01953125 560: max(sin(17 * (pi)), -infty) = sin(17 * (pi)) vs. sin(17 * (pi)) 561: max(sin(17 * (pi)), infty) = infty vs. infty 562: max(sin(17 * (pi)), NaN) = sin(17 * (pi)) vs. sin(17 * (pi)) 563: max(sin(17 * (pi)), 0) = sin(17 * (pi)) vs. sin(17 * (pi)) or 0 564: max(sin(17 * (pi)), sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 565: max(sin(17 * (pi)), sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 566: max(sin(17 * (pi)), 42) = 42 vs. 42 567: max(sin(17 * (pi)), 1664) = 1664 vs. 1664 568: max(sin(17 * (pi)), (log2(13) / log2(17)) - (log(13) / log(17))) = sin(17 * (pi)) vs. sin(17 * (pi)) or (log2(13) / log2(17)) - (log(13) / log(17)) 569: max(sin(17 * (pi)), exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 570: max(sin(17 * (pi)), log2(2076)) = log2(2076) vs. log2(2076) 571: max(sin(17 * (pi)), -23) = sin(17 * (pi)) vs. sin(17 * (pi)) 572: max(sin(17 * (pi)), 11.01953125) = 11.01953125 vs. 11.01953125 573: max(sin(17 * (pi)) + 42, -infty) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 574: max(sin(17 * (pi)) + 42, infty) = infty vs. infty 575: max(sin(17 * (pi)) + 42, NaN) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 576: max(sin(17 * (pi)) + 42, 0) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 577: max(sin(17 * (pi)) + 42, sin(17 * (pi))) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 578: max(sin(17 * (pi)) + 42, sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 579: max(sin(17 * (pi)) + 42, 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 or 42 580: max(sin(17 * (pi)) + 42, 1664) = 1664 vs. 1664 581: max(sin(17 * (pi)) + 42, (log2(13) / log2(17)) - (log(13) / log(17))) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 582: max(sin(17 * (pi)) + 42, exp(24 / 10)) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 583: max(sin(17 * (pi)) + 42, log2(2076)) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 584: max(sin(17 * (pi)) + 42, -23) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 585: max(sin(17 * (pi)) + 42, 11.01953125) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 586: max(42, -infty) = 42 vs. 42 587: max(42, infty) = infty vs. infty 588: max(42, NaN) = 42 vs. 42 589: max(42, 0) = 42 vs. 42 590: max(42, sin(17 * (pi))) = 42 vs. 42 591: max(42, sin(17 * (pi)) + 42) = 42 vs. 42 or sin(17 * (pi)) + 42 592: max(42, 42) = 42 vs. 42 593: max(42, 1664) = 1664 vs. 1664 594: max(42, (log2(13) / log2(17)) - (log(13) / log(17))) = 42 vs. 42 595: max(42, exp(24 / 10)) = 42 vs. 42 596: max(42, log2(2076)) = 42 vs. 42 597: max(42, -23) = 42 vs. 42 598: max(42, 11.01953125) = 42 vs. 42 599: max(1664, -infty) = 1664 vs. 1664 600: max(1664, infty) = infty vs. infty 601: max(1664, NaN) = 1664 vs. 1664 602: max(1664, 0) = 1664 vs. 1664 603: max(1664, sin(17 * (pi))) = 1664 vs. 1664 604: max(1664, sin(17 * (pi)) + 42) = 1664 vs. 1664 605: max(1664, 42) = 1664 vs. 1664 606: max(1664, 1664) = 1664 vs. 1664 607: max(1664, (log2(13) / log2(17)) - (log(13) / log(17))) = 1664 vs. 1664 608: max(1664, exp(24 / 10)) = 1664 vs. 1664 609: max(1664, log2(2076)) = 1664 vs. 1664 610: max(1664, -23) = 1664 vs. 1664 611: max(1664, 11.01953125) = 1664 vs. 1664 612: max((log2(13) / log2(17)) - (log(13) / log(17)), -infty) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 613: max((log2(13) / log2(17)) - (log(13) / log(17)), infty) = infty vs. infty 614: max((log2(13) / log2(17)) - (log(13) / log(17)), NaN) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 615: max((log2(13) / log2(17)) - (log(13) / log(17)), 0) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) or 0 616: max((log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) or sin(17 * (pi)) 617: max((log2(13) / log2(17)) - (log(13) / log(17)), sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 618: max((log2(13) / log2(17)) - (log(13) / log(17)), 42) = 42 vs. 42 619: max((log2(13) / log2(17)) - (log(13) / log(17)), 1664) = 1664 vs. 1664 620: max((log2(13) / log2(17)) - (log(13) / log(17)), (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 621: max((log2(13) / log2(17)) - (log(13) / log(17)), exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 622: max((log2(13) / log2(17)) - (log(13) / log(17)), log2(2076)) = log2(2076) vs. log2(2076) 623: max((log2(13) / log2(17)) - (log(13) / log(17)), -23) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 624: max((log2(13) / log2(17)) - (log(13) / log(17)), 11.01953125) = 11.01953125 vs. 11.01953125 625: max(exp(24 / 10), -infty) = exp(24 / 10) vs. exp(24 / 10) 626: max(exp(24 / 10), infty) = infty vs. infty 627: max(exp(24 / 10), NaN) = exp(24 / 10) vs. exp(24 / 10) 628: max(exp(24 / 10), 0) = exp(24 / 10) vs. exp(24 / 10) 629: max(exp(24 / 10), sin(17 * (pi))) = exp(24 / 10) vs. exp(24 / 10) 630: max(exp(24 / 10), sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 631: max(exp(24 / 10), 42) = 42 vs. 42 632: max(exp(24 / 10), 1664) = 1664 vs. 1664 633: max(exp(24 / 10), (log2(13) / log2(17)) - (log(13) / log(17))) = exp(24 / 10) vs. exp(24 / 10) 634: max(exp(12 / 5), exp(12 / 5)) = exp(12 / 5) vs. exp(12 / 5) 635: max(exp(12 / 5), log2(2076)) = exp(12 / 5) vs. exp(12 / 5) 636: max(exp(12 / 5), -23) = exp(12 / 5) vs. exp(12 / 5) 637: max(exp(12 / 5), 11.01953125) = exp(12 / 5) vs. exp(12 / 5) 638: max(log2(2076), -infty) = log2(2076) vs. log2(2076) 639: max(log2(2076), infty) = infty vs. infty 640: max(log2(2076), NaN) = log2(2076) vs. log2(2076) 641: max(log2(2076), 0) = log2(2076) vs. log2(2076) 642: max(log2(2076), sin(17 * (pi))) = log2(2076) vs. log2(2076) 643: max(log2(2076), sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 644: max(log2(2076), 42) = 42 vs. 42 645: max(log2(2076), 1664) = 1664 vs. 1664 646: max(log2(2076), (log2(13) / log2(17)) - (log(13) / log(17))) = log2(2076) vs. log2(2076) 647: max(log2(2076), exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 648: max(log2(2076), log2(2076)) = log2(2076) vs. log2(2076) 649: max(log2(2076), -23) = log2(2076) vs. log2(2076) 650: max(log2(2076), 11.01953125) = log2(2076) vs. log2(2076) 651: max(-23, -infty) = -23 vs. -23 652: max(-23, infty) = infty vs. infty 653: max(-23, NaN) = -23 vs. -23 654: max(-23, 0) = 0 vs. 0 655: max(-23, sin(17 * (pi))) = sin(17 * (pi)) vs. sin(17 * (pi)) 656: max(-23, sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 657: max(-23, 42) = 42 vs. 42 658: max(-23, 1664) = 1664 vs. 1664 659: max(-23, (log2(13) / log2(17)) - (log(13) / log(17))) = log2(13) / log2(17) - log(13) / log(17) vs. (log2(13) / log2(17)) - (log(13) / log(17)) 660: max(-23, exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 661: max(-23, log2(2076)) = log2(2076) vs. log2(2076) 662: max(-23, -23) = -23 vs. -23 663: max(-23, 11.01953125) = 11.01953125 vs. 11.01953125 664: max(11.01953125, -infty) = 11.01953125 vs. 11.01953125 665: max(11.01953125, infty) = infty vs. infty 666: max(11.01953125, NaN) = 11.01953125 vs. 11.01953125 667: max(11.01953125, 0) = 11.01953125 vs. 11.01953125 668: max(11.01953125, sin(17 * (pi))) = 11.01953125 vs. 11.01953125 669: max(11.01953125, sin(17 * (pi)) + 42) = sin(17 * (pi)) + 42 vs. sin(17 * (pi)) + 42 670: max(11.01953125, 42) = 42 vs. 42 671: max(11.01953125, 1664) = 1664 vs. 1664 672: max(11.01953125, (log2(13) / log2(17)) - (log(13) / log(17))) = 11.01953125 vs. 11.01953125 673: max(11.01953125, exp(24 / 10)) = exp(24 / 10) vs. exp(24 / 10) 674: max(11.01953125, log2(2076)) = log2(2076) vs. log2(2076) 675: max(11.01953125, -23) = 11.01953125 vs. 11.01953125 676: max(11.01953125, 11.01953125) = 11.01953125 vs. 11.01953125 sollya-6.0+ds/tests-tool/check030.sollya000066400000000000000000000400451300174114700201270ustar00rootroot00000000000000/* These are basic tests for function annotation */ print("=============== Check #1 ================"); restart; f = exp(x); procedure EXP(X,n,p) { var res, oldPrec; oldPrec = prec; prec = p!; "Using procedure function exponential"; res = exp(X); prec = oldPrec!; return res; }; g = function(EXP); h = annotatefunction(f,g,[-5;5],[0]); "h = ", h, ", h(3) = "; h(3); "h = ", h, ", h(3) = "; h(3); /* Check that the value is cached */ "h = ", h, ", h(2) = "; h(2); "h = ", h, ", h(6) = "; h(6); /* Outside the range where an annotation is known */ "f = ", f, ", f(3) = "; f(3); /* We do not expect the cached value to be used here because ?????? */ "f = ", f, ", f(3) = "; f(3); "f = ", f, ", f(2) = "; f(2); "f = ", f, ", f(6) = "; f(6); hp = annotatefunction(diff(f),g,[-5;5],[0]); t = diff(f); "t = ", t, ", t(3) = "; t(3); /* We expect t to use the annotation because ?????? */ "t = ", t, ", t(2) = "; t(2); "hp = ", hp, ", hp(2) = "; hp(2); "hp = ", hp, ", hp(3) = "; hp(3); /* We expect hp to use a cached value at 2 and not at 3 because ?????? */ match sin(diff(f)) with sin(q) : { "q = ", q, ", q(4) = "; q(4); } default : {}; /* Another set of basic tests for function annotation */ print("=============== Check #2 ================"); restart; procedure EXP(X,n,p) { var res, oldPrec; oldPrec = prec; prec = p!; "Using procedure function exponential"; res = exp(X); prec = oldPrec!; return res; }; g = function(EXP); p = 46768052394588893382516870161332864698044514954899b-165 + x * (23384026197294446691258465802074096632225783601255b-164 + x * (5846006549323611672948426613035653821819225877423b-163 + x * (3897337699549074448627696490806815137319821946501b-164 + x * (7794675399098148717422744621371434831048848817417b-167 + x * (24942961277114075921122941174178849425809856036737b-171 + x * (8314320425704876115613838900105097456456371179471b-172 + x * (19004160973039701371579356991645932289422670402995b-176 + x * (19004160972669324148912122254449912156003926801563b-179 + x * (33785175062542597526738679493857229456702396042255b-183 + x * (6757035113643674378393625988264926886191860669891b-184 + x * (9828414707511252769908089206114262766633532289937b-188 + x * (26208861108003813314724515233584738706961162212965b-193 + x * (32257064253325954315953742396999456577223350602741b-197 + x * (578429089657689569703509185903214676926704485495b-195 + x * 2467888542176675658523627105540996778984959471957b-201)))))))))))))); h = annotatefunction(g, p, [-1/2;1/2], [-475294848522543b-124;475294848522543b-124]); hp = annotatefunction(diff(g), p, [-1/2;1/2], [-475294848522543b-124;475294848522543b-124]); /* This is defined because ?????? */ prec = 24; "h(0.25) = "; h(0.25); "h(0.75) = "; h(0.75); /* Outside of the range where an annotation is known */ prec = 36; "h(0.25) = "; h(0.25); prec = 48; "h(0.25) = "; h(0.25); prec = 60; "h(0.25) = "; h(0.25); prec = 72; "h(0.25) = "; h(0.25); prec = 24; "h(0) = "; h(0); "h(0.125) = "; h(0.125); "evaluate(h,[-0.25;0.25]) = "; evaluate(h,[-0.25;0.25]); prec = 72; "evaluate(h,[-0.25;0.25]) = "; evaluate(h,[-0.25;0.25]); prec = 24; q = sin(0.5 * h(x - 1)); "q = "; q; "q(1.25) = "; q(1.25); prec = 36; "q(133/100) = "; q(133/100); prec = 165; "q(1.25) = "; q(1.25); prec = 24; qp = diff(q); qp(1.25); /* We do not expect qp to use the procedure EXP at all because ??????? */ qp(133/100); t = q(x + 1/1000); tp = diff(t); tp(1.25); t(133/100); /* Checks #3 to #8 all make use of the following auxiliary procedure. It is used to decorate a function f with a message s in order to trace its calls. procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; */ /* In this test we create two annotations with overlapping domains and with inconsistent values */ print("=============== Check #3 ================"); restart; roundingwarnings=on; procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; f = cos(x); procedure main_g(X,n,p) { return proc_aux(X,n,p, "Main function", f); }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", 1); }; procedure g2(X,n,p) { return proc_aux(X,n,p, "Annotation 2", 2); }; g = function(main_g); prec=15; g = annotatefunction(g, function(g1), [0,1], [-1b-20, 1b-20]); g = annotatefunction(g, function(g2), [0.5,1.5], [-1b-20, 1b-20]); g(0.75); /* Same as check #3 but with more accurate annotations */ print("=============== Check #4 ================"); restart; roundingwarnings=on; procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; f = cos(x); procedure main_g(X,n,p) { return proc_aux(X,n,p, "Main function", f); }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", 1); }; procedure g2(X,n,p) { return proc_aux(X,n,p, "Annotation 2", 2); }; g = function(main_g); prec=15; g = annotatefunction(g, function(g1), [0,1], [-1b-40, 1b-40]); g = annotatefunction(g, function(g2), [0.5,1.5], [-1b-40, 1b-40]); g(0.75); /* Same as check #3 but with a first call before setting the second annotation in order to cache the value */ print("=============== Check #5 ================"); restart; roundingwarnings=on; procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; f = cos(x); procedure main_g(X,n,p) { return proc_aux(X,n,p, "Main function", f); }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", 1); }; procedure g2(X,n,p) { return proc_aux(X,n,p, "Annotation 2", 2); }; g = function(main_g); prec=15; g = annotatefunction(g, function(g1), [0,1], [-1b-20, 1b-20]); g(0.75); g = annotatefunction(g, function(g2), [0.5,1.5], [-1b-20, 1b-20]); g(0.75); /* Same as check #4 but with a first call before setting the second annotation in order to cache the value */ print("=============== Check #6 ================"); restart; roundingwarnings=on; procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; f = cos(x); procedure main_g(X,n,p) { return proc_aux(X,n,p, "Main function", f); }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", 1); }; procedure g2(X,n,p) { return proc_aux(X,n,p, "Annotation 2", 2); }; g = function(main_g); prec=15; g = annotatefunction(g, function(g1), [0,1], [-1b-40, 1b-40]); g(0.75); g = annotatefunction(g, function(g2), [0.5,1.5], [-1b-40, 1b-40]); g(0.75); /* Same as check #3 but the evaluation is made at a precision where the annotations are useless */ print("=============== Check #7 ================"); restart; roundingwarnings=on; procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; f = cos(x); procedure main_g(X,n,p) { return proc_aux(X,n,p, "Main function", f); }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", 1); }; procedure g2(X,n,p) { return proc_aux(X,n,p, "Annotation 2", 2); }; g = function(main_g); prec=50; g = annotatefunction(g, function(g1), [0,1], [-1b-20, 1b-20]); g = annotatefunction(g, function(g2), [0.5,1.5], [-1b-20, 1b-20]); g(0.75); /***************************************************************************************/ /* Checks 8 to 12 replay checks 3 to 7 but with *consistent* values for the annotation */ /***************************************************************************************/ /* In this test we create two annotations with overlapping domains and with consistent values */ print("=============== Check #8 ================"); restart; roundingwarnings=on; procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; f = cos(x); procedure main_g(X,n,p) { return proc_aux(X,n,p, "Main function", f); }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", f); }; procedure g2(X,n,p) { return proc_aux(X,n,p, "Annotation 2", f); }; g = function(main_g); prec=15; g = annotatefunction(g, function(g1), [0,1], [-1b-20, 1b-20]); g = annotatefunction(g, function(g2), [0.5,1.5], [-1b-20, 1b-20]); g(0.75); /* Same as check #8 but with more accurate annotations */ print("=============== Check #9 ================"); restart; roundingwarnings=on; procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; f = cos(x); procedure main_g(X,n,p) { return proc_aux(X,n,p, "Main function", f); }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", f); }; procedure g2(X,n,p) { return proc_aux(X,n,p, "Annotation 2", f); }; g = function(main_g); prec=15; g = annotatefunction(g, function(g1), [0,1], [-1b-40, 1b-40]); g = annotatefunction(g, function(g2), [0.5,1.5], [-1b-40, 1b-40]); g(0.75); /* Same as check #8 but with a first call before setting the second annotation in order to cache the value */ print("=============== Check #10 ================"); restart; roundingwarnings=on; procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; f = cos(x); procedure main_g(X,n,p) { return proc_aux(X,n,p, "Main function", f); }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", f); }; procedure g2(X,n,p) { return proc_aux(X,n,p, "Annotation 2", f); }; g = function(main_g); prec=15; g = annotatefunction(g, function(g1), [0,1], [-1b-20, 1b-20]); g(0.75); g = annotatefunction(g, function(g2), [0.5,1.5], [-1b-20, 1b-20]); g(0.75); /* Same as check #9 but with a first call before setting the second annotation in order to cache the value */ print("=============== Check #11 ================"); restart; roundingwarnings=on; procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; f = cos(x); procedure main_g(X,n,p) { return proc_aux(X,n,p, "Main function", f); }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", f); }; procedure g2(X,n,p) { return proc_aux(X,n,p, "Annotation 2", f); }; g = function(main_g); prec=15; g = annotatefunction(g, function(g1), [0,1], [-1b-40, 1b-40]); g(0.75); g = annotatefunction(g, function(g2), [0.5,1.5], [-1b-40, 1b-40]); g(0.75); /* Same as check #8 but the evaluation is made at a precision where the annotations are useless */ print("=============== Check #12 ================"); restart; roundingwarnings=on; procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; f = cos(x); procedure main_g(X,n,p) { return proc_aux(X,n,p, "Main function", f); }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", f); }; procedure g2(X,n,p) { return proc_aux(X,n,p, "Annotation 2", f); }; g = function(main_g); prec=50; g = annotatefunction(g, function(g1), [0,1], [-1b-20, 1b-20]); g = annotatefunction(g, function(g2), [0.5,1.5], [-1b-20, 1b-20]); g(0.75); /* In this check, we define two concurrent annotations providing approximations with different accuracies for the same domain */ print("=============== Check #13 ================"); restart; roundingwarnings=on; procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; f = cos(x); procedure main_g(X,n,p) { return proc_aux(X,n,p, "Main function", f); }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", f); }; procedure g2(X,n,p) { return proc_aux(X,n,p, "Annotation 2", f); }; g = function(main_g); prec=15; g = annotatefunction(g, function(g1), [0,1], [-1b-40, 1b-40]); g = annotatefunction(g, function(g2), [0,1], [-1b-80, 1b-80]); g(0.75); /* Same as check #13, but the annotations are registered in reverse order */ print("=============== Check #14 ================"); restart; roundingwarnings=on; procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; f = cos(x); procedure main_g(X,n,p) { return proc_aux(X,n,p, "Main function", f); }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", f); }; procedure g2(X,n,p) { return proc_aux(X,n,p, "Annotation 2", f); }; g = function(main_g); prec=15; g = annotatefunction(g, function(g2), [0,1], [-1b-40, 1b-40]); g = annotatefunction(g, function(g1), [0,1], [-1b-80, 1b-80]); g(0.75); /* In this test, we check how functions compare when annotated (or not) and how annotations are transmitted through composition and differentiation */ print("=============== Check #15 ================"); restart; roundingwarnings=on; f = cos(x); procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", f); }; g = annotatefunction(f, function(g1), [0,1], [-1b-40, 1b-40]); h = cos(x); u = 1+f; v = diff(diff(f)); s = diff(f^2); prec=15; f == g; g == h; f == -v; f == -diff(diff(h)); f(0); g(0.125); h(0.25); u(0.5); v(0.625); s(0.75); restart; roundingwarnings=on; f = exp(x); procedure proc_aux(X,n,p,s,f) { var oldPrec, res; if n==0 then { oldPrec=prec; prec=p!; res=f(X); prec=oldPrec!; print(s @ " (X=" @ X @ ", f=" @ f @ ", p=" @ p @ " res="@ res @ ")"); } else res = proc_aux(X,n-1,p,s,diff(f)); return res; }; procedure g1(X,n,p) { return proc_aux(X,n,p, "Annotation 1", f); }; g = annotatefunction(f, function(g1), [0,1], [-1b-40, 1b-40]); prec=15; f(1b-1); g(1b-2); h = exp(x); h(1b-3); s = diff(g); s(1b-4); s == g; /* Non-regression tests for bug #12892 */ print("=============== Check #15 ================"); restart; verbosity=0!; f=1;monomials=[|0, 2, 3, 4, 5|];I=[-5.158181719508547757868655025959014892578125e-3;3.3904318280491452242131344974040985107421875e-2]; w=2.72690438442525646171725409080713295993895958208664491819205040039740209363522566946082937318997664648385448213348272231703116245827453863732419606661852985461094238653954479036005438091191783057812245321703983^(4.5005158181719508547757868655025959014892578125e1 + x) / ((3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034824 + sin(0.9001031636343901709551573731005191802978515625 + x / 50)) * exp(4.5005158181719508547757868655025959014892578125e1 + x)) ; p=remez(f,monomials,I,w); p==p; restart; verbosity=0!; p = remez(acos(x), [|exp(x), sin(x), cos(x)-1, sin(x)^4, sin(x^5)|], [-1/2;1/3]); p==p; restart; verbosity=0!; prec = 300!; points = 65!; p=remez(1,[|0, 1, 3, 5, 7, 8|],[-4;3083658896642633b-51],1 / (sin(x * 1 / 17) + 42),2621b-19,[3b-56;3b-54]); p==p; restart; verbosity=0!; p=remez(1,[|0, 4, 7, 9, 10, 11, 12|],[-163b-6;489b-6],1 / erf(-861b-6 + x),2621b-19,[13b-61;13b-59]); p==p;sollya-6.0+ds/tests-tool/check030.sollya.reference000066400000000000000000000300651300174114700220650ustar00rootroot00000000000000=============== Check #1 ================ The tool has been restarted. h = exp(x), h(3) = Using procedure function exponential 20.0855369231876677409285296545817178969879078385544 h = exp(x), h(3) = 20.0855369231876677409285296545817178969879078385544 h = exp(x), h(2) = Using procedure function exponential 7.3890560989306502272304274605750078131803155705519 h = exp(x), h(6) = 403.42879349273512260838718054338827960589989735713 f = exp(x), f(3) = Using procedure function exponential 20.0855369231876677409285296545817178969879078385544 f = exp(x), f(3) = 20.0855369231876677409285296545817178969879078385544 f = exp(x), f(2) = Using procedure function exponential 7.3890560989306502272304274605750078131803155705519 f = exp(x), f(6) = 403.42879349273512260838718054338827960589989735713 t = exp(x), t(3) = Using procedure function exponential 20.0855369231876677409285296545817178969879078385544 t = exp(x), t(2) = Using procedure function exponential 7.3890560989306502272304274605750078131803155705519 hp = exp(x), hp(2) = 7.3890560989306502272304274605750078131803155705519 hp = exp(x), hp(3) = Using procedure function exponential 20.0855369231876677409285296545817178969879078385544 q = exp(x), q(4) = Using procedure function exponential 54.598150033144239078110261202860878402790737038614 =============== Check #2 ================ The tool has been restarted. The precision has been set to 24 bits. h(0.25) = 1.2840254 h(0.75) = Using procedure function exponential 2.117 The precision has been set to 36 bits. h(0.25) = 1.28402541668 The precision has been set to 48 bits. h(0.25) = 1.28402541668774 The precision has been set to 60 bits. h(0.25) = 1.284025416687741485 The precision has been set to 72 bits. h(0.25) = 1.2840254166877414840735 The precision has been set to 24 bits. h(0) = 1 h(0.125) = 1.1331484 evaluate(h,[-0.25;0.25]) = [0.7788007;1.2840254] The precision has been set to 72 bits. evaluate(h,[-0.25;0.25]) = [0.778800783071404868245;1.2840254166877414840735] The precision has been set to 24 bits. q = sin(0.5 * (function(proc(X, n, p) { var res, oldPrec; oldPrec = prec; prec = p!; "Using procedure function exponential"; res = exp(X); prec = oldPrec!; return res; }))(-1 + x)) q(1.25) = 0.5988086 The precision has been set to 36 bits. q(133/100) = 0.64075715182 The precision has been set to 165 bits. q(1.25) = Using procedure function exponential 0.59880861547946331000832206558954188255903073392375 The precision has been set to 24 bits. 0.5141829 0.5339534 0.5144501 0.6412912 =============== Check #3 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 15 bits. Annotation 2 (X=[0.75;0.75], f=2, p=45 res=[2;2]) Annotation 1 (X=[0.75;0.75], f=1, p=45 res=[1;1]) Warning: an inconsistency has been detected between the results obtained with the evaluation of two distinct annotations of the same function. Warning: an inconsistency has been detected between the results obtained with the evaluation of two distinct annotations of the same function. Main function (X=[0.75;0.75], f=cos(x), p=35 res=[0.73168886887;0.7316888689]) Annotation 2 (X=[0.75;0.75], f=2, p=62 res=[2;2]) Annotation 1 (X=[0.75;0.75], f=1, p=62 res=[1;1]) Warning: an inconsistency has been detected between the results obtained with the evaluation of two distinct annotations of the same function. Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 0.7317 =============== Check #4 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 15 bits. Annotation 2 (X=[0.75;0.75], f=2, p=45 res=[2;2]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 2 =============== Check #5 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 15 bits. Annotation 1 (X=[0.75;0.75], f=1, p=45 res=[1;1]) Annotation 1 (X=[0.75;0.75], f=1, p=62 res=[1;1]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1 Annotation 2 (X=[0.75;0.75], f=2, p=45 res=[2;2]) Warning: an inconsistency has been detected between the results obtained with the evaluation of two distinct annotations of the same function. Warning: an inconsistency has been detected between the results obtained with the evaluation of two distinct annotations of the same function. Main function (X=[0.75;0.75], f=cos(x), p=35 res=[0.73168886887;0.7316888689]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1 =============== Check #6 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 15 bits. Annotation 1 (X=[0.75;0.75], f=1, p=45 res=[1;1]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1 Annotation 2 (X=[0.75;0.75], f=2, p=45 res=[2;2]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1 =============== Check #7 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 50 bits. Annotation 2 (X=[0.75;0.75], f=2, p=80 res=[2;2]) Annotation 1 (X=[0.75;0.75], f=1, p=80 res=[1;1]) Warning: an inconsistency has been detected between the results obtained with the evaluation of two distinct annotations of the same function. Warning: an inconsistency has been detected between the results obtained with the evaluation of two distinct annotations of the same function. Main function (X=[0.75;0.75], f=cos(x), p=70 res=[0.7316888688738208863116;0.731688868873820886312]) Annotation 2 (X=[0.75;0.75], f=2, p=115 res=[2;2]) Annotation 1 (X=[0.75;0.75], f=1, p=115 res=[1;1]) Warning: an inconsistency has been detected between the results obtained with the evaluation of two distinct annotations of the same function. Warning: rounding has happened. The value displayed is a faithful rounding to 50 bits of the true result. 0.731688868873821 =============== Check #8 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 15 bits. Annotation 2 (X=[0.75;0.75], f=cos(x), p=45 res=[0.73168886887382;0.73168886887385]) Annotation 1 (X=[0.75;0.75], f=cos(x), p=45 res=[0.73168886887382;0.73168886887385]) Annotation 2 (X=[0.75;0.75], f=cos(x), p=62 res=[0.7316888688738208862;0.7316888688738208864]) Annotation 1 (X=[0.75;0.75], f=cos(x), p=62 res=[0.7316888688738208862;0.7316888688738208864]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 0.7317 =============== Check #9 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 15 bits. Annotation 2 (X=[0.75;0.75], f=cos(x), p=45 res=[0.73168886887382;0.73168886887385]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 0.7317 =============== Check #10 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 15 bits. Annotation 1 (X=[0.75;0.75], f=cos(x), p=45 res=[0.73168886887382;0.73168886887385]) Annotation 1 (X=[0.75;0.75], f=cos(x), p=62 res=[0.7316888688738208862;0.7316888688738208864]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 0.7317 Annotation 2 (X=[0.75;0.75], f=cos(x), p=45 res=[0.73168886887382;0.73168886887385]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 0.7317 =============== Check #11 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 15 bits. Annotation 1 (X=[0.75;0.75], f=cos(x), p=45 res=[0.73168886887382;0.73168886887385]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 0.7317 Annotation 2 (X=[0.75;0.75], f=cos(x), p=45 res=[0.73168886887382;0.73168886887385]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 0.7317 =============== Check #12 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 50 bits. Annotation 2 (X=[0.75;0.75], f=cos(x), p=80 res=[0.731688868873820886311838;0.731688868873820886311839]) Annotation 1 (X=[0.75;0.75], f=cos(x), p=80 res=[0.731688868873820886311838;0.731688868873820886311839]) Annotation 2 (X=[0.75;0.75], f=cos(x), p=115 res=[0.73168886887382088631183875300008453;0.73168886887382088631183875300008455]) Annotation 1 (X=[0.75;0.75], f=cos(x), p=115 res=[0.73168886887382088631183875300008453;0.73168886887382088631183875300008455]) Annotation 2 (X=[0.75;0.75], f=cos(x), p=125 res=[0.73168886887382088631183875300008454383;0.73168886887382088631183875300008454385]) Annotation 1 (X=[0.75;0.75], f=cos(x), p=125 res=[0.73168886887382088631183875300008454383;0.73168886887382088631183875300008454385]) Main function (X=[0.75;0.75], f=cos(x), p=70 res=[0.7316888688738208863116;0.731688868873820886312]) Warning: rounding has happened. The value displayed is a faithful rounding to 50 bits of the true result. 0.731688868873821 =============== Check #13 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 15 bits. Annotation 2 (X=[0.75;0.75], f=cos(x), p=45 res=[0.73168886887382;0.73168886887385]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 0.7317 =============== Check #14 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 15 bits. Annotation 1 (X=[0.75;0.75], f=cos(x), p=45 res=[0.73168886887382;0.73168886887385]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 0.7317 =============== Check #15 ================ The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 15 bits. true true true true Annotation 1 (X=[0;0], f=cos(x), p=45 res=[1;1]) 1 Annotation 1 (X=[0.125;0.125], f=cos(x), p=45 res=[0.9921976672293;0.99219766722933]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 0.9922 Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 0.9689 Annotation 1 (X=[0.5;0.5], f=cos(x), p=55 res=[0.8775825618903727;0.87758256189037273]) Annotation 1 (X=[0.5;0.5], f=cos(x), p=65 res=[0.8775825618903727161;0.87758256189037271613]) Annotation 1 (X=[0.5;0.5], f=cos(x), p=92 res=[0.8775825618903727161162815826;0.8775825618903727161162815828]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1.87756 Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. -0.81097 Annotation 1 (X=[0.75;0.75], f=cos(x), p=55 res=[0.73168886887382087;0.7316888688738209]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. -0.9975 The tool has been restarted. Rounding warning mode has been activated. The precision has been set to 15 bits. Annotation 1 (X=[0.5;0.5], f=exp(x), p=45 res=[1.6487212707001;1.64872127070015]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1.64874 Annotation 1 (X=[0.25;0.25], f=exp(x), p=45 res=[1.2840254166877;1.28402541668777]) Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1.284 Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1.1332 Warning: rounding has happened. The value displayed is a faithful rounding to 15 bits of the true result. 1.0645 true =============== Check #15 ================ The tool has been restarted. true The tool has been restarted. true The tool has been restarted. true The tool has been restarted. true sollya-6.0+ds/tests-tool/check031.sollya000066400000000000000000000046441300174114700201350ustar00rootroot00000000000000/* IMPORTANT WARNING */ /* This file has DOS-style new lines */ /*************************************/ restart; print("Test #1"); a=1; b=2; a+b; /* Trying what happens when executing a file */ restart; print("Test #2"); filename = "temp" @ __unique_id; print("a=1;\r\nb=2;\r\na+b;\r\n") > filename; execute(filename); bashexecute("rm -rf " @ filename); /* Trying what happens when executing a file with standard '\n' new lines */ restart; print("Test #3"); filename = "temp" @ __unique_id; print("a=1;\nb=2;\na+b;\n") > filename; execute(filename); bashexecute("rm -rf " @ filename); /* Trying what happens when using parse */ restart; print("Test #4"); filename = "temp" @ __unique_id; a=1; b=2; print("a\r\n+\r\nb;\r\n") > filename; s=readfile(filename); bashexecute("rm -rf " @ filename); parse(s); /* Trying what happens when using parse on a string with normal '\n' */ restart; print("Test #5"); filename = "temp" @ __unique_id; a=1; b=2; print("a\n+\nb;\n") > filename; s=readfile(filename); bashexecute("rm -rf " @ filename); parse(s); /* Trying parse inside a file that is executed */ restart; print("Test #6"); filename = "temp" @ __unique_id; print("a\r\n+\r\nb;\r\n") > filename; s=readfile(filename); bashexecute("rm -rf " @ filename); print("a=1;\r\nb=2;\r\nparse(s);\r\n") > filename; execute(filename); bashexecute("rm -rf " @ filename); /* Trying parse inside a file that is executed, with different new lines */ restart; print("Test #7"); filename = "temp" @ __unique_id; print("a\r\n+\r\nb;\r\n") > filename; s=readfile(filename); bashexecute("rm -rf " @ filename); print("a=1;\nb=2;\nparse(s);\n") > filename; execute(filename); bashexecute("rm -rf " @ filename); /* Trying parse inside a file that is executed, with different new lines, the other way */ restart; print("Test #8"); filename = "temp" @ __unique_id; print("a\n+\nb;\n") > filename; s=readfile(filename); bashexecute("rm -rf " @ filename); print("a=1;\r\nb=2;\r\nparse(s);\r\n") > filename; execute(filename); bashexecute("rm -rf " @ filename); /* Trying parse inside a file that is executed, having both standard '\n' */ restart; print("Test #9"); filename = "temp" @ __unique_id; print("a\n+\nb;\n") > filename; s=readfile(filename); bashexecute("rm -rf " @ filename); print("a=1;\nb=2;\nparse(s);\n") > filename; execute(filename); bashexecute("rm -rf " @ filename); sollya-6.0+ds/tests-tool/check031.sollya.reference000066400000000000000000000005371300174114700220670ustar00rootroot00000000000000The tool has been restarted. Test #1 3 The tool has been restarted. Test #2 3 The tool has been restarted. Test #3 3 The tool has been restarted. Test #4 3 The tool has been restarted. Test #5 3 The tool has been restarted. Test #6 3 The tool has been restarted. Test #7 3 The tool has been restarted. Test #8 3 The tool has been restarted. Test #9 3 sollya-6.0+ds/tests-tool/libraryexample.c000066400000000000000000000001771300174114700205700ustar00rootroot00000000000000#include int foo(mpfi_t rop, mpfi_t op, int n) { (void) n; (void) op; mpfi_interv_ui(rop, 0, 1); return 0; } sollya-6.0+ds/tests-tool/timecheck.sollya000066400000000000000000000637441300174114700205760ustar00rootroot00000000000000verbosity=0!; yardstick = time(nop(5000)); i = 0; variance = [1/10;10]; bigVariance = [1/1000;100]; /* Test #0 */ i; t = time(p = remez(exp(x),15,[-1b-1;1b-1]))/yardstick; if (t in 6.29e-3 * variance) then "Okay" else round(t,12,RN); i := i + 1; /* Test #1 */ i; t = time(p = remez(1,[|1,...,15|],[-1b-1;1b-1],1/sin(x)))/yardstick; if (t in 3.24859619140625e-2 * variance) then "Okay" else round(t,12,RN); i := i + 1; /* Test #2 */ i; p = ( (x-pi)^25-exp(1) )^3; t = time(c = coeff(p,65))/yardstick; if (t in 0.05 * variance) then "Okay" else round(t,12,RN); i := i + 1; /* Test #3 */ i; t = time(eps = dirtyinfnorm(p/sin(x)-1,[-1b-1;1b-1]))/yardstick; if (t in 9.429931640625e-2 * variance) then "Okay" else round(t,12,RN); i := i + 1; /* Test #4 */ i; t = time(p = horner((x - (x + 3)^2)^17))/yardstick; if (t in 2.712249755859375e-3 * variance) then "Okay" else round(t,12,RN); i := i + 1; /* Test #5 */ i; t = time(h = (diff(horner((x - (x + 3)^2)^17)))(0))/yardstick; if (t in 6.71446323394775390625e-5 * variance) then "Okay" else round(t,12,RN); i := i + 1; /* Test #6 */ i; t = time(w = evaluate(sin(pi * x),5))/yardstick; if (t in 5.00 * bigVariance) then "Okay" else round(t,12,RN); i := i + 1; /* Test #7 */ i; g=2459622443407096130603922553910791619344453683235b-161 + x * (-25268883760268508124390396265385208781677459970591b-165 + x * (-14085297510063801424926808282934010153407741369921b-166 + x * (4919690150708675242175371118264726566064251658765b-163 + x * (-30234846084156062527259170670458534894432096140199b-166 + x * (13106657919167141361231703760753023119313255357211b-166 + x * (-32261918764422751201282738111872472526619593554251b-170 + x * (-26867827662947273463442414039578299014449169557867b-170 + x * (23714805850229248824685665833141775842452231424717b-170 + x * (-34959043924322834830838904754038179037086560229997b-172 + x * 43304790452874839227215830298539051565855964259641b-175))))))))) - sin(1 / exp(x)); t = time(w = dirtyinfnorm(g,[0;1]))/yardstick; if (t in 1.4331817626953125e-2 * variance) then "Okay" else round(t,12,RN); i := i + 1; /* Check related to bug #10069 */ /* Test #8 */ i; t = time(pstar = remez(1, 5, [0,1], 1/exp(x)))/yardstick; if (t in 1e-2 * variance) then "Okay" else round(t,12,RN); i := i+1; /* Test #9 */ i; t = time(r = dirtyinfnorm(pstar/exp(x)-1,[0,1]))/yardstick; if (t in 7e-3 * variance) then "Okay" else round(t,12,RN); i := i+1; /* Test #10 */ i; rationalmode = on!; pbug = 1.1000000111011000100011101101001000010101110000000100100100000010011100010111000000000100010110101011000111000110010001101100100001011111001111100010100110111010111_2 * 2^(-1) + x * (1.0101111100001110100011101100101000001010000101101001010111000111101100100010101000100000110011101101000000110111100111010110011001011001110101000101011000010001111_2 + x * (1.11000011101110111000110010100000111111001111000110100101101111100101111010001101100101111001000101010110001010000111100000010110111011001011111111011101000011011_2 * 2^(-1) + x * (1.1001000010101010111000101111001101101010111110111111001100011110001111110010100001010100010010001101111101111000111110011010010110111000010111111000011100111101101_2 + x * (1.100010010000010110101011010010001000011001001010000000111111010011010000010111101111011101111101100110011111011100110001111011111011100000100111000101001010101101_2 * 2^(1) + x * (1.101101101100011011100011001110011101010110000001001111110111001001100101010000010011110110000101101001010001000010000100110101000001110000001101100000110000101011_2 * 2^(2) + x * (1.000001010000000000011010111110000101011011100111101011100111110101011010010101000101100000010000011010101110110110011000111101011000001000101101001010011101011_2 * 2^(4) + x * (1.01000101010001100110111001100110100111011011101001001111001001111111011110011110101010100110111100010100100010110111001101011111001001110001110101110000110111000101_2 * 2^(5) + x * (1.10100010111101010101101011100010001111100011010110111100110100110101110000101110011100001000010011000101000010001100010101110010101110101001000100000011010111101_2 * 2^(6) + x * (1.000101001010100111010001000000000010001111101101010011000000010011010000101100000000101000101111101011100010110011001011010111101010100011101111100110010111000111_2 * 2^(8) + x * (1.0111010010100010101010011001011001100111110101111110011101100101110100000011001001100011010011101111010111111001101001000001111000111110001110110110000000011001011_2 * 2^(9) + x * (1.111111011110001110111111010111100110101110011011011011011110100111101010011001110000001001110010000111000111011001011010110111000001111010011111110011001001101001_2 * 2^(10) + x * (1.01100001011010001010001011011000100001010110101100110101011111101111110011001011101100010111011101001100000101000100110100010100100101000001101100010011001010001001_2 * 2^(12) + x * (1.11101111010000001001011011001000010100010010010010111100010010000100000101010110100000111110000100110011100100010000000011111011001101010010110001111010001101100111_2 * 2^(13) + x * (1.0101111000111010100000111111011000101011001110101001011000110101110000010111000100101100001000011100110110110111010000001110111010011101111011100001100010000011011_2 * 2^(15) + x * (1.11110011010010010111101001101001101000111101011110011101110110010100110100010011110110011000110011111001100000110001111111110101111001011001011011111011101100001101_2 * 2^(16) + x * (1.01100110010110100101110111011110010000000011001010101110000100001010001000101010000000100111111100110000001111011011101101010010001100000110001001010010111011011001_2 * 2^(18) + x * (1.0000001011000010010101011100110000101000011000110100001000111101111101010100000001000001001111010000111100100000010111111110011001110010110000110100011110001101011_2 * 2^(20) + x * (1.01110111101100001011100111110110000000101101111100111111111101100101111101110111000001011011000100110110000101110011111011010001000001100000101101001111000110111_2 * 2^(21) + x * (1.00010010000001111111101101010010010001100110011111101011010101111100001000101001100100000010010001011000110010000101100100010000011011110110011011010010000111001_2 * 2^(23) + x * (1.100100010111011111010001111100000011010110110111111001010110100110000110101100011100000000101000011010110111000000000100011011000100100110001111010110101011110011_2 * 2^(24) + x * (1.0010011100110111010111100001001001101110010100011100100101001101011101101010011010101011000010001001011001010010001100000010000101001101000011011010001010110101111_2 * 2^(26) + x * (1.101100111010111011110000001001000000010101101001111000010011000100100100101001111100111000000010001011100101110011100001000010011000010011110000011011011001001011_2 * 2^(27) + x * (1.01000010100000110101001000011110010001001111111110001101100011110000110011100101010101110111101100000100000011001110101110010000110110010011101000000000010101010001_2 * 2^(29) + x * (1.110111101101110011000010001111111001011000100100001010001010100011000001110011110110110110001001100110011011100100000011000110110001000011011011001000010101001001_2 * 2^(30) + x * (1.011001000111001100000111110011001101101101010100010101110001110010111011100010110001111111101110100100011110100010011111101101111000000101010010110011011010101101_2 * 2^(32) + x * (1.0000100111111010100110110011001001011010011010010110110000111101111010100010000110010000100100100100011101001011000100111100010001011111111101010110011000010110011_2 * 2^(34) + x * (1.10001101110101101111001001010010000101101010011101001100001100111000011001111011110000001101110111100001100111100000100011000000111000111000111100011101011000001101_2 * 2^(35) + x * (1.0010101000101000110000110110110101110110100101110001101111111101011000100001000100000101100000001000111110001010010010101111101001000101011111001000010000110011001_2 * 2^(37) + x * (1.1011111111000111010111100111010111010011110111111010111110001001001011101100111110000111011100001101000000001001010001001111100001010100110001000100101100110011111_2 * 2^(38) + x * (1.0101000011011001100000001001011010001000011000101000000001011101110101010000000001001101110010100111110100011101111011111010100100111111111001001100011010001000111_2 * 2^(40) + x * (1.111110111010100100111011111011111110111000100011111001100100111000111000000010110101001110110101001111111001100000000011011000000010000110010110110001111010101001_2 * 2^(41) + x * (1.011111110010011010100011110101011000110001001001010001001101010111100101000000000011101001111001111000001001000001000111011101100010000101001001110010011100010101_2 * 2^(43))))))))))))))))))))))))))))))))); pnobug = 1.011111110010011010100011110101011000110001001001010001001101010111100101000000000011101001111001111000001001000001000111011101100010000101001001110010011100010101_2 * 2^(43) * x^(1_2 * 2^(5)) + 1.111110111010100100111011111011111110111000100011111001100100111000111000000010110101001110110101001111111001100000000011011000000010000110010110110001111010101001_2 * 2^(41) * x^(1.1111_2 * 2^(4)) + 1.0101000011011001100000001001011010001000011000101000000001011101110101010000000001001101110010100111110100011101111011111010100100111111111001001100011010001000111_2 * 2^(40) * x^(1.111_2 * 2^(4)) + 1.1011111111000111010111100111010111010011110111111010111110001001001011101100111110000111011100001101000000001001010001001111100001010100110001000100101100110011111_2 * 2^(38) * x^(1.1101_2 * 2^(4)) + 1.0010101000101000110000110110110101110110100101110001101111111101011000100001000100000101100000001000111110001010010010101111101001000101011111001000010000110011001_2 * 2^(37) * x^(1.11_2 * 2^(4)) + 1.10001101110101101111001001010010000101101010011101001100001100111000011001111011110000001101110111100001100111100000100011000000111000111000111100011101011000001101_2 * 2^(35) * x^(1.1011_2 * 2^(4)) + 1.0000100111111010100110110011001001011010011010010110110000111101111010100010000110010000100100100100011101001011000100111100010001011111111101010110011000010110011_2 * 2^(34) * x^(1.101_2 * 2^(4)) + 1.011001000111001100000111110011001101101101010100010101110001110010111011100010110001111111101110100100011110100010011111101101111000000101010010110011011010101101_2 * 2^(32) * x^(1.1001_2 * 2^(4)) + 1.110111101101110011000010001111111001011000100100001010001010100011000001110011110110110110001001100110011011100100000011000110110001000011011011001000010101001001_2 * 2^(30) * x^(1.1_2 * 2^(4)) + 1.01000010100000110101001000011110010001001111111110001101100011110000110011100101010101110111101100000100000011001110101110010000110110010011101000000000010101010001_2 * 2^(29) * x^(1.0111_2 * 2^(4)) + 1.101100111010111011110000001001000000010101101001111000010011000100100100101001111100111000000010001011100101110011100001000010011000010011110000011011011001001011_2 * 2^(27) * x^(1.011_2 * 2^(4)) + 1.0010011100110111010111100001001001101110010100011100100101001101011101101010011010101011000010001001011001010010001100000010000101001101000011011010001010110101111_2 * 2^(26) * x^(1.0101_2 * 2^(4)) + 1.100100010111011111010001111100000011010110110111111001010110100110000110101100011100000000101000011010110111000000000100011011000100100110001111010110101011110011_2 * 2^(24) * x^(1.01_2 * 2^(4)) + 1.00010010000001111111101101010010010001100110011111101011010101111100001000101001100100000010010001011000110010000101100100010000011011110110011011010010000111001_2 * 2^(23) * x^(1.0011_2 * 2^(4)) + 1.01110111101100001011100111110110000000101101111100111111111101100101111101110111000001011011000100110110000101110011111011010001000001100000101101001111000110111_2 * 2^(21) * x^(1.001_2 * 2^(4)) + 1.0000001011000010010101011100110000101000011000110100001000111101111101010100000001000001001111010000111100100000010111111110011001110010110000110100011110001101011_2 * 2^(20) * x^(1.0001_2 * 2^(4)) + 1.01100110010110100101110111011110010000000011001010101110000100001010001000101010000000100111111100110000001111011011101101010010001100000110001001010010111011011001_2 * 2^(18) * x^(1_2 * 2^(4)) + 1.11110011010010010111101001101001101000111101011110011101110110010100110100010011110110011000110011111001100000110001111111110101111001011001011011111011101100001101_2 * 2^(16) * x^(1.111_2 * 2^(3)) + 1.0101111000111010100000111111011000101011001110101001011000110101110000010111000100101100001000011100110110110111010000001110111010011101111011100001100010000011011_2 * 2^(15) * x^(1.11_2 * 2^(3)) + 1.11101111010000001001011011001000010100010010010010111100010010000100000101010110100000111110000100110011100100010000000011111011001101010010110001111010001101100111_2 * 2^(13) * x^(1.101_2 * 2^(3)) + 1.01100001011010001010001011011000100001010110101100110101011111101111110011001011101100010111011101001100000101000100110100010100100101000001101100010011001010001001_2 * 2^(12) * x^(1.1_2 * 2^(3)) + 1.111111011110001110111111010111100110101110011011011011011110100111101010011001110000001001110010000111000111011001011010110111000001111010011111110011001001101001_2 * 2^(10) * x^(1.011_2 * 2^(3)) + 1.0111010010100010101010011001011001100111110101111110011101100101110100000011001001100011010011101111010111111001101001000001111000111110001110110110000000011001011_2 * 2^(9) * x^(1.01_2 * 2^(3)) + 1.000101001010100111010001000000000010001111101101010011000000010011010000101100000000101000101111101011100010110011001011010111101010100011101111100110010111000111_2 * 2^(8) * x^(1.001_2 * 2^(3)) + 1.10100010111101010101101011100010001111100011010110111100110100110101110000101110011100001000010011000101000010001100010101110010101110101001000100000011010111101_2 * 2^(6) * x^(1_2 * 2^(3)) + 1.01000101010001100110111001100110100111011011101001001111001001111111011110011110101010100110111100010100100010110111001101011111001001110001110101110000110111000101_2 * 2^(5) * x^(1.11_2 * 2^(2)) + 1.000001010000000000011010111110000101011011100111101011100111110101011010010101000101100000010000011010101110110110011000111101011000001000101101001010011101011_2 * 2^(4) * x^(1.1_2 * 2^(2)) + 1.101101101100011011100011001110011101010110000001001111110111001001100101010000010011110110000101101001010001000010000100110101000001110000001101100000110000101011_2 * 2^(2) * x^(1.01_2 * 2^(2)) + 1.100010010000010110101011010010001000011001001010000000111111010011010000010111101111011101111101100110011111011100110001111011111011100000100111000101001010101101_2 * 2^(1) * x^(1_2 * 2^(2)) + 1.1001000010101010111000101111001101101010111110111111001100011110001111110010100001010100010010001101111101111000111110011010010110111000010111111000011100111101101_2 * x^(1.1_2 * 2^(1)) + 1.11000011101110111000110010100000111111001111000110100101101111100101111010001101100101111001000101010110001010000111100000010110111011001011111111011101000011011_2 * 2^(-1) * x^(1_2 * 2^(1)) + 1.0101111100001110100011101100101000001010000101101001010111000111101100100010101000100000110011101101000000110111100111010110011001011001110101000101011000010001111_2 * x + (1.1000000111011000100011101101001000010101110000000100100100000010011100010111000000000100010110101011000111000110010001101100100001011111001111100010100110111010111_2 * 2^(-1)); x0 = 1.0100001_2 * 2^(-45); t1 = time(q=horner(simplify(pnobug(x-x0))))/yardstick; t2 = time(r=horner(simplify(pbug(x-x0))))/yardstick; if (t1 in 1.0e-6 * variance) then "Okay" else print("t1 = ", round(t1,12,RN)); if (t2 in 5.0e-7 * variance) then "Okay" else print("t2 = ", round(t2,12,RN)); rationalmode=default!; i := i+1; /* Test #11 */ i; /* The computation is run once for filling MPFR chache */ test=(log2(10)==1/log10(2)); /* Now we can safely compare the timings of several tests */ t1 = time(test=(log2(10)==1/log10(2))); t2 = time(test=(log2(10)<=1/log10(2))); t3 = time(test=(log2(10)<1/log10(2))); t4 = time(test=(log2(10)>=1/log10(2))); t5 = time(test=(log2(10)>1/log10(2))); /* Non-regression of timings */ if 1.70*t1 >= t2 then "Okay" else print("t1 = ", round(t1,12,RN), " and t2 = ", round(t2, 12, RN)); if 1.70*t1 >= t3 then "Okay" else print("t1 = ", round(t1,12,RN), " and t3 = ", round(t3, 12, RN)); if 1.70*t1 >= t4 then "Okay" else print("t1 = ", round(t1,12,RN), " and t4 = ", round(t4, 12, RN)); if 1.70*t1 >= t5 then "Okay" else print("t1 = ", round(t1,12,RN), " and t5 = ", round(t5, 12, RN)); if 1.70*t2 >= t1 then "Okay" else print("t2 = ", round(t2,12,RN), " and t1 = ", round(t1, 12, RN)); if 1.70*t2 >= t3 then "Okay" else print("t2 = ", round(t2,12,RN), " and t3 = ", round(t3, 12, RN)); if 1.70*t2 >= t4 then "Okay" else print("t2 = ", round(t2,12,RN), " and t4 = ", round(t4, 12, RN)); if 1.70*t2 >= t5 then "Okay" else print("t2 = ", round(t2,12,RN), " and t5 = ", round(t5, 12, RN)); if 1.70*t3 >= t1 then "Okay" else print("t3 = ", round(t3,12,RN), " and t1 = ", round(t1, 12, RN)); if 1.70*t3 >= t2 then "Okay" else print("t3 = ", round(t3,12,RN), " and t2 = ", round(t2, 12, RN)); if 1.70*t3 >= t4 then "Okay" else print("t3 = ", round(t3,12,RN), " and t4 = ", round(t4, 12, RN)); if 1.70*t3 >= t5 then "Okay" else print("t3 = ", round(t3,12,RN), " and t5 = ", round(t5, 12, RN)); if 1.70*t4 >= t1 then "Okay" else print("t4 = ", round(t4,12,RN), " and t1 = ", round(t1, 12, RN)); if 1.70*t4 >= t2 then "Okay" else print("t4 = ", round(t4,12,RN), " and t2 = ", round(t2, 12, RN)); if 1.70*t4 >= t3 then "Okay" else print("t4 = ", round(t4,12,RN), " and t3 = ", round(t3, 12, RN)); if 1.70*t4 >= t5 then "Okay" else print("t4 = ", round(t4,12,RN), " and t5 = ", round(t5, 12, RN)); if 1.70*t5 >= t1 then "Okay" else print("t5 = ", round(t5,12,RN), " and t1 = ", round(t1, 12, RN)); if 1.70*t5 >= t2 then "Okay" else print("t5 = ", round(t5,12,RN), " and t2 = ", round(t2, 12, RN)); if 1.70*t5 >= t3 then "Okay" else print("t5 = ", round(t5,12,RN), " and t3 = ", round(t3, 12, RN)); if 1.70*t5 >= t4 then "Okay" else print("t5 = ", round(t5,12,RN), " and t4 = ", round(t4, 12, RN)); i := i+1; /* Test #12 */ /* Non-regression for bug #15363, solved at revision 1934 */ i; f = 5 / 48 * cos(x^(-0.625) / 2)^(-3.5) + 5 / 48 * cos((x^(-0.625) + (2 * (pi)) / 3) / 2)^(-3.5) + 5 / 48 * cos((x^(-0.625) - (2 * (pi)) / 3) / 2)^(-3.5) + 5 / 48 * cos(x^(-0.625) / 2)^(-3.5) * 5 / 48 * cos((x^(-0.625) + (2 * (pi)) / 3) / 2)^(-3.5) + 5 / 48 * cos(x^(-0.625) / 2)^(-3.5) * 5 / 48 * cos((x^(-0.625) - (2 * (pi)) / 3) / 2)^(-3.5) + 5 / 48 * cos((x^(-0.625) + (2 * (pi)) / 3) / 2)^(-3.5) * 5 / 48 * cos((x^(-0.625) - (2 * (pi)) / 3) / 2)^(-3.5) + 5 / 48 * cos(x^(-0.625) / 2)^(-3.5) * 5 / 48 * cos((x^(-0.625) + (2 * (pi)) / 3) / 2)^(-3.5) * 5 / 48 * cos((x^(-0.625) - (2 * (pi)) / 3) / 2)^(-3.5); t = time(for iiii from 1 to 100 do { a=evaluate(f, [10]); b=f(1); })/(yardstick * 100); if (t in 3e-4 * variance) then "Okay" else round(t,12,RN); i := i + 1; /* Test #13 */ /* Other problem, discovered as a side effect of bug report #15363, solved at revision 1935 */ i; f = 5 / 48 * cos(x^(-0.625) / 2)^(-3.5) + 5 / 48 * cos((x^(-0.625) + (2 * (pi)) / 3) / 2)^(-3.5) + 5 / 48 * cos((x^(-0.625) - (2 * (pi)) / 3) / 2)^(-3.5) + 5 / 48 * cos(x^(-0.625) / 2)^(-3.5) * 5 / 48 * cos((x^(-0.625) + (2 * (pi)) / 3) / 2)^(-3.5) + 5 / 48 * cos(x^(-0.625) / 2)^(-3.5) * 5 / 48 * cos((x^(-0.625) - (2 * (pi)) / 3) / 2)^(-3.5) + 5 / 48 * cos((x^(-0.625) + (2 * (pi)) / 3) / 2)^(-3.5) * 5 / 48 * cos((x^(-0.625) - (2 * (pi)) / 3) / 2)^(-3.5) + 5 / 48 * cos(x^(-0.625) / 2)^(-3.5) * 5 / 48 * cos((x^(-0.625) + (2 * (pi)) / 3) / 2)^(-3.5) * 5 / 48 * cos((x^(-0.625) - (2 * (pi)) / 3) / 2)^(-3.5); t1 = time(for k from 0 to 1000 do a=horner(f))/yardstick; t2 = time(for k from 0 to 1000 do a=horner(f*5))/yardstick; if 15/10*t1 >= t2 then "Okay" else print("t1 = ", round(t1,12,RN), " and t2 = ", round(t2, 12, RN)); if 15/10*t2 >= t1 then "Okay" else print("t1 = ", round(t1,12,RN), " and t2 = ", round(t2, 12, RN)); i := i + 1; /* Test #14 */ /* Non-regression tests for memory optimizations introduced into the trunk at revision 1775 */ i; n = 1000; t1 = time({L=[||]; for k from 0 to n do L = 1.:L;})/yardstick; t2 = time(for k from 0 to n do a = head(L))/yardstick; t3 = time(for k from 0 to n do L = tail(L))/yardstick; if (t1 in 1.38e-3 * variance) then "Okay" else "t1 = ", round(t1,12,RN); if (t2 in 9.25e-4 * variance) then "Okay" else "t2 = ", round(t2,12,RN); if (t3 in 8.5e-4 * variance) then "Okay" else "t3 = ", round(t3,12,RN); i := i+1; /* Test #15 */ /* Non-regression tests for optimizations of lists introduced in the branch optimLists */ i; n = 60000; L = [||]; for k from 0 to n do L = 1.:L; t1 = time(for k from 0 to n do a = L[n]); n = 120000; L = [||]; for k from 0 to n do L = 1.:L; t2 = time(for k from 0 to n do a = L[n]); if (13/10 <= t2/t1) && (t2/t1 <= 26/10) then "Okay" else print("t1 = ", round(t1,12,RN), " and t2 = ", round(t2, 12, RN)); i:=i+1; /* Test #16 */ /* This non-regression test addresses two bugs discovered because valgrind exhausted all the available memory on one of the tests. The effect of these bugs on the following example was that t1 was the order of 40 times bigger that t3~=t4. Also, t2 was 2.5 bigger than t3~=t4. A first bug has been fixed at commit e0b3184427c1aeedd4f5e191a32477af825b8c63 reducing t1 to within a factor 6 to t3~=t4 and t2 only slightly bigger than t3~=t4. The non-regression of this fix is checked by comparing t2 to t3. A second bug has fixed at commit 50ed66ada2402807f9ebb3a7c76555ce2025927a and practically equates all timings. The non-regression of this fix is checked by comparing all four values and checking that their value is not far from 0.5 (experiments on three different machines with different characteristics -- namely whisky, yber and kosmos -- showed that their common value ranges from 0.2 to 1.3). */ i; prec=30!; f=(((x^8) * 1220122329078112111507291147589605846332159835986645150749590969395708999908386786025293768305545765720163562133849625224226209220255396299539055092859079474439673891084004631503687145554767395662893595b-680) + (((x^6) * (-71715508548145200950077025200366683480894254284916505717100740809457045677362204851527036286540250794733933233091959390527962504452336314934415451111911137886934451972269b-571)) + (((x^4) * 896768353735365200783941380399679560892057280074710285596808721039428827249497766919069037376996976310396508163802115252299488288154514645b-461) + (((x^2) * (-34929642931383029455818526560499975039909420968120331377299772636097910811575206208826204942817211250711507b-354)) + (1809040241216242111378895524443847148140641271195740093242624529845306570743b-250 + ((-568608045753120929621015727561082350296964753953361285006172985034690325553b-268 * ((((x^9) * 13838586548080362858940014402840360268995306239673696598277155473497177385003491303000131757744686625519952014193459235397229970270226467527713b-468) * sqrt(1 - (x^2))) / x)) + ((1340063586453992785020690538673363742466390948910331662017999028288639932469b-262 * ((((x^7) * 358246915606274140191920304152769949749350577336553141294816968955983915567186730677646875115691472828069001697b-364) * sqrt(1 - (x^2))) / x)) + ((-956406481930174940521834341712205002043941496528760169508857423454450639491b-256 * ((((x^5) * 9274130135726315977204924027295787401259172547694862836311277722826903837042593b-260) * sqrt(1 - (x^2))) / x)) + ((1205217331155988957618263779803029703830148102503084541761207288507603220315b-252 * ((((x^3) * 240084383221639362889634237063322305672153048417b-156) * sqrt(1 - (x^2))) / x)) + (-1809098390388435196046577181545352749842462507070771847780099649403523024427b-250 * (((x * 6215193255146273b-52) * sqrt(1 - (x^2))) / x))))))))))) - (cos(x * 6215193255146273b-52) - ((sin(x * 6215193255146273b-52) * sqrt(1 - (x^2))) / x)); g = x^8 * 1220122329078112111507291147589605846332159835986645150749590969395708999908386786025293768305545765720163562133849625224226209220255396299539055092859079474439673891084004631503687145554767395662893595b-680 + x^6 * (-71715508548145200950077025200366683480894254284916505717100740809457045677362204851527036286540250794733933233091959390527962504452336314934415451111911137886934451972269b-571) + x^4 * 896768353735365200783941380399679560892057280074710285596808721039428827249497766919069037376996976310396508163802115252299488288154514645b-461 + x^2 * (-34929642931383029455818526560499975039909420968120331377299772636097910811575206208826204942817211250711507b-354) + 1809040241216242111378895524443847148140641271195740093242624529845306570743b-250 + -568608045753120929621015727561082350296964753953361285006172985034690325553b-268 * (x^9 * 13838586548080362858940014402840360268995306239673696598277155473497177385003491303000131757744686625519952014193459235397229970270226467527713b-468 * sqrt(1 - x^2)) / x + 1340063586453992785020690538673363742466390948910331662017999028288639932469b-262 * (x^7 * 358246915606274140191920304152769949749350577336553141294816968955983915567186730677646875115691472828069001697b-364 * sqrt(1 - x^2)) / x + -956406481930174940521834341712205002043941496528760169508857423454450639491b-256 * (x^5 * 9274130135726315977204924027295787401259172547694862836311277722826903837042593b-260 * sqrt(1 - x^2)) / x + 1205217331155988957618263779803029703830148102503084541761207288507603220315b-252 * (x^3 * 240084383221639362889634237063322305672153048417b-156 * sqrt(1 - x^2)) / x + -1809098390388435196046577181545352749842462507070771847780099649403523024427b-250 * (x * 6215193255146273b-52 * sqrt(1 - x^2)) / x - (cos(x * 6215193255146273b-52) - (sin(x * 6215193255146273b-52) * sqrt(1 - x^2)) / x); u = 1b-100; v=9007199254740991b-53; prec=27!; t1 = time(res1 = dirtyinfnorm(f,[u,v])); t2 = time(res2 = dirtyinfnorm(g,[u,v])); prec=28!; t3 = time(res1 = dirtyinfnorm(f,[u,v])); t4 = time(res2 = dirtyinfnorm(g,[u,v])); /* Non-regression of commit e0b3184427c1aeedd4f5e191a32477af825b8c63 */ if t2 <= 1.5*t3 then "Okay" else print("t2 = ", round(t2,12,RN), " and t3 = ", round(t3, 12, RN)); if t3 <= 1.5*t2 then "Okay" else print("t2 = ", round(t2,12,RN), " and t3 = ", round(t3, 12, RN)); /* Non-regression of commit 50ed66ada2402807f9ebb3a7c76555ce2025927a */ if t1 <= 1.5*t2 then "Okay" else print("t1 = ", round(t1,12,RN), " and t2 = ", round(t2, 12, RN)); if t2 <= 1.5*t1 then "Okay" else print("t1 = ", round(t1,12,RN), " and t2 = ", round(t2, 12, RN)); if t4 <= 1.5*t2 then "Okay" else print("t2 = ", round(t2,12,RN), " and t4 = ", round(t4, 12, RN)); if t2 <= 1.5*t4 then "Okay" else print("t2 = ", round(t2,12,RN), " and t4 = ", round(t4, 12, RN)); if (t1 in 0.5 * variance) then "Okay" else print("t1 = ", round(t1,12,RN), " and t2 = ", round(t2,12,RN), " and t3 = ", round(t3,12,RN), " and t4 = ", round(t4,12,RN)); prec=default!; i := i+1; "End of test";sollya-6.0+ds/tests-tool/timecheck.sollya.reference000066400000000000000000000004331300174114700225150ustar00rootroot000000000000000 Okay 1 Okay 2 Okay 3 Okay 4 Okay 5 Okay 6 Okay 7 Okay 8 Okay 9 Okay 10 Okay Okay 11 Okay Okay Okay Okay Okay Okay Okay Okay Okay Okay Okay Okay Okay Okay Okay Okay Okay Okay Okay Okay 12 Okay 13 Okay Okay 14 Okay Okay Okay 15 Okay 16 Okay Okay Okay Okay Okay Okay Okay End of test sollya-6.0+ds/version.h000066400000000000000000000174041300174114700151260ustar00rootroot00000000000000/* Copyright 2006-2016 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2), Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN Sorbonne Universités UPMC Univ Paris 06 UMR 7606, LIP6 Boîte Courrier 169 4, place Jussieu F-75252 Paris Cedex 05 France and by Centre de recherche INRIA Sophia-Antipolis Mediterranee, equipe APICS, Sophia Antipolis, France. Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef VERSION_H #define VERSION_H #ifdef HAVE_CONFIG_H #include "config.h" #else #define PACKAGE_BUGREPORT error@error.com #endif #define VERSION_COPYRIGHT_YEARS "2006-2016" #define VERSION_COPYRIGHT_TEXT \ "Copyright " VERSION_COPYRIGHT_YEARS " by\n" \ "\n" \ " Laboratoire de l'Informatique du Parallelisme,\n" \ " UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668,\n" \ "\n" \ " LORIA (CNRS, INPL, INRIA, UHP, U-Nancy 2),\n" \ "\n" \ " Laboratoire d'Informatique de Paris 6 - Équipe PEQUAN\n" \ " Sorbonne Universités\n" \ " UPMC Univ Paris 06\n" \ " UMR 7606, LIP6\n" \ " Boîte Courrier 169\n" \ " 4, place Jussieu\n" \ " F-75252 Paris Cedex 05\n" \ " France,\n" \ "\n" \ " CNRS, LIP6, UPMC\n" \ " Sorbonne Universités, UPMC Univ Paris 06,\n" \ " CNRS, LIP6 UMR 7606, 4 place Jussieu 75005 Paris," \ "\n" \ "\n" \ "and by\n" \ "\n" \ " INRIA Sophia-Antipolis Mediterranee, APICS Team,\n" \ " Sophia-Antipolis, France.\n" \ "\n" \ "All rights reserved.\n" \ "\n" \ "Contributors:\n" \ " Ch. Lauter, \n" \ " S. Chevillard, \n" \ " M. Joldes, \n" \ " N. Jourdan, \n" \ " M. Mezzarobba, \n" \ " J. Benoit.\n" \ " \n" \ "License:\n" \ " This software is governed by the CeCILL-C license under French law and\n" \ " abiding by the rules of distribution of free software. You can use,\n" \ " modify and/or redistribute the software under the terms of the CeCILL-C\n" \ " license as circulated by CEA, CNRS and INRIA at the following URL\n" \ " \"http://www.cecill.info\".\n" \ "\n" \ " As a counterpart to the access to the source code and rights to copy,\n" \ " modify and redistribute granted by the license, users are provided only\n" \ " with a limited warranty and the software's author, the holder of the\n" \ " economic rights, and the successive licensors have only limited\n" \ " liability.\n" \ "\n" \ " In this respect, the user's attention is drawn to the risks associated\n" \ " with loading, using, modifying and/or developing or reproducing the\n" \ " software by the user in light of its specific status of free software,\n" \ " that may mean that it is complicated to manipulate, and that also\n" \ " therefore means that it is reserved for developers and experienced\n" \ " professionals having in-depth computer knowledge. Users are therefore\n" \ " encouraged to load and test the software's suitability as regards their\n" \ " requirements in conditions enabling the security of their systems and/or\n" \ " data to be ensured and, more generally, to use and operate it in the\n" \ " same conditions as regards security.\n" \ "\n" \ " The fact that you are presently reading this means that you have had\n" \ " knowledge of the CeCILL-C license and that you accept its terms.\n" \ "\n" \ " This program is distributed WITHOUT ANY WARRANTY; without even the\n" \ " implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n" \ "\n" #endif /* ifdef VERSION_H*/ sollya-6.0+ds/worstcase.c000066400000000000000000000272641300174114700154530ustar00rootroot00000000000000/* Copyright 2006-2012 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668, and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France, Contributors Ch. Lauter, S. Chevillard christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include #include "worstcase.h" #include /* fprinft, fopen, fclose, */ #include /* exit, free, mktemp */ #include #include #include "general.h" #include "infnorm.h" #include "double.h" int mpfrToInt(int *res, mpfr_t val) { mpfr_t verg; if (!mpfr_integer_p(val)) { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_INTEGER,"Warning: an expression given in this context does not evaluate to integer.\n"); *res = 0; return 0; } *res = mpfr_get_si(val,GMP_RNDN); mpfr_init2(verg,mpfr_get_prec(val)); if (mpfr_set_si(verg,*res,GMP_RNDN) != 0) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_CONVERTING_A_MACHINE_INTEGER,"Warning: rounding occurred on reconverting back an integer variable.\n"); *res = 0; mpfr_clear(verg); return 0; } if (mpfr_cmp(verg,val) != 0) { printMessage(1,SOLLYA_MSG_EXPR_DOES_NOT_EVALUATE_TO_MACHINE_INTEGER,"Warning: an expression given in this context does not evaluate to a machine integer.\n"); *res = 0; mpfr_clear(verg); return 0; } mpfr_clear(verg); return 1; } void printWorstCases(node *func, mpfr_t inputprec, rangetype inputExponRange, mpfr_t outputprec, mpfr_t epsilon, mp_prec_t prec, FILE *fd) { int inputprecision, outputprecision, firstexponent, lastexponent; mpfr_t temp, temp2, x, y, yR, xL; double eps; long long int i; sollyaPrintf("prec = %d\n",(int) prec); if (!(mpfrToInt(&inputprecision, inputprec) && mpfrToInt(&outputprecision, outputprec) && mpfrToInt(&firstexponent, *(inputExponRange.a)) && mpfrToInt(&lastexponent, *(inputExponRange.b)))) { printMessage(1,SOLLYA_MSG_HARMLESS_ERROR_OCCURRED_COMMAND_NOT_EXECUTED,"Warning: an error occurred. The last command will not succeed. This is harmless.\n"); return; } if ((inputprecision < 10) || (outputprecision < 10)) { printMessage(1,SOLLYA_MSG_INPUT_AND_OUTPUT_PRECISION_MUST_BE_GREATER_TEN,"Warning: input and outputprecision must be greater or equal to 10.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Warning: an error occurred. The last command will not succeed. This is harmless.\n"); return; } if ((prec < (mp_prec_t) inputprecision) || (prec < (mp_prec_t) outputprecision)) { printMessage(1,SOLLYA_MSG_INTERNAL_PREC_LESS_THAN_IN_AND_OUT_PREC,"Warning: the internal precision is less than the input or output precision.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Try to increase the tool's precision.\n"); printMessage(1,SOLLYA_MSG_CONTINUATION,"Warning: an error occurred. The last command will not succeed. This is harmless.\n"); return; } mpfr_init2(temp,prec); mpfr_init2(temp2,prec); mpfr_mul_2ui(temp,epsilon,(unsigned int) (outputprecision + 1),GMP_RNDN); mpfr_set_d(temp2,1.0,GMP_RNDN); if (mpfr_cmp(temp,temp2) >= 0) { printMessage(1,SOLLYA_MSG_EPS_SPECIFIED_GREATER_THAN_HALFULP_OF_OUT_PREC,"Warning: the epsilon asked is greater than half an ulp of a %d bit format.\n", outputprecision); printMessage(1,SOLLYA_MSG_CONTINUATION,"Warning: an error occurred. The last command will not succeed. This is harmless.\n"); mpfr_clear(temp); mpfr_clear(temp2); return; } if (mpfr_sgn(epsilon) < 0) { printMessage(1,SOLLYA_MSG_GIVEN_EPS_MUST_BE_POSITIVE_TAKING_ABS,"Warning: the epsilon given is negative. Will take its absolute value.\n"); mpfr_abs(epsilon,epsilon,GMP_RNDN); } mpfr_init2(x,inputprecision); mpfr_init2(xL,inputprecision); mpfr_init2(yR,outputprecision); mpfr_init2(y,prec); mpfr_set_d(x,1.0,GMP_RNDN); mpfr_mul_2si(x,x,firstexponent,GMP_RNDN); mpfr_set_d(xL,1.0,GMP_RNDN); mpfr_mul_2si(xL,xL,lastexponent-1,GMP_RNDN); mpfr_nextbelow(x); if (mpfr_cmp(x,xL) > 0) { mpfr_swap(x,xL); } i = 0; while (mpfr_cmp(x,xL) <= 0) { if (verbosity >= 2) { if ((i % 1000) == 0) printMessage(2,SOLLYA_MSG_CERTAIN_AMOUNT_OF_CASES_HANDLED,"Information: %d cases handled.\n",i); i++; } mpfr_set(temp,x,GMP_RNDN); evaluate(y,func,temp,prec); mpfr_set(yR,y,GMP_RNDN); mpfr_sub(temp2,y,yR,GMP_RNDN); mpfr_abs(temp2,temp2,GMP_RNDN); if (mpfr_zero_p(y)) { printMessage(1,SOLLYA_MSG_FUNC_EVALUATED_TO_ZERO_TAKING_ABSOLUTE_ERROR,"Warning: the given function evaluates to 0 on %v\nThe rounding error will be considered as an absolute one.\n",x); } else { mpfr_div(temp2,temp2,y,GMP_RNDN); } if (mpfr_cmp(temp2,epsilon) <= 0) { sollyaPrintf("%s = ",((variablename == NULL) ? "_x_" : variablename)); printValue(&x); sollyaPrintf("\t\tf(%s) = ",((variablename == NULL) ? "_x_" : variablename)); printValue(&yR); sollyaPrintf("\t\teps = "); printValue(&temp2); mpfr_log2(temp,temp2,GMP_RNDN); eps = sollya_mpfr_get_d(temp,GMP_RNDN); sollyaPrintf(" = 2^(%f) \n",eps); if (fd != NULL) { sollyaFprintf(fd,"%s = ",((variablename == NULL) ? "_x_" : variablename)); fprintValue(fd,x); sollyaFprintf(fd,"\tf(%s) = ",((variablename == NULL) ? "_x_" : variablename)); fprintValue(fd,yR); sollyaFprintf(fd,"\teps = "); fprintValue(fd,temp2); sollyaFprintf(fd," = 2^(%f) ",eps); if (mpfr_zero_p(y)) { sollyaFprintf(fd,"ABSOLUTE"); } sollyaFprintf(fd,"\n"); } } mpfr_nextabove(x); } mpfr_clear(temp); mpfr_clear(temp2); mpfr_clear(x); mpfr_clear(xL); mpfr_clear(y); mpfr_clear(yR); } int searchGalValue(chain *funcs, mpfr_t foundValue, mpfr_t startValue, mp_prec_t searchPrec, int steps, chain *imageFormats, chain *epsilons, mp_prec_t prec) { mpfr_t currLeft, currRight; mpfr_t yCurrLeft, yCurrRight; mpfr_t yCurrLeftRound, yCurrRightRound; mpfr_t errorLeft, errorRight; mp_prec_t p; mpfr_t t, one; int res; int numberFuncs, numberFormats, numberEpsilons; chain *myFuncs; chain *currFunc, *currFormat, *currEpsilon; if (steps > 63) { printMessage(1,SOLLYA_MSG_CANNOT_PERFORM_MORE_THAN_63_STEPS,"Warning: cannot perform more than 63 steps. Will decrease step number to 63.\n"); steps = 63; } p = prec; if (searchPrec > p) p = searchPrec; if (p < 165) p = 165; if (mpfr_get_prec(foundValue) < searchPrec) { printMessage(1,SOLLYA_MSG_SEARCH_PREC_HIGHER_THAN_TOOL_PREC,"Warning: the search precision is higher than the current precision of the tool.\nNo search is possible.\n"); return 0; } numberFuncs = lengthChain(funcs); numberFormats = lengthChain(imageFormats); numberEpsilons = lengthChain(epsilons); if ((numberFuncs != numberFormats) || (numberFuncs != numberEpsilons)) { printMessage(1,SOLLYA_MSG_NUMBERS_OF_FUNCS_AND_FORMATS_DIFFER,"Warning: the numbers of the given functions, formats and accuracies differ.\nNo search is possible.\n"); return 0; } myFuncs = copyChain(funcs, copyTreeOnVoid); mpfr_init2(currLeft, searchPrec); mpfr_init2(currRight, searchPrec); mpfr_init2(yCurrLeft, p); mpfr_init2(yCurrRight, p); mpfr_init2(yCurrLeftRound, p); mpfr_init2(yCurrRightRound, p); mpfr_init2(errorLeft, p); mpfr_init2(errorRight, p); if ((mpfr_set(currLeft,startValue,GMP_RNDN) != 0) || (mpfr_set(currRight,startValue,GMP_RNDN) != 0)) { printMessage(1,SOLLYA_MSG_START_POINT_TOO_PRECISE_FOR_GIVEN_INPUT_PREC,"Warning: the given start point is too precise for the given search precision.\nIt has been rounded to: %v",currLeft); } mpfr_init2(t,128); mpfr_init2(one,12); mpfr_set_si(t,1,GMP_RNDN); mpfr_set_si(one,1,GMP_RNDN); mpfr_mul_2ui(t,t,steps,GMP_RNDN); res = 1; while (mpfr_sgn(t) > 0) { res = 1; currFunc = myFuncs; currFormat = imageFormats; currEpsilon = epsilons; while ((currFunc != NULL) && (currFormat != NULL) && (currEpsilon != NULL)) { evaluateFaithful(yCurrLeft, (node *) (currFunc->value), currLeft, p); mpfr_round_to_format(yCurrLeftRound, yCurrLeft, *((int *) (currFormat->value))); mpfr_sub(errorLeft,yCurrLeftRound,yCurrLeft,GMP_RNDN); mpfr_div(errorLeft,errorLeft,yCurrLeft,GMP_RNDN); if (!(mpfr_number_p(errorLeft) && (mpfr_cmpabs(errorLeft,*((mpfr_t *) (currEpsilon->value))) <= 0))) { res = 0; break; } currFunc = currFunc->next; currFormat = currFormat->next; currEpsilon = currEpsilon->next; } if (res) { mpfr_set(foundValue,currLeft,GMP_RNDN); break; } res = 1; currFunc = myFuncs; currFormat = imageFormats; currEpsilon = epsilons; while ((currFunc != NULL) && (currFormat != NULL) && (currEpsilon != NULL)) { evaluateFaithful(yCurrRight, (node *) (currFunc->value), currRight, p); mpfr_round_to_format(yCurrRightRound, yCurrRight, *((int *) (currFormat->value))); mpfr_sub(errorRight,yCurrRightRound,yCurrRight,GMP_RNDN); mpfr_div(errorRight,errorRight,yCurrRight,GMP_RNDN); if (!(mpfr_number_p(errorRight) && (mpfr_cmpabs(errorRight,*((mpfr_t *) (currEpsilon->value))) <= 0))) { res = 0; break; } currFunc = currFunc->next; currFormat = currFormat->next; currEpsilon = currEpsilon->next; } if (res) { mpfr_set(foundValue,currRight,GMP_RNDN); break; } mpfr_nextbelow(currLeft); mpfr_nextabove(currRight); mpfr_sub(t,t,one,GMP_RNDN); /* exact*/ } mpfr_clear(currLeft); mpfr_clear(currRight); mpfr_clear(yCurrLeft); mpfr_clear(yCurrRight); mpfr_clear(yCurrLeftRound); mpfr_clear(yCurrRightRound); mpfr_clear(errorLeft); mpfr_clear(errorRight); mpfr_clear(one); mpfr_clear(t); freeChain(myFuncs, freeMemoryOnVoid); return res; } sollya-6.0+ds/worstcase.h000066400000000000000000000050471300174114700154530ustar00rootroot00000000000000/* Copyright 2006-2009 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 Contributor Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef WORSTCASE_H #define WORSTCASE_H #include #include #include "expression.h" void printWorstCases(node *func, mpfr_t inputprec, rangetype inputExponRange, mpfr_t outputprec, mpfr_t epsilon, mp_prec_t prec, FILE *fd); int searchGalValue(chain *funcs, mpfr_t foundValue, mpfr_t startValue, mp_prec_t searchPrec, int steps, chain *imageFormats, chain *epsilons, mp_prec_t prec); #endif /* ifdef WORSTCASE_H*/ sollya-6.0+ds/xml.c000066400000000000000000001114441300174114700142330ustar00rootroot00000000000000/* Copyright 2007-2014 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 and by Laboratoire d'Informatique de Paris 6, equipe PEQUAN, UPMC Universite Paris 06 - CNRS - UMR 7606 - LIP6, Paris, France. Contributors Ch. Lauter, S. Chevillard, N. Jourdan christoph.lauter@ens-lyon.org sylvain.chevillard@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #include #include "mpfi-compat.h" #include #include "execute.h" #include #include #include #include #include "general.h" #include "expression.h" #include "xml.h" #include "execute.h" #ifdef HAVE_CONFIG_H #include "config.h" #endif void printXml(node *tree) { fPrintXml(stdout,tree); } void fPrintXmlInner(FILE *fd, node *tree) { char *procString; if (tree == NULL) return; switch (tree->nodeType) { case MEMREF: fPrintXmlInner(fd, getMemRefChild(tree)); return; break; case VARIABLE: if (variablename == NULL) sollyaFprintf(fd," _x_ \n"); else sollyaFprintf(fd," %s \n",variablename); break; case CONSTANT: fprintValueForXml(fd, *(tree->value)); break; case ADD: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); fPrintXmlInner(fd, tree->child2); sollyaFprintf(fd,"\n"); break; case SUB: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); fPrintXmlInner(fd, tree->child2); sollyaFprintf(fd,"\n"); break; case MUL: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); fPrintXmlInner(fd, tree->child2); sollyaFprintf(fd,"\n"); break; case DIV: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); fPrintXmlInner(fd, tree->child2); sollyaFprintf(fd,"\n"); break; case SQRT: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case EXP: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case LOG: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case LOG_2: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"2\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case LOG_10: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case SIN: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case COS: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case TAN: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case ASIN: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case ACOS: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case ATAN: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case SINH: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case COSH: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case TANH: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case ASINH: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case ACOSH: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case ATANH: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case POW: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); fPrintXmlInner(fd, tree->child2); sollyaFprintf(fd,"\n"); break; case NEG: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case ABS: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case DOUBLE: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"double\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case SINGLE: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"single\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case QUAD: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"quad\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case HALFPRECISION: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"halfprecision\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case DOUBLEDOUBLE: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"doubledouble\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case TRIPLEDOUBLE: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"tripledouble\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case ERF: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"erf\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case ERFC: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"erfc\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case LOG_1P: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"log1p\n"); /* fprintf(fd,"1\n");*/ fPrintXmlInner(fd, tree->child1); /* fprintf(fd,"\n");*/ sollyaFprintf(fd,"\n"); break; case EXP_M1: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"expm1\n"); /* fprintf(fd,"\n");*/ fPrintXmlInner(fd, tree->child1); /* fprintf(fd,"1\n");*/ sollyaFprintf(fd,"\n"); break; case DOUBLEEXTENDED: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"doubleextended\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case LIBRARYFUNCTION: if (tree->libFunDeriv == 0) { sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"%s\n", tree->libFun->functionName); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); } else { sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); if (variablename == NULL) sollyaFprintf(fd," _x_ \n"); else sollyaFprintf(fd," %s \n",variablename); sollyaFprintf(fd,"\n"); sollyaFprintf(fd," %d \n",tree->libFunDeriv); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"%s\n", tree->libFun->functionName); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); } break; case PROCEDUREFUNCTION: if (tree->libFunDeriv == 0) { procString = sPrintThing(tree->child2); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"function(%s)\n", procString); safeFree(procString); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); } else { sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); if (variablename == NULL) sollyaFprintf(fd," _x_ \n"); else sollyaFprintf(fd," %s \n",variablename); sollyaFprintf(fd,"\n"); sollyaFprintf(fd," %d \n",tree->libFunDeriv); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); procString = sPrintThing(tree->child2); sollyaFprintf(fd,"function(%s)\n", procString); safeFree(procString); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); } break; case CEIL: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case FLOOR: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case NEARESTINT: sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"nearestint\n"); fPrintXmlInner(fd, tree->child1); sollyaFprintf(fd,"\n"); break; case PI_CONST: sollyaFprintf(fd,""); break; default: sollyaFprintf(stderr,"Error: fPrintXml: unknown identifier (%d) in the tree\n",tree->nodeType); exit(1); } return; } void fPrintXml(FILE *fd, node *tree) { sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n",PACKAGE_NAME); sollyaFprintf(fd,"\n"); /* fprintf(fd,"\n");*/ /* fprintf(fd,"\n");*/ sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); if (variablename != NULL) sollyaFprintf(fd," %s \n",variablename); else sollyaFprintf(fd," _x_ \n"); sollyaFprintf(fd,"\n"); fPrintXmlInner(fd,tree); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,""); fprintTree(fd, tree); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n"); sollyaFprintf(fd,"\n\n"); } /* Nico:*/ /* From: libxml2-2.6.30 and reader1.c example*/ /* http://xmlsoft.org/examples/index.html#reader1.c*/ /** * section: xmlReader * synopsis: Parse an XML file with an xmlReader * purpose: Demonstrate the use of xmlReaderForFile() to parse an XML file * and dump the informations about the nodes found in the process. * (Note that the XMLReader functions require libxml2 version later * than 2.6.) * usage: reader1 * test: reader1 test2.xml > reader1.tmp ; diff reader1.tmp reader1.res ; rm reader1.tmp * author: Daniel Veillard * copy: see the copyright notice for the status of this software. */ #include #include #ifdef LIBXML_READER_ENABLED #define change_xmlparser(new_parser) do { \ printMessage(3,SOLLYA_MSG_XML_PARSER_CHANGE,"%p => ",next_xmlparser); \ next_xmlparser=new_parser; \ printMessage(3,SOLLYA_MSG_CONTINUATION,"%p\n",next_xmlparser); } while(0) /* PARSER MATHML - return: 0 (not found) -1 (sync lost) 1 (found)*/ int search_annotations (xmlTextReaderPtr reader); int process_annotation (xmlTextReaderPtr reader); int search_lambda (xmlTextReaderPtr reader); int search_text (xmlTextReaderPtr reader); int search_basic_element (xmlTextReaderPtr reader); int search_return_offset (xmlTextReaderPtr reader); int search_math_tree (xmlTextReaderPtr reader); static int (*next_xmlparser)(xmlTextReaderPtr reader)=search_basic_element; /*search_mathml;*/ static int current_depth; static const xmlChar *xml_name, *xml_value; static node *result_node; char *var_name; int action_variable (xmlTextReaderPtr reader) { if (!xmlTextReaderHasValue(reader)) return 0; var_name=(char*)xml_value; return 1; } /*typedef node*(*pfn_op_binaire)(node*,node*);*/ typedef struct treemath nodemath; struct treemath { nodemath* child; nodemath* parent; node* (*operator)(node*,node*); int op_type; /* 0=no use, 1=csymbol, 2=ci, 3=cn*/ node* op1; node* op2; } math_tree={NULL,NULL,NULL,0,NULL,NULL},*mthis=&math_tree; node* xml_make_neg (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeNeg (n1); return 0; } node* xml_make_add (node* n1,node* n2) {if (n1&&n2) return makeAdd(n1,n2); return n1; } node* xml_make_sub (node* n1,node* n2) {if (n1&&n2) return makeSub(n1,n2); return xml_make_neg(n1,0); } node* xml_make_mul (node* n1,node* n2) {if (n1&&n2) return makeMul(n1,n2); return 0; } node* xml_make_div (node* n1,node* n2) {if (n1&&n2) return makeDiv(n1,n2); return 0; } node* xml_make_sqrt(node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeSqrt (n1); return 0; } node* xml_make_exp (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeExp (n1); return 0; } node* xml_make_log (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeLog (n1); return 0; } node* xml_make_log2(node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeLog2 (n1); return 0; } node* xml_make_logA(node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeLog10(n1); return 0; } node* xml_make_sin (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeSin (n1); return 0; } node* xml_make_cos (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeCos (n1); return 0; } node* xml_make_tan (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeTan (n1); return 0; } node* xml_make_asin(node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeAsin (n1); return 0; } node* xml_make_acos(node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeAcos (n1); return 0; } node* xml_make_atan(node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeAtan (n1); return 0; } node* xml_make_sh (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeSinh (n1); return 0; } node* xml_make_ch (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeCosh (n1); return 0; } node* xml_make_th (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeTanh (n1); return 0; } node* xml_make_ash (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeAsinh(n1); return 0; } node* xml_make_ach (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeAcosh(n1); return 0; } node* xml_make_ath (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeAtanh(n1); return 0; } node* xml_make_pow (node* n1,node* n2) {if (n1&&n2) return makePow(n1,n2); return 0; } node* xml_make_abs (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeAbs (n1); return 0; } node* xml_make_db (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeDouble(n1); return 0; } node* xml_make_sg (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeSingle(n1); return 0; } node* xml_make_hp (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeHalfPrecision(n1); return 0; } node* xml_make_qd (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeQuad(n1); return 0; } node* xml_make_db2 (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeDoubledouble(n1); return 0; } node* xml_make_db3 (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeTripledouble(n1); return 0; } node* xml_make_dbex(node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeDoubleextended(n1); return 0; } node* xml_make_ceil(node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeCeil (n1); return 0; } node* xml_make_floor(node* n1,node* n2){UNUSED_PARAM(n2); if (n1) return makeFloor(n1); return 0; } node* xml_make_erf (node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeErf (n1); return 0; } node* xml_make_erfc(node* n1,node* n2) {UNUSED_PARAM(n2); if (n1) return makeErfc (n1); return 0; } node* xml_make_log1p(node* n1,node* n2){UNUSED_PARAM(n2); if (n1) return makeLog1p(n1); return 0; } node* xml_make_expm1(node* n1,node* n2){UNUSED_PARAM(n2); if (n1) return makeExpm1(n1); return 0; } struct { char* element; /* name of element, "math" for */ int type; /* type of XML chunk, 1 = , 15 = , ...*/ int (*parser)(xmlTextReaderPtr reader); /* parser to use to detect/validate this statement*/ int next_xmlparser; /* index in mml_parser[] in case of parsing success*/ int onerror_parser; /* index in mml_parser[] in case of parsing error*/ int depth; /* current XML depth*/ int offset_depth; /* offset of next parser, (-1)==any child level, 1==next child level */ int (*action)(xmlTextReaderPtr reader); /* ?*/ } mml_parser[]={ /* element: type: parser: next: err: d: offs: */ { "math", 1, search_basic_element, 1, -1, 0, -1, 0 }, /* search_mathml*/ { "semantics", 1, search_basic_element, 2, 0, 0, 1, 0 }, /* search_semantics*/ { "annotations", 1, search_annotations, 3, 1, 0, 1, 0 }, /* search_annotations*/ { "lambda", 1, search_basic_element, 4, 2, 0, -1, 0 }, /* search_lambda*/ { "bvar", 1, search_basic_element, 5, 3, 0, 1, 0 }, /* search_bvar*/ { "ci", 1, search_basic_element, 6, 3, 0, 1, 0 }, /* search_ci*/ { "#text", 3, search_basic_element, 7, 3, 0, 1, action_variable }, /* search_variable*/ { "ci", 15,search_basic_element, 8, 3, 0, 1, 0 }, /* search_ci*/ { "bvar", 15,search_basic_element, 9, 3, 0, 1, 0 }, /* search_bvar*/ { "bvar", 15,search_math_tree, 10,3, 0, 1, 0 }, /* math tree*/ { "simul-error", 0, search_return_offset, -1,4, 0, -1, 0 }, },*current_parser=&mml_parser[0]; void switch_parser_index (int new_index) { printMessage(3,SOLLYA_MSG_XML_PARSER_INDEX_CHANGE,"%s => %s\n",current_parser->element,mml_parser[new_index].element); current_parser=&mml_parser[new_index]; change_xmlparser(current_parser->parser); printMessage(3,SOLLYA_MSG_CONTINUATION,"depth: %i\n",current_parser->depth); } void *sollyaXmlMallocFunc(size_t); void sollyaXmlFreeFunc(void *); int search_math_tree (xmlTextReaderPtr reader) { node* temp=0; if (xmlTextReaderNodeType(reader)==1) { if (!strcmp((char*)xml_name, "apply")) { mthis->child=sollyaXmlMallocFunc(sizeof(nodemath)); mthis->child->parent=mthis; mthis=mthis->child; mthis->child=0; mthis->operator=0; mthis->op_type=0; mthis->op1=0; mthis->op2=0; printMessage(3,SOLLYA_MSG_XML_PARSER_STATE_INFORMATION,"This: %p Parent: %p Name: %s\n",mthis,mthis->parent,xml_name); } else if (!strcmp((char*)xml_name, "csymbol")) mthis->op_type=1; else if (!strcmp((char*)xml_name, "ci")) mthis->op_type=2; else if (!strcmp((char*)xml_name, "cn")) mthis->op_type=3; else if (!strcmp((char*)xml_name, "plus")) mthis->operator=xml_make_add; else if (!strcmp((char*)xml_name, "minus")) mthis->operator=xml_make_sub; else if (!strcmp((char*)xml_name, "times")) mthis->operator=xml_make_mul; else if (!strcmp((char*)xml_name, "divide")) mthis->operator=xml_make_div; else if (!strcmp((char*)xml_name, "root")) mthis->operator=xml_make_sqrt; else if (!strcmp((char*)xml_name, "exp")) mthis->operator=xml_make_exp; else if (!strcmp((char*)xml_name, "ln")) mthis->operator=xml_make_log; else if (!strcmp((char*)xml_name, "log")) mthis->operator=xml_make_logA; else if (!strcmp((char*)xml_name, "sin")) mthis->operator=xml_make_sin; else if (!strcmp((char*)xml_name, "cos")) mthis->operator=xml_make_cos; else if (!strcmp((char*)xml_name, "tan")) mthis->operator=xml_make_tan; else if (!strcmp((char*)xml_name, "arcsin")) mthis->operator=xml_make_asin; else if (!strcmp((char*)xml_name, "arccos")) mthis->operator=xml_make_acos; else if (!strcmp((char*)xml_name, "arctan")) mthis->operator=xml_make_atan; else if (!strcmp((char*)xml_name, "sinh")) mthis->operator=xml_make_sh; else if (!strcmp((char*)xml_name, "cosh")) mthis->operator=xml_make_ch; else if (!strcmp((char*)xml_name, "tanh")) mthis->operator=xml_make_th; else if (!strcmp((char*)xml_name, "arcsinh")) mthis->operator=xml_make_ash; else if (!strcmp((char*)xml_name, "arccosh")) mthis->operator=xml_make_ach; else if (!strcmp((char*)xml_name, "arctanh")) mthis->operator=xml_make_ath; else if (!strcmp((char*)xml_name, "power")) mthis->operator=xml_make_pow; else if (!strcmp((char*)xml_name, "abs")) mthis->operator=xml_make_abs; else if (!strcmp((char*)xml_name, "ceiling")) mthis->operator=xml_make_ceil; else if (!strcmp((char*)xml_name, "floor")) mthis->operator=xml_make_floor; else if (!strcmp((char*)xml_name, "pi")) temp=makePi(); else if (!strcmp((char*)xml_name, "exponentiale")) temp=makeExp(makeConstantDouble(1.)); else { switch_parser_index(current_parser->onerror_parser); return -1; } /* error: markup unknown*/ } else if (xmlTextReaderNodeType(reader)==3) /* Text*/ { if (mthis->op_type==1) /* csymbol*/ { if (!strcmp((char*)xml_value,"erf")) mthis->operator=xml_make_erf; else if (!strcmp((char*)xml_value,"erfc")) mthis->operator=xml_make_erfc; else if (!strcmp((char*)xml_value,"log1p")) mthis->operator=xml_make_log1p; else if (!strcmp((char*)xml_value,"expm1")) mthis->operator=xml_make_expm1; else if (!strcmp((char*)xml_value,"single")) mthis->operator=xml_make_sg; else if (!strcmp((char*)xml_value,"halfprecision")) mthis->operator=xml_make_hp; else if (!strcmp((char*)xml_value,"quad")) mthis->operator=xml_make_qd; else if (!strcmp((char*)xml_value,"double")) mthis->operator=xml_make_db; else if (!strcmp((char*)xml_value,"doubledouble")) mthis->operator=xml_make_db2; else if (!strcmp((char*)xml_value,"tripledouble")) mthis->operator=xml_make_db3; else if (!strcmp((char*)xml_value,"doubleextended"))mthis->operator=xml_make_dbex; } if (mthis->op_type==2) /* temp=makeVariable(); // ci*/ { /* Test only one variable (in bvar) and always the same name */ if(!strcmp((char*)xml_value,var_name)) temp=makeVariable(); /* ci*/ else { switch_parser_index(current_parser->onerror_parser); return -1; } /* error: variable unknown*/ } if (mthis->op_type==3) /*temp=parseString((char*)xml_value);// cn*/ { mpfr_t n; mpfr_init2(n,tools_precision); if (readDecimalConstant(n,(char*)xml_value)) { if (!noRoundingWarnings) { printMessage(1,SOLLYA_MSG_ROUNDING_ON_READING_CONSTANT_IN_XML_FILE,"Warning: rounding has happened upon reading constant \"%s\" in an XML file.\n",xml_value); } } temp = makeConstant(n); mpfr_clear(n); } } else if (xmlTextReaderNodeType(reader)==15) { if (!strcmp((char*)xml_name, "lambda")) { result_node=mthis->op1; printMessage(3,SOLLYA_MSG_XML_PARSER_STATE_INFORMATION,"This: %p Result: %p Name: /%s\n",mthis,result_node,xml_name); change_xmlparser(search_annotations); } else if (!strcmp((char*)xml_name, "apply") && mthis->operator) { printMessage(3,SOLLYA_MSG_XML_PARSER_STATE_INFORMATION,"op1: %p op2: %p op: %p\n",mthis->op1,mthis->op2,mthis->operator); temp=mthis->operator(mthis->op1,mthis->op2); /*printTree(temp); printMessage(2,"\n");*/ if (mthis->parent) mthis=mthis->parent; if (mthis->child) sollyaXmlFreeFunc(mthis->child); mthis->child=0; } else if (!strcmp((char*)xml_name, "csymbol")) mthis->op_type=0; /* the following line should test the case of a logarithm in an exotic basis */ /* Currently we DO NOT support this kind of logarithm but only ln and log10 */ /* Any patch is welcome */ /* if (!strcmp((char*)xml_name, "logbase")) ... */ printMessage(3,SOLLYA_MSG_XML_PARSER_STATE_INFORMATION,"This: %p Temp: %p Name: /%s\n",mthis,temp,xml_name); } if (temp) /* some value/result to add in the tree*/ { if (!mthis->op1) mthis->op1=temp; else if (!mthis->op2) mthis->op2=temp; else if (mthis->operator) { mthis->op1=mthis->operator(mthis->op1,mthis->op2); mthis->op2=temp; } else mthis->op1=mthis->op2=0,mthis->operator=0; /* error*/ printMessage(3,SOLLYA_MSG_XML_PARSER_STATE_INFORMATION,"This: %p Temp: %p Name: /%s\n",mthis,temp,xml_name); } return 1; } int search_return_offset (xmlTextReaderPtr reader) { UNUSED_PARAM(reader); switch_parser_index(current_parser->onerror_parser); return current_parser->offset_depth; } int search_basic_element (xmlTextReaderPtr reader) { /* on_error */ if (current_parser->onerror_parser!=-1 && current_parser->depth>=xmlTextReaderDepth(reader)) { switch_parser_index(current_parser->onerror_parser); return -1; } /* on_cannot_find*/ if (xmlTextReaderIsEmptyElement(reader) || strcmp((char*)xml_name,current_parser->element) || xmlTextReaderNodeType(reader)!=current_parser->type || (current_parser->offset_depth!=-1 && current_parser->depth+1!=xmlTextReaderDepth(reader)) ) return 0; /* on_found*/ if (current_parser->action) if (!current_parser->action(reader)) return 0; switch_parser_index(current_parser->next_xmlparser); current_parser->depth=xmlTextReaderDepth(reader); if (current_parser->type==15) current_parser->depth-=2; return 1; } int process_annotation(xmlTextReaderPtr reader) { /* using external node *parseString(char *)*/ /* Depth: 03 Type: 03 Name: #text (HasValue) ((x^(1b1)) + (1b2 * x)) - sin(x)*/ /* on_error */ if (current_parser->depth+1>=xmlTextReaderDepth(reader)) { change_xmlparser(search_annotations); return -1; } /* on_search*/ if (xmlTextReaderIsEmptyElement(reader) || xmlTextReaderNodeType(reader)!=3 || current_parser->depth+2!=xmlTextReaderDepth(reader) ) return 0; result_node=parseString((char*)xml_value); change_xmlparser(search_annotations); return 1; } int search_annotations(xmlTextReaderPtr reader) { /* on_error */ if (current_parser->depth>=xmlTextReaderDepth(reader)) { printMessage(3,SOLLYA_MSG_XML_PARSER_STATE_INFORMATION,"%s => %s\n",current_parser->element,mml_parser[current_parser->onerror_parser].element); current_parser=&mml_parser[current_parser->onerror_parser]; change_xmlparser(current_parser->parser); return -1; } /* on_search*/ if (xmlTextReaderIsEmptyElement(reader) || xmlTextReaderNodeType(reader)!=1 || current_parser->depth+1!=xmlTextReaderDepth(reader) ) return 0; if (!strcmp((char*)xml_name,"annotation") && xmlTextReaderHasAttributes(reader) && !strcmp((char *) xmlTextReaderGetAttribute(reader,(unsigned char *)"encoding"),"sollya/text") ) {change_xmlparser(process_annotation); return 1;} if (!strcmp((char*)xml_name,"annotation-xml") && xmlTextReaderHasAttributes(reader) && !strcmp((char *) xmlTextReaderGetAttribute(reader,(unsigned char *)"encoding"),"MathML-Content") ) { switch_parser_index(3); current_parser->depth=xmlTextReaderDepth(reader); return 1;} /* on_not_found*/ return 0; } /** * processNode: * @reader: the xmlReader * * Dump information about the current node */ static int processNode(xmlTextReaderPtr reader) { /* doc/info: http://xmlsoft.planetmirror.com/html/libxml-xmlreader.html*/ int ret; ret = xmlTextReaderRead(reader); if (ret!=1) { /* EOF or ERROR*/ if (ret) printMessage(1,SOLLYA_MSG_XML_PARSER_FAILURE,"Warning: on parsing an XML file: failed to parse, return code %i\n",ret); return ret; } xml_name = xmlTextReaderConstName(reader); if (xml_name == NULL) xml_name = BAD_CAST "--"; xml_value = xmlTextReaderConstValue(reader); printMessage(3,SOLLYA_MSG_XML_PARSER_STATE_INFORMATION,"Depth: %02d Type: %02d Name: %s", xmlTextReaderDepth(reader), xmlTextReaderNodeType(reader), xml_name); if (xmlTextReaderIsEmptyElement(reader)) printMessage(3,SOLLYA_MSG_XML_PARSER_STATE_INFORMATION," (EmptyElt)"); if (xmlTextReaderHasValue(reader)) printMessage(3,SOLLYA_MSG_XML_PARSER_STATE_INFORMATION," (HasValue)"); if (xmlTextReaderHasAttributes(reader)) printMessage(3,SOLLYA_MSG_XML_PARSER_STATE_INFORMATION," (HasAttrb)"); if (xml_value == NULL || /* XmlNodeType.SignificantWhitespace*/ xmlTextReaderNodeType(reader)==14) printMessage(3,SOLLYA_MSG_CONTINUATION,"\n"); else { if (xmlStrlen(xml_value) > 40) printMessage(3,SOLLYA_MSG_XML_PARSER_STATE_INFORMATION," %.40s...\n", xml_value); else printMessage(3,SOLLYA_MSG_XML_PARSER_STATE_INFORMATION," %s\n", xml_value); } while((*next_xmlparser)(reader)<0) printMessage(2,SOLLYA_MSG_XML_SYNCHRONIZATION_LOST_TRYING_TO_RESYNCH,"Lost Sync! Try resync...\n"); return ret; } /** * streamFile: * @filename: the file name to parse * * Parse and print information about an XML file. */ static node* streamXmlFile(const char *filename) { xmlTextReaderPtr reader; reader = xmlReaderForFile(filename, NULL, 0); if (reader == NULL) { printMessage(1,SOLLYA_MSG_XML_PARSER_UNABLE_TO_OPEN_A_CERTAIN_FILE,"Warning: Unable to open %s\n", filename); return NULL; } for(result_node=NULL,current_depth=0;processNode(reader)==1 && !result_node;); xmlFreeTextReader(reader); return result_node; } chain *sollyaXmlAllocatedMemory = NULL; void sollyaXmlMarkAllocated(void *ptr) { sollyaXmlAllocatedMemory = addElement(sollyaXmlAllocatedMemory, ptr); } void sollyaXmlMarkFreed(void *ptr) { chain *curr, *prev; for (curr=sollyaXmlAllocatedMemory, prev=NULL; curr != NULL; curr=((prev=curr)->next)) { if (curr->value == ptr) { if (prev == NULL) { sollyaXmlAllocatedMemory = curr->next; } else { prev->next = curr->next; } safeFree(curr); return; } } } void cleanupSollyaXmlMemory() { chain *curr, *prev; if (sollyaXmlAllocatedMemory == NULL) return; curr = sollyaXmlAllocatedMemory; while (curr != NULL) { safeFree(curr->value); prev = curr; curr = curr->next; safeFree(prev); } sollyaXmlAllocatedMemory = NULL; } void sollyaXmlFreeFunc(void *ptr) { sollyaXmlMarkFreed(ptr); safeFree(ptr); } void *sollyaXmlMallocFunc(size_t size) { void *ptr; ptr = safeMalloc(size); sollyaXmlMarkAllocated(ptr); return ptr; } void *sollyaXmlReallocFunc(void *ptr, size_t size) { void *reallocPtr; reallocPtr = safeRealloc(ptr, size); if (ptr == NULL) { /* realloc is like malloc */ sollyaXmlMarkAllocated(reallocPtr); } else { if (size == 0) { /* realloc is like free */ sollyaXmlMarkFreed(ptr); } else { /* realloc is a real realloc If the new pointer is the same, do nothing. Otherwise mark the old pointer as freed and the new one as allocated. */ if (reallocPtr != ptr) { sollyaXmlMarkFreed(ptr); sollyaXmlMarkAllocated(reallocPtr); } } } return reallocPtr; } char *sollyaXmlStrdupFunc(const char *str) { void *ptr; ptr = safeCalloc(strlen(str) + 1, sizeof(char)); strcpy(ptr, str); sollyaXmlMarkAllocated(ptr); return ptr; } /* Reads the file filename containing a lambda construct into a node * Return NULL if parsing the file is impossible Indication: use make... found in expression.h for building the nodes. Attention: do not forget do free incomplete trees if the parsing fails. Use free_memory(node *) for this (found in expression.h). If warnings to the user shall be indicated, use printMessage(verbosity level, format string, ...) verbosity level=0 nothing 1 important 2 information 3 internal/debug... */ node *readXml(char *filename) { node* result=NULL; /* Initialize the xml memory functions */ sollyaXmlAllocatedMemory = NULL; if (xmlMemSetup(sollyaXmlFreeFunc, sollyaXmlMallocFunc, sollyaXmlReallocFunc, sollyaXmlStrdupFunc)) return NULL; /* * this initialize the library and check potential ABI mismatches * between the version it was compiled for and the actual shared * library used. */ LIBXML_TEST_VERSION /* Parse the xml file */ result=streamXmlFile(filename); /* * Cleanup function for the XML library. */ xmlCleanupParser(); /* * this is to debug memory for regression tests */ xmlMemoryDump(); cleanupSollyaXmlMemory(); return result; } #else node *readXml(char *filename) { printMessage(1,SOLLYA_MSG_XML_PARSE_FUNCTIONALITY_NOT_COMPILED_IN,"Warning: We should now read the XML file \"%s\".\n",filename); printMessage(1,SOLLYA_MSG_CONTINUATION,"XInclude support not compiled in, cannot parse XML file.\n"); return NULL; } #endif ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������sollya-6.0+ds/xml.h���������������������������������������������������������������������������������0000664�0000000�0000000�00000004510�13001741147�0014233�0����������������������������������������������������������������������������������������������������ustar�00root����������������������������root����������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* Copyright 2007-2009 by Laboratoire de l'Informatique du Parallelisme, UMR CNRS - ENS Lyon - UCB Lyon 1 - INRIA 5668 Contributor Ch. Lauter christoph.lauter@ens-lyon.org This software is a computer program whose purpose is to provide an environment for safe floating-point code development. It is particularly targeted to the automated implementation of mathematical floating-point libraries (libm). Amongst other features, it offers a certified infinity norm, an automatic polynomial implementer and a fast Remez algorithm. This software is governed by the CeCILL-C license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL-C license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL-C license and that you accept its terms. This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. */ #ifndef XML_H #define XML_H #include #include #include "general.h" #include "expression.h" void printXml(node *); void fPrintXml(FILE *, node *); node *readXml(char *); #endif /* ifdef XML_H*/ ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������